PLplot 5.15.0
plplot_octaveOCTAVE_wrap.cxx
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.2
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12#ifndef SWIGOCTAVE
13#define SWIGOCTAVE
14#endif
15
16#define SWIG_name_d "plplot_octave"
17#define SWIG_name plplot_octave
18
19#define SWIG_global_name "cvar"
20#define SWIG_op_prefix "op_"
21
22
23#ifdef __cplusplus
24/* SwigValueWrapper is described in swig.swg */
25template<typename T> class SwigValueWrapper {
26 struct SwigMovePointer {
27 T *ptr;
28 SwigMovePointer(T *p) : ptr(p) { }
29 ~SwigMovePointer() { delete ptr; }
30 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
31 } pointer;
32 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
33 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
34public:
35 SwigValueWrapper() : pointer(0) { }
36 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
37 operator T&() const { return *pointer.ptr; }
38 T *operator&() { return pointer.ptr; }
39};
40
41template <typename T> T SwigValueInit() {
42 return T();
43}
44#endif
45
46/* -----------------------------------------------------------------------------
47 * This section contains generic SWIG labels for method/variable
48 * declarations/attributes, and other compiler dependent labels.
49 * ----------------------------------------------------------------------------- */
50
51/* template workaround for compilers that cannot correctly implement the C++ standard */
52#ifndef SWIGTEMPLATEDISAMBIGUATOR
53# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54# define SWIGTEMPLATEDISAMBIGUATOR template
55# elif defined(__HP_aCC)
56/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
57/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
58# define SWIGTEMPLATEDISAMBIGUATOR template
59# else
60# define SWIGTEMPLATEDISAMBIGUATOR
61# endif
62#endif
63
64/* inline attribute */
65#ifndef SWIGINLINE
66# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67# define SWIGINLINE inline
68# else
69# define SWIGINLINE
70# endif
71#endif
72
73/* attribute recognised by some compilers to avoid 'unused' warnings */
74#ifndef SWIGUNUSED
75# if defined(__GNUC__)
76# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77# define SWIGUNUSED __attribute__ ((__unused__))
78# else
79# define SWIGUNUSED
80# endif
81# elif defined(__ICC)
82# define SWIGUNUSED __attribute__ ((__unused__))
83# else
84# define SWIGUNUSED
85# endif
86#endif
87
88#ifndef SWIG_MSC_UNSUPPRESS_4505
89# if defined(_MSC_VER)
90# pragma warning(disable : 4505) /* unreferenced local function has been removed */
91# endif
92#endif
93
94#ifndef SWIGUNUSEDPARM
95# ifdef __cplusplus
96# define SWIGUNUSEDPARM(p)
97# else
98# define SWIGUNUSEDPARM(p) p SWIGUNUSED
99# endif
100#endif
101
102/* internal SWIG method */
103#ifndef SWIGINTERN
104# define SWIGINTERN static SWIGUNUSED
105#endif
106
107/* internal inline SWIG method */
108#ifndef SWIGINTERNINLINE
109# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
110#endif
111
112/* exporting methods */
113#if defined(__GNUC__)
114# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115# ifndef GCC_HASCLASSVISIBILITY
116# define GCC_HASCLASSVISIBILITY
117# endif
118# endif
119#endif
120
121#ifndef SWIGEXPORT
122# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123# if defined(STATIC_LINKED)
124# define SWIGEXPORT
125# else
126# define SWIGEXPORT __declspec(dllexport)
127# endif
128# else
129# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130# define SWIGEXPORT __attribute__ ((visibility("default")))
131# else
132# define SWIGEXPORT
133# endif
134# endif
135#endif
136
137/* calling conventions for Windows */
138#ifndef SWIGSTDCALL
139# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140# define SWIGSTDCALL __stdcall
141# else
142# define SWIGSTDCALL
143# endif
144#endif
145
146/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
147#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148# define _CRT_SECURE_NO_DEPRECATE
149#endif
150
151/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
152#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153# define _SCL_SECURE_NO_DEPRECATE
154#endif
155
156/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
157#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
159#endif
160
161/* Intel's compiler complains if a variable which was never initialised is
162 * cast to void, which is a common idiom which we use to indicate that we
163 * are aware a variable isn't used. So we just silence that warning.
164 * See: https://github.com/swig/swig/issues/192 for more discussion.
165 */
166#ifdef __INTEL_COMPILER
167# pragma warning disable 592
168#endif
169
170//
171// This header includes all C++ headers required for generated Octave wrapper code.
172// Using a single header file allows pre-compilation of Octave headers, as follows:
173// * Check out this header file:
174// swig -octave -co octheaders.hpp
175// * Pre-compile header file into octheaders.hpp.gch:
176// g++ -c ... octheaders.hpp
177// * Use pre-compiled header file:
178// g++ -c -include octheaders.hpp ...
179//
180
181#if !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
182#define _SWIG_OCTAVE_OCTHEADERS_HPP
183
184// Required C++ headers
185#include <cstdlib>
186#include <climits>
187#include <iostream>
188#include <exception>
189#include <functional>
190#include <complex>
191#include <string>
192#include <vector>
193#include <map>
194
195// Minimal headers to define Octave version
196#include <octave/oct.h>
197#include <octave/version.h>
198
199// Macro for enabling features which require Octave version >= major.minor.patch
200// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
201#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
202 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
203
204// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
205#if !defined(OCTAVE_MAJOR_VERSION)
206
207# if !defined(OCTAVE_API_VERSION_NUMBER)
208
209// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
210// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
211# include <octave/ov.h>
212# if defined(octave_ov_h)
213# define OCTAVE_MAJOR_VERSION 3
214# define OCTAVE_MINOR_VERSION 8
215# define OCTAVE_PATCH_VERSION 0
216# else
217
218// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
219# define ComplexLU __ignore
220# include <octave/CmplxLU.h>
221# undef ComplexLU
222# if defined(octave_Complex_LU_h)
223
224// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
225# define OCTAVE_MAJOR_VERSION 3
226# define OCTAVE_MINOR_VERSION 1
227# define OCTAVE_PATCH_VERSION 99
228
229# else
230
231// OCTAVE_API_VERSION_NUMBER == 37
232# define OCTAVE_MAJOR_VERSION 3
233# define OCTAVE_MINOR_VERSION 2
234# define OCTAVE_PATCH_VERSION 0
235
236# endif // defined(octave_Complex_LU_h)
237
238# endif // defined(octave_ov_h)
239
240// Correlation between Octave API and version numbers extracted from Octave's
241// ChangeLogs; version is the *earliest* released Octave with that API number
242# elif OCTAVE_API_VERSION_NUMBER >= 48
243# define OCTAVE_MAJOR_VERSION 3
244# define OCTAVE_MINOR_VERSION 6
245# define OCTAVE_PATCH_VERSION 0
246
247# elif OCTAVE_API_VERSION_NUMBER >= 45
248# define OCTAVE_MAJOR_VERSION 3
249# define OCTAVE_MINOR_VERSION 4
250# define OCTAVE_PATCH_VERSION 1
251
252# elif OCTAVE_API_VERSION_NUMBER >= 42
253# define OCTAVE_MAJOR_VERSION 3
254# define OCTAVE_MINOR_VERSION 3
255# define OCTAVE_PATCH_VERSION 54
256
257# elif OCTAVE_API_VERSION_NUMBER >= 41
258# define OCTAVE_MAJOR_VERSION 3
259# define OCTAVE_MINOR_VERSION 3
260# define OCTAVE_PATCH_VERSION 53
261
262# elif OCTAVE_API_VERSION_NUMBER >= 40
263# define OCTAVE_MAJOR_VERSION 3
264# define OCTAVE_MINOR_VERSION 3
265# define OCTAVE_PATCH_VERSION 52
266
267# elif OCTAVE_API_VERSION_NUMBER >= 39
268# define OCTAVE_MAJOR_VERSION 3
269# define OCTAVE_MINOR_VERSION 3
270# define OCTAVE_PATCH_VERSION 51
271
272# else // OCTAVE_API_VERSION_NUMBER == 38
273# define OCTAVE_MAJOR_VERSION 3
274# define OCTAVE_MINOR_VERSION 3
275# define OCTAVE_PATCH_VERSION 50
276
277# endif // !defined(OCTAVE_API_VERSION_NUMBER)
278
279#endif // !defined(OCTAVE_MAJOR_VERSION)
280
281// Required Octave headers
282#include <octave/Cell.h>
283#include <octave/dynamic-ld.h>
284#include <octave/oct-env.h>
285#include <octave/oct-map.h>
286#include <octave/ov-scalar.h>
287#include <octave/ov-fcn-handle.h>
288#include <octave/parse.h>
289#if SWIG_OCTAVE_PREREQ(4,2,0)
290#include <octave/interpreter.h>
291#else
292#include <octave/toplev.h>
293#endif
294#include <octave/unwind-prot.h>
295#if SWIG_OCTAVE_PREREQ(4,2,0)
296#include <octave/call-stack.h>
297#endif
298
299#endif // !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
300
301/* -----------------------------------------------------------------------------
302 * swigrun.swg
303 *
304 * This file contains generic C API SWIG runtime support for pointer
305 * type checking.
306 * ----------------------------------------------------------------------------- */
307
308/* This should only be incremented when either the layout of swig_type_info changes,
309 or for whatever reason, the runtime changes incompatibly */
310#define SWIG_RUNTIME_VERSION "4"
311
312/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
313#ifdef SWIG_TYPE_TABLE
314# define SWIG_QUOTE_STRING(x) #x
315# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
316# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
317#else
318# define SWIG_TYPE_TABLE_NAME
319#endif
320
321/*
322 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
323 creating a static or dynamic library from the SWIG runtime code.
324 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
325
326 But only do this if strictly necessary, ie, if you have problems
327 with your compiler or suchlike.
328*/
329
330#ifndef SWIGRUNTIME
331# define SWIGRUNTIME SWIGINTERN
332#endif
333
334#ifndef SWIGRUNTIMEINLINE
335# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
336#endif
337
338/* Generic buffer size */
339#ifndef SWIG_BUFFER_SIZE
340# define SWIG_BUFFER_SIZE 1024
341#endif
342
343/* Flags for pointer conversions */
344#define SWIG_POINTER_DISOWN 0x1
345#define SWIG_CAST_NEW_MEMORY 0x2
346#define SWIG_POINTER_NO_NULL 0x4
347
348/* Flags for new pointer objects */
349#define SWIG_POINTER_OWN 0x1
350
351
352/*
353 Flags/methods for returning states.
354
355 The SWIG conversion methods, as ConvertPtr, return an integer
356 that tells if the conversion was successful or not. And if not,
357 an error code can be returned (see swigerrors.swg for the codes).
358
359 Use the following macros/flags to set or process the returning
360 states.
361
362 In old versions of SWIG, code such as the following was usually written:
363
364 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
365 // success code
366 } else {
367 //fail code
368 }
369
370 Now you can be more explicit:
371
372 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
373 if (SWIG_IsOK(res)) {
374 // success code
375 } else {
376 // fail code
377 }
378
379 which is the same really, but now you can also do
380
381 Type *ptr;
382 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
383 if (SWIG_IsOK(res)) {
384 // success code
385 if (SWIG_IsNewObj(res) {
386 ...
387 delete *ptr;
388 } else {
389 ...
390 }
391 } else {
392 // fail code
393 }
394
395 I.e., now SWIG_ConvertPtr can return new objects and you can
396 identify the case and take care of the deallocation. Of course that
397 also requires SWIG_ConvertPtr to return new result values, such as
398
399 int SWIG_ConvertPtr(obj, ptr,...) {
400 if (<obj is ok>) {
401 if (<need new object>) {
402 *ptr = <ptr to new allocated object>;
403 return SWIG_NEWOBJ;
404 } else {
405 *ptr = <ptr to old object>;
406 return SWIG_OLDOBJ;
407 }
408 } else {
409 return SWIG_BADOBJ;
410 }
411 }
412
413 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
414 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
415 SWIG errors code.
416
417 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
418 allows to return the 'cast rank', for example, if you have this
419
420 int food(double)
421 int fooi(int);
422
423 and you call
424
425 food(1) // cast rank '1' (1 -> 1.0)
426 fooi(1) // cast rank '0'
427
428 just use the SWIG_AddCast()/SWIG_CheckState()
429*/
430
431#define SWIG_OK (0)
432#define SWIG_ERROR (-1)
433#define SWIG_IsOK(r) (r >= 0)
434#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
435
436/* The CastRankLimit says how many bits are used for the cast rank */
437#define SWIG_CASTRANKLIMIT (1 << 8)
438/* The NewMask denotes the object was created (using new/malloc) */
439#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
440/* The TmpMask is for in/out typemaps that use temporal objects */
441#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
442/* Simple returning values */
443#define SWIG_BADOBJ (SWIG_ERROR)
444#define SWIG_OLDOBJ (SWIG_OK)
445#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
446#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
447/* Check, add and del mask methods */
448#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
449#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
450#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
451#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
452#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
453#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
454
455/* Cast-Rank Mode */
456#if defined(SWIG_CASTRANK_MODE)
457# ifndef SWIG_TypeRank
458# define SWIG_TypeRank unsigned long
459# endif
460# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
461# define SWIG_MAXCASTRANK (2)
462# endif
463# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
464# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
466 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
467}
469 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
470}
471#else /* no cast-rank mode */
472# define SWIG_AddCast(r) (r)
473# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
474#endif
475
476
477#include <string.h>
478
479#ifdef __cplusplus
480extern "C" {
481#endif
482
483typedef void *(*swig_converter_func)(void *, int *);
484typedef struct swig_type_info *(*swig_dycast_func)(void **);
485
486/* Structure to store information on one type */
487typedef struct swig_type_info {
488 const char *name; /* mangled name of this type */
489 const char *str; /* human readable name of this type */
490 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
491 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
492 void *clientdata; /* language specific type data */
493 int owndata; /* flag if the structure owns the clientdata */
495
496/* Structure to store a type and conversion function used for casting */
497typedef struct swig_cast_info {
498 swig_type_info *type; /* pointer to type that is equivalent to this type */
499 swig_converter_func converter; /* function to cast the void pointers */
500 struct swig_cast_info *next; /* pointer to next cast in linked list */
501 struct swig_cast_info *prev; /* pointer to the previous cast */
503
504/* Structure used to store module information
505 * Each module generates one structure like this, and the runtime collects
506 * all of these structures and stores them in a circularly linked list.*/
507typedef struct swig_module_info {
508 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
509 size_t size; /* Number of types in this module */
510 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
511 swig_type_info **type_initial; /* Array of initially generated type structures */
512 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
513 void *clientdata; /* Language specific module data */
515
516/*
517 Compare two type names skipping the space characters, therefore
518 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
519
520 Return 0 when the two name types are equivalent, as in
521 strncmp, but skipping ' '.
522*/
523SWIGRUNTIME int
524SWIG_TypeNameComp(const char *f1, const char *l1,
525 const char *f2, const char *l2) {
526 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
527 while ((*f1 == ' ') && (f1 != l1)) ++f1;
528 while ((*f2 == ' ') && (f2 != l2)) ++f2;
529 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
530 }
531 return (int)((l1 - f1) - (l2 - f2));
532}
533
534/*
535 Check type equivalence in a name list like <name1>|<name2>|...
536 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
537*/
538SWIGRUNTIME int
539SWIG_TypeCmp(const char *nb, const char *tb) {
540 int equiv = 1;
541 const char* te = tb + strlen(tb);
542 const char* ne = nb;
543 while (equiv != 0 && *ne) {
544 for (nb = ne; *ne; ++ne) {
545 if (*ne == '|') break;
546 }
547 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
548 if (*ne) ++ne;
549 }
550 return equiv;
551}
552
553/*
554 Check type equivalence in a name list like <name1>|<name2>|...
555 Return 0 if not equal, 1 if equal
556*/
557SWIGRUNTIME int
558SWIG_TypeEquiv(const char *nb, const char *tb) {
559 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
560}
561
562/*
563 Check the typename
564*/
566SWIG_TypeCheck(const char *c, swig_type_info *ty) {
567 if (ty) {
568 swig_cast_info *iter = ty->cast;
569 while (iter) {
570 if (strcmp(iter->type->name, c) == 0) {
571 if (iter == ty->cast)
572 return iter;
573 /* Move iter to the top of the linked list */
574 iter->prev->next = iter->next;
575 if (iter->next)
576 iter->next->prev = iter->prev;
577 iter->next = ty->cast;
578 iter->prev = 0;
579 if (ty->cast) ty->cast->prev = iter;
580 ty->cast = iter;
581 return iter;
582 }
583 iter = iter->next;
584 }
585 }
586 return 0;
587}
588
589/*
590 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
591*/
594 if (ty) {
595 swig_cast_info *iter = ty->cast;
596 while (iter) {
597 if (iter->type == from) {
598 if (iter == ty->cast)
599 return iter;
600 /* Move iter to the top of the linked list */
601 iter->prev->next = iter->next;
602 if (iter->next)
603 iter->next->prev = iter->prev;
604 iter->next = ty->cast;
605 iter->prev = 0;
606 if (ty->cast) ty->cast->prev = iter;
607 ty->cast = iter;
608 return iter;
609 }
610 iter = iter->next;
611 }
612 }
613 return 0;
614}
615
616/*
617 Cast a pointer up an inheritance hierarchy
618*/
620SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
621 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
622}
623
624/*
625 Dynamic pointer casting. Down an inheritance hierarchy
626*/
629 swig_type_info *lastty = ty;
630 if (!ty || !ty->dcast) return ty;
631 while (ty && (ty->dcast)) {
632 ty = (*ty->dcast)(ptr);
633 if (ty) lastty = ty;
634 }
635 return lastty;
636}
637
638/*
639 Return the name associated with this type
640*/
641SWIGRUNTIMEINLINE const char *
643 return ty->name;
644}
645
646/*
647 Return the pretty name associated with this type,
648 that is an unmangled type name in a form presentable to the user.
649*/
650SWIGRUNTIME const char *
652 /* The "str" field contains the equivalent pretty names of the
653 type, separated by vertical-bar characters. We choose
654 to print the last name, as it is often (?) the most
655 specific. */
656 if (!type) return NULL;
657 if (type->str != NULL) {
658 const char *last_name = type->str;
659 const char *s;
660 for (s = type->str; *s; s++)
661 if (*s == '|') last_name = s+1;
662 return last_name;
663 }
664 else
665 return type->name;
666}
667
668/*
669 Set the clientdata field for a type
670*/
671SWIGRUNTIME void
673 swig_cast_info *cast = ti->cast;
674 /* if (ti->clientdata == clientdata) return; */
676
677 while (cast) {
678 if (!cast->converter) {
679 swig_type_info *tc = cast->type;
680 if (!tc->clientdata) {
682 }
683 }
684 cast = cast->next;
685 }
686}
687SWIGRUNTIME void
690 ti->owndata = 1;
691}
692
693/*
694 Search for a swig_type_info structure only by mangled name
695 Search is a O(log #types)
696
697 We start searching at module start, and finish searching when start == end.
698 Note: if start == end at the beginning of the function, we go all the way around
699 the circular list.
700*/
703 swig_module_info *end,
704 const char *name) {
705 swig_module_info *iter = start;
706 do {
707 if (iter->size) {
708 size_t l = 0;
709 size_t r = iter->size - 1;
710 do {
711 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
712 size_t i = (l + r) >> 1;
713 const char *iname = iter->types[i]->name;
714 if (iname) {
715 int compare = strcmp(name, iname);
716 if (compare == 0) {
717 return iter->types[i];
718 } else if (compare < 0) {
719 if (i) {
720 r = i - 1;
721 } else {
722 break;
723 }
724 } else if (compare > 0) {
725 l = i + 1;
726 }
727 } else {
728 break; /* should never happen */
729 }
730 } while (l <= r);
731 }
732 iter = iter->next;
733 } while (iter != end);
734 return 0;
735}
736
737/*
738 Search for a swig_type_info structure for either a mangled name or a human readable name.
739 It first searches the mangled names of the types, which is a O(log #types)
740 If a type is not found it then searches the human readable names, which is O(#types).
741
742 We start searching at module start, and finish searching when start == end.
743 Note: if start == end at the beginning of the function, we go all the way around
744 the circular list.
745*/
748 swig_module_info *end,
749 const char *name) {
750 /* STEP 1: Search the name field using binary search */
752 if (ret) {
753 return ret;
754 } else {
755 /* STEP 2: If the type hasn't been found, do a complete search
756 of the str field (the human readable name) */
757 swig_module_info *iter = start;
758 do {
759 size_t i = 0;
760 for (; i < iter->size; ++i) {
761 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
762 return iter->types[i];
763 }
764 iter = iter->next;
765 } while (iter != end);
766 }
767
768 /* neither found a match */
769 return 0;
770}
771
772/*
773 Pack binary data into a string
774*/
775SWIGRUNTIME char *
776SWIG_PackData(char *c, void *ptr, size_t sz) {
777 static const char hex[17] = "0123456789abcdef";
778 const unsigned char *u = (unsigned char *) ptr;
779 const unsigned char *eu = u + sz;
780 for (; u != eu; ++u) {
781 unsigned char uu = *u;
782 *(c++) = hex[(uu & 0xf0) >> 4];
783 *(c++) = hex[uu & 0xf];
784 }
785 return c;
786}
787
788/*
789 Unpack binary data from a string
790*/
791SWIGRUNTIME const char *
792SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
793 unsigned char *u = (unsigned char *) ptr;
794 const unsigned char *eu = u + sz;
795 for (; u != eu; ++u) {
796 char d = *(c++);
797 unsigned char uu;
798 if ((d >= '0') && (d <= '9'))
799 uu = (unsigned char)((d - '0') << 4);
800 else if ((d >= 'a') && (d <= 'f'))
801 uu = (unsigned char)((d - ('a'-10)) << 4);
802 else
803 return (char *) 0;
804 d = *(c++);
805 if ((d >= '0') && (d <= '9'))
806 uu |= (unsigned char)(d - '0');
807 else if ((d >= 'a') && (d <= 'f'))
808 uu |= (unsigned char)(d - ('a'-10));
809 else
810 return (char *) 0;
811 *u = uu;
812 }
813 return c;
814}
815
816/*
817 Pack 'void *' into a string buffer.
818*/
819SWIGRUNTIME char *
820SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
821 char *r = buff;
822 if ((2*sizeof(void *) + 2) > bsz) return 0;
823 *(r++) = '_';
824 r = SWIG_PackData(r,&ptr,sizeof(void *));
825 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
826 strcpy(r,name);
827 return buff;
828}
829
830SWIGRUNTIME const char *
831SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
832 if (*c != '_') {
833 if (strcmp(c,"NULL") == 0) {
834 *ptr = (void *) 0;
835 return name;
836 } else {
837 return 0;
838 }
839 }
840 return SWIG_UnpackData(++c,ptr,sizeof(void *));
841}
842
843SWIGRUNTIME char *
844SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
845 char *r = buff;
846 size_t lname = (name ? strlen(name) : 0);
847 if ((2*sz + 2 + lname) > bsz) return 0;
848 *(r++) = '_';
849 r = SWIG_PackData(r,ptr,sz);
850 if (lname) {
851 strncpy(r,name,lname+1);
852 } else {
853 *r = 0;
854 }
855 return buff;
856}
857
858SWIGRUNTIME const char *
859SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
860 if (*c != '_') {
861 if (strcmp(c,"NULL") == 0) {
862 memset(ptr,0,sz);
863 return name;
864 } else {
865 return 0;
866 }
867 }
868 return SWIG_UnpackData(++c,ptr,sz);
869}
870
871#ifdef __cplusplus
872}
873#endif
874
875/* Errors in SWIG */
876#define SWIG_UnknownError -1
877#define SWIG_IOError -2
878#define SWIG_RuntimeError -3
879#define SWIG_IndexError -4
880#define SWIG_TypeError -5
881#define SWIG_DivisionByZero -6
882#define SWIG_OverflowError -7
883#define SWIG_SyntaxError -8
884#define SWIG_ValueError -9
885#define SWIG_SystemError -10
886#define SWIG_AttributeError -11
887#define SWIG_MemoryError -12
888#define SWIG_NullReferenceError -13
889
890
891
892#if !SWIG_OCTAVE_PREREQ(3,2,0)
893#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
894#else
895#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
896#endif
897
898SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
899 if (num_args > max_args && !varargs)
900 error("function %s takes at most %i arguments", func_name, max_args);
901 else if (num_args < min_args)
902 error("function %s requires at least %i arguments", func_name, min_args);
903 else
904 return true;
905 return false;
906}
907
908SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
909 ovl->append(ov);
910 return ovl;
911}
912
913SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
914 switch (code) {
915 case SWIG_MemoryError:
916 return "SWIG_MemoryError";
917 case SWIG_IOError:
918 return "SWIG_IOError";
920 return "SWIG_RuntimeError";
921 case SWIG_IndexError:
922 return "SWIG_IndexError";
923 case SWIG_TypeError:
924 return "SWIG_TypeError";
926 return "SWIG_DivisionByZero";
928 return "SWIG_OverflowError";
929 case SWIG_SyntaxError:
930 return "SWIG_SyntaxError";
931 case SWIG_ValueError:
932 return "SWIG_ValueError";
933 case SWIG_SystemError:
934 return "SWIG_SystemError";
936 return "SWIG_AttributeError";
937 }
938 return "SWIG unknown error";
939}
940
941SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
942 octave_value type(SWIG_ErrorType(code));
943 std::string r = msg;
944 r += " (" + type.string_value() + ")";
945 error("%s", r.c_str());
946 return octave_value(r);
947}
948
949#define SWIG_fail goto fail
950
951#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
952#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
953#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
954#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
955#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
956#define swig_owntype int
957
958#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
959#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
960
961#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
962#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
963
964#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
965#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
966
967#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
968#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
969#define SWIG_MODULE_CLIENTDATA_TYPE void*
970
971#define Octave_Error_Occurred() 0
972#define SWIG_Octave_AddErrorMsg(msg) {;}
973
976
977// For backward compatibility only
978#define SWIG_POINTER_EXCEPTION 0
979#define SWIG_arg_fail(arg) 0
980
981// Runtime API implementation
982
983typedef octave_value_list(*octave_func) (const octave_value_list &, int);
984class octave_swig_type;
985
986namespace Swig {
987
988#ifdef SWIG_DIRECTORS
989
990 class Director;
991
992 typedef std::map < void *, Director * > rtdir_map;
993 SWIGINTERN rtdir_map* get_rtdir_map();
994 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
995 SWIGINTERNINLINE void erase_rtdir(void *vptr);
996 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
997
998 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
999 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
1000 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
1001
1002#endif
1003
1004 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
1006 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
1007}
1008
1009#ifdef SWIG_DIRECTORS
1010SWIGRUNTIME void swig_acquire_ownership(void *vptr);
1011SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
1012SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
1013#endif
1014
1016 const char *name;
1020 int flags; // 1 static, 2 global
1021 const char *doc;
1022 bool is_static() const {
1023 return flags &1;
1024 } bool is_global() const {
1025 return flags &2;
1026 }
1027 };
1028
1030 const char *name;
1034 const char *constructor_doc;
1037 const char **base_names;
1039 };
1040
1041#if SWIG_OCTAVE_PREREQ(4,4,0)
1042 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1043 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1044#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1045 class octave_swig_bound_func : public octave_function {
1046 public:
1047
1048 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1049 { }
1050
1051 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1052 : octave_function("", ""), method(_method), first_args(_first_args)
1053 { }
1054
1055 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1056
1057 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1058
1059 ~octave_swig_bound_func(void) = default;
1060
1061 bool is_function(void) const { return true; }
1062
1063 octave_function* function_value(bool = false) { return this; }
1064
1065#if SWIG_OCTAVE_PREREQ(6,0,0)
1066 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1067 return execute(tw,nargout,args);
1068 }
1069#endif
1070#if SWIG_OCTAVE_PREREQ(6,0,0)
1071 octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1072#else
1073 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1074#endif
1075 octave_value_list all_args;
1076 all_args.append(first_args);
1077 all_args.append(args);
1078 return method->call(tw, nargout, all_args);
1079 }
1080
1081 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1082 octave_value_list ovl = subsref(ops, idx, 1);
1083 return ovl.length() ? ovl(0) : octave_value();
1084 }
1085
1086 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1087 assert(ops.size() > 0);
1088 assert(ops.size() == idx.size());
1089 if (ops != "(")
1090 error("invalid function call");
1091 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1092 return call(tw, nargout, *idx.begin());
1093 }
1094
1095 protected:
1096
1097 octave_function* method;
1098 octave_value_list first_args;
1099
1100 std::set<std::string> dispatch_classes;
1101
1102 };
1103#else
1104#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1105#endif
1106
1107 // octave_swig_type plays the role of both the shadow class and the class
1108 // representation within Octave, since there is no support for classes.
1109 //
1110 // These should really be decoupled, with the class support added to Octave
1111 // and the shadow class given by an m-file script. That would dramatically
1112 // reduce the runtime complexity, and be more in line w/ other modules.
1113
1114 class octave_swig_type:public octave_base_value {
1115 struct cpp_ptr {
1116 void *ptr;
1118 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1119 }};
1120 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1121
1123
1124 const swig_type_info *construct_type; // type of special type object
1125 std::vector < type_ptr_pair > types; // our c++ base classes
1126 int own; // whether we call c++ destructors when we die
1127
1128 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1129 typedef std::map < std::string, member_value_pair > member_map;
1132
1133 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1134 if (!type->clientdata)
1135 return 0;
1137 const swig_octave_member *m;
1138 for (m = c->members; m->name; ++m)
1139 if (m->name == name)
1140 return m;
1141 for (int j = 0; c->base_names[j]; ++j) {
1142 if (!c->base[j]) {
1143 if (!module)
1144 module = SWIG_GetModule(0);
1145 assert(module);
1146 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1147 }
1148 if (!c->base[j])
1149 return 0;
1150 if ((m = find_member(c->base[j], name)))
1151 return m;
1152 }
1153 return 0;
1154 }
1155
1156 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1157 member_map::iterator it = members.find(name);
1158 if (it != members.end())
1159 return &it->second;
1160 const swig_octave_member *m;
1161 for (unsigned int j = 0; j < types.size(); ++j)
1162 if ((m = find_member(types[j].first, name)))
1163 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1164 if (!insert_if_not_found)
1165 return 0;
1166 return &members[name];
1167 }
1168
1169 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1170 if (!base) {
1171 for (unsigned int j = 0; j < types.size(); ++j) {
1172 assert(types[j].first->clientdata);
1173 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1174 if (cj->name == name)
1175 return types[j].first;
1176 }
1177 return 0;
1178 }
1179 assert(base->clientdata);
1181 for (int j = 0; c->base_names[j]; ++j) {
1182 if (!c->base[j]) {
1183 if (!module)
1184 module = SWIG_GetModule(0);
1185 assert(module);
1186 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1187 }
1188 if (!c->base[j])
1189 return 0;
1190 assert(c->base[j]->clientdata);
1192 if (cj->name == name)
1193 return c->base[j];
1194 }
1195 return 0;
1196 }
1197
1198 void load_members(const swig_octave_class* c,member_map& out) const {
1199 for (const swig_octave_member *m = c->members; m->name; ++m) {
1200 if (out.find(m->name) == out.end())
1201 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1202 }
1203 for (int j = 0; c->base_names[j]; ++j) {
1204 if (!c->base[j]) {
1205 if (!module)
1206 module = SWIG_GetModule(0);
1207 assert(module);
1208 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1209 }
1210 if (!c->base[j])
1211 continue;
1212 assert(c->base[j]->clientdata);
1213 const swig_octave_class *cj =
1214 (const swig_octave_class *) c->base[j]->clientdata;
1215 load_members(cj,out);
1216 }
1217 }
1218
1219 void load_members(member_map& out) const {
1220 out=members;
1221 for (unsigned int j = 0; j < types.size(); ++j)
1222 if (types[j].first->clientdata)
1223 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1224 }
1225
1226 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1227 if (m->second.is_defined())
1228 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1229 else if (m->first && m->first->method)
1230 return m->first->method(args, nargout);
1231 error("member not defined or not invocable");
1232 return octave_value_list();
1233 }
1234
1235 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1236 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1237 member_value_pair *m = nc_this->find_member(symbol, false);
1238 if (!m || m->first->is_static() || m->first->is_global())
1239 return false;
1240 octave_value_list args;
1241 args.append(nc_this->as_value());
1242 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1243 if (argout.length() < 1)
1244 return false;
1245 ret = argout(0);
1246 return true;
1247 }
1248
1249 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1250 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1251 member_value_pair *m = nc_this->find_member(symbol, false);
1252 if (!m || m->first->is_static() || m->first->is_global())
1253 return false;
1254 octave_value_list args;
1255 args.append(nc_this->as_value());
1256 args.append(make_value_hack(rhs));
1257 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1258 if (argout.length() < 1)
1259 return false;
1260 ret = argout(0);
1261 return true;
1262 }
1263
1264 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1265 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1266 member_value_pair *m = nc_this->find_member(symbol, false);
1267 if (!m || m->first->is_static() || m->first->is_global())
1268 return false;
1269 octave_value_list args;
1270 args.append(nc_this->as_value());
1271 args.append(rhs);
1272 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1273 if (argout.length() >= 1)
1274 ret = argout(0);
1275 return true;
1276 }
1277
1278 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1279 if (m->second.is_defined()) {
1280 if (m->second.is_function() || m->second.is_function_handle()) {
1281 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1282 } else {
1283 return m->second;
1284 }
1285 } else if (m->first) {
1286 if (m->first->get_method)
1287 return m->first->get_method(args, 1);
1288 else if (m->first->method)
1289 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1290 }
1291 error("undefined member");
1292 return octave_value_list();
1293 }
1294
1295 static octave_value make_value_hack(const octave_base_value &x) {
1296 ((octave_swig_type &) x).count++;
1297 return octave_value((octave_base_value *) &x);
1298 }
1299
1302 public:
1303
1304 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1305 bool _always_static = false)
1306 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1307 always_static(_always_static) {
1308 if (_type || _ptr)
1309 types.push_back(std::make_pair(_type, _ptr));
1310#ifdef SWIG_DIRECTORS
1311 if (_ptr) {
1312 Swig::Director *d = Swig::get_rtdir(_ptr);
1313 if (d)
1314 Swig::swig_director_set_self(d, this);
1315 }
1316#endif
1317 }
1318
1320 if (own) {
1321 ++count;
1322 for (unsigned int j = 0; j < types.size(); ++j) {
1323 if (!types[j].first || !types[j].first->clientdata)
1324 continue;
1325 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1326 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1327 c->destructor(as_value(), 0);
1328 }
1329 }
1330 }
1331#ifdef SWIG_DIRECTORS
1332 for (unsigned int j = 0; j < types.size(); ++j)
1333 Swig::erase_rtdir(types[j].second.ptr);
1334#endif
1335 }
1336
1337 dim_vector dims(void) const {
1338 octave_value out;
1339 if (!dispatch_unary_op("__dims__", out))
1340 return dim_vector(1,1);
1341
1342 // Return value should be cell or matrix of integers
1343#if SWIG_OCTAVE_PREREQ(4,4,0)
1344 if (out.iscell()) {
1345#else
1346 if (out.is_cell()) {
1347#endif
1348 const Cell & c=out.cell_value();
1349 int ndim = c.rows();
1350 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1351
1352 dim_vector d;
1353 d.resize(ndim < 2 ? 2 : ndim);
1354 d(0) = d(1) = 1;
1355
1356 // Fill in dim_vector
1357 for (int k=0;k<ndim;k++) {
1358 const octave_value& obj = c(k);
1359#if SWIG_OCTAVE_PREREQ(6,0,0)
1360 try {
1361 d.elem(k) = obj.int_value();
1362 }
1363 catch (octave::execution_exception& oee) {
1364 // __dims__ should return a cell filled with integers
1365 return dim_vector(1,1);
1366 }
1367#else
1368 d.elem(k) = obj.int_value();
1369
1370 // __dims__ should return a cell filled with integers
1371 if (error_state) return dim_vector(1,1);
1372#endif
1373 }
1374 return d;
1375#if SWIG_OCTAVE_PREREQ(4,4,0)
1376 } else if (out.is_matrix_type() || out.isnumeric() ) {
1377#else
1378 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1379#endif
1380 if (out.rows()==1 || out.columns()==1) {
1381#if SWIG_OCTAVE_PREREQ(6,0,0)
1382 Array<int> a;
1383 try {
1384 a = out.int_vector_value();
1385 }
1386 catch (octave::execution_exception& oee) {
1387 return dim_vector(1,1);
1388 }
1389#else
1390 Array<int> a = out.int_vector_value();
1391 if (error_state) return dim_vector(1,1);
1392#endif
1393 dim_vector d;
1394 d.resize(a.numel() < 2 ? 2 : a.numel());
1395 d(0) = d(1) = 1;
1396 for (int k=0;k<a.numel();k++) {
1397 d.elem(k) = a(k);
1398 }
1399 return d;
1400 } else {
1401 return dim_vector(1,1);
1402 }
1403 } else {
1404 return dim_vector(1,1);
1405 }
1406 }
1407
1408 octave_value as_value() {
1409 ++count;
1410 return Swig::swig_value_ref(this);
1411 }
1412
1413 void incref() {
1414 ++count;
1415 }
1416
1417 void decref() {
1418 if (!--count)
1419 delete this;
1420 }
1421
1422 size_t swig_this() const {
1423 if (!types.size())
1424 return (size_t) this;
1425 return (size_t) types[0].second.ptr;
1426 }
1427 const char* help_text() const {
1428 if (!types.size())
1429 return 0;
1430 if (!types[0].first->clientdata)
1431 return 0;
1432 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1433 return c->constructor_doc;
1434 }
1435
1436 std::string swig_type_name() const {
1437 // * need some way to manually name subclasses.
1438 // * eg optional first arg to subclass(), or named_subclass()
1439 std::string ret;
1440 for (unsigned int j = 0; j < types.size(); ++j) {
1441 if (j)
1442 ret += "_";
1443 if (types[j].first->clientdata) {
1444 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1445 ret += c->name;
1446 } else
1447 ret += types[j].first->name;
1448 }
1449 return ret;
1450 }
1451
1453 rhs.own = 0;
1454 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1455 assert(!rhs.types[j].second.destroyed);
1456#ifdef SWIG_DIRECTORS
1457 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1458 if (d)
1459 Swig::swig_director_set_self(d, this);
1460#endif
1461 }
1462 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1463 members.insert(rhs.members.begin(), rhs.members.end());
1464#if SWIG_OCTAVE_PREREQ(4,4,0)
1465 assign(rhs.swig_type_name(), rhs.as_value());
1466#else
1467 rhs.types.clear();
1468 rhs.members.clear();
1469#endif
1470 }
1471
1472 typedef member_map::const_iterator swig_member_const_iterator;
1475
1476 int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1477 int res = SWIG_ERROR;
1478 if (_own)
1479 *_own = own;
1480 if (flags &SWIG_POINTER_DISOWN)
1481 own = 0;
1482 if (!type && types.size()) {
1483 if(vptr)
1484 *vptr = types[0].second.ptr;
1485 return SWIG_OK;
1486 }
1487 for (unsigned int j = 0; j < types.size(); ++j)
1488 if (type == types[j].first) {
1489 if(vptr)
1490 *vptr = types[j].second.ptr;
1491 return SWIG_OK;
1492 }
1493 for (unsigned int j = 0; j < types.size(); ++j) {
1494 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1495 if (!tc)
1496 continue;
1497 if(vptr) {
1498 int newmemory = 0;
1499 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1500 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1501 assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1502 if (_own)
1503 *_own = *_own | SWIG_CAST_NEW_MEMORY;
1504 }
1505 }
1506 res = SWIG_OK;
1507 break;
1508 }
1509 return res;
1510 }
1511
1512 bool is_owned() const {
1513 return own;
1514 }
1515
1516#ifdef SWIG_DIRECTORS
1517 void director_destroyed(Swig::Director *d) {
1518 bool found = false;
1519 for (unsigned int j = 0; j < types.size(); ++j) {
1520 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1521 if (dj == d) {
1522 types[j].second.destroyed = true;
1523 found = true;
1524 }
1525 }
1526 assert(found);
1527 }
1528#endif
1529
1530 void assign(const std::string &name, const octave_value &ov) {
1531 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1532 }
1533
1534 void assign(const std::string &name, const swig_octave_member *m) {
1535 members[name] = std::make_pair(m, octave_value());
1536 }
1537
1538 octave_base_value *clone() const {
1539 // pass-by-value is probably not desired, and is harder;
1540 // requires calling copy constructors of contained types etc.
1541 assert(0);
1542 *(int *) 0 = 0;
1543 return 0;
1544 }
1545
1546 octave_base_value *empty_clone() const {
1547 return new octave_swig_type();
1548 }
1549
1550 bool is_defined() const {
1551 return true;
1552 }
1553
1554#if SWIG_OCTAVE_PREREQ(6,0,0)
1555 virtual bool isstruct() const {
1556#else
1557 virtual bool is_map() const {
1558#endif
1559 return true;
1560 }
1561
1562 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1563 octave_value_list ovl = subsref(ops, idx, 1);
1564 return ovl.length()? ovl(0) : octave_value();
1565 }
1566
1567 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1568 assert(ops.size() > 0);
1569 assert(ops.size() == idx.size());
1570
1571 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1572 int skip = 0;
1573 octave_value_list sub_ovl;
1574
1575 // constructor invocation
1576 if (ops[skip] == '(' && construct_type) {
1577 assert(construct_type->clientdata);
1578 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1579 if (!c->constructor) {
1580 error("cannot create instance");
1581 return octave_value_list();
1582 }
1583 octave_value_list args;
1584 if (c->director)
1585 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1586 args.append(*idx_it++);
1587 ++skip;
1588 sub_ovl = c->constructor(args, nargout);
1589 }
1590 // member dereference or invocation
1591 else if (ops[skip] == '.') {
1592 std::string subname;
1593 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1594 for (;;) {
1595 octave_value_list subname_ovl(*idx_it++);
1596 ++skip;
1597 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1598 subname = subname_ovl(0).string_value();
1599
1600 const swig_type_info *next_base = find_base(subname, base);
1601 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1602 break;
1603 base = next_base;
1604 }
1605
1606 member_value_pair tmp, *m = &tmp;
1607 if (!base || !(m->first = find_member(base, subname)))
1608 m = find_member(subname, false);
1609 if (!m) {
1610 error("member not found");
1611 return octave_value_list();
1612 }
1613
1614 octave_value_list args;
1615 if (!always_static &&
1616 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1617 args.append(as_value());
1618 if (skip < (int) ops.size() && ops[skip] == '(' &&
1619 ((m->first && m->first->method) || m->second.is_function() ||
1620 m->second.is_function_handle())) {
1621 args.append(*idx_it++);
1622 ++skip;
1623 sub_ovl = member_invoke(m, args, nargout);
1624 } else {
1625 sub_ovl = member_deref(m, args);
1626 }
1627 }
1628 // index operator
1629 else {
1630 if (ops[skip] == '(' || ops[skip] == '{') {
1631 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1632 octave_value_list args;
1633 args.append(*idx_it++);
1634 ++skip;
1635 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1636 error("error evaluating index operator");
1637 return octave_value_list();
1638 }
1639 } else {
1640 error("unsupported subsref");
1641 return octave_value_list();
1642 }
1643 }
1644
1645 if (skip >= (int) ops.size())
1646 return sub_ovl;
1647 if (sub_ovl.length() < 1) {
1648 error("bad subs ref");
1649 return octave_value_list();
1650 }
1651 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1652 }
1653
1654 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1655 assert(ops.size() > 0);
1656 assert(ops.size() == idx.size());
1657
1658 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1659 int skip = 0;
1660
1661 if (ops.size() > 1) {
1662 std::list < octave_value_list >::const_iterator last = idx.end();
1663 --last;
1664 std::list < octave_value_list > next_idx(idx.begin(), last);
1665 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1666 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1667 }
1668
1669 else if (ops[skip] == '(' || ops[skip] == '{') {
1670 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1671 member_value_pair *m = find_member(op_name, false);
1672 if (m) {
1673 octave_value_list args;
1674 args.append(as_value());
1675 args.append(*idx_it);
1676 args.append(rhs);
1677 member_invoke(m, args, 1);
1678 } else
1679 error("%s member not found", op_name);
1680 }
1681
1682 else if (ops[skip] == '.') {
1683 octave_value_list subname_ovl(*idx_it++);
1684 ++skip;
1685 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1686 std::string subname = subname_ovl(0).string_value();
1687
1688 member_value_pair *m = find_member(subname, true);
1689 if (!m->first || !m->first->set_method) {
1690 m->first = 0;
1691 m->second = rhs;
1692 } else if (m->first->set_method) {
1693 octave_value_list args;
1694 if (!m->first->is_static() && !m->first->is_global())
1695 args.append(as_value());
1696 args.append(rhs);
1697 m->first->set_method(args, 1);
1698 } else
1699 error("member not assignable");
1700 } else
1701 error("unsupported subsasgn");
1702
1703 return as_value();
1704 }
1705
1706#if SWIG_OCTAVE_PREREQ(6,0,0)
1707 virtual bool isobject() const {
1708#else
1709 virtual bool is_object() const {
1710#endif
1711 return true;
1712 }
1713
1714 virtual bool is_string() const {
1715 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1716 return !!nc_this->find_member("__str__", false);
1717 }
1718
1719 virtual std::string string_value(bool force = false) const {
1720 octave_value ret;
1721 if (!dispatch_unary_op("__str__", ret)) {
1722 error("__str__ method not defined");
1723 return std::string();
1724 }
1725 if (!ret.is_string()) {
1726 error("__str__ method did not return a string");
1727 return std::string();
1728 }
1729 return ret.string_value();
1730 }
1731
1732 virtual double scalar_value(bool frc_str_conv = false) const {
1733 octave_value ret;
1734 if (!dispatch_unary_op("__float__", ret)) {
1735 error("__float__ method not defined");
1736 }
1737 return ret.scalar_value();
1738 }
1739
1740#if SWIG_OCTAVE_PREREQ(4,2,0)
1741 virtual octave_value as_double(void) const {
1742 octave_value ret;
1743 if (!dispatch_unary_op("__float__", ret)) {
1744 error("__float__ method not defined");
1745 }
1746 return ret.as_double();
1747 }
1748
1749 virtual octave_value as_single(void) const {
1750 octave_value ret;
1751 if (!dispatch_unary_op("__float__", ret)) {
1752 error("__float__ method not defined");
1753 }
1754 return ret.as_single();
1755 }
1756#endif
1757
1758#if SWIG_OCTAVE_PREREQ(3,8,0)
1759 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1760 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1761 octave_value ret;
1762 if (!dispatch_unary_op(opname, ret)) {
1763 error("%s", (opname + std::string(" method not found")).c_str());
1764 return octave_value();
1765 }
1766 return ret;
1767 }
1768#endif
1769
1770#if SWIG_OCTAVE_PREREQ(3,3,52)
1771 virtual octave_map map_value() const {
1772 return octave_map();
1773 }
1774#else
1775 virtual Octave_map map_value() const {
1776 return Octave_map();
1777 }
1778#endif
1779
1780 virtual string_vector map_keys() const {
1781 member_map tmp;
1782 load_members(tmp);
1783
1784 string_vector keys(tmp.size());
1785 int k = 0;
1786 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1787 keys(k++) = it->first;
1788
1789 return keys;
1790 }
1791
1792 virtual bool save_ascii (std::ostream& os) {
1793 return true;
1794 }
1795
1796 virtual bool load_ascii (std::istream& is) {
1797 return true;
1798 }
1799
1800 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1801 return true;
1802 }
1803
1804 virtual bool load_binary (std::istream& is, bool swap,
1805#if SWIG_OCTAVE_PREREQ(6,0,0)
1806 octave::mach_info::float_format fmt) {
1807#else
1808 oct_mach_info::float_format fmt) {
1809#endif
1810 return true;
1811 }
1812
1813#if defined (HAVE_HDF5)
1814# if SWIG_OCTAVE_PREREQ(4,0,0)
1815 virtual bool
1816 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1817 return true;
1818 }
1819
1820 virtual bool
1821 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1822 return true;
1823 }
1824# else
1825 virtual bool
1826 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1827 return true;
1828 }
1829
1830 virtual bool
1831 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1832 return true;
1833 }
1834# endif
1835#endif
1836
1837 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1838 return string_value();
1839 }
1840
1841 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1842 return string_value();
1843 }
1844
1845 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1846 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1847 // (rather than any module namespace).
1848
1849 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1850 if (!fcn)
1851 return false;
1852#if SWIG_OCTAVE_PREREQ(4,4,0)
1853 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1854 octave_value_list retval = fcn->call(tw, 1, args);
1855 if (retval.length() == 1)
1856 ret = retval(0);
1857#else
1858 ret = fcn->do_multi_index_op(1, args)(0);
1859#endif
1860 return true;
1861 }
1862
1863 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1865 assert(ost);
1866
1867 octave_value ret;
1868 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1869 return ret;
1870 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1871 octave_value_list args;
1872 args.append(make_value_hack(x));
1873 if (dispatch_global_op(symbol, args, ret))
1874 return ret;
1875
1876 error("could not dispatch unary operator");
1877 return octave_value();
1878 }
1879
1880 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1883
1884 octave_value ret;
1885 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1886 return ret;
1887 if (rhs_ost) {
1888 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1889 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1890 return ret;
1891 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1892 return ret;
1893 }
1894 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1895 return ret;
1896 }
1897
1898 std::string symbol;
1899 octave_value_list args;
1900 args.append(make_value_hack(lhs));
1901 args.append(make_value_hack(rhs));
1902
1903 symbol = SWIG_op_prefix;
1904 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1905 symbol += "_";
1906 symbol += op_name;
1907 symbol += "_";
1908 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1909 if (dispatch_global_op(symbol, args, ret))
1910 return ret;
1911
1912 symbol = SWIG_op_prefix;
1913 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1914 symbol += "_";
1915 symbol += op_name;
1916 symbol += "_";
1917 symbol += "any";
1918 if (dispatch_global_op(symbol, args, ret))
1919 return ret;
1920
1921 symbol = SWIG_op_prefix;
1922 symbol += "any";
1923 symbol += "_";
1924 symbol += op_name;
1925 symbol += "_";
1926 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1927 if (dispatch_global_op(symbol, args, ret))
1928 return ret;
1929
1930 error("could not dispatch binary operator");
1931 return octave_value();
1932 }
1933
1934#if SWIG_OCTAVE_PREREQ(4,0,0)
1935 void print(std::ostream &os, bool pr_as_read_syntax = false)
1936#else
1937 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1938#endif
1939 {
1940 if (is_string()) {
1941 os << string_value();
1942 return;
1943 }
1944
1945 member_map tmp;
1946 load_members(tmp);
1947
1948 indent(os);
1949 os << "{"; newline(os);
1950 increment_indent_level();
1951 for (unsigned int j = 0; j < types.size(); ++j) {
1952 indent(os);
1953 if (types[j].first->clientdata) {
1954 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1955 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1956 } else {
1957 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1958 }
1959 }
1960 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1961 indent(os);
1962 if (it->second.first) {
1963 const char *objtype = it->second.first->method ? "method" : "variable";
1964 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1965 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1966 assert(it->second.first->name == it->first);
1967 } else {
1968 os << it->first; newline(os);
1969 }
1970 }
1971 decrement_indent_level();
1972 indent(os);
1973 os << "}"; newline(os);
1974 }
1975 };
1976
1977 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1978 // will call clone() via make_unique() if there is more than one outstanding
1979 // reference to the lhs, and forces the clone's reference count to 1
1980 // (so you can't just increment your own count and return this).
1981 //
1982 // One way to fix this (without modifying Octave) is to add a level of
1983 // indirection such that clone copies ref-counted pointer and we keep
1984 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1985 //
1986 // Supporting both pass-by-{ref,value} and toggling via %feature/option
1987 // might be nice.
1988
1989 class octave_swig_ref:public octave_base_value {
1991 public:
1993 :ptr(_ptr)
1994 {
1995 // Ensure type_id() is set correctly
1996 if (t_id == -1) {
1997 t_id = octave_swig_ref::static_type_id();
1998 }
1999 }
2000
2002 { if (ptr) ptr->decref(); }
2003
2005 { return ptr; }
2006
2007 octave_base_value *clone() const
2008 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2009
2010 octave_base_value *empty_clone() const
2011 { return new octave_swig_ref(0); }
2012
2013 dim_vector dims(void) const
2014 { return ptr->dims(); }
2015
2016 bool is_defined() const
2017 { return ptr->is_defined(); }
2018
2019#if SWIG_OCTAVE_PREREQ(6,0,0)
2020 virtual bool isstruct() const
2021 { return ptr->isstruct(); }
2022#else
2023 virtual bool is_map() const
2024 { return ptr->is_map(); }
2025#endif
2026
2027 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2028 { return ptr->subsref(ops, idx); }
2029
2030 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2031 { return ptr->subsref(ops, idx, nargout); }
2032
2033 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2034 { return ptr->subsasgn(ops, idx, rhs); }
2035
2036#if SWIG_OCTAVE_PREREQ(6,0,0)
2037 virtual bool isobject() const
2038 { return ptr->isobject(); }
2039#else
2040 virtual bool is_object() const
2041 { return ptr->is_object(); }
2042#endif
2043
2044 virtual bool is_string() const
2045 { return ptr->is_string(); }
2046
2047 virtual std::string string_value(bool force = false) const
2048 { return ptr->string_value(force); }
2049
2050 virtual double scalar_value(bool frc_str_conv = false) const
2051 { return ptr->scalar_value(frc_str_conv); }
2052
2053#if SWIG_OCTAVE_PREREQ(4,2,0)
2054 virtual octave_value as_double(void) const
2055 { return ptr->as_double(); }
2056
2057 virtual octave_value as_single(void) const
2058 { return ptr->as_single(); }
2059#endif
2060
2061#if SWIG_OCTAVE_PREREQ(3,8,0)
2062 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2063 { return ptr->map(umap); }
2064#endif
2065
2066#if SWIG_OCTAVE_PREREQ(3,3,52)
2067 virtual octave_map map_value() const
2068 { return ptr->map_value(); }
2069#else
2070 virtual Octave_map map_value() const
2071 { return ptr->map_value(); }
2072#endif
2073
2074 virtual string_vector map_keys() const
2075 { return ptr->map_keys(); }
2076
2077 virtual bool save_ascii (std::ostream& os)
2078 { return ptr->save_ascii(os); }
2079
2080 virtual bool load_ascii (std::istream& is)
2081 { return ptr->load_ascii(is); }
2082
2083 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2084 { return ptr->save_binary(os, save_as_floats); }
2085
2086 virtual bool load_binary (std::istream& is, bool swap,
2087#if SWIG_OCTAVE_PREREQ(6,0,0)
2088 octave::mach_info::float_format fmt)
2089#else
2090 oct_mach_info::float_format fmt)
2091#endif
2092 { return ptr->load_binary(is, swap, fmt); }
2093
2094#if defined (HAVE_HDF5)
2095# if SWIG_OCTAVE_PREREQ(4,0,0)
2096 virtual bool
2097 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2098 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2099
2100 virtual bool
2101 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2102 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2103# else
2104 virtual bool
2105 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2106 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2107
2108 virtual bool
2109 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2110 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2111# endif
2112#endif
2113
2114 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2115 { return ptr->convert_to_str(pad, force, type); }
2116
2117 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2118 { return ptr->convert_to_str_internal(pad, force, type); }
2119
2120#if SWIG_OCTAVE_PREREQ(4,0,0)
2121 void print(std::ostream &os, bool pr_as_read_syntax = false)
2122#else
2123 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2124#endif
2125 { return ptr->print(os, pr_as_read_syntax); }
2126
2127#if SWIG_OCTAVE_PREREQ(4,4,0)
2128 static void set_type_id(int type_id) { t_id=type_id; }
2129#endif
2130
2131 virtual type_conv_info numeric_conversion_function(void) const {
2132 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2133 octave_scalar::static_type_id ());
2134 }
2135
2136 private:
2137 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2138 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2139 return new octave_scalar(v.scalar_value());
2140 }
2141
2142#if !SWIG_OCTAVE_PREREQ(4,0,0)
2144#endif
2146 };
2147#if !SWIG_OCTAVE_PREREQ(4,0,0)
2149#endif
2151
2152 class octave_swig_packed:public octave_base_value {
2154 std::vector < char > buf;
2155 public:
2156
2157 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2158 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2159 {
2160 // Ensure type_id() is set correctly
2161 if (t_id == -1) {
2162 t_id = octave_swig_packed::static_type_id();
2163 }
2164 }
2165
2166 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2167 if (outtype && outtype != type)
2168 return false;
2169 assert(sz <= buf.size());
2170 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2171 return true;
2172 }
2173
2174 octave_base_value *clone() const {
2175 return new octave_swig_packed(*this);
2176 }
2177
2178 octave_base_value *empty_clone() const {
2179 return new octave_swig_packed();
2180 }
2181
2182 bool is_defined() const {
2183 return true;
2184 }
2185
2186#if SWIG_OCTAVE_PREREQ(4,0,0)
2187 void print(std::ostream &os, bool pr_as_read_syntax = false)
2188#else
2189 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2190#endif
2191 {
2192 indent(os);
2193 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2194 }
2195
2196
2197 virtual bool save_ascii (std::ostream& os) {
2198 return true;
2199 }
2200
2201 virtual bool load_ascii (std::istream& is) {
2202 return true;
2203 }
2204
2205 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2206 return true;
2207 }
2208
2209 virtual bool load_binary (std::istream& is, bool swap,
2210#if SWIG_OCTAVE_PREREQ(6,0,0)
2211 octave::mach_info::float_format fmt) {
2212#else
2213 oct_mach_info::float_format fmt) {
2214#endif
2215 return true;
2216 }
2217
2218#if defined (HAVE_HDF5)
2219# if SWIG_OCTAVE_PREREQ(4,0,0)
2220 virtual bool
2221 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2222 return true;
2223 }
2224
2225 virtual bool
2226 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2227 return true;
2228 }
2229# else
2230 virtual bool
2231 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2232 return true;
2233 }
2234
2235 virtual bool
2236 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2237 return true;
2238 }
2239# endif
2240#endif
2241
2242#if SWIG_OCTAVE_PREREQ(4,4,0)
2243 static void set_type_id(int type_id) { t_id=type_id; }
2244#endif
2245
2246 private:
2247#if !SWIG_OCTAVE_PREREQ(4,0,0)
2249#endif
2251 };
2252#if !SWIG_OCTAVE_PREREQ(4,0,0)
2254#endif
2256
2257 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2258 error("attempt to set immutable member variable");
2259 return octave_value_list();
2260 }
2261
2263 const octave_value_list &ovl;
2264 int j;
2265
2266 octave_value_ref(const octave_value_list &_ovl, int _j)
2267 :ovl(_ovl), j(_j) { }
2268
2269 operator octave_value() const {
2270 return ovl(j);
2271 }
2272
2273 octave_value operator*() const {
2274 return ovl(j);
2275 }
2276 };
2277
2278
2279namespace Swig {
2280
2282 return new octave_swig_ref(ost);
2283 }
2284
2286 if (
2287#if SWIG_OCTAVE_PREREQ(4,4,0)
2288 ov.iscell()
2289#else
2290 ov.is_cell()
2291#endif
2292 && ov.rows() == 1 && ov.columns() == 1)
2293 ov = ov.cell_value()(0);
2294 return swig_value_deref(*ov.internal_rep());
2295 }
2296
2297 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2298 if (ov.type_id() != octave_swig_ref::static_type_id())
2299 return 0;
2300 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2301 return osr->get_ptr();
2302 }
2303
2304}
2305
2306
2307#define swig_unary_op(name) \
2308SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2309 return octave_swig_type::dispatch_unary_op(x,#name); \
2310}
2311#define swig_binary_op(name) \
2312SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2313 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2314}
2315#if SWIG_OCTAVE_PREREQ(4,4,0)
2316#define swigreg_unary_op(name) \
2317if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2318typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2319#else
2320#define swigreg_unary_op(name) \
2321if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2322octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2323#endif
2324#if SWIG_OCTAVE_PREREQ(4,4,0)
2325#define swigreg_binary_op(name) \
2326if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2327typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2328#else
2329#define swigreg_binary_op(name) \
2330if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2331octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2332#endif
2333
2337 swig_unary_op(transpose);
2338 swig_unary_op(hermitian);
2341
2348#if !SWIG_OCTAVE_PREREQ(4,2,0)
2351#endif
2364
2366#if SWIG_OCTAVE_PREREQ(4,4,0)
2367 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2368#endif
2369 swigreg_unary_op(not);
2370 swigreg_unary_op(uplus);
2371 swigreg_unary_op(uminus);
2372 swigreg_unary_op(transpose);
2373 swigreg_unary_op(hermitian);
2374 swigreg_unary_op(incr);
2375 swigreg_unary_op(decr);
2376 }
2377 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2378#if SWIG_OCTAVE_PREREQ(4,4,0)
2379 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2380#endif
2381 swigreg_binary_op(add);
2382 swigreg_binary_op(sub);
2383 swigreg_binary_op(mul);
2384 swigreg_binary_op(div);
2385 swigreg_binary_op(pow);
2386 swigreg_binary_op(ldiv);
2387#if !SWIG_OCTAVE_PREREQ(4,2,0)
2388 swigreg_binary_op(lshift);
2389 swigreg_binary_op(rshift);
2390#endif
2397 swigreg_binary_op(el_mul);
2398 swigreg_binary_op(el_div);
2399 swigreg_binary_op(el_pow);
2400 swigreg_binary_op(el_ldiv);
2401 swigreg_binary_op(el_and);
2402 swigreg_binary_op(el_or);
2403 }
2405 // here we assume that tid are conseq integers increasing from zero, and
2406 // that our tid is the last one. might be better to have explicit string
2407 // list of types we should bind to, and use lookup_type to resolve their tid.
2408
2410 SWIG_InstallBinaryOps(tid, tid);
2411 for (int j = 0; j < tid; ++j) {
2412 SWIG_InstallBinaryOps(j, tid);
2413 SWIG_InstallBinaryOps(tid, j);
2414 }
2415 }
2416
2417SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2418 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2419
2420#ifdef SWIG_DIRECTORS
2421 Swig::Director *d = Swig::get_rtdir(ptr);
2422 if (d && Swig::swig_director_get_self(d))
2423 return Swig::swig_director_get_self(d)->as_value();
2424#endif
2425 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2426}
2427
2428SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2429 if (
2430#if SWIG_OCTAVE_PREREQ(4,4,0)
2431 ov.iscell()
2432#else
2433 ov.is_cell()
2434#endif
2435 && ov.rows() == 1 && ov.columns() == 1)
2436 ov = ov.cell_value()(0);
2437 if (!ov.is_defined() ||
2438 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2439 if (ptr)
2440 *ptr = 0;
2442 }
2443 if (ov.type_id() != octave_swig_ref::static_type_id())
2444 return SWIG_ERROR;
2445 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2446 octave_swig_type *ost = osr->get_ptr();
2447 return ost->cast(ptr, type, own, flags);
2448}
2449
2450SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2451 return new octave_swig_packed(type, (char *) ptr, sz);
2452}
2453
2454SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2455 if (!ov.is_defined())
2456 return SWIG_ERROR;
2457 if (ov.type_id() != octave_swig_packed::static_type_id())
2458 return SWIG_ERROR;
2459 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2460 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2461}
2462
2463SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2464 module_ns->assign(name, ov);
2465}
2466
2468#if SWIG_OCTAVE_PREREQ(6,0,0)
2469 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2470 return interp->global_varval(name);
2471#else
2472#if SWIG_OCTAVE_PREREQ(4,4,0)
2473 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2474 return symtab.global_varval(name);
2475#else
2476 return get_global_value(name, true);
2477#endif
2478#endif
2479}
2480
2481SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2482#if SWIG_OCTAVE_PREREQ(6,0,0)
2483 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2484 interp->global_assign(name, value);
2485#elif SWIG_OCTAVE_PREREQ(4,4,0)
2486 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2487 symtab.global_assign(name, value);
2488#else
2489 set_global_value(name, value);
2490#endif
2491}
2492
2494#if SWIG_OCTAVE_PREREQ(4,4,0)
2495 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2496#if SWIG_OCTAVE_PREREQ(6,0,0)
2497 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2498 interp->assign(name, interp->global_varval(name));
2499 octave::tree_evaluator& tree_eval = interp->get_evaluator();
2500 octave::call_stack& callStack = tree_eval.get_call_stack();
2501 std::shared_ptr<octave::stack_frame> stackFrame = callStack.get_current_stack_frame();
2502 octave::symbol_record sym=symscope.lookup_symbol(name);
2503 stackFrame->mark_global(sym);
2504#else
2505 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2506 symscope.assign(name, symtab.global_varval(name));
2507 symscope.mark_global(name);
2508#endif
2509#else
2510#if !SWIG_OCTAVE_PREREQ(3,2,0)
2511 link_to_global_variable(curr_sym_tab->lookup(name, true));
2512#else
2513#if !SWIG_OCTAVE_PREREQ(3,8,0)
2514 symbol_table::varref(name);
2515#endif
2516 symbol_table::mark_global(name);
2517#endif
2518#endif
2519}
2520
2522 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2523 if (!ov.is_defined() ||
2524 ov.type_id() != octave_swig_packed::static_type_id())
2525 return 0;
2526 const octave_swig_packed* osp =
2527 static_cast < const octave_swig_packed *> (ov.internal_rep());
2528 swig_module_info *pointer = 0;
2529 osp->copy(0, &pointer, sizeof(swig_module_info *));
2530 return pointer;
2531}
2532
2533SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2534 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2536}
2537
2538
2539
2540#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2541
2542#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2543
2544
2545
2546/* -------- TYPES TABLE (BEGIN) -------- */
2547
2548#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2549#define SWIGTYPE_p_char swig_types[1]
2550#define SWIGTYPE_p_double swig_types[2]
2551#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2552#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2553#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2554#define SWIGTYPE_p_int swig_types[6]
2555#define SWIGTYPE_p_p_char swig_types[7]
2556#define SWIGTYPE_p_unsigned_int swig_types[8]
2558static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2559#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2560#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2561
2562/* -------- TYPES TABLE (END) -------- */
2563
2564
2565#define SWIGVERSION 0x040002
2566#define SWIG_VERSION SWIGVERSION
2567
2568
2569#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2570#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2571
2572
2573#include <stdexcept>
2574
2575
2576// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2577#undef PACKAGE
2578#undef VERSION
2579
2580#include "plplotP.h"
2581
2582// Temporary fix for problems with -fvisibility=hidden and octave headers.
2583#ifdef OCTAVE_EXPORT
2584 #if defined ( __GNUC__ ) && __GNUC__ > 3
2585 #undef OCTAVE_EXPORT
2586 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2587 #endif
2588#endif
2589
2590
2591
2592// I hate global variables but this is the best way I can think of
2593// to manage consistency checking among function arguments.
2594 static PLINT Alen = 0;
2595 static PLINT Xlen = 0, Ylen = 0;
2596
2597
2598// Convenience functions copied from matwrap-based approach (currently
2599// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2600// tricky scalar case and also adopted so that the resulting
2601// swig-generated source code will look similar to the matwrap-generated
2602// source code.
2603
2604 inline int max( int a, int b )
2605 {
2606 return a >= b ? a : b;
2607 }
2608 inline int min( int a, int b )
2609 {
2610 return a >= b ? a : b;
2611 }
2612
2613//
2614// Function to get the total length (rows*columns) of an octave object of
2615// arbitrary type.
2616// Arguments:
2617// 1) The octave object.
2618//
2619// If the object is a scalar, the array length is 1.
2620//
2621 static int
2622 _arraylen( const octave_value &o_obj )
2623 {
2624 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2625 // max is necessary because sometimes
2626 // rows() or columns() return -1 or 0 for
2627 // scalars.
2628 }
2629
2630//
2631// Function to get the number of dimensions of an object.
2632//
2633 static int
2634 _n_dims( const octave_value &o_obj )
2635 {
2636 if ( max( o_obj.columns(), 1 ) > 1 )
2637 return 2;
2638 // max is necessary because sometimes
2639 // rows() or columns() return -1 or 0 for
2640 // scalars.
2641 else if ( max( o_obj.rows(), 1 ) > 1 )
2642 return 1;
2643 else
2644 return 0;
2645 }
2646
2647//
2648// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2649//
2650 static inline int
2651 _dim( const octave_value &o_obj, int dim_idx )
2652 {
2653 if ( dim_idx == 0 )
2654 return max( o_obj.rows(), 0 );
2655 // max is necessary because sometimes
2656 // rows() or columns() return -1 or 0 for
2657 // scalars.
2658 else if ( dim_idx == 1 )
2659 return max( o_obj.columns(), 0 );
2660 else
2661 return 1;
2662 }
2663
2664//
2665// The following function converts an array of doubles into some other
2666// numeric type. Arguments:
2667// 1) Where to store the result. The type is determined from the type of
2668// this pointer.
2669// 2) A vector of doubles to convert.
2670// 3) The number of doubles.
2671//
2672 template <class FLOAT>
2673 static inline void
2674 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2675 {
2676 while ( n_el-- > 0 )
2677 *out_arr++ = (FLOAT) ( *in_arr++ );
2678 }
2679
2680 template void _cvt_double_to( int *, double *, unsigned );
2681 template void _cvt_double_to( unsigned *, double *, unsigned );
2682 template void _cvt_double_to( long *, double *, unsigned );
2683 template void _cvt_double_to( unsigned long *, double *, unsigned );
2684 template void _cvt_double_to( short *, double *, unsigned );
2685 template void _cvt_double_to( unsigned short *, double *, unsigned );
2686 template void _cvt_double_to( float *, double *, unsigned );
2687 // Instantiate our templates. Octave uses
2688 // manual template instantiation.
2689
2690//
2691// Convert an array of some other type into an array of doubles. Arguments:
2692// 1) The array of objects of other type.
2693// 2) The output array of doubles.
2694// 3) The number of elements to convert.
2695//
2696 template <class FLOAT>
2697 static inline void
2698 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2699 {
2700 while ( n_el-- > 0 )
2701 *d_arr++ = double(*arr++);
2702 }
2703
2704 template void _cvt_to_double( int *, double *, unsigned );
2705 template void _cvt_to_double( unsigned *, double *, unsigned );
2706 template void _cvt_to_double( long *, double *, unsigned );
2707 template void _cvt_to_double( unsigned long *, double *, unsigned );
2708 template void _cvt_to_double( short *, double *, unsigned );
2709 template void _cvt_to_double( unsigned short *, double *, unsigned );
2710 template void _cvt_to_double( float *, double *, unsigned );
2711 // Instantiate our templates. Octave uses
2712 // manual template instantiation.
2713
2714
2715 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2716 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2717 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2718 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2719 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2721 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2722
2723
2724#include <iostream>
2725
2726 octave_function *fcnMapForm;
2727 std::string nameMapForm;
2728
2730 {
2731 octave_idx_type i;
2732 octave_value_list functionArguments;
2733 octave_value_list retval;
2734
2735 Matrix xin( n, 1 );
2736 Matrix yin( n, 1 );
2737 Matrix xout;
2738 Matrix yout;
2739
2740 for ( i = 0; i < n; i++ )
2741 {
2742 xin( i, 0 ) = x[i];
2743 yin( i, 0 ) = y[i];
2744 }
2745
2746 functionArguments( 0 ) = xin;
2747 functionArguments( 1 ) = yin;
2748
2749 if ( fcnMapForm != NULL )
2750#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2751 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2752#else
2753 retval = feval( fcnMapForm, functionArguments, 1 );
2754#endif
2755 else
2756#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2757 retval = octave::feval( nameMapForm, functionArguments, 1 );
2758#else
2759 retval = feval( nameMapForm, functionArguments, 1 );
2760#endif
2761
2762 if ( retval.length() >= 2 )
2763 {
2764 xout = retval( 0 ).matrix_value();
2765 yout = retval( 1 ).matrix_value();
2766
2767 for ( i = 0; i < n; i++ )
2768 {
2769 x[i] = xout( i, 0 );
2770 y[i] = yout( i, 0 );
2771 }
2772 }
2773 }
2774
2775
2776 octave_function *fcnLabelFunc;
2777 std::string nameLabelFunc;
2778
2779 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2780 {
2781 int i;
2782 octave_value_list functionArguments;
2783 octave_value_list retval;
2784
2785 Matrix inAxis( 1, 1 );
2786 Matrix inValue( 1, 1 );
2787 inAxis( 0, 0 ) = axis;
2788 inValue( 0, 0 ) = value;
2789
2790 functionArguments( 0 ) = inAxis;
2791 functionArguments( 1 ) = inValue;
2792
2793 if ( fcnLabelFunc != NULL )
2794#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2795 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2796#else
2797 retval = feval( fcnLabelFunc, functionArguments, 1 );
2798#endif
2799 else
2800#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2801 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2802#else
2803 retval = feval( nameLabelFunc, functionArguments, 1 );
2804#endif
2805
2806 strncpy( label, retval( 0 ).string_value().c_str(), length );
2807 }
2808
2809
2810 octave_function *fcnCoordTrans;
2811 std::string nameCoordTrans;
2812
2813 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2814 {
2815 octave_idx_type i;
2816 octave_value_list functionArguments;
2817 octave_value_list retval;
2818
2819 Matrix xin( 1, 1 );
2820 Matrix yin( 1, 1 );
2821 Matrix xout;
2822 Matrix yout;
2823
2824 xin( 0, 0 ) = x;
2825 yin( 0, 0 ) = y;
2826
2827 functionArguments( 0 ) = xin;
2828 functionArguments( 1 ) = yin;
2829
2830 if ( fcnCoordTrans != NULL )
2831#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2832 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2833#else
2834 retval = feval( fcnCoordTrans, functionArguments, 1 );
2835#endif
2836 else
2837#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2838 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2839#else
2840 retval = feval( nameCoordTrans, functionArguments, 1 );
2841#endif
2842
2843 if ( retval.length() >= 2 )
2844 {
2845 xout = retval( 0 ).matrix_value();
2846 yout = retval( 1 ).matrix_value();
2847
2848 *xt = xout( 0, 0 );
2849 *yt = yout( 0, 0 );
2850 }
2851 }
2852
2853
2854 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2855 {
2856 PLINT i;
2857 printf( "nlegend =%d\n", nlegend );
2858 for ( i = 0; i < nlegend; i++ )
2859 {
2860 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2861 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2862 printf( "text[%d] =%s\n", i, text[i] );
2863 }
2864 }
2865
2866
2867#include <limits.h>
2868#if !defined(SWIG_NO_LLONG_MAX)
2869# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2870# define LLONG_MAX __LONG_LONG_MAX__
2871# define LLONG_MIN (-LLONG_MAX - 1LL)
2872# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2873# endif
2874#endif
2875
2876
2877 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2878 {
2879 if (!ov.is_scalar_type())
2880 return SWIG_TypeError;
2881 if (ov.is_complex_scalar())
2882 return SWIG_TypeError;
2883 if (ov.is_double_type()||ov.is_single_type()) {
2884 double v=ov.double_value();
2885 if (v!=floor(v))
2886 return SWIG_TypeError;
2887 }
2888 if (val)
2889 *val = ov.long_value();
2890 return SWIG_OK;
2891 }
2892
2893
2894SWIGINTERN int
2895SWIG_AsVal_int (octave_value obj, int *val)
2896{
2897 long v;
2898 int res = SWIG_AsVal_long (obj, &v);
2899 if (SWIG_IsOK(res)) {
2900 if ((v < INT_MIN || v > INT_MAX)) {
2901 return SWIG_OverflowError;
2902 } else {
2903 if (val) *val = static_cast< int >(v);
2904 }
2905 }
2906 return res;
2907}
2908
2909
2910 static int my_plGetCursor( int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin )
2911 {
2912 PLGraphicsIn gin;
2913 int status; status = plGetCursor( &gin );
2914 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2915 strncpy( string, gin.string, PL_MAXKEY - 1 );
2916 string[PL_MAXKEY - 1] = '\0';
2917
2918 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2919 return status;
2920 }
2921
2922
2923SWIGINTERN int
2924SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2925{
2926 if (
2927#if SWIG_OCTAVE_PREREQ(4,4,0)
2928 ov.iscell()
2929#else
2930 ov.is_cell()
2931#endif
2932 && ov.rows() == 1 && ov.columns() == 1)
2933 ov = ov.cell_value()(0);
2934 if (!ov.is_string())
2935 return SWIG_TypeError;
2936
2937 std::string str=ov.string_value();
2938 size_t len=str.size();
2939 char* cstr=(char*)str.c_str();
2940 if (alloc) {
2941 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2942 *alloc = SWIG_NEWOBJ;
2943 } else if (cptr)
2944 *cptr = cstr;
2945 if (psize)
2946 *psize = len + 1;
2947 return SWIG_OK;
2948}
2949
2950
2951
2952
2953
2955 {
2956 return octave_value(value);
2957 }
2958
2959
2960SWIGINTERNINLINE octave_value
2962{
2963 return SWIG_From_long (value);
2964}
2965
2966
2968 {
2969 return octave_value(value);
2970 }
2971
2972
2973// Translates relative device coordinates to world coordinates.
2974 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2975 {
2976 PLGraphicsIn gin;
2977 int st;
2978 gin.dX = x_in; gin.dY = y_in;
2979 st = plTranslateCursor( &gin );
2980 *x = gin.wX; *y = gin.wY;
2981 return st;
2982 }
2983
2984
2985 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2986 {
2987 if (!ov.is_scalar_type())
2988 return SWIG_TypeError;
2989 if (ov.is_complex_scalar())
2990 return SWIG_TypeError;
2991 if (val)
2992 *val = ov.double_value();
2993 return SWIG_OK;
2994 }
2995
2996
2997// Create 1d stripchart
2998
2999 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3000 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3001 PLFLT xlpos, PLFLT ylpos,
3002 PLBOOL y_ascl, PLBOOL acc,
3003 PLINT colbox, PLINT collab,
3004 const PLINT *colline, const PLINT *styline,
3005 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3006 const char *labx, const char *laby, const char *labtop )
3007 {
3008 const char *legline[4];
3009 legline[0] = legline1; legline[1] = legline2;
3010 legline[2] = legline3; legline[3] = legline4;
3011 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3012 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3013 labx, laby, labtop );
3014 }
3015
3016
3017// One more hack. As it is not possible (and would not be desirable) to pass
3018// an Octave function to plcont(), I have defined three plcont():
3019// plcont uses a defined here xform()
3020// plcont0 uses pltr0()
3021// plcont1 uses pltr1()
3022// plcont2 uses pltr2()
3023// plcont2p uses pltr2p()
3024//
3025// Also, as plplot expect vectorized bidimensional arrays, I provided a
3026// f2c, which is a #define that does the necessary conversion.
3027//
3028
3029 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3030 {
3031 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3032 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3033 }
3034
3035// convert from Fortran like arrays (one vector), to C like 2D arrays
3036
3037#define f2c( f, ff, nx, ny ) \
3038 PLFLT * *ff; \
3039 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3040 for ( int i = 0; i < nx; i++ ) { \
3041 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3042 for ( int j = 0; j < ny; j++ ) \
3043 *( ff[i] + j ) = *( f + nx * j + i );}
3044
3045// simpler plcont() for use with xform()
3046
3047 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3048 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3049 {
3050 f2c( f, ff, nx, ny );
3051 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3052 }
3053
3054// plcont() for use with pltr0() NOT TESTED
3055
3056 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3057 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3058 {
3059 f2c( f, ff, nx, ny );
3060 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3061 }
3062
3063// plcont() for use with pltr1()
3064
3065 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3066 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3067 {
3068 PLcGrid grid1;
3069 grid1.nx = nx; grid1.ny = ny;
3070 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3071 f2c( f, ff, nx, ny );
3072 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3073 }
3074
3075// plcont() for use with pltr2()
3076 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3077 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3078 {
3079 PLcGrid2 grid2;
3080 f2c( xg, xgg, nx, ny );
3081 f2c( yg, ygg, nx, ny );
3082 grid2.nx = nx; grid2.ny = ny;
3083 grid2.xg = xgg; grid2.yg = ygg;
3084 f2c( f, ff, nx, ny );
3085 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3086 }
3087
3088// plcont() for use with pltr2p()
3089
3090 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3091 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3092 {
3093 PLcGrid2 grid2;
3094 f2c( xg, xgg, nx, ny );
3095 f2c( yg, ygg, nx, ny );
3096 grid2.nx = nx; grid2.ny = ny;
3097 grid2.xg = xgg; grid2.yg = ygg;
3098 f2c( f, ff, nx, ny );
3099 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3100 }
3101
3102
3103 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3104 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3105 PLFLT *zg, int type, PLFLT data )
3106 {
3107 f2c( zg, zgg, nptsx, nptsy );
3108 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3109 for ( int i = 0; i < nptsx; i++ )
3110 for ( int j = 0; j < nptsy; j++ )
3111 *( zg + nptsx * j + i ) = zgg[i][j];
3112 }
3113
3114
3115// Plots a mesh representation of the function z[x][y].
3116
3117 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3118 {
3119 f2c( z, zz, nx, ny );
3120 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3121 }
3122
3123// Plots a mesh representation of the function z[x][y] with contour
3124
3125 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3126 {
3127 f2c( z, zz, nx, ny );
3128 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3129 }
3130
3131
3132// Plots a 3-d representation of the function z[x][y].
3133 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3134 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3135 {
3136 f2c( z, zz, nx, ny );
3137 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3138 }
3139
3140// Plots a 3-d representation of the function z[x][y] with contour
3141 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3142 PLINT nx, PLINT ny, PLINT opt,
3143 const PLFLT *clevel, PLINT nlevel )
3144 {
3145 f2c( z, zz, nx, ny );
3146 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3147 }
3148// Plots a 3-d representation of the function z[x][y] with contour with y
3149// index limits
3150 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3151 PLINT nx, PLINT ny, PLINT opt,
3152 const PLFLT * clevel, PLINT nlevel,
3153 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3154 {
3155 f2c( z, zz, nx, ny );
3156 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3157 indexxmin, indexxmax, indexymin, indexymax );
3158 }
3159
3160
3161 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3162 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3163 {
3164 f2c( z, zz, nx, ny );
3165 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3166 }
3167
3168 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3169 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3170 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3171 {
3172 f2c( z, zz, nx, ny );
3173 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3174 indexxmin, indexxmax, indexymin, indexymax );
3175 }
3176
3177
3178// The same as in plcont. I have hardcoded the first function pointer
3179// to plfill(). The second function pointer will use the same convention
3180// as in plcont().
3181//
3182
3183// the simpler plshade()
3184 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3185 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3186 PLFLT shade_min, PLFLT shade_max,
3187 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3188 PLINT min_color, PLINT min_width,
3189 PLINT max_color, PLINT max_width,
3190 PLINT rectangular, PLFLT *tr )
3191 {
3192 f2c( a, aa, nx, ny );
3193 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3194 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3195 min_color, min_width, max_color, max_width,
3196 plfill, rectangular, xform, tr );
3197 }
3198
3199// plshade() for use with pltr1
3200 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3201 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3202 PLFLT shade_min, PLFLT shade_max,
3203 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3204 PLINT min_color, PLINT min_width,
3205 PLINT max_color, PLINT max_width,
3206 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3207 {
3208 PLcGrid grid1;
3209 grid1.nx = nx; grid1.ny = ny;
3210 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3211 f2c( a, aa, nx, ny );
3212 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3213 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3214 min_color, min_width, max_color, max_width,
3215 plfill, rectangular, pltr1, &grid1 );
3216 }
3217
3218// plshade() for use with pltr2
3219 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3220 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3221 PLFLT shade_min, PLFLT shade_max,
3222 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3223 PLINT min_color, PLINT min_width,
3224 PLINT max_color, PLINT max_width,
3225 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3226 {
3227 PLcGrid2 grid2;
3228 f2c( xg, xgg, nx, ny );
3229 f2c( yg, ygg, nx, ny );
3230 grid2.nx = nx; grid2.ny = ny;
3231 grid2.xg = xgg; grid2.yg = ygg;
3232 f2c( a, aa, nx, ny );
3233 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3234 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3235 min_color, min_width, max_color, max_width,
3236 plfill, rectangular, pltr2, &grid2 );
3237 }
3238
3239
3240
3241 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3242 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3243 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3244 PLINT cont_color, PLINT cont_width,
3245 PLINT rectangular )
3246 {
3247 f2c( a, aa, nx, ny );
3248 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3249 clevel, nlevel, fill_width, cont_color, cont_width,
3250 plfill, rectangular, NULL, NULL );
3251 }
3252
3253 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3254 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3255 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3256 PLINT cont_color, PLINT cont_width,
3257 PLINT rectangular, PLFLT *tr )
3258 {
3259 f2c( a, aa, nx, ny );
3260 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3261 clevel, nlevel, fill_width, cont_color, cont_width,
3262 plfill, rectangular, xform, tr );
3263 }
3264
3265 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3266 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3267 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3268 PLINT cont_color, PLINT cont_width,
3269 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3270 {
3271 PLcGrid grid1;
3272 grid1.nx = nx; grid1.ny = ny;
3273 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3274
3275 f2c( a, aa, nx, ny );
3276 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3277 clevel, nlevel, fill_width, cont_color, cont_width,
3278 plfill, rectangular, pltr1, &grid1 );
3279 }
3280
3281 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3282 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3283 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3284 PLINT cont_color, PLINT cont_width,
3285 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3286 {
3287 PLcGrid2 grid2;
3288 f2c( xg, xgg, nx, ny );
3289 f2c( yg, ygg, nx, ny );
3290 grid2.nx = nx; grid2.ny = ny;
3291 grid2.xg = xgg; grid2.yg = ygg;
3292 f2c( a, aa, nx, ny );
3293 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3294 clevel, nlevel, fill_width, cont_color, cont_width,
3295 plfill, rectangular, pltr2, &grid2 );
3296 }
3297
3298
3299// Plot an array of vector arrows - uses the same function pointer
3300// convention as plcont
3301
3302 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3303 {
3304 f2c( u, uu, nx, ny );
3305 f2c( v, vv, nx, ny );
3306 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3307 }
3308
3309// plvect() for use with pltr1
3310 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3311 {
3312 PLcGrid grid1;
3313 grid1.nx = nx; grid1.ny = ny;
3314 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3315 f2c( u, uu, nx, ny );
3316 f2c( v, vv, nx, ny );
3317 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3318 }
3319
3320// plvect() for use with pltr2
3321 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3322 {
3323 PLcGrid2 grid2;
3324 f2c( xg, xgg, nx, ny );
3325 f2c( yg, ygg, nx, ny );
3326 grid2.nx = nx; grid2.ny = ny;
3327 grid2.xg = xgg; grid2.yg = ygg;
3328 f2c( u, uu, nx, ny );
3329 f2c( v, vv, nx, ny );
3330 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3331 }
3332
3333
3334// Plot an image with distortion - uses the same function pointer
3335 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3336 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3337 PLFLT zmin, PLFLT zmax,
3338 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3339 {
3340 f2c( a, aa, nx, ny );
3341 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3342 }
3343
3344// Plot an image with distortion - uses the same function pointer
3345// convention as plcont
3346 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3347 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3348 PLFLT zmin, PLFLT zmax,
3349 PLFLT valuemin, PLFLT valuemax )
3350 {
3351 f2c( a, aa, nx, ny );
3352 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3353 }
3354
3355 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3356 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3357 PLFLT zmin, PLFLT zmax,
3358 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3359 {
3360 f2c( a, aa, nx, ny );
3361 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3362 }
3363
3364// plimagefr() for use with pltr1
3365 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3366 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3367 PLFLT zmin, PLFLT zmax,
3368 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3369 {
3370 PLcGrid grid1;
3371 grid1.nx = nx + 1; grid1.ny = ny + 1;
3372 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3373 f2c( a, aa, nx, ny );
3374 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3375 }
3376
3377// plimagefr() for use with pltr2
3378 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3379 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3380 PLFLT zmin, PLFLT zmax,
3381 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3382 {
3383 PLcGrid2 grid2;
3384 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3385 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3386 grid2.nx = nx + 1; grid2.ny = ny + 1;
3387 grid2.xg = xgg; grid2.yg = ygg;
3388 f2c( a, aa, nx, ny );
3389 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3390 }
3391
3392
3393
3394 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3395 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3396 PLFLT x_length, PLFLT y_length,
3397 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3398 PLFLT low_cap_color, PLFLT high_cap_color,
3399 PLINT cont_color, PLFLT cont_width,
3400 PLINT n_labels, const PLINT *label_opts, const char **label,
3401 PLINT n_axes, const char ** axis_opts,
3402 const PLFLT *ticks, const PLINT *sub_ticks,
3403 const PLINT *n_values, const PLFLT *a )
3404 {
3405 PLINT nx, ny, i;
3406 nx = n_axes;
3407 ny = -1;
3408 for ( i = 0; i < nx; i++ )
3409 if ( n_values[i] > ny )
3410 ny = n_values[i];
3411 f2c( a, aa, nx, ny );
3412 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3413 opt, position, x, y,
3414 x_length, y_length,
3415 bg_color, bb_color, bb_style,
3416 low_cap_color, high_cap_color,
3417 cont_color, cont_width,
3418 n_labels, label_opts, label,
3419 n_axes, axis_opts,
3420 ticks, sub_ticks,
3421 n_values, aa );
3422 }
3423
3424
3425
3426 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3427 {
3428 if (!ov.is_scalar_type())
3429 return SWIG_TypeError;
3430 if (ov.is_complex_scalar())
3431 return SWIG_TypeError;
3432 if (ov.is_double_type()||ov.is_single_type()) {
3433 double v=ov.double_value();
3434 if (v<0)
3435 return SWIG_OverflowError;
3436 if (v!=floor(v))
3437 return SWIG_TypeError;
3438 }
3439 if (ov.is_int8_type()||ov.is_int16_type()||
3440 ov.is_int32_type()) {
3441 long v=ov.long_value();
3442 if (v<0)
3443 return SWIG_OverflowError;
3444 }
3445 if (ov.is_int64_type()) {
3446 long long v=ov.int64_scalar_value().value();
3447 if (v<0)
3448 return SWIG_OverflowError;
3449 }
3450 if (val)
3451 *val = ov.ulong_value();
3452 return SWIG_OK;
3453 }
3454
3455
3456SWIGINTERN int
3457SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3458{
3459 unsigned long v;
3460 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3461 if (SWIG_IsOK(res)) {
3462 if ((v > UINT_MAX)) {
3463 return SWIG_OverflowError;
3464 } else {
3465 if (val) *val = static_cast< unsigned int >(v);
3466 }
3467 }
3468 return res;
3469}
3470
3471
3473 {
3474 return octave_value(value);
3475 }
3476
3477
3478SWIGINTERNINLINE octave_value
3480{
3482}
3483
3484
3485SWIGINTERN int
3486SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3487{
3488 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3489 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3490 if (SWIG_IsOK(res)) {
3491 /* special case of single char conversion when we don't need space for NUL */
3492 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3493 if (csize <= size) {
3494 if (val) {
3495 if (csize) memcpy(val, cptr, csize*sizeof(char));
3496 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3497 }
3498 if (alloc == SWIG_NEWOBJ) {
3499 delete[] cptr;
3500 res = SWIG_DelNewMask(res);
3501 }
3502 return res;
3503 }
3504 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3505 }
3506 return SWIG_TypeError;
3507}
3508
3509
3512{
3513 static int init = 0;
3514 static swig_type_info* info = 0;
3515 if (!init) {
3516 info = SWIG_TypeQuery("_p_char");
3517 init = 1;
3518 }
3519 return info;
3520}
3521
3522
3523SWIGINTERNINLINE octave_value
3524SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3525{
3526 return std::string(carray,carray+size);
3527}
3528
3529
3530SWIGINTERN size_t
3531SWIG_strnlen(const char* s, size_t maxlen)
3532{
3533 const char *p;
3534 for (p = s; maxlen-- && *p; p++)
3535 ;
3536 return p - s;
3537}
3538
3539
3540SWIGINTERN int
3541SWIG_AsVal_char (octave_value obj, char *val)
3542{
3543 int res = SWIG_AsCharArray(obj, val, 1);
3544 if (!SWIG_IsOK(res)) {
3545 long v;
3546 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3547 if (SWIG_IsOK(res)) {
3548 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3549 if (val) *val = static_cast< char >(v);
3550 } else {
3551 res = SWIG_OverflowError;
3552 }
3553 }
3554 }
3555 return res;
3556}
3557
3558static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3559Specify viewport in absolute coordinates\n\
3560\n\
3561DESCRIPTION:\n\
3562\n\
3563 Alternate routine to plvpor for setting up the viewport. This routine\n\
3564 should be used only if the viewport is required to have a definite\n\
3565 size in millimeters. The routine plgspa is useful for finding out the\n\
3566 size of the current subpage.\n\
3567\n\
3568 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3569\n\
3570 This function is used in example 10.\n\
3571\n\
3572\n\
3573\n\
3574SYNOPSIS:\n\
3575\n\
3576plsvpa(xmin, xmax, ymin, ymax)\n\
3577\n\
3578ARGUMENTS:\n\
3579\n\
3580 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3581 viewport from the left-hand edge of the subpage in millimeters.\n\
3582\n\
3583 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3584 viewport from the left-hand edge of the subpage in millimeters.\n\
3585\n\
3586 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3587 viewport from the bottom edge of the subpage in millimeters.\n\
3588\n\
3589 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3590 from the bottom edge of the subpage in millimeters.\n\
3591";
3592static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3593Write text relative to viewport boundaries in 3D plots\n\
3594\n\
3595DESCRIPTION:\n\
3596\n\
3597 Writes text at a specified position relative to the viewport\n\
3598 boundaries. Text may be written inside or outside the viewport, but\n\
3599 is clipped at the subpage boundaries. The reference point of a string\n\
3600 lies along a line passing through the string at half the height of a\n\
3601 capital letter. The position of the reference point along this line\n\
3602 is determined by just, and the position of the reference point\n\
3603 relative to the viewport is set by disp and pos.\n\
3604\n\
3605 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3606\n\
3607 This function is used in example 28.\n\
3608\n\
3609\n\
3610\n\
3611SYNOPSIS:\n\
3612\n\
3613plmtex3(side, disp, pos, just, text)\n\
3614\n\
3615ARGUMENTS:\n\
3616\n\
3617 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3618 the side of the viewport along which the text is to be written.\n\
3619 The string should contain one or more of the following characters:\n\
3620 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3621 only label the X axis, not both the X and Y axes. x: Label the X\n\
3622 axis.\n\
3623 y: Label the Y axis.\n\
3624 z: Label the Z axis.\n\
3625 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3626 For X it is the axis that starts at y-min. For Y it is the\n\
3627 axis that starts at x-min.\n\
3628 s: Label the secondary axis.\n\
3629 v: Draw the text perpendicular to the axis.\n\
3630\n\
3631\n\
3632 disp (PLFLT, input) : Position of the reference point of string,\n\
3633 measured outwards from the specified viewport edge in units of the\n\
3634 current character height. Use negative disp to write within the\n\
3635 viewport.\n\
3636\n\
3637 pos (PLFLT, input) : Position of the reference point of string\n\
3638 along the specified edge, expressed as a fraction of the length of\n\
3639 the edge.\n\
3640\n\
3641 just (PLFLT, input) : Specifies the position of the string relative\n\
3642 to its reference point. If just=0. , the reference point is at\n\
3643 the left and if just=1. , it is at the right of the string. Other\n\
3644 values of just give intermediate justifications.\n\
3645\n\
3646 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3647 written out.\n\
3648";
3649static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3650Set semitransparent cmap1 RGBA colors.\n\
3651\n\
3652DESCRIPTION:\n\
3653\n\
3654 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3655 RGBA vector values. This function also sets the number of cmap1\n\
3656 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3657 floating-point index in the range from 0.0-1.0 which is linearly\n\
3658 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3659 vectors in the range from 0 to\n\
3660 ncol1-1. So in order for this continuous color model to work\n\
3661 properly, it is the responsibility of the user of plscmap1 to insure\n\
3662 that these RGBA vectors are continuous functions of their integer\n\
3663 indices.\n\
3664\n\
3665 Redacted form: plscmap1a(r, g, b, alpha)\n\
3666\n\
3667 This function is used in example 31.\n\
3668\n\
3669\n\
3670\n\
3671SYNOPSIS:\n\
3672\n\
3673plscmap1a(r, g, b, alpha, ncol1)\n\
3674\n\
3675ARGUMENTS:\n\
3676\n\
3677 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3678 8-bit integers in the range from 0-255) the degree of red in the\n\
3679 color as a continuous function of the integer index of the vector.\n\
3680\n\
3681 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3682 8-bit integers in the range from 0-255) the degree of green in the\n\
3683 color as a continuous function of the integer index of the vector.\n\
3684\n\
3685 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3686 8-bit integers in the range from 0-255) the degree of blue in the\n\
3687 color as a continuous function of the integer index of the vector.\n\
3688\n\
3689 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3690 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3691 completely transparent and 1.0 corresponds to completely opaque)\n\
3692 the alpha transparency of the color as a continuous function of\n\
3693 the integer index of the vector.\n\
3694\n\
3695 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3696 vectors.\n\
3697";
3698static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3699Select standard viewport\n\
3700\n\
3701DESCRIPTION:\n\
3702\n\
3703 Selects the largest viewport within the subpage that leaves a standard\n\
3704 margin (left-hand margin of eight character heights, and a margin\n\
3705 around the other three sides of five character heights).\n\
3706\n\
3707 Redacted form: plvsta()\n\
3708\n\
3709 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3710\n\
3711\n\
3712\n\
3713SYNOPSIS:\n\
3714\n\
3715plvsta()\n\
3716";
3717static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3718Switch to graphics screen\n\
3719\n\
3720DESCRIPTION:\n\
3721\n\
3722 Sets an interactive device to graphics mode, used in conjunction with\n\
3723 pltext to allow graphics and text to be interspersed. On a device\n\
3724 which supports separate text and graphics windows, this command causes\n\
3725 control to be switched to the graphics window. If already in graphics\n\
3726 mode, this command is ignored. It is also ignored on devices which\n\
3727 only support a single window or use a different method for shifting\n\
3728 focus. See also pltext.\n\
3729\n\
3730 Redacted form: plgra()\n\
3731\n\
3732 This function is used in example 1.\n\
3733\n\
3734\n\
3735\n\
3736SYNOPSIS:\n\
3737\n\
3738plgra()\n\
3739";
3740static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3741Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3742\n\
3743DESCRIPTION:\n\
3744\n\
3745 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3746 (see the PLplot documentation) index. Overwrites the previous color\n\
3747 value for the given index and, thus, does not result in any additional\n\
3748 allocation of space for colors.\n\
3749\n\
3750 This function is used in example 30.\n\
3751\n\
3752\n\
3753\n\
3754SYNOPSIS:\n\
3755\n\
3756plscol0a(icol0, r, g, b, alpha)\n\
3757\n\
3758ARGUMENTS:\n\
3759\n\
3760 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3761 number of colors (which is set by default, by plscmap0n, or even\n\
3762 by plscmap0).\n\
3763\n\
3764 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3765 degree of red in the color.\n\
3766\n\
3767 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3768 degree of green in the color.\n\
3769\n\
3770 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3771 degree of blue in the color.\n\
3772\n\
3773 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3774 (0.0-1.0).\n\
3775";
3776static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3777Set y axis parameters\n\
3778\n\
3779DESCRIPTION:\n\
3780\n\
3781 Identical to plsxax, except that arguments are flags for y axis. See\n\
3782 the description of plsxax for more detail.\n\
3783\n\
3784 Redacted form: plsyax(digmax, digits)\n\
3785\n\
3786 This function is used in examples 1, 14, and 31.\n\
3787\n\
3788\n\
3789\n\
3790SYNOPSIS:\n\
3791\n\
3792plsyax(digmax, digits)\n\
3793\n\
3794ARGUMENTS:\n\
3795\n\
3796 digmax (PLINT, input) : Variable to set the maximum number of\n\
3797 digits for the y axis. If nonzero, the printed label will be\n\
3798 switched to a floating-point representation when the number of\n\
3799 digits exceeds digmax.\n\
3800\n\
3801 digits (PLINT, input) : Field digits value. Currently, changing\n\
3802 its value here has no effect since it is set only by plbox or\n\
3803 plbox3. However, the user may obtain its value after a call to\n\
3804 either of these functions by calling plgyax.\n\
3805";
3806static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3807Returns 8-bit RGB values for given color index from cmap0\n\
3808\n\
3809DESCRIPTION:\n\
3810\n\
3811 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3812 PLplot documentation). Values are negative if an invalid color id is\n\
3813 given.\n\
3814\n\
3815 Redacted form: plgcol0(icol0, r, g, b)\n\
3816\n\
3817 This function is used in example 2.\n\
3818\n\
3819\n\
3820\n\
3821SYNOPSIS:\n\
3822\n\
3823plgcol0(icol0, r, g, b)\n\
3824\n\
3825ARGUMENTS:\n\
3826\n\
3827 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3828\n\
3829 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3830 value.\n\
3831\n\
3832 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3833 value.\n\
3834\n\
3835 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3836 value.\n\
3837";
3838static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3839Set seed for internal random number generator.\n\
3840\n\
3841DESCRIPTION:\n\
3842\n\
3843 Set the seed for the internal random number generator. See plrandd for\n\
3844 further details.\n\
3845\n\
3846 Redacted form: plseed(seed)\n\
3847\n\
3848 This function is used in example 21.\n\
3849\n\
3850\n\
3851\n\
3852SYNOPSIS:\n\
3853\n\
3854plseed(seed)\n\
3855\n\
3856ARGUMENTS:\n\
3857\n\
3858 seed (unsigned int, input) : Seed for random number generator.\n\
3859";
3860static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3861Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3862\n\
3863DESCRIPTION:\n\
3864\n\
3865 When the implementation is completed this variant of plot3dc (see that\n\
3866 function\'s documentation for more details) should be suitable for the\n\
3867 case where the area of the x, y coordinate grid where z is defined can\n\
3868 be non-rectangular. The implementation is incomplete so the last 4\n\
3869 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3870 indexymax; are currently ignored and the functionality is otherwise\n\
3871 identical to that of plot3dc.\n\
3872\n\
3873 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3874 indexymin, indexymax)\n\
3875\n\
3876\n\
3877 This function is not used in any example.\n\
3878\n\
3879\n\
3880\n\
3881SYNOPSIS:\n\
3882\n\
3883plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3884\n\
3885ARGUMENTS:\n\
3886\n\
3887 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3888 which the function is evaluated.\n\
3889\n\
3890 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3891 which the function is evaluated.\n\
3892\n\
3893 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3894 plot. Should have dimensions of\n\
3895 nx by\n\
3896 ny.\n\
3897\n\
3898 nx (PLINT, input) : Number of x values at which the function is\n\
3899 evaluated.\n\
3900\n\
3901 ny (PLINT, input) : Number of y values at which the function is\n\
3902 evaluated.\n\
3903\n\
3904 opt (PLINT, input) : Determines the way in which the surface is\n\
3905 represented. To specify more than one option just add the options,\n\
3906 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3907 showing z as a function of x for each value of y[j] .\n\
3908 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3909 for each value of x[i] .\n\
3910 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3911 at which function is defined.\n\
3912 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3913 the z value being plotted. The color is used from the current\n\
3914 cmap1.\n\
3915 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3916 using parameters\n\
3917 nlevel and\n\
3918 clevel.\n\
3919 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3920 the borders of the plotted function.\n\
3921\n\
3922\n\
3923 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3924 levels.\n\
3925\n\
3926 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3927\n\
3928 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3929 corresponds to the first x index where z is defined.\n\
3930\n\
3931 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3932 which corresponds (by convention) to one more than the last x\n\
3933 index value where z is defined.\n\
3934\n\
3935 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3936 values which all must be ≥ 0. These values are the first y index\n\
3937 where z is defined for a particular x index in the range from\n\
3938 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3939 indexxmax.\n\
3940\n\
3941 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3942 values which all must be ≤ ny. These values correspond (by\n\
3943 convention) to one more than the last y index where z is defined\n\
3944 for a particular x index in the range from indexxmin to indexxmax\n\
3945 - 1. The dimension of indexymax is indexxmax.\n\
3946";
3947static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3948Get output file name\n\
3949\n\
3950DESCRIPTION:\n\
3951\n\
3952 Gets the current output file name, if applicable.\n\
3953\n\
3954 Redacted form: plgfnam(fnam)\n\
3955\n\
3956 This function is used in example 31.\n\
3957\n\
3958\n\
3959\n\
3960SYNOPSIS:\n\
3961\n\
3962plgfnam(fnam)\n\
3963\n\
3964ARGUMENTS:\n\
3965\n\
3966 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3967 (with preallocated length of 80 characters or more) containing the\n\
3968 file name.\n\
3969";
3970static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3971Specify window\n\
3972\n\
3973DESCRIPTION:\n\
3974\n\
3975 Specify the window, i.e., the world coordinates of the edges of the\n\
3976 viewport.\n\
3977\n\
3978 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3979\n\
3980 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3981 29, and 31.\n\
3982\n\
3983\n\
3984\n\
3985SYNOPSIS:\n\
3986\n\
3987plwind(xmin, xmax, ymin, ymax)\n\
3988\n\
3989ARGUMENTS:\n\
3990\n\
3991 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3992 of the viewport.\n\
3993\n\
3994 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3995 of the viewport.\n\
3996\n\
3997 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3998 the viewport.\n\
3999\n\
4000 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
4001 viewport.\n\
4002";
4003static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
4004Set cmap1 colors using a piece-wise linear relationship\n\
4005\n\
4006DESCRIPTION:\n\
4007\n\
4008 Set cmap1 colors using a piece-wise linear relationship between the\n\
4009 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
4010 (see the PLplot documentation). May be called at any time.\n\
4011\n\
4012 The idea here is to specify a number of control points that define the\n\
4013 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
4014 these points, linear interpolation is used which gives a smooth\n\
4015 variation of color with intensity index. Any number of control points\n\
4016 may be specified, located at arbitrary positions, although typically 2\n\
4017 - 4 are enough. Another way of stating this is that we are traversing\n\
4018 a given number of lines through HLS or RGB space as we move through\n\
4019 cmap1 intensity indices. The control points at the minimum and\n\
4020 maximum position (0 and 1) must always be specified. By adding more\n\
4021 control points you can get more variation. One good technique for\n\
4022 plotting functions that vary about some expected average is to use an\n\
4023 additional 2 control points in the center (position ~= 0.5) that are\n\
4024 the same lightness as the background (typically white for paper\n\
4025 output, black for crt), and same hue as the boundary control points.\n\
4026 This allows the highs and lows to be very easily distinguished.\n\
4027\n\
4028 Each control point must specify the cmap1 intensity index and the\n\
4029 associated three coordinates in HLS or RGB space. The first point\n\
4030 must correspond to position = 0, and the last to position = 1.\n\
4031\n\
4032 If RGB colors are provided then the interpolation takes place in RGB\n\
4033 space and is trivial. However if HLS colors are provided then, because\n\
4034 of the circular nature of the color wheel for the hue coordinate, the\n\
4035 interpolation could be performed in either direction around the color\n\
4036 wheel. The default behaviour is for the hue to be linearly\n\
4037 interpolated ignoring this circular property of hue. So for example,\n\
4038 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
4039 green and cyan. If instead you wish to interpolate the other way\n\
4040 around the color wheel you have two options. You may provide hues\n\
4041 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
4042 for red the interpolation will proceed via magenta. Alternatively you\n\
4043 can utilise the alt_hue_path variable to reverse the direction of\n\
4044 interpolation if you need to provide hues within the [0-360) range.\n\
4045\n\
4046 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
4047 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
4048 -120]falsegreen-yellow-red-magenta-blue[240\n\
4049 480]falseblue-magenta-red-yellow-green[120\n\
4050 240]truegreen-yellow-red-magenta-blue[240\n\
4051 120]trueblue-magenta-red-yellow-green\n\
4052\n\
4053 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
4054 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
4055 1]magnitudeHLSsaturation[0, 1]magnitude\n\
4056\n\
4057 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
4058 alt_hue_path)\n\
4059\n\
4060 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
4061\n\
4062\n\
4063\n\
4064SYNOPSIS:\n\
4065\n\
4066plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
4067\n\
4068ARGUMENTS:\n\
4069\n\
4070 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
4071\n\
4072 npts (PLINT, input) : number of control points\n\
4073\n\
4074 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
4075 intensity index (0.0-1.0) in ascending order for each control\n\
4076 point.\n\
4077\n\
4078 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
4079 coordinate (H or R) for each control point.\n\
4080\n\
4081 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
4082 coordinate (L or G) for each control point.\n\
4083\n\
4084 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
4085 coordinate (S or B) for each control point.\n\
4086\n\
4087 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
4088 npts - 1 elements), each containing either true to use the reversed\n\
4089 HLS interpolation or false to use the regular HLS interpolation.\n\
4090 (alt_hue_path[i] refers to the interpolation interval between the\n\
4091 i and i + 1 control points). This parameter is not used for RGB\n\
4092 colors (\n\
4093 itype = true).\n\
4094";
4095static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
4096Set the pause (on end-of-page) status\n\
4097\n\
4098DESCRIPTION:\n\
4099\n\
4100 Set the pause (on end-of-page) status.\n\
4101\n\
4102 Redacted form: plspause(pause)\n\
4103\n\
4104 This function is in examples 14,20.\n\
4105\n\
4106\n\
4107\n\
4108SYNOPSIS:\n\
4109\n\
4110plspause(pause)\n\
4111\n\
4112ARGUMENTS:\n\
4113\n\
4114 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4115 end-of-page for those drivers which support this. Otherwise there\n\
4116 is no pause.\n\
4117";
4118static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4119Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4120\n\
4121DESCRIPTION:\n\
4122\n\
4123 Routine for creating a discrete plot legend with a plotted filled box,\n\
4124 line, and/or line of symbols for each annotated legend entry. (See\n\
4125 plcolorbar for similar functionality for creating continuous color\n\
4126 bars.) The arguments of pllegend provide control over the location\n\
4127 and size of the legend as well as the location and characteristics of\n\
4128 the elements (most of which are optional) within that legend. The\n\
4129 resulting legend is clipped at the boundaries of the current subpage.\n\
4130 (N.B. the adopted coordinate system used for some of the parameters is\n\
4131 defined in the documentation of the position parameter.)\n\
4132\n\
4133 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4134 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4135 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4136 test_justification, text_colors, text, box_colors, box_patterns,\n\
4137 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4138 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4139\n\
4140 This function is used in examples 4, 26, and 33.\n\
4141\n\
4142\n\
4143\n\
4144SYNOPSIS:\n\
4145\n\
4146pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4147\n\
4148ARGUMENTS:\n\
4149\n\
4150 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4151 legend width in adopted coordinates. This quantity is calculated\n\
4152 from plot_width, text_offset, ncolumn (possibly modified inside\n\
4153 the routine depending on nlegend and nrow), and the length\n\
4154 (calculated internally) of the longest text string.\n\
4155\n\
4156 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4157 legend height in adopted coordinates. This quantity is calculated\n\
4158 from text_scale, text_spacing, and nrow (possibly modified inside\n\
4159 the routine depending on nlegend and nrow).\n\
4160\n\
4161 opt (PLINT, input) : opt contains bits controlling the overall\n\
4162 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4163 on the left of the legend and the plotted area on the right.\n\
4164 Otherwise, put the text area on the right of the legend and the\n\
4165 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4166 plot a (semitransparent) background for the legend. If the\n\
4167 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4168 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4169 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4170 plot the resulting array of legend entries in row-major order.\n\
4171 Otherwise, plot the legend entries in column-major order.\n\
4172\n\
4173 position (PLINT, input) : position contains bits which control the\n\
4174 overall position of the legend and the definition of the adopted\n\
4175 coordinates used for positions just like what is done for the\n\
4176 position argument for plcolorbar. However, note that the defaults\n\
4177 for the position bits (see below) are different than the\n\
4178 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4179 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4180 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4181 the 16 possible standard positions (the 4 corners and centers of\n\
4182 the 4 sides for both the inside and outside cases) of the legend\n\
4183 relative to the adopted coordinate system. The corner positions\n\
4184 are specified by the appropriate combination of two of the\n\
4185 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4186 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4187 value of one of those bits. The adopted coordinates are\n\
4188 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4189 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4190 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4191 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4192 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4193 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4194 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4195 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4196\n\
4197 x (PLFLT, input) : X offset of the legend position in adopted\n\
4198 coordinates from the specified standard position of the legend.\n\
4199 For positive x, the direction of motion away from the standard\n\
4200 position is inward/outward from the standard corner positions or\n\
4201 standard left or right positions if the\n\
4202 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4203 For the standard top or bottom positions, the direction of motion\n\
4204 is toward positive X.\n\
4205\n\
4206 y (PLFLT, input) : Y offset of the legend position in adopted\n\
4207 coordinates from the specified standard position of the legend.\n\
4208 For positive y, the direction of motion away from the standard\n\
4209 position is inward/outward from the standard corner positions or\n\
4210 standard top or bottom positions if the\n\
4211 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4212 the standard left or right positions, the direction of motion is\n\
4213 toward positive Y.\n\
4214\n\
4215 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4216 of the plot area (where the colored boxes, lines, and/or lines of\n\
4217 symbols are drawn) of the legend.\n\
4218\n\
4219 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4220 legend (PL_LEGEND_BACKGROUND).\n\
4221\n\
4222 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4223 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4224\n\
4225 bb_style (PLINT, input) : The pllsty style number for the\n\
4226 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4227\n\
4228 nrow (PLINT, input) : The number of rows in the matrix used to\n\
4229 render the\n\
4230 nlegend legend entries. For internal transformations of\n\
4231 nrow, see further remarks under\n\
4232 nlegend.\n\
4233\n\
4234 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4235 to render the\n\
4236 nlegend legend entries. For internal transformations of\n\
4237 ncolumn, see further remarks under\n\
4238 nlegend.\n\
4239\n\
4240 nlegend (PLINT, input) : Number of legend entries. The above\n\
4241 nrow and\n\
4242 ncolumn values are transformed internally to be consistent with\n\
4243 nlegend. If either\n\
4244 nrow or\n\
4245 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4246 of\n\
4247 nrow and\n\
4248 ncolumn is less than\n\
4249 nlegend, the smaller of the two (or\n\
4250 nrow, if\n\
4251 nrow ==\n\
4252 ncolumn) is increased so the product is >=\n\
4253 nlegend. Thus, for example, the common\n\
4254 nrow = 0,\n\
4255 ncolumn = 0 case is transformed internally to\n\
4256 nrow =\n\
4257 nlegend,\n\
4258 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4259 column.\n\
4260\n\
4261 opt_array (PLINT_VECTOR, input) : A vector of\n\
4262 nlegend values of options to control each individual plotted area\n\
4263 corresponding to a legend entry. If the\n\
4264 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4265 area. If the\n\
4266 PL_LEGEND_COLOR_BOX,\n\
4267 PL_LEGEND_LINE, and/or\n\
4268 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4269 entry is plotted with a colored box; a line; and/or a line of\n\
4270 symbols.\n\
4271\n\
4272 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4273 area in units of character width.\n\
4274\n\
4275 text_scale (PLFLT, input) : Character height scale for text\n\
4276 annotations.\n\
4277\n\
4278 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4279 character height from one legend entry to the next.\n\
4280\n\
4281 text_justification (PLFLT, input) : Justification parameter used\n\
4282 for text justification. The most common values of\n\
4283 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4284 is left justified, centred, or right justified within the text\n\
4285 area, but other values are allowed as well.\n\
4286\n\
4287 text_colors (PLINT_VECTOR, input) : A vector containing\n\
4288 nlegend cmap0 text colors.\n\
4289\n\
4290 text (PLCHAR_MATRIX, input) : A vector of\n\
4291 nlegend UTF-8 character strings containing the legend annotations.\n\
4292\n\
4293 box_colors (PLINT_VECTOR, input) : A vector containing\n\
4294 nlegend cmap0 colors for the discrete colored boxes (\n\
4295 PL_LEGEND_COLOR_BOX).\n\
4296\n\
4297 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4298 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4299 PL_LEGEND_COLOR_BOX).\n\
4300\n\
4301 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4302 nlegend scales (units of fraction of character height) for the height\n\
4303 of the discrete colored boxes (\n\
4304 PL_LEGEND_COLOR_BOX).\n\
4305\n\
4306 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4307 nlegend line widths for the patterns specified by box_patterns (\n\
4308 PL_LEGEND_COLOR_BOX).\n\
4309\n\
4310 line_colors (PLINT_VECTOR, input) : A vector containing\n\
4311 nlegend cmap0 line colors (\n\
4312 PL_LEGEND_LINE).\n\
4313\n\
4314 line_styles (PLINT_VECTOR, input) : A vector containing\n\
4315 nlegend line styles (plsty indices) (\n\
4316 PL_LEGEND_LINE).\n\
4317\n\
4318 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4319 nlegend line widths (\n\
4320 PL_LEGEND_LINE).\n\
4321\n\
4322 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4323 nlegend cmap0 symbol colors (\n\
4324 PL_LEGEND_SYMBOL).\n\
4325\n\
4326 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4327 nlegend scale values for the symbol height (\n\
4328 PL_LEGEND_SYMBOL).\n\
4329\n\
4330 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4331 nlegend numbers of symbols to be drawn across the width of the plotted\n\
4332 area (\n\
4333 PL_LEGEND_SYMBOL).\n\
4334\n\
4335 symbols (PLCHAR_MATRIX, input) : A vector of\n\
4336 nlegend UTF-8 character strings containing the legend symbols. (\n\
4337 PL_LEGEND_SYMBOL).\n\
4338";
4339static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4340Set number of colors in cmap1\n\
4341\n\
4342DESCRIPTION:\n\
4343\n\
4344 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4345 values if this is the first allocation (see the PLplot documentation).\n\
4346\n\
4347 Redacted form: plscmap1n(ncol1)\n\
4348\n\
4349 This function is used in examples 8, 11, 20, and 21.\n\
4350\n\
4351\n\
4352\n\
4353SYNOPSIS:\n\
4354\n\
4355plscmap1n(ncol1)\n\
4356\n\
4357ARGUMENTS:\n\
4358\n\
4359 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4360 the cmap1 palette. If this number is zero or less, then the value\n\
4361 from the previous call to plscmap1n is used and if there is no\n\
4362 previous call, then a default value is used.\n\
4363";
4364static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4365Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4366\n\
4367DESCRIPTION:\n\
4368\n\
4369 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4370 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4371 Values are negative if an invalid color id is given.\n\
4372\n\
4373 Redacted form: plgcola(r, g, b)\n\
4374\n\
4375 This function is used in example 30.\n\
4376\n\
4377\n\
4378\n\
4379SYNOPSIS:\n\
4380\n\
4381plgcol0a(icol0, r, g, b, alpha)\n\
4382\n\
4383ARGUMENTS:\n\
4384\n\
4385 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4386\n\
4387 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4388 in the range from 0 to 255.\n\
4389\n\
4390 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4391 in the range from 0 to 255.\n\
4392\n\
4393 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4394 in the range from 0 to 255.\n\
4395\n\
4396 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4397 transparency in the range from (0.0-1.0).\n\
4398";
4399static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4400Replays contents of plot buffer to current device/file\n\
4401\n\
4402DESCRIPTION:\n\
4403\n\
4404 Replays contents of plot buffer to current device/file.\n\
4405\n\
4406 Redacted form: plreplot()\n\
4407\n\
4408 This function is used in example 1,20.\n\
4409\n\
4410\n\
4411\n\
4412SYNOPSIS:\n\
4413\n\
4414plreplot()\n\
4415";
4416static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4417Simple routine to write labels\n\
4418\n\
4419DESCRIPTION:\n\
4420\n\
4421 Routine for writing simple labels. Use plmtex for more complex labels.\n\
4422\n\
4423 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4424\n\
4425 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4426\n\
4427\n\
4428\n\
4429SYNOPSIS:\n\
4430\n\
4431pllab(xlabel, ylabel, tlabel)\n\
4432\n\
4433ARGUMENTS:\n\
4434\n\
4435 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4436 the label for the x axis.\n\
4437\n\
4438 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4439 the label for the y axis.\n\
4440\n\
4441 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4442 the title of the plot.\n\
4443";
4444static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4445Set parameters that define current device-space window\n\
4446\n\
4447DESCRIPTION:\n\
4448\n\
4449 Set relative margin width, aspect ratio, and relative justification\n\
4450 that define current device-space window. If you want to just use the\n\
4451 previous value for any of these, just pass in the magic value\n\
4452 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4453 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4454 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4455 to a device-specific value.\n\
4456\n\
4457 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4458\n\
4459 This function is used in example 31.\n\
4460\n\
4461\n\
4462\n\
4463SYNOPSIS:\n\
4464\n\
4465plsdidev(mar, aspect, jx, jy)\n\
4466\n\
4467ARGUMENTS:\n\
4468\n\
4469 mar (PLFLT, input) : Relative margin width.\n\
4470\n\
4471 aspect (PLFLT, input) : Aspect ratio.\n\
4472\n\
4473 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4474 the range -0.5 to 0.5.\n\
4475\n\
4476 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4477 the range -0.5 to 0.5.\n\
4478";
4479static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4480Begin a new page\n\
4481\n\
4482DESCRIPTION:\n\
4483\n\
4484 Begins a new page. For a file driver, the output file is opened if\n\
4485 necessary. Advancing the page via pleop and plbop is useful when a\n\
4486 page break is desired at a particular point when plotting to subpages.\n\
4487 Another use for pleop and plbop is when plotting pages to different\n\
4488 files, since you can manually set the file name by calling plsfnam\n\
4489 after the call to pleop. (In fact some drivers may only support a\n\
4490 single page per file, making this a necessity.) One way to handle\n\
4491 this case automatically is to page advance via pladv, but enable\n\
4492 familying (see plsfam) with a small limit on the file size so that a\n\
4493 new family member file will be created on each page break.\n\
4494\n\
4495 Redacted form: plbop()\n\
4496\n\
4497 This function is used in examples 2 and 20.\n\
4498\n\
4499\n\
4500\n\
4501SYNOPSIS:\n\
4502\n\
4503plbop()\n\
4504";
4505static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4506Set cmap0 colors by 8-bit RGB values\n\
4507\n\
4508DESCRIPTION:\n\
4509\n\
4510 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4511 documentation). This sets the entire color map -- only as many colors\n\
4512 as specified will be allocated.\n\
4513\n\
4514 Redacted form: plscmap0(r, g, b)\n\
4515\n\
4516 This function is used in examples 2 and 24.\n\
4517\n\
4518\n\
4519\n\
4520SYNOPSIS:\n\
4521\n\
4522plscmap0(r, g, b, ncol0)\n\
4523\n\
4524ARGUMENTS:\n\
4525\n\
4526 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4527 integers (0-255) representing the degree of red in the color.\n\
4528\n\
4529 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4530 integers (0-255) representing the degree of green in the color.\n\
4531\n\
4532 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4533 integers (0-255) representing the degree of blue in the color.\n\
4534\n\
4535 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4536";
4537static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4538Set the number of subpages in x and y\n\
4539\n\
4540DESCRIPTION:\n\
4541\n\
4542 Set the number of subpages in x and y.\n\
4543\n\
4544 Redacted form: plssub(nx, ny)\n\
4545\n\
4546 This function is examples 1,2,14,21,25,27.\n\
4547\n\
4548\n\
4549\n\
4550SYNOPSIS:\n\
4551\n\
4552plssub(nx, ny)\n\
4553\n\
4554ARGUMENTS:\n\
4555\n\
4556 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4557 of window columns).\n\
4558\n\
4559 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4560 of window rows).\n\
4561";
4562static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4563Set a global coordinate transform function\n\
4564\n\
4565DESCRIPTION:\n\
4566\n\
4567 This function can be used to define a coordinate transformation which\n\
4568 affects all elements drawn within the current plot window. The\n\
4569 coordinate_transform callback function is similar to that provided for\n\
4570 the plmap and plmeridians functions. The coordinate_transform_data\n\
4571 parameter may be used to pass extra data to coordinate_transform.\n\
4572\n\
4573 Redacted form: General: plstransform(coordinate_transform,\n\
4574 coordinate_transform_data)\n\
4575\n\
4576\n\
4577 This function is used in examples 19 and 22.\n\
4578\n\
4579\n\
4580\n\
4581SYNOPSIS:\n\
4582\n\
4583plstransform(coordinate_transform, coordinate_transform_data)\n\
4584\n\
4585ARGUMENTS:\n\
4586\n\
4587 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4588 function that defines the transformation from the input (x, y)\n\
4589 world coordinates to new PLplot world coordinates. If\n\
4590 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4591 case), then no transform is applied.\n\
4592\n\
4593 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4594 for\n\
4595 coordinate_transform.\n\
4596";
4597static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4598Set opaque RGB cmap1 colors values\n\
4599\n\
4600DESCRIPTION:\n\
4601\n\
4602 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4603 vector values. This function also sets the number of cmap1 colors.\n\
4604 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4605 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4606 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4607 to\n\
4608 ncol1-1. So in order for this continuous color model to work\n\
4609 properly, it is the responsibility of the user of plscmap1 to insure\n\
4610 that these RGB vectors are continuous functions of their integer\n\
4611 indices.\n\
4612\n\
4613 Redacted form: plscmap1(r, g, b)\n\
4614\n\
4615 This function is used in example 31.\n\
4616\n\
4617\n\
4618\n\
4619SYNOPSIS:\n\
4620\n\
4621plscmap1(r, g, b, ncol1)\n\
4622\n\
4623ARGUMENTS:\n\
4624\n\
4625 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4626 8-bit integers in the range from 0-255) the degree of red in the\n\
4627 color as a continuous function of the integer index of the vector.\n\
4628\n\
4629 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4630 8-bit integers in the range from 0-255) the degree of green in the\n\
4631 color as a continuous function of the integer index of the vector.\n\
4632\n\
4633 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4634 8-bit integers in the range from 0-255) the degree of blue in the\n\
4635 color as a continuous function of the integer index of the vector.\n\
4636\n\
4637 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4638";
4639static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4640Configure the transformation between continuous and broken-down time for the current stream\n\
4641\n\
4642DESCRIPTION:\n\
4643\n\
4644 Configure the transformation between continuous and broken-down time\n\
4645 for the current stream. This transformation is used by both plbtime\n\
4646 and plctime.\n\
4647\n\
4648 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4649 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4650\n\
4651\n\
4652 This function is used in example 29.\n\
4653\n\
4654\n\
4655\n\
4656SYNOPSIS:\n\
4657\n\
4658plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4659\n\
4660ARGUMENTS:\n\
4661\n\
4662 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4663 As a special case, if\n\
4664 scale is 0., then all other arguments are ignored, and the result (the\n\
4665 default used by PLplot) is the equivalent of a call to\n\
4666 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4667 That is, for this special case broken-down time is calculated with\n\
4668 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4669 and the continuous time is defined as the number of seconds since\n\
4670 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4671\n\
4672 offset1 (PLFLT, input) : If\n\
4673 ifbtime_offset is true, the parameters\n\
4674 offset1 and\n\
4675 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4676 (with units in days) specify the epoch of the continuous time\n\
4677 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4678 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4679 are used to specify the origin to allow users (by specifying\n\
4680 offset1 as an integer that can be exactly represented by a\n\
4681 floating-point variable and specifying\n\
4682 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4683 the numerical errors of the continuous time representation.\n\
4684\n\
4685 offset2 (PLFLT, input) : See documentation of\n\
4686 offset1.\n\
4687\n\
4688 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4689 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4690 calendar is used for broken-down time rather than the proleptic\n\
4691 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4692 have been historically used to define UTC are inserted into the\n\
4693 broken-down time. Other possibilities for additional control bits\n\
4694 for ccontrol exist such as making the historical time corrections\n\
4695 in the broken-down time corresponding to ET (ephemeris time) or\n\
4696 making the (slightly non-constant) corrections from international\n\
4697 atomic time (TAI) to what astronomers define as terrestrial time\n\
4698 (TT). But those additional possibilities have not been\n\
4699 implemented yet in the qsastime library (one of the PLplot utility\n\
4700 libraries).\n\
4701\n\
4702 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4703 epoch of the continuous time scale is specified by the user. If\n\
4704 ifbtime_offset is false, then\n\
4705 offset1 and\n\
4706 offset2 are used to specify the epoch, and the following broken-down\n\
4707 time parameters are completely ignored. If\n\
4708 ifbtime_offset is true, then\n\
4709 offset1 and\n\
4710 offset2 are completely ignored, and the following broken-down time\n\
4711 parameters are used to specify the epoch.\n\
4712\n\
4713 year (PLINT, input) : Year of epoch.\n\
4714\n\
4715 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4716 11 (December).\n\
4717\n\
4718 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4719\n\
4720 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4721\n\
4722 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4723\n\
4724 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4725";
4726static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4727Set length of minor ticks\n\
4728\n\
4729DESCRIPTION:\n\
4730\n\
4731 This sets up the length of the minor ticks and the length of the\n\
4732 terminals on error bars. The actual length is the product of the\n\
4733 default length and a scaling factor as for character height.\n\
4734\n\
4735 Redacted form: plsmin(def, scale)\n\
4736\n\
4737 This function is used in example 29.\n\
4738\n\
4739\n\
4740\n\
4741SYNOPSIS:\n\
4742\n\
4743plsmin(def, scale)\n\
4744\n\
4745ARGUMENTS:\n\
4746\n\
4747 def (PLFLT, input) : The default length of a minor tick in\n\
4748 millimeters, should be set to zero if the default length is to\n\
4749 remain unchanged.\n\
4750\n\
4751 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4752 actual tick length.\n\
4753";
4754static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4755Set character size\n\
4756\n\
4757DESCRIPTION:\n\
4758\n\
4759 This sets up the size of all subsequent characters drawn. The actual\n\
4760 height of a character is the product of the default character size and\n\
4761 a scaling factor.\n\
4762\n\
4763 Redacted form: plschr(def, scale)\n\
4764\n\
4765 This function is used in examples 2, 13, 23, and 24.\n\
4766\n\
4767\n\
4768\n\
4769SYNOPSIS:\n\
4770\n\
4771plschr(def, scale)\n\
4772\n\
4773ARGUMENTS:\n\
4774\n\
4775 def (PLFLT, input) : The default height of a character in\n\
4776 millimeters, should be set to zero if the default height is to\n\
4777 remain unchanged. For rasterized drivers the dx and dy values\n\
4778 specified in plspage are used to convert from mm to pixels (note\n\
4779 the different unit systems used). This dpi aware scaling is not\n\
4780 implemented for all drivers yet.\n\
4781\n\
4782 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4783 actual character height.\n\
4784";
4785static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4786Initialize PLplot\n\
4787\n\
4788DESCRIPTION:\n\
4789\n\
4790 Initializing the plotting package. The program prompts for the device\n\
4791 keyword or number of the desired output device. Hitting a RETURN in\n\
4792 response to the prompt is the same as selecting the first device.\n\
4793 plinit will issue no prompt if either the device was specified\n\
4794 previously (via command line flag, the plsetopt function, or the\n\
4795 plsdev function), or if only one device is enabled when PLplot is\n\
4796 installed. If subpages have been specified, the output device is\n\
4797 divided into nx by ny subpages, each of which may be used\n\
4798 independently. If plinit is called again during a program, the\n\
4799 previously opened file will be closed. The subroutine pladv is used\n\
4800 to advance from one subpage to the next.\n\
4801\n\
4802 Redacted form: plinit()\n\
4803\n\
4804 This function is used in all of the examples.\n\
4805\n\
4806\n\
4807\n\
4808SYNOPSIS:\n\
4809\n\
4810plinit()\n\
4811";
4812static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4813Draw a box with axes, etc\n\
4814\n\
4815DESCRIPTION:\n\
4816\n\
4817 Draws a box around the currently defined viewport, and labels it with\n\
4818 world coordinate values appropriate to the window. Thus plbox should\n\
4819 only be called after defining both viewport and window. The ascii\n\
4820 character strings xopt and yopt specify how the box should be drawn as\n\
4821 described below. If ticks and/or subticks are to be drawn for a\n\
4822 particular axis, the tick intervals and number of subintervals may be\n\
4823 specified explicitly, or they may be defaulted by setting the\n\
4824 appropriate arguments to zero.\n\
4825\n\
4826 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4827\n\
4828\n\
4829 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4830 and 29.\n\
4831\n\
4832\n\
4833\n\
4834SYNOPSIS:\n\
4835\n\
4836plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4837\n\
4838ARGUMENTS:\n\
4839\n\
4840 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4841 options for the x axis. The string can include any combination of\n\
4842 the following letters (upper or lower case) in any order: a: Draws\n\
4843 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4844 (x=0).\n\
4845 b: Draws bottom (X) or left (Y) edge of frame.\n\
4846 c: Draws top (X) or right (Y) edge of frame.\n\
4847 d: Plot labels as date / time. Values are assumed to be\n\
4848 seconds since the epoch (as used by gmtime).\n\
4849 f: Always use fixed point numeric labels.\n\
4850 g: Draws a grid at the major tick interval.\n\
4851 h: Draws a grid at the minor tick interval.\n\
4852 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4853 inwards.\n\
4854 l: Labels axis logarithmically. This only affects the labels,\n\
4855 not the data, and so it is necessary to compute the logarithms\n\
4856 of data points before passing them to any of the drawing\n\
4857 routines.\n\
4858 m: Writes numeric labels at major tick intervals in the\n\
4859 unconventional location (above box for X, right of box for Y).\n\
4860 n: Writes numeric labels at major tick intervals in the\n\
4861 conventional location (below box for X, left of box for Y).\n\
4862 o: Use custom labelling function to generate axis label text.\n\
4863 The custom labelling function can be defined with the\n\
4864 plslabelfunc command.\n\
4865 s: Enables subticks between major ticks, only valid if t is\n\
4866 also specified.\n\
4867 t: Draws major ticks.\n\
4868 u: Exactly like \"b\" except don\'t draw edge line.\n\
4869 w: Exactly like \"c\" except don\'t draw edge line.\n\
4870 x: Exactly like \"t\" (including the side effect of the\n\
4871 numerical labels for the major ticks) except exclude drawing\n\
4872 the major and minor tick marks.\n\
4873\n\
4874\n\
4875 xtick (PLFLT, input) : World coordinate interval between major\n\
4876 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4877 generates a suitable tick interval.\n\
4878\n\
4879 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4880 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4881 generates a suitable minor tick interval.\n\
4882\n\
4883 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4884 options for the y axis. The string can include any combination of\n\
4885 the letters defined above for xopt, and in addition may contain:\n\
4886 v: Write numeric labels for the y axis parallel to the base of the\n\
4887 graph, rather than parallel to the axis.\n\
4888\n\
4889\n\
4890 ytick (PLFLT, input) : World coordinate interval between major\n\
4891 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4892 generates a suitable tick interval.\n\
4893\n\
4894 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4895 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4896 generates a suitable minor tick interval.\n\
4897";
4898static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4899Get parameters that define current device-space window\n\
4900\n\
4901DESCRIPTION:\n\
4902\n\
4903 Get relative margin width, aspect ratio, and relative justification\n\
4904 that define current device-space window. If plsdidev has not been\n\
4905 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4906 p_jy will all be 0.\n\
4907\n\
4908 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4909\n\
4910 This function is used in example 31.\n\
4911\n\
4912\n\
4913\n\
4914SYNOPSIS:\n\
4915\n\
4916plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4917\n\
4918ARGUMENTS:\n\
4919\n\
4920 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4921 margin width.\n\
4922\n\
4923 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4924 ratio.\n\
4925\n\
4926 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4927 justification in x.\n\
4928\n\
4929 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4930 justification in y.\n\
4931";
4932static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4933Plot a glyph at the specified points\n\
4934\n\
4935DESCRIPTION:\n\
4936\n\
4937 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4938 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4939 is specified with a PLplot user string. Note that the user string is\n\
4940 not actually limited to one glyph so it is possible (but not normally\n\
4941 useful) to plot more than one glyph at the specified points with this\n\
4942 function. As with plmtex and plptex, the user string can contain FCI\n\
4943 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4944 else PLplot escapes for Hershey or unicode text to determine the\n\
4945 glyph.\n\
4946\n\
4947 Redacted form: plstring(x, y, string)\n\
4948\n\
4949 This function is used in examples 4, 21 and 26.\n\
4950\n\
4951\n\
4952\n\
4953SYNOPSIS:\n\
4954\n\
4955plstring(n, x, y, string)\n\
4956\n\
4957ARGUMENTS:\n\
4958\n\
4959 n (PLINT, input) : Number of points in the x and y vectors.\n\
4960\n\
4961 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4962 the points.\n\
4963\n\
4964 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4965 the points.\n\
4966\n\
4967 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4968 the glyph(s) to be plotted at each of the n points.\n\
4969";
4970static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4971Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4972\n\
4973DESCRIPTION:\n\
4974\n\
4975 As per plmapline, however the items are plotted as strings or points\n\
4976 in the same way as plstring.\n\
4977\n\
4978 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4979 maxy, plotentries)\n\
4980\n\
4981 This function is not used in any examples.\n\
4982\n\
4983\n\
4984\n\
4985SYNOPSIS:\n\
4986\n\
4987plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4988\n\
4989ARGUMENTS:\n\
4990\n\
4991 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4992 transform the coordinates given in the shapefile into a plot\n\
4993 coordinate system. By using this transform, we can change from a\n\
4994 longitude, latitude coordinate to a polar stereographic project,\n\
4995 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4996 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4997 mapform(), x[] and y[] should be replaced by the corresponding\n\
4998 plot coordinates. If no transform is desired, mapform can be\n\
4999 replaced by NULL.\n\
5000\n\
5001 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5002 the file name of a set of Shapefile files without the file\n\
5003 extension.\n\
5004\n\
5005 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5006 drawn.\n\
5007\n\
5008 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5009 be in the same units as used by the Shapefile. You could use a\n\
5010 very large negative number to plot everything, but you can improve\n\
5011 performance by limiting the area drawn. The units must match those\n\
5012 of the Shapefile projection, which may be for example longitude or\n\
5013 distance. The value of minx must be less than the value of maxx.\n\
5014\n\
5015 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5016 use a very large number to plot everything, but you can improve\n\
5017 performance by limiting the area drawn.\n\
5018\n\
5019 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5020 be in the same units as used by the Shapefile. You could use a\n\
5021 very large negative number to plot everything, but you can improve\n\
5022 performance by limiting the area drawn. The units must match those\n\
5023 of the Shapefile projection, which may be for example latitude or\n\
5024 distance. The value of miny must be less than the value of maxy.\n\
5025\n\
5026 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5027 use a very large number to plot everything, but you can improve\n\
5028 performance by limiting the area drawn.\n\
5029\n\
5030 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5031 zero-based indices of the Shapefile elements which will be drawn.\n\
5032 Setting\n\
5033 plotentries to NULL will plot all elements of the Shapefile.\n\
5034\n\
5035 nplotentries (PLINT, input) : The number of items in\n\
5036 plotentries. Ignored if\n\
5037 plotentries is NULL.\n\
5038";
5039static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
5040Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
5041\n\
5042DESCRIPTION:\n\
5043\n\
5044 Sets up plotter environment for simple graphs by calling pladv and\n\
5045 setting up viewport and window to sensible default values. plenv0\n\
5046 leaves a standard margin (left-hand margin of eight character heights,\n\
5047 and a margin around the other three sides of five character heights)\n\
5048 around most graphs for axis labels and a title. When these defaults\n\
5049 are not suitable, use the individual routines plvpas, plvpor, or\n\
5050 plvasp for setting up the viewport, plwind for defining the window,\n\
5051 and plbox for drawing the box.\n\
5052\n\
5053 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5054\n\
5055 This function is used in example 21.\n\
5056\n\
5057\n\
5058\n\
5059SYNOPSIS:\n\
5060\n\
5061plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5062\n\
5063ARGUMENTS:\n\
5064\n\
5065 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
5066 world coordinates).\n\
5067\n\
5068 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
5069 world coordinates).\n\
5070\n\
5071 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
5072 coordinates).\n\
5073\n\
5074 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
5075 coordinates).\n\
5076\n\
5077 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
5078 scales will not be set, the user must set up the scale before\n\
5079 calling plenv0 using plsvpa, plvasp or other.\n\
5080 0: the x and y axes are scaled independently to use as much of\n\
5081 the screen as possible.\n\
5082 1: the scales of the x and y axes are made equal.\n\
5083 2: the axis of the x and y axes are made equal, and the plot\n\
5084 box will be square.\n\
5085\n\
5086\n\
5087 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
5088 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
5089 -1: draw box only.\n\
5090 0: draw box, ticks, and numeric tick labels.\n\
5091 1: also draw coordinate axes at x=0 and y=0.\n\
5092 2: also draw a grid at major tick positions in both\n\
5093 coordinates.\n\
5094 3: also draw a grid at minor tick positions in both\n\
5095 coordinates.\n\
5096 10: same as 0 except logarithmic x tick marks. (The x data\n\
5097 have to be converted to logarithms separately.)\n\
5098 11: same as 1 except logarithmic x tick marks. (The x data\n\
5099 have to be converted to logarithms separately.)\n\
5100 12: same as 2 except logarithmic x tick marks. (The x data\n\
5101 have to be converted to logarithms separately.)\n\
5102 13: same as 3 except logarithmic x tick marks. (The x data\n\
5103 have to be converted to logarithms separately.)\n\
5104 20: same as 0 except logarithmic y tick marks. (The y data\n\
5105 have to be converted to logarithms separately.)\n\
5106 21: same as 1 except logarithmic y tick marks. (The y data\n\
5107 have to be converted to logarithms separately.)\n\
5108 22: same as 2 except logarithmic y tick marks. (The y data\n\
5109 have to be converted to logarithms separately.)\n\
5110 23: same as 3 except logarithmic y tick marks. (The y data\n\
5111 have to be converted to logarithms separately.)\n\
5112 30: same as 0 except logarithmic x and y tick marks. (The x\n\
5113 and y data have to be converted to logarithms separately.)\n\
5114 31: same as 1 except logarithmic x and y tick marks. (The x\n\
5115 and y data have to be converted to logarithms separately.)\n\
5116 32: same as 2 except logarithmic x and y tick marks. (The x\n\
5117 and y data have to be converted to logarithms separately.)\n\
5118 33: same as 3 except logarithmic x and y tick marks. (The x\n\
5119 and y data have to be converted to logarithms separately.)\n\
5120 40: same as 0 except date / time x labels.\n\
5121 41: same as 1 except date / time x labels.\n\
5122 42: same as 2 except date / time x labels.\n\
5123 43: same as 3 except date / time x labels.\n\
5124 50: same as 0 except date / time y labels.\n\
5125 51: same as 1 except date / time y labels.\n\
5126 52: same as 2 except date / time y labels.\n\
5127 53: same as 3 except date / time y labels.\n\
5128 60: same as 0 except date / time x and y labels.\n\
5129 61: same as 1 except date / time x and y labels.\n\
5130 62: same as 2 except date / time x and y labels.\n\
5131 63: same as 3 except date / time x and y labels.\n\
5132 70: same as 0 except custom x and y labels.\n\
5133 71: same as 1 except custom x and y labels.\n\
5134 72: same as 2 except custom x and y labels.\n\
5135 73: same as 3 except custom x and y labels.\n\
5136";
5137static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5138Configure the transformations required for projecting a 3D surface on a 2D window\n\
5139\n\
5140DESCRIPTION:\n\
5141\n\
5142 Configure the transformations required for projecting a 3D surface on\n\
5143 an existing 2D window. Those transformations (see the PLplot\n\
5144 documentation) are done to a rectangular cuboid enclosing the 3D\n\
5145 surface which has its limits expressed in 3D world coordinates and\n\
5146 also normalized 3D coordinates (used for interpreting the altitude and\n\
5147 azimuth of the viewing angle). The transformations consist of the\n\
5148 linear transform from 3D world coordinates to normalized 3D\n\
5149 coordinates, and the 3D rotation of normalized coordinates required to\n\
5150 align the pole of the new 3D coordinate system with the viewing\n\
5151 direction specified by altitude and azimuth so that x and y of the\n\
5152 surface elements in that transformed coordinate system are the\n\
5153 projection of the 3D surface with given viewing direction on the 2D\n\
5154 window.\n\
5155\n\
5156 The enclosing rectangular cuboid for the surface plot is defined by\n\
5157 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5158 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5159 sizes of basex by basey by height so that xmin maps to -\n\
5160 basex/2, xmax maps to basex/2, ymin maps to -\n\
5161 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5162 The resulting rectangular cuboid in normalized coordinates is then\n\
5163 viewed by an observer at altitude alt and azimuth az. This routine\n\
5164 must be called before plbox3 or any of the 3D surface plotting\n\
5165 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5166 plsurf3dl or plfill3.\n\
5167\n\
5168 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5169 zmin, zmax, alt, az)\n\
5170\n\
5171 This function is examples 8, 11, 18, and 21.\n\
5172\n\
5173\n\
5174\n\
5175SYNOPSIS:\n\
5176\n\
5177plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5178\n\
5179ARGUMENTS:\n\
5180\n\
5181 basex (PLFLT, input) : The normalized x coordinate size of the\n\
5182 rectangular cuboid.\n\
5183\n\
5184 basey (PLFLT, input) : The normalized y coordinate size of the\n\
5185 rectangular cuboid.\n\
5186\n\
5187 height (PLFLT, input) : The normalized z coordinate size of the\n\
5188 rectangular cuboid.\n\
5189\n\
5190 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5191 rectangular cuboid.\n\
5192\n\
5193 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5194 rectangular cuboid.\n\
5195\n\
5196 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5197 rectangular cuboid.\n\
5198\n\
5199 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5200 rectangular cuboid.\n\
5201\n\
5202 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5203 rectangular cuboid.\n\
5204\n\
5205 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5206 rectangular cuboid.\n\
5207\n\
5208 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5209 plane of the rectangular cuboid in normalized coordinates.\n\
5210\n\
5211 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5212 rectangular cuboid in normalized coordinates. When az=0, the\n\
5213 observer is looking face onto the zx plane of the rectangular\n\
5214 cuboid in normalized coordinates, and as az is increased, the\n\
5215 observer moves clockwise around that cuboid when viewed from above\n\
5216 the xy plane.\n\
5217";
5218static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5219Draw filled polygon\n\
5220\n\
5221DESCRIPTION:\n\
5222\n\
5223 Fills the polygon defined by the n points (\n\
5224 x[i],\n\
5225 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5226 style is a solid fill. The routine will automatically close the\n\
5227 polygon between the last and first vertices. If multiple closed\n\
5228 polygons are passed in x and y then plfill will fill in between them.\n\
5229\n\
5230 Redacted form: plfill(x,y)\n\
5231\n\
5232 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5233\n\
5234\n\
5235\n\
5236SYNOPSIS:\n\
5237\n\
5238plfill(n, x, y)\n\
5239\n\
5240ARGUMENTS:\n\
5241\n\
5242 n (PLINT, input) : Number of vertices in polygon.\n\
5243\n\
5244 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5245 vertices.\n\
5246\n\
5247 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5248 vertices.\n\
5249";
5250static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5251Magnitude colored plot surface with contour\n\
5252\n\
5253DESCRIPTION:\n\
5254\n\
5255 Aside from dropping the\n\
5256 side functionality this is a more powerful form of plot3d: the surface\n\
5257 mesh can be colored accordingly to the current z value being plotted,\n\
5258 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5259 drawn between the plotted function border and the base XY plane. The\n\
5260 arguments are identical to those of plmeshc. The only difference\n\
5261 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5262 the surface, while plot3dc only draws the surface as viewed from the\n\
5263 top.\n\
5264\n\
5265 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5266\n\
5267\n\
5268 This function is used in example 21.\n\
5269\n\
5270\n\
5271\n\
5272SYNOPSIS:\n\
5273\n\
5274plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5275\n\
5276ARGUMENTS:\n\
5277\n\
5278 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5279 which the function is evaluated.\n\
5280\n\
5281 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5282 which the function is evaluated.\n\
5283\n\
5284 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5285 plot. Should have dimensions of\n\
5286 nx by\n\
5287 ny.\n\
5288\n\
5289 nx (PLINT, input) : Number of x values at which function is\n\
5290 evaluated.\n\
5291\n\
5292 ny (PLINT, input) : Number of y values at which function is\n\
5293 evaluated.\n\
5294\n\
5295 opt (PLINT, input) : Determines the way in which the surface is\n\
5296 represented. To specify more than one option just add the options,\n\
5297 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5298 showing z as a function of x for each value of y[j] .\n\
5299 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5300 for each value of x[i] .\n\
5301 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5302 at which function is defined.\n\
5303 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5304 the z value being plotted. The color is used from the current\n\
5305 cmap1.\n\
5306 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5307 using parameters\n\
5308 nlevel and\n\
5309 clevel.\n\
5310 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5311 the borders of the plotted function.\n\
5312\n\
5313\n\
5314 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5315 levels.\n\
5316\n\
5317 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5318";
5319static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5320Write text relative to viewport boundaries\n\
5321\n\
5322DESCRIPTION:\n\
5323\n\
5324 Writes text at a specified position relative to the viewport\n\
5325 boundaries. Text may be written inside or outside the viewport, but\n\
5326 is clipped at the subpage boundaries. The reference point of a string\n\
5327 lies along a line passing through the string at half the height of a\n\
5328 capital letter. The position of the reference point along this line\n\
5329 is determined by just, and the position of the reference point\n\
5330 relative to the viewport is set by disp and pos.\n\
5331\n\
5332 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5333\n\
5334\n\
5335 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5336 26.\n\
5337\n\
5338\n\
5339\n\
5340SYNOPSIS:\n\
5341\n\
5342plmtex(side, disp, pos, just, text)\n\
5343\n\
5344ARGUMENTS:\n\
5345\n\
5346 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5347 the side of the viewport along which the text is to be written.\n\
5348 The string must be one of: b: Bottom of viewport, text written\n\
5349 parallel to edge.\n\
5350 bv: Bottom of viewport, text written at right angles to edge.\n\
5351 l: Left of viewport, text written parallel to edge.\n\
5352 lv: Left of viewport, text written at right angles to edge.\n\
5353 r: Right of viewport, text written parallel to edge.\n\
5354 rv: Right of viewport, text written at right angles to edge.\n\
5355 t: Top of viewport, text written parallel to edge.\n\
5356 tv: Top of viewport, text written at right angles to edge.\n\
5357\n\
5358\n\
5359 disp (PLFLT, input) : Position of the reference point of string,\n\
5360 measured outwards from the specified viewport edge in units of the\n\
5361 current character height. Use negative disp to write within the\n\
5362 viewport.\n\
5363\n\
5364 pos (PLFLT, input) : Position of the reference point of string\n\
5365 along the specified edge, expressed as a fraction of the length of\n\
5366 the edge.\n\
5367\n\
5368 just (PLFLT, input) : Specifies the position of the string relative\n\
5369 to its reference point. If just=0. , the reference point is at\n\
5370 the left and if just=1. , it is at the right of the string. Other\n\
5371 values of just give intermediate justifications.\n\
5372\n\
5373 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5374 written out.\n\
5375";
5376static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5377Set arrow style for vector plots\n\
5378\n\
5379DESCRIPTION:\n\
5380\n\
5381 Set the style for the arrow used by plvect to plot vectors.\n\
5382\n\
5383 Redacted form: plsvect(arrowx, arrowy, fill)\n\
5384\n\
5385 This function is used in example 22.\n\
5386\n\
5387\n\
5388\n\
5389SYNOPSIS:\n\
5390\n\
5391plsvect(arrowx, arrowy, npts, fill)\n\
5392\n\
5393ARGUMENTS:\n\
5394\n\
5395 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5396 the x and y points which make up the arrow. The arrow is plotted\n\
5397 by joining these points to form a polygon. The scaling assumes\n\
5398 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5399 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5400 will be reset to its default.\n\
5401\n\
5402 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5403 arrowy.\n\
5404\n\
5405 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5406 fill is false then the arrow is open.\n\
5407";
5408static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5409Get family file parameters\n\
5410\n\
5411DESCRIPTION:\n\
5412\n\
5413 Gets information about current family file, if familying is enabled.\n\
5414 See the PLplot documentation for more information.\n\
5415\n\
5416 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5417\n\
5418 This function is used in examples 14 and 31.\n\
5419\n\
5420\n\
5421\n\
5422SYNOPSIS:\n\
5423\n\
5424plgfam(p_fam, p_num, p_bmax)\n\
5425\n\
5426ARGUMENTS:\n\
5427\n\
5428 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5429 family flag value. If nonzero, familying is enabled for the\n\
5430 current device.\n\
5431\n\
5432 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5433 family file number.\n\
5434\n\
5435 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5436 file size (in bytes) for a family file.\n\
5437";
5438static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5439Random number generator returning a real random number in the range [0,1]\n\
5440\n\
5441DESCRIPTION:\n\
5442\n\
5443 Random number generator returning a real random number in the range\n\
5444 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5445 / compilers provide their own random number generator, and so this is\n\
5446 provided purely for convenience and to give a consistent random number\n\
5447 generator across all languages supported by PLplot. This is\n\
5448 particularly useful for comparing results from the test suite of\n\
5449 examples.\n\
5450\n\
5451 Redacted form: plrandd()\n\
5452\n\
5453 This function is used in examples 17 and 21.\n\
5454\n\
5455\n\
5456\n\
5457SYNOPSIS:\n\
5458\n\
5459plrandd()\n\
5460";
5461static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5462Contour plot\n\
5463\n\
5464DESCRIPTION:\n\
5465\n\
5466 Draws a contour plot of the data in f[\n\
5467 nx][\n\
5468 ny], using the nlevel contour levels specified by clevel. Only the\n\
5469 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5470 where all these index ranges are interpreted as one-based for\n\
5471 historical reasons. A transformation routine pointed to by pltr with\n\
5472 a generic pointer pltr_data for additional data required by the\n\
5473 transformation routine is used to map indices within the matrix to the\n\
5474 world coordinates.\n\
5475\n\
5476 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5477 where (see above discussion) the pltr, pltr_data callback arguments\n\
5478 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5479 vectors; or xg and yg matrices.\n\
5480\n\
5481 This function is used in examples 9, 14, 16, and 22.\n\
5482\n\
5483\n\
5484\n\
5485SYNOPSIS:\n\
5486\n\
5487plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5488\n\
5489ARGUMENTS:\n\
5490\n\
5491 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5492\n\
5493 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5494\n\
5495 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5496 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5497 zero-based for historical backwards-compatibility reasons.\n\
5498\n\
5499 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5500 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5501 zero-based for historical backwards-compatibility reasons.\n\
5502\n\
5503 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5504 which to draw contours.\n\
5505\n\
5506 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5507\n\
5508 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5509 defines the transformation between the zero-based indices of the\n\
5510 matrix f and the world coordinates.For the C case, transformation\n\
5511 functions are provided in the PLplot library: pltr0 for the\n\
5512 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5513 respectively defined by vectors and matrices. In addition, C\n\
5514 callback routines for the transformation can be supplied by the\n\
5515 user such as the mypltr function in examples/c/x09c.c which\n\
5516 provides a general linear transformation between index coordinates\n\
5517 and world coordinates.For languages other than C you should\n\
5518 consult the PLplot documentation for the details concerning how\n\
5519 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5520 general, a particular pattern of callback-associated arguments\n\
5521 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5522 yg matrices are respectively interfaced to a linear-transformation\n\
5523 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5524 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5525 the PLplot documentation) support native language callbacks for\n\
5526 handling index to world-coordinate transformations. Examples of\n\
5527 these various approaches are given in examples/<language>x09*,\n\
5528 examples/<language>x16*, examples/<language>x20*,\n\
5529 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5530 supported languages.\n\
5531\n\
5532 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5533 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5534 that is externally supplied.\n\
5535";
5536static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5537Set line style\n\
5538\n\
5539DESCRIPTION:\n\
5540\n\
5541 This sets up the line style for all lines subsequently drawn. A line\n\
5542 consists of segments in which the pen is alternately down and up. The\n\
5543 lengths of these segments are passed in the vectors mark and space\n\
5544 respectively. The number of mark-space pairs is specified by nms. In\n\
5545 order to return the line style to the default continuous line, plstyl\n\
5546 should be called with nms =0 .(see also pllsty)\n\
5547\n\
5548 Redacted form: plstyl(mark, space)\n\
5549\n\
5550 This function is used in examples 1, 9, and 14.\n\
5551\n\
5552\n\
5553\n\
5554SYNOPSIS:\n\
5555\n\
5556plstyl(nms, mark, space)\n\
5557\n\
5558ARGUMENTS:\n\
5559\n\
5560 nms (PLINT, input) : The number of mark and space elements in a\n\
5561 line. Thus a simple broken line can be obtained by setting nms=1\n\
5562 . A continuous line is specified by setting nms=0 .\n\
5563\n\
5564 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5565 segments during which the pen is down, measured in micrometers.\n\
5566\n\
5567 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5568 the segments during which the pen is up, measured in micrometers.\n\
5569";
5570static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5571Set the cmap0 palette using the specified cmap0*.pal format file\n\
5572\n\
5573DESCRIPTION:\n\
5574\n\
5575 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5576\n\
5577 Redacted form: plspal0(filename)\n\
5578\n\
5579 This function is in example 16.\n\
5580\n\
5581\n\
5582\n\
5583SYNOPSIS:\n\
5584\n\
5585plspal0(filename)\n\
5586\n\
5587ARGUMENTS:\n\
5588\n\
5589 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5590 containing the name of the cmap0*.pal file. If this string is\n\
5591 empty, use the default cmap0*.pal file.\n\
5592";
5593static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5594Set the cmap1 palette using the specified cmap1*.pal format file\n\
5595\n\
5596DESCRIPTION:\n\
5597\n\
5598 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5599\n\
5600 Redacted form: plspal1(filename, interpolate)\n\
5601\n\
5602 This function is used in example 16.\n\
5603\n\
5604\n\
5605\n\
5606SYNOPSIS:\n\
5607\n\
5608plspal1(filename, interpolate)\n\
5609\n\
5610ARGUMENTS:\n\
5611\n\
5612 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5613 containing the name of the cmap1*.pal file. If this string is\n\
5614 empty, use the default cmap1*.pal file.\n\
5615\n\
5616 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5617 columns containing the intensity index, r, g, b, alpha and\n\
5618 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5619 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5620 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5621 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5622 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5623 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5624 are used instead to set the cmap1 palette directly with a call to\n\
5625 plscmap1a.\n\
5626";
5627static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5628Set current output stream\n\
5629\n\
5630DESCRIPTION:\n\
5631\n\
5632 Sets the number of the current output stream. The stream number\n\
5633 defaults to 0 unless changed by this routine. The first use of this\n\
5634 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5635\n\
5636 Redacted form: plsstrm(strm)\n\
5637\n\
5638 This function is examples 1,14,20.\n\
5639\n\
5640\n\
5641\n\
5642SYNOPSIS:\n\
5643\n\
5644plsstrm(strm)\n\
5645\n\
5646ARGUMENTS:\n\
5647\n\
5648 strm (PLINT, input) : The current stream number.\n\
5649";
5650static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5651Specify viewport using normalized subpage coordinates\n\
5652\n\
5653DESCRIPTION:\n\
5654\n\
5655 Device-independent routine for setting up the viewport. This defines\n\
5656 the viewport in terms of normalized subpage coordinates which run from\n\
5657 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5658 current subpage. Use the alternate routine plsvpa in order to create\n\
5659 a viewport of a definite size.\n\
5660\n\
5661 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5662\n\
5663 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5664 24, 26, 27, and 31.\n\
5665\n\
5666\n\
5667\n\
5668SYNOPSIS:\n\
5669\n\
5670plvpor(xmin, xmax, ymin, ymax)\n\
5671\n\
5672ARGUMENTS:\n\
5673\n\
5674 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5675 left-hand edge of the viewport.\n\
5676\n\
5677 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5678 right-hand edge of the viewport.\n\
5679\n\
5680 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5681 bottom edge of the viewport.\n\
5682\n\
5683 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5684 edge of the viewport.\n\
5685";
5686static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5687Write text inside the viewport\n\
5688\n\
5689DESCRIPTION:\n\
5690\n\
5691 Writes text at a specified position and inclination within the\n\
5692 viewport. Text is clipped at the viewport boundaries. The reference\n\
5693 point of a string lies along a line passing through the string at half\n\
5694 the height of a capital letter. The position of the reference point\n\
5695 along this line is determined by just, the reference point is placed\n\
5696 at world coordinates (\n\
5697 x,\n\
5698 y) within the viewport. The inclination of the string is specified\n\
5699 in terms of differences of world coordinates making it easy to write\n\
5700 text parallel to a line in a graph.\n\
5701\n\
5702 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5703\n\
5704 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5705\n\
5706\n\
5707\n\
5708SYNOPSIS:\n\
5709\n\
5710plptex(x, y, dx, dy, just, text)\n\
5711\n\
5712ARGUMENTS:\n\
5713\n\
5714 x (PLFLT, input) : x coordinate of reference point of string.\n\
5715\n\
5716 y (PLFLT, input) : y coordinate of reference point of string.\n\
5717\n\
5718 dx (PLFLT, input) : Together with dy, this specifies the\n\
5719 inclination of the string. The baseline of the string is parallel\n\
5720 to a line joining (\n\
5721 x,\n\
5722 y) to (\n\
5723 x+\n\
5724 dx,\n\
5725 y+\n\
5726 dy) .\n\
5727\n\
5728 dy (PLFLT, input) : Together with dx, this specifies the\n\
5729 inclination of the string.\n\
5730\n\
5731 just (PLFLT, input) : Specifies the position of the string relative\n\
5732 to its reference point. If just=0. , the reference point is at\n\
5733 the left and if just=1. , it is at the right of the string. Other\n\
5734 values of just give intermediate justifications.\n\
5735\n\
5736 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5737 written out.\n\
5738";
5739static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5740Set z axis parameters\n\
5741\n\
5742DESCRIPTION:\n\
5743\n\
5744 Identical to plsxax, except that arguments are flags for z axis. See\n\
5745 the description of plsxax for more detail.\n\
5746\n\
5747 Redacted form: plszax(digmax, digits)\n\
5748\n\
5749 This function is used in example 31.\n\
5750\n\
5751\n\
5752\n\
5753SYNOPSIS:\n\
5754\n\
5755plszax(digmax, digits)\n\
5756\n\
5757ARGUMENTS:\n\
5758\n\
5759 digmax (PLINT, input) : Variable to set the maximum number of\n\
5760 digits for the z axis. If nonzero, the printed label will be\n\
5761 switched to a floating-point representation when the number of\n\
5762 digits exceeds digmax.\n\
5763\n\
5764 digits (PLINT, input) : Field digits value. Currently, changing\n\
5765 its value here has no effect since it is set only by plbox or\n\
5766 plbox3. However, the user may obtain its value after a call to\n\
5767 either of these functions by calling plgzax.\n\
5768";
5769static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5770Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5771\n\
5772DESCRIPTION:\n\
5773\n\
5774 This variant of plsurf3d (see that function\'s documentation for more\n\
5775 details) should be suitable for the case where the area of the x, y\n\
5776 coordinate grid where z is defined can be non-rectangular. The limits\n\
5777 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5778 indexymin, and indexymax.\n\
5779\n\
5780 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5781 indexymax)\n\
5782\n\
5783 This function is used in example 8.\n\
5784\n\
5785\n\
5786\n\
5787SYNOPSIS:\n\
5788\n\
5789plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5790\n\
5791ARGUMENTS:\n\
5792\n\
5793 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5794 which the function is evaluated.\n\
5795\n\
5796 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5797 which the function is evaluated.\n\
5798\n\
5799 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5800 plot. Should have dimensions of\n\
5801 nx by\n\
5802 ny.\n\
5803\n\
5804 nx (PLINT, input) : Number of x values at which function is\n\
5805 evaluated.\n\
5806\n\
5807 ny (PLINT, input) : Number of y values at which function is\n\
5808 evaluated.\n\
5809\n\
5810 opt (PLINT, input) : Determines the way in which the surface is\n\
5811 represented. To specify more than one option just add the options,\n\
5812 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5813 connecting points at which function is defined.\n\
5814 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5815 using parameters\n\
5816 nlevel and\n\
5817 clevel.\n\
5818 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5819 using parameters\n\
5820 nlevel and\n\
5821 clevel.\n\
5822 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5823 the borders of the plotted function.\n\
5824 opt=MAG_COLOR : the surface is colored according to the value\n\
5825 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5826 according to the intensity of the reflected light in the\n\
5827 surface from a light source whose position is set using\n\
5828 pllightsource.\n\
5829\n\
5830\n\
5831 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5832 levels.\n\
5833\n\
5834 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5835\n\
5836 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5837 corresponds to the first x index where z is defined.\n\
5838\n\
5839 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5840 which corresponds (by convention) to one more than the last x\n\
5841 index value where z is defined.\n\
5842\n\
5843 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5844 values which all must be ≥ 0. These values are the first y index\n\
5845 where z is defined for a particular x index in the range from\n\
5846 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5847 indexxmax.\n\
5848\n\
5849 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5850 values which all must be ≤ ny. These values correspond (by\n\
5851 convention) to one more than the last y index where z is defined\n\
5852 for a particular x index in the range from indexxmin to indexxmax\n\
5853 - 1. The dimension of indexymax is indexxmax.\n\
5854";
5855static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5856Set font\n\
5857\n\
5858DESCRIPTION:\n\
5859\n\
5860 Sets the font used for subsequent text and symbols. For devices that\n\
5861 still use Hershey fonts this routine has no effect unless the Hershey\n\
5862 fonts with extended character set are loaded (see plfontld). For\n\
5863 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5864 this routine calls the plsfci routine with argument set up\n\
5865 appropriately for the various cases below. However, this method of\n\
5866 specifying the font for unicode-aware devices is deprecated, and the\n\
5867 much more flexible method of calling plsfont directly is recommended\n\
5868 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5869\n\
5870 Redacted form: plfont(ifont)\n\
5871\n\
5872 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5873\n\
5874\n\
5875\n\
5876SYNOPSIS:\n\
5877\n\
5878plfont(ifont)\n\
5879\n\
5880ARGUMENTS:\n\
5881\n\
5882 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5883 (simplest and fastest)\n\
5884 2: Serif font\n\
5885 3: Italic font\n\
5886 4: Script font\n\
5887";
5888static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5889Get the cmap1 argument range for continuous color plots\n\
5890\n\
5891DESCRIPTION:\n\
5892\n\
5893 Get the cmap1 argument range for continuous color plots. (Use\n\
5894 plscmap1_range to set the cmap1 argument range.)\n\
5895\n\
5896 Redacted form: plgcmap1_range(min_color, max_color)\n\
5897\n\
5898 This function is currently not used in any example.\n\
5899\n\
5900\n\
5901\n\
5902SYNOPSIS:\n\
5903\n\
5904plgcmap1_range(min_color, max_color)\n\
5905\n\
5906ARGUMENTS:\n\
5907\n\
5908 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5909 minimum cmap1 argument.\n\
5910\n\
5911 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5912 maximum cmap1 argument.\n\
5913";
5914static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5915Set the cmap1 argument range for continuous color plots\n\
5916\n\
5917DESCRIPTION:\n\
5918\n\
5919 Set the cmap1 argument range for continuous color plots that\n\
5920 corresponds to the range of data values. The maximum range\n\
5921 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5922 the cmap1 argument range that is specified with this routine, the\n\
5923 smaller the subset of the cmap1 color palette that is used to\n\
5924 represent the continuous data being plotted. If\n\
5925 min_color is greater than\n\
5926 max_color or\n\
5927 max_color is greater than 1.0 or\n\
5928 min_color is less than 0.0 then no change is made to the cmap1\n\
5929 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5930\n\
5931 Redacted form: plscmap1_range(min_color, max_color)\n\
5932\n\
5933 This function is currently used in example 33.\n\
5934\n\
5935\n\
5936\n\
5937SYNOPSIS:\n\
5938\n\
5939plscmap1_range(min_color, max_color)\n\
5940\n\
5941ARGUMENTS:\n\
5942\n\
5943 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5944 than 0.0, then 0.0 is used instead.\n\
5945\n\
5946 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5947 than 1.0, then 1.0 is used instead.\n\
5948";
5949static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5950Draw a circular or elliptical arc\n\
5951\n\
5952DESCRIPTION:\n\
5953\n\
5954 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5955 semiminor axis b, starting at angle1 and ending at angle2.\n\
5956\n\
5957 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5958 fill)\n\
5959\n\
5960\n\
5961 This function is used in examples 3 and 27.\n\
5962\n\
5963\n\
5964\n\
5965SYNOPSIS:\n\
5966\n\
5967plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5968\n\
5969ARGUMENTS:\n\
5970\n\
5971 x (PLFLT, input) : X coordinate of arc center.\n\
5972\n\
5973 y (PLFLT, input) : Y coordinate of arc center.\n\
5974\n\
5975 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5976\n\
5977 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5978\n\
5979 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5980 semimajor axis.\n\
5981\n\
5982 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5983 semimajor axis.\n\
5984\n\
5985 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5986 X-axis.\n\
5987\n\
5988 fill (PLBOOL, input) : Draw a filled arc.\n\
5989";
5990static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5991Plot 3-d surface plot\n\
5992\n\
5993DESCRIPTION:\n\
5994\n\
5995 Plots a three-dimensional surface plot within the environment set up\n\
5996 by plw3d. The surface is defined by the matrix z[\n\
5997 nx][\n\
5998 ny] , the point z[i][j] being the value of the function at (\n\
5999 x[i],\n\
6000 y[j]). Note that the points in vectors x and y do not need to be\n\
6001 equally spaced, but must be stored in ascending order. The parameter\n\
6002 opt controls the way in which the surface is displayed. For further\n\
6003 details see the PLplot documentation. The only difference between\n\
6004 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
6005 while plot3d only draws the surface as viewed from the top.\n\
6006\n\
6007 Redacted form: plot3d(x, y, z, opt, side)\n\
6008\n\
6009 This function is used in examples 11 and 21.\n\
6010\n\
6011\n\
6012\n\
6013SYNOPSIS:\n\
6014\n\
6015plot3d(x, y, z, nx, ny, opt, side)\n\
6016\n\
6017ARGUMENTS:\n\
6018\n\
6019 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6020 which the function is evaluated.\n\
6021\n\
6022 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6023 which the function is evaluated.\n\
6024\n\
6025 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6026 plot. Should have dimensions of\n\
6027 nx by\n\
6028 ny.\n\
6029\n\
6030 nx (PLINT, input) : Number of x values at which function is\n\
6031 evaluated.\n\
6032\n\
6033 ny (PLINT, input) : Number of y values at which function is\n\
6034 evaluated.\n\
6035\n\
6036 opt (PLINT, input) : Determines the way in which the surface is\n\
6037 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
6038 function of x for each value of y[j] .\n\
6039 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6040 for each value of x[i] .\n\
6041 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6042 at which function is defined.\n\
6043\n\
6044\n\
6045 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
6046 should be draw on the figure. If side is true sides are drawn,\n\
6047 otherwise no sides are drawn.\n\
6048";
6049static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
6050Set area line fill pattern\n\
6051\n\
6052DESCRIPTION:\n\
6053\n\
6054 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
6055 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
6056 inclinations and spacings. The arguments to this routine are the\n\
6057 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
6058 elements) specifying the inclinations in tenths of a degree and the\n\
6059 spacing in micrometers. (See also plpsty)\n\
6060\n\
6061 Redacted form: General: plpat(inc, del)\n\
6062\n\
6063\n\
6064 This function is used in example 15.\n\
6065\n\
6066\n\
6067\n\
6068SYNOPSIS:\n\
6069\n\
6070plpat(nlin, inc, del)\n\
6071\n\
6072ARGUMENTS:\n\
6073\n\
6074 nlin (PLINT, input) : Number of sets of lines making up the\n\
6075 pattern, either 1 or 2.\n\
6076\n\
6077 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6078 inclination in tenths of a degree. (Should be between -900 and\n\
6079 900).\n\
6080\n\
6081 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6082 spacing in micrometers between the lines making up the pattern.\n\
6083";
6084static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
6085Get x axis parameters\n\
6086\n\
6087DESCRIPTION:\n\
6088\n\
6089 Returns current values of the p_digmax and p_digits flags for the x\n\
6090 axis. p_digits is updated after the plot is drawn, so this routine\n\
6091 should only be called after the call to plbox (or plbox3) is complete.\n\
6092 See the PLplot documentation for more information.\n\
6093\n\
6094 Redacted form: plgxax(p_digmax, p_digits)\n\
6095\n\
6096 This function is used in example 31.\n\
6097\n\
6098\n\
6099\n\
6100SYNOPSIS:\n\
6101\n\
6102plgxax(p_digmax, p_digits)\n\
6103\n\
6104ARGUMENTS:\n\
6105\n\
6106 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6107 number of digits for the x axis. If nonzero, the printed label\n\
6108 has been switched to a floating-point representation when the\n\
6109 number of digits exceeds this value.\n\
6110\n\
6111 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6112 number of digits for the numeric labels (x axis) from the last\n\
6113 plot.\n\
6114";
6115static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
6116Draw filled polygon in 3D\n\
6117\n\
6118DESCRIPTION:\n\
6119\n\
6120 Fills the 3D polygon defined by the n points in the x, y, and z\n\
6121 vectors using the pattern defined by plpsty or plpat. The routine\n\
6122 will automatically close the polygon between the last and first\n\
6123 vertices. If multiple closed polygons are passed in x, y, and z then\n\
6124 plfill3 will fill in between them.\n\
6125\n\
6126 Redacted form: General: plfill3(x, y, z)\n\
6127\n\
6128\n\
6129 This function is used in example 15.\n\
6130\n\
6131\n\
6132\n\
6133SYNOPSIS:\n\
6134\n\
6135plfill3(n, x, y, z)\n\
6136\n\
6137ARGUMENTS:\n\
6138\n\
6139 n (PLINT, input) : Number of vertices in polygon.\n\
6140\n\
6141 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6142 vertices.\n\
6143\n\
6144 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6145 vertices.\n\
6146\n\
6147 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6148 vertices.\n\
6149";
6150static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6151Set color, cmap0\n\
6152\n\
6153DESCRIPTION:\n\
6154\n\
6155 Sets the color index for cmap0 (see the PLplot documentation).\n\
6156\n\
6157 Redacted form: plcol0(icol0)\n\
6158\n\
6159 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6160\n\
6161\n\
6162\n\
6163SYNOPSIS:\n\
6164\n\
6165plcol0(icol0)\n\
6166\n\
6167ARGUMENTS:\n\
6168\n\
6169 icol0 (PLINT, input) : Integer representing the color. The\n\
6170 defaults at present are (these may change):\n\
6171 0 black (default background)\n\
6172 1 red (default foreground)\n\
6173 2 yellow\n\
6174 3 green\n\
6175 4 aquamarine\n\
6176 5 pink\n\
6177 6 wheat\n\
6178 7 grey\n\
6179 8 brown\n\
6180 9 blue\n\
6181 10 BlueViolet\n\
6182 11 cyan\n\
6183 12 turquoise\n\
6184 13 magenta\n\
6185 14 salmon\n\
6186 15 white\n\
6187\n\
6188 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6189 change an individual color in the cmap0 color palette.\n\
6190";
6191static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6192Draw text at points defined by Shapefile data in world coordinates\n\
6193\n\
6194DESCRIPTION:\n\
6195\n\
6196 As per plmapline, however the items are plotted as text in the same\n\
6197 way as plptex.\n\
6198\n\
6199 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6200 miny, maxy, plotentry)\n\
6201\n\
6202 This function is used in example 19.\n\
6203\n\
6204\n\
6205\n\
6206SYNOPSIS:\n\
6207\n\
6208plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6209\n\
6210ARGUMENTS:\n\
6211\n\
6212 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6213 transform the coordinates given in the shapefile into a plot\n\
6214 coordinate system. By using this transform, we can change from a\n\
6215 longitude, latitude coordinate to a polar stereographic project,\n\
6216 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6217 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6218 mapform(), x[] and y[] should be replaced by the corresponding\n\
6219 plot coordinates. If no transform is desired, mapform can be\n\
6220 replaced by NULL.\n\
6221\n\
6222 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6223 the file name of a set of Shapefile files without the file\n\
6224 extension.\n\
6225\n\
6226 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6227 dy/dx.\n\
6228\n\
6229 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6230 dy/dx.\n\
6231\n\
6232 just (PLFLT, input) : Set the justification of the text. The value\n\
6233 given will be the fraction of the distance along the string that\n\
6234 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6235 centralized text and 1.0 gives right aligned text.\n\
6236\n\
6237 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6238\n\
6239 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6240 be in the same units as used by the Shapefile. You could use a\n\
6241 very large negative number to plot everything, but you can improve\n\
6242 performance by limiting the area drawn. The units must match those\n\
6243 of the Shapefile projection, which may be for example longitude or\n\
6244 distance. The value of minx must be less than the value of maxx.\n\
6245\n\
6246 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6247 use a very large number to plot everything, but you can improve\n\
6248 performance by limiting the area drawn.\n\
6249\n\
6250 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6251 be in the same units as used by the Shapefile. You could use a\n\
6252 very large negative number to plot everything, but you can improve\n\
6253 performance by limiting the area drawn. The units must match those\n\
6254 of the Shapefile projection, which may be for example latitude or\n\
6255 distance. The value of miny must be less than the value of maxy.\n\
6256\n\
6257 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6258 use a very large number to plot everything, but you can improve\n\
6259 performance by limiting the area drawn.\n\
6260\n\
6261 plotentry (PLINT, input) : An integer indicating which text string\n\
6262 of the Shapefile (zero indexed) will be drawn.\n\
6263";
6264static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6265Draw a line between two points\n\
6266\n\
6267DESCRIPTION:\n\
6268\n\
6269 Joins the point (\n\
6270 x1,\n\
6271 y1) to (\n\
6272 x2,\n\
6273 y2).\n\
6274\n\
6275 Redacted form: pljoin(x1,y1,x2,y2)\n\
6276\n\
6277 This function is used in examples 3 and 14.\n\
6278\n\
6279\n\
6280\n\
6281SYNOPSIS:\n\
6282\n\
6283pljoin(x1, y1, x2, y2)\n\
6284\n\
6285ARGUMENTS:\n\
6286\n\
6287 x1 (PLFLT, input) : x coordinate of first point.\n\
6288\n\
6289 y1 (PLFLT, input) : y coordinate of first point.\n\
6290\n\
6291 x2 (PLFLT, input) : x coordinate of second point.\n\
6292\n\
6293 y2 (PLFLT, input) : y coordinate of second point.\n\
6294";
6295static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6296Set color, cmap1\n\
6297\n\
6298DESCRIPTION:\n\
6299\n\
6300 Sets the color for cmap1 (see the PLplot documentation).\n\
6301\n\
6302 Redacted form: plcol1(col1)\n\
6303\n\
6304 This function is used in examples 12 and 21.\n\
6305\n\
6306\n\
6307\n\
6308SYNOPSIS:\n\
6309\n\
6310plcol1(col1)\n\
6311\n\
6312ARGUMENTS:\n\
6313\n\
6314 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6315 is mapped to color using the continuous cmap1 palette which by\n\
6316 default ranges from blue to the background color to red. The\n\
6317 cmap1 palette can also be straightforwardly changed by the user\n\
6318 with plscmap1 or plscmap1l.\n\
6319";
6320static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6321Set orientation\n\
6322\n\
6323DESCRIPTION:\n\
6324\n\
6325 Set integer plot orientation parameter. This function is identical to\n\
6326 plsdiori except for the type of the argument, and should be used in\n\
6327 the same way. See the documentation of plsdiori for details.\n\
6328\n\
6329 Redacted form: plsori(ori)\n\
6330\n\
6331 This function is used in example 3.\n\
6332\n\
6333\n\
6334\n\
6335SYNOPSIS:\n\
6336\n\
6337plsori(ori)\n\
6338\n\
6339ARGUMENTS:\n\
6340\n\
6341 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6342 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6343 angle.\n\
6344";
6345static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6346Calculate continuous time from broken-down time for the current stream\n\
6347\n\
6348DESCRIPTION:\n\
6349\n\
6350 Calculate continuous time, ctime, from broken-down time for the\n\
6351 current stream. The broken-down\n\
6352 time is specified by the following parameters: year, month, day, hour,\n\
6353 min, and sec. This function is the inverse of plbtime.\n\
6354\n\
6355 The PLplot definition of broken-down time is a calendar time that\n\
6356 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6357 responsibility to apply those offsets (if so desired) before using the\n\
6358 PLplot time API. By default broken-down time is defined using the\n\
6359 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6360 continuous time is defined as the number of seconds since the Unix\n\
6361 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6362 broken-down and continuous time are possible, see plconfigtime which\n\
6363 specifies that transformation for the current stream.\n\
6364\n\
6365 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6366 ctime)\n\
6367\n\
6368\n\
6369 This function is used in example 29.\n\
6370\n\
6371\n\
6372\n\
6373SYNOPSIS:\n\
6374\n\
6375plctime(year, month, day, hour, min, sec, ctime)\n\
6376\n\
6377ARGUMENTS:\n\
6378\n\
6379 year (PLINT, input) : Input year.\n\
6380\n\
6381 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6382 (December).\n\
6383\n\
6384 day (PLINT, input) : Input day in range from 1 to 31.\n\
6385\n\
6386 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6387\n\
6388 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6389\n\
6390 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6391\n\
6392 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6393 time calculated from the broken-down time specified by the\n\
6394 previous parameters.\n\
6395";
6396static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6397Plot continental outline or shapefile data in world coordinates\n\
6398\n\
6399DESCRIPTION:\n\
6400\n\
6401 Plots continental outlines or shapefile data in world coordinates. A\n\
6402 demonstration of how to use this function to create different\n\
6403 projections can be found in examples/c/x19c. PLplot is provided with\n\
6404 basic coastal outlines and USA state borders. To use the map\n\
6405 functionality PLplot must be compiled with the shapelib library.\n\
6406 Shapefiles have become a popular standard for geographical data and\n\
6407 data in this format can be easily found from a number of online\n\
6408 sources. Shapefile data is actually provided as three or more files\n\
6409 with the same filename, but different extensions. The .shp and .shx\n\
6410 files are required for plotting Shapefile data with PLplot.\n\
6411\n\
6412 PLplot currently supports the point, multipoint, polyline and polygon\n\
6413 objects within shapefiles. However holes in polygons are not\n\
6414 supported. When plmap is used the type of object is derived from the\n\
6415 shapefile, if you wish to override the type then use one of the other\n\
6416 plmap variants. The built in maps have line data only.\n\
6417\n\
6418 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6419\n\
6420 This function is used in example 19.\n\
6421\n\
6422\n\
6423\n\
6424SYNOPSIS:\n\
6425\n\
6426plmap(mapform, name, minx, maxx, miny, maxy)\n\
6427\n\
6428ARGUMENTS:\n\
6429\n\
6430 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6431 transform the original map data coordinates to a new coordinate\n\
6432 system. The PLplot-supplied map data is provided as latitudes and\n\
6433 longitudes; other Shapefile data may be provided in other\n\
6434 coordinate systems as can be found in their .prj plain text files.\n\
6435 For example, by using this transform we can change from a\n\
6436 longitude, latitude coordinate to a polar stereographic\n\
6437 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6438 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6439 corresponding y coordinates (latitudes for the PLplot supplied\n\
6440 data). After the call to mapform(), x[] and y[] should be\n\
6441 replaced by the corresponding plot coordinates. If no transform is\n\
6442 desired, mapform can be replaced by NULL.\n\
6443\n\
6444 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6445 the type of map plotted. This is either one of the PLplot built-in\n\
6446 maps or the file name of a set of Shapefile files without the file\n\
6447 extensions. For the PLplot built-in maps the possible values are:\n\
6448 \"globe\" -- continental outlines\n\
6449 \"usa\" -- USA and state boundaries\n\
6450 \"cglobe\" -- continental outlines and countries\n\
6451 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6452\n\
6453\n\
6454 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6455 drawn. The units must match the shapefile (built in maps are\n\
6456 degrees lat/lon). Objects in the file which do not encroach on the\n\
6457 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6458 note this is simply an optimisation, not a clipping so for objects\n\
6459 with some points inside the box and some points outside the box\n\
6460 all the points will be rendered. These parameters also define\n\
6461 latitude and longitude wrapping for shapefiles using these units.\n\
6462 Longitude points will be wrapped by integer multiples of 360\n\
6463 degrees to place them in the box. This allows the same data to be\n\
6464 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6465 you plot from -180-540 you will get two cycles of data drawn. The\n\
6466 value of minx must be less than the value of maxx. Passing in a\n\
6467 nan, max/-max floating point number or +/-infinity will case the\n\
6468 bounding box from the shapefile to be used.\n\
6469\n\
6470 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6471 drawn - see minx.\n\
6472\n\
6473 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6474 drawn - see minx.\n\
6475\n\
6476 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6477 drawn - see minx.\n\
6478";
6479static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6480Calculate broken-down time from continuous time for the current stream\n\
6481\n\
6482DESCRIPTION:\n\
6483\n\
6484 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6485 continuous time, ctime for the current stream. This function is the\n\
6486 inverse of plctime.\n\
6487\n\
6488 The PLplot definition of broken-down time is a calendar time that\n\
6489 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6490 responsibility to apply those offsets (if so desired) before using the\n\
6491 PLplot time API. By default broken-down time is defined using the\n\
6492 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6493 continuous time is defined as the number of seconds since the Unix\n\
6494 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6495 broken-down and continuous time are possible, see plconfigtime.\n\
6496\n\
6497 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6498 ctime)\n\
6499\n\
6500\n\
6501 This function is used in example 29.\n\
6502\n\
6503\n\
6504\n\
6505SYNOPSIS:\n\
6506\n\
6507plbtime(year, month, day, hour, min, sec, ctime)\n\
6508\n\
6509ARGUMENTS:\n\
6510\n\
6511 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6512 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6513 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6514 BCE, etc.)\n\
6515\n\
6516 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6517 the year in the range from 0 (January) to 11 (December).\n\
6518\n\
6519 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6520 month in the range from 1 to 31.\n\
6521\n\
6522 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6523 day in the range from 0 to 23.\n\
6524\n\
6525 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6526 hour in the range from 0 to 59\n\
6527\n\
6528 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6529 minute in range from 0. to 60.\n\
6530\n\
6531 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6532 time is calculated.\n\
6533";
6534static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6535Get current stream number\n\
6536\n\
6537DESCRIPTION:\n\
6538\n\
6539 Gets the number of the current output stream. See also plsstrm.\n\
6540\n\
6541 Redacted form: plgstrm(p_strm)\n\
6542\n\
6543 This function is used in example 1,20.\n\
6544\n\
6545\n\
6546\n\
6547SYNOPSIS:\n\
6548\n\
6549plgstrm(p_strm)\n\
6550\n\
6551ARGUMENTS:\n\
6552\n\
6553 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6554 stream value.\n\
6555";
6556static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6557Draw a line in 3 space\n\
6558\n\
6559DESCRIPTION:\n\
6560\n\
6561 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6562 first set up the viewport, the 2d viewing window (in world\n\
6563 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6564 more info.\n\
6565\n\
6566 Redacted form: plline3(x, y, z)\n\
6567\n\
6568 This function is used in example 18.\n\
6569\n\
6570\n\
6571\n\
6572SYNOPSIS:\n\
6573\n\
6574plline3(n, x, y, z)\n\
6575\n\
6576ARGUMENTS:\n\
6577\n\
6578 n (PLINT, input) : Number of points defining line.\n\
6579\n\
6580 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6581 points.\n\
6582\n\
6583 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6584 points.\n\
6585\n\
6586 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6587 points.\n\
6588";
6589static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6590Load Hershey fonts\n\
6591\n\
6592DESCRIPTION:\n\
6593\n\
6594 Loads the Hershey fonts used for text and symbols. This routine may\n\
6595 be called before or after initializing PLplot. If not explicitly\n\
6596 called before PLplot initialization, then by default that\n\
6597 initialization loads Hershey fonts with the extended character set.\n\
6598 This routine only has a practical effect for devices that still use\n\
6599 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6600 system fonts instead of Hershey fonts).\n\
6601\n\
6602 Redacted form: plfontld(fnt)\n\
6603\n\
6604 This function is used in examples 1 and 7.\n\
6605\n\
6606\n\
6607\n\
6608SYNOPSIS:\n\
6609\n\
6610plfontld(fnt)\n\
6611\n\
6612ARGUMENTS:\n\
6613\n\
6614 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6615 A zero value specifies Hershey fonts with the standard character\n\
6616 set and a non-zero value (the default assumed if plfontld is never\n\
6617 called) specifies Hershey fonts with the extended character set.\n\
6618";
6619static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6620Set any command-line option\n\
6621\n\
6622DESCRIPTION:\n\
6623\n\
6624 Set any command-line option internally from a program before it\n\
6625 invokes plinit. opt is the name of the command-line option and optarg\n\
6626 is the corresponding command-line option argument.\n\
6627\n\
6628 This function returns 0 on success.\n\
6629\n\
6630 Redacted form: plsetopt(opt, optarg)\n\
6631\n\
6632 This function is used in example 14.\n\
6633\n\
6634\n\
6635\n\
6636SYNOPSIS:\n\
6637\n\
6638PLINT plsetopt(opt, optarg)\n\
6639\n\
6640ARGUMENTS:\n\
6641\n\
6642 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6643 the command-line option.\n\
6644\n\
6645 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6646 containing the argument of the command-line option.\n\
6647";
6648static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6649Plot all or a subset of Shapefile data using lines in world coordinates\n\
6650\n\
6651DESCRIPTION:\n\
6652\n\
6653 Plot all or a subset of Shapefile data using lines in world\n\
6654 coordinates. Our 19th standard example demonstrates how to use this\n\
6655 function. This function plots data from a Shapefile using lines as in\n\
6656 plmap, however it also has the option of also only drawing specified\n\
6657 elements from the Shapefile. The vector of indices of the required\n\
6658 elements are passed as a function argument. The Shapefile data should\n\
6659 include a metadata file (extension.dbf) listing all items within the\n\
6660 Shapefile. This file can be opened by most popular spreadsheet\n\
6661 programs and can be used to decide which indices to pass to this\n\
6662 function.\n\
6663\n\
6664 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6665 plotentries)\n\
6666\n\
6667 This function is used in example 19.\n\
6668\n\
6669\n\
6670\n\
6671SYNOPSIS:\n\
6672\n\
6673plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6674\n\
6675ARGUMENTS:\n\
6676\n\
6677 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6678 transform the coordinates given in the shapefile into a plot\n\
6679 coordinate system. By using this transform, we can change from a\n\
6680 longitude, latitude coordinate to a polar stereographic project,\n\
6681 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6682 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6683 mapform(), x[] and y[] should be replaced by the corresponding\n\
6684 plot coordinates. If no transform is desired, mapform can be\n\
6685 replaced by NULL.\n\
6686\n\
6687 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6688 the file name of a set of Shapefile files without the file\n\
6689 extension.\n\
6690\n\
6691 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6692 be in the same units as used by the Shapefile. You could use a\n\
6693 very large negative number to plot everything, but you can improve\n\
6694 performance by limiting the area drawn. The units must match those\n\
6695 of the Shapefile projection, which may be for example longitude or\n\
6696 distance. The value of minx must be less than the value of maxx.\n\
6697\n\
6698 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6699 use a very large number to plot everything, but you can improve\n\
6700 performance by limiting the area drawn.\n\
6701\n\
6702 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6703 be in the same units as used by the Shapefile. You could use a\n\
6704 very large negative number to plot everything, but you can improve\n\
6705 performance by limiting the area drawn. The units must match those\n\
6706 of the Shapefile projection, which may be for example latitude or\n\
6707 distance. The value of miny must be less than the value of maxy.\n\
6708\n\
6709 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6710 use a very large number to plot everything, but you can improve\n\
6711 performance by limiting the area drawn.\n\
6712\n\
6713 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6714 zero-based indices of the Shapefile elements which will be drawn.\n\
6715 Setting\n\
6716 plotentries to NULL will plot all elements of the Shapefile.\n\
6717\n\
6718 nplotentries (PLINT, input) : The number of items in\n\
6719 plotentries. Ignored if\n\
6720 plotentries is NULL.\n\
6721";
6722static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6723Used to globally turn color output on/off\n\
6724\n\
6725DESCRIPTION:\n\
6726\n\
6727 Used to globally turn color output on/off for those drivers/devices\n\
6728 that support it.\n\
6729\n\
6730 Redacted form: plscolor(color)\n\
6731\n\
6732 This function is used in example 31.\n\
6733\n\
6734\n\
6735\n\
6736SYNOPSIS:\n\
6737\n\
6738plscolor(color)\n\
6739\n\
6740ARGUMENTS:\n\
6741\n\
6742 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6743 turned off. If non-zero, color is turned on.\n\
6744";
6745static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6746Wait for graphics input event and translate to world coordinates.\n\
6747\n\
6748DESCRIPTION:\n\
6749\n\
6750 Wait for graphics input event and translate to world coordinates.\n\
6751 Returns 0 if no translation to world coordinates is possible.\n\
6752\n\
6753 This function returns 1 on success and 0 if no translation to world\n\
6754 coordinates is possible.\n\
6755\n\
6756 Redacted form: plGetCursor(gin)\n\
6757\n\
6758 This function is used in examples 1 and 20.\n\
6759\n\
6760\n\
6761\n\
6762SYNOPSIS:\n\
6763\n\
6764PLINT plGetCursor(gin)\n\
6765\n\
6766ARGUMENTS:\n\
6767\n\
6768 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6769 which will contain the output. The structure is not allocated by\n\
6770 the routine and must exist before the function is called.\n\
6771";
6772static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6773Get the current device (keyword) name\n\
6774\n\
6775DESCRIPTION:\n\
6776\n\
6777 Get the current device (keyword) name. Note: you must have allocated\n\
6778 space for this (80 characters is safe).\n\
6779\n\
6780 Redacted form: plgdev(p_dev)\n\
6781\n\
6782 This function is used in example 14.\n\
6783\n\
6784\n\
6785\n\
6786SYNOPSIS:\n\
6787\n\
6788plgdev(p_dev)\n\
6789\n\
6790ARGUMENTS:\n\
6791\n\
6792 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6793 (with preallocated length of 80 characters or more) containing the\n\
6794 device (keyword) name.\n\
6795";
6796static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6797Add a point to a strip chart\n\
6798\n\
6799DESCRIPTION:\n\
6800\n\
6801 Add a point to a given pen of a given strip chart. There is no need\n\
6802 for all pens to have the same number of points or to be equally\n\
6803 sampled in the x coordinate. Allocates memory and rescales as\n\
6804 necessary.\n\
6805\n\
6806 Redacted form: plstripa(id, pen, x, y)\n\
6807\n\
6808 This function is used in example 17.\n\
6809\n\
6810\n\
6811\n\
6812SYNOPSIS:\n\
6813\n\
6814plstripa(id, pen, x, y)\n\
6815\n\
6816ARGUMENTS:\n\
6817\n\
6818 id (PLINT, input) : Identification number of the strip chart (set\n\
6819 up in plstripc).\n\
6820\n\
6821 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6822\n\
6823 x (PLFLT, input) : X coordinate of point to plot.\n\
6824\n\
6825 y (PLFLT, input) : Y coordinate of point to plot.\n\
6826";
6827static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6828Create a 4-pen strip chart\n\
6829\n\
6830DESCRIPTION:\n\
6831\n\
6832 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6833\n\
6834 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6835 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6836 styline, legline, labx, laby, labz)\n\
6837\n\
6838\n\
6839 This function is used in example 17.\n\
6840\n\
6841\n\
6842\n\
6843SYNOPSIS:\n\
6844\n\
6845plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6846\n\
6847ARGUMENTS:\n\
6848\n\
6849 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6850 number of the strip chart to use on plstripa and plstripd.\n\
6851\n\
6852 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6853 the x-axis specification as in plbox.\n\
6854\n\
6855 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6856 the y-axis specification as in plbox.\n\
6857\n\
6858 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6859 change as data are added.\n\
6860\n\
6861 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6862 change as data are added.\n\
6863\n\
6864 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6865 is multiplied by the factor (1 +\n\
6866 xjump) .\n\
6867\n\
6868 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6869 change as data are added.\n\
6870\n\
6871 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6872 change as data are added.\n\
6873\n\
6874 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6875\n\
6876 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6877\n\
6878 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6879 true, otherwise not.\n\
6880\n\
6881 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6882 otherwise slide display.\n\
6883\n\
6884 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6885\n\
6886 collab (PLINT, input) : Legend color index (cmap0).\n\
6887\n\
6888 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6889 indices for the 4 pens.\n\
6890\n\
6891 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6892 indices for the 4 pens.\n\
6893\n\
6894 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6895 strings containing legends for the 4 pens.\n\
6896\n\
6897 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6898 the label for the x axis.\n\
6899\n\
6900 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6901 the label for the y axis.\n\
6902\n\
6903 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6904 the plot title.\n\
6905";
6906static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6907Deletes and releases memory used by a strip chart\n\
6908\n\
6909DESCRIPTION:\n\
6910\n\
6911 Deletes and releases memory used by a strip chart.\n\
6912\n\
6913 Redacted form: plstripd(id)\n\
6914\n\
6915 This function is used in example 17.\n\
6916\n\
6917\n\
6918\n\
6919SYNOPSIS:\n\
6920\n\
6921plstripd(id)\n\
6922\n\
6923ARGUMENTS:\n\
6924\n\
6925 id (PLINT, input) : Identification number of strip chart to delete.\n\
6926";
6927static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6928Specify viewport using coordinates and aspect ratio\n\
6929\n\
6930DESCRIPTION:\n\
6931\n\
6932 Device-independent routine for setting up the viewport. The viewport\n\
6933 is chosen to be the largest with the given aspect ratio that fits\n\
6934 within the specified region (in terms of normalized subpage\n\
6935 coordinates). This routine is functionally equivalent to plvpor when\n\
6936 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6937 routine reserves no extra space at the edges for labels.\n\
6938\n\
6939 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6940\n\
6941 This function is used in example 9.\n\
6942\n\
6943\n\
6944\n\
6945SYNOPSIS:\n\
6946\n\
6947plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6948\n\
6949ARGUMENTS:\n\
6950\n\
6951 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6952 left-hand edge of the viewport.\n\
6953\n\
6954 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6955 right-hand edge of the viewport.\n\
6956\n\
6957 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6958 bottom edge of the viewport.\n\
6959\n\
6960 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6961 edge of the viewport.\n\
6962\n\
6963 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6964 axis.\n\
6965";
6966static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6967Assign a function to use for generating custom axis labels\n\
6968\n\
6969DESCRIPTION:\n\
6970\n\
6971 This function allows a user to provide their own function to provide\n\
6972 axis label text. The user function is given the numeric value for a\n\
6973 point on an axis and returns a string label to correspond with that\n\
6974 value. Custom axis labels can be enabled by passing appropriate\n\
6975 arguments to plenv, plbox, plbox3 and similar functions.\n\
6976\n\
6977 This function is used in example 19.\n\
6978\n\
6979\n\
6980\n\
6981SYNOPSIS:\n\
6982\n\
6983plslabelfunc(label_func, label_data)\n\
6984\n\
6985ARGUMENTS:\n\
6986\n\
6987 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6988 label function. In order to reset to the default labelling, set\n\
6989 this to NULL. The labelling function parameters are, in order:\n\
6990 axis: This indicates which axis a label is being requested for.\n\
6991 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6992\n\
6993 value: This is the value along the axis which is being labelled.\n\
6994\n\
6995 label_text: The string representation of the label value.\n\
6996\n\
6997 length: The maximum length in characters allowed for label_text.\n\
6998\n\
6999\n\
7000 label_data (PLPointer, input) : This parameter may be used to pass\n\
7001 data to the label_func function.\n\
7002";
7003static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
7004Set length of major ticks\n\
7005\n\
7006DESCRIPTION:\n\
7007\n\
7008 This sets up the length of the major ticks. The actual length is the\n\
7009 product of the default length and a scaling factor as for character\n\
7010 height.\n\
7011\n\
7012 Redacted form: plsmaj(def, scale)\n\
7013\n\
7014 This function is used in example 29.\n\
7015\n\
7016\n\
7017\n\
7018SYNOPSIS:\n\
7019\n\
7020plsmaj(def, scale)\n\
7021\n\
7022ARGUMENTS:\n\
7023\n\
7024 def (PLFLT, input) : The default length of a major tick in\n\
7025 millimeters, should be set to zero if the default length is to\n\
7026 remain unchanged.\n\
7027\n\
7028 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
7029 actual tick length.\n\
7030";
7031static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
7032Get the current library version number\n\
7033\n\
7034DESCRIPTION:\n\
7035\n\
7036 Get the current library version number. Note: you must have allocated\n\
7037 space for this (80 characters is safe).\n\
7038\n\
7039 Redacted form: plgver(p_ver)\n\
7040\n\
7041 This function is used in example 1.\n\
7042\n\
7043\n\
7044\n\
7045SYNOPSIS:\n\
7046\n\
7047plgver(p_ver)\n\
7048\n\
7049ARGUMENTS:\n\
7050\n\
7051 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
7052 (with preallocated length of 80 characters or more) containing the\n\
7053 PLplot version number.\n\
7054";
7055static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
7056Set format of numerical label for contours\n\
7057\n\
7058DESCRIPTION:\n\
7059\n\
7060 Set format of numerical label for contours.\n\
7061\n\
7062 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
7063\n\
7064 This function is used example 9.\n\
7065\n\
7066\n\
7067\n\
7068SYNOPSIS:\n\
7069\n\
7070pl_setcontlabelformat(lexp, sigdig)\n\
7071\n\
7072ARGUMENTS:\n\
7073\n\
7074 lexp (PLINT, input) : If the contour numerical label is greater\n\
7075 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
7076 format is used. Default value of lexp is 4.\n\
7077\n\
7078 sigdig (PLINT, input) : Number of significant digits. Default\n\
7079 value is 2.\n\
7080";
7081static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
7082Parse command-line arguments\n\
7083\n\
7084DESCRIPTION:\n\
7085\n\
7086 Parse command-line arguments.\n\
7087\n\
7088 plparseopts removes all recognized flags (decreasing argc\n\
7089 accordingly), so that invalid input may be readily detected. It can\n\
7090 also be used to process user command line flags. The user can merge\n\
7091 an option table of type PLOptionTable into the internal option table\n\
7092 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7093 the external table(s) be parsed by calling plClearOpts before\n\
7094 plMergeOpts.\n\
7095\n\
7096 The default action taken by plparseopts is as follows:\n\
7097 Returns with an error if an unrecognized option or badly formed\n\
7098 option-value pair are encountered.\n\
7099 Returns immediately (return code 0) when the first non-option command\n\
7100 line argument is found.\n\
7101 Returns with the return code of the option handler, if one was called.\n\
7102\n\
7103 Deletes command line arguments from argv list as they are found, and\n\
7104 decrements argc accordingly.\n\
7105 Does not show \"invisible\" options in usage or help messages.\n\
7106 Assumes the program name is contained in argv[0].\n\
7107\n\
7108 These behaviors may be controlled through the\n\
7109 mode argument.\n\
7110\n\
7111 Redacted form: General: plparseopts(argv, mode)\n\
7112\n\
7113\n\
7114 This function is used in all of the examples.\n\
7115\n\
7116\n\
7117\n\
7118SYNOPSIS:\n\
7119\n\
7120PLINT plparseopts(p_argc, argv, mode)\n\
7121\n\
7122ARGUMENTS:\n\
7123\n\
7124 p_argc (int *, input/output) : Number of arguments.\n\
7125\n\
7126 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7127 strings containing *p_argc command-line arguments.\n\
7128\n\
7129 mode (PLINT, input) : Parsing mode with the following\n\
7130 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7131 and all error messages enabled, including program exit when an\n\
7132 error occurs. Anything on the command line that isn\'t recognized\n\
7133 as a valid option or option argument is flagged as an error.\n\
7134 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7135 of errors.\n\
7136 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7137 arguments.\n\
7138 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7139 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7140 pointer to the program name.\n\
7141 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7142 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7143 unrecognized arguments.\n\
7144";
7145static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7146Initialization\n\
7147\n\
7148DESCRIPTION:\n\
7149\n\
7150 Initializing the plotting package. The program prompts for the device\n\
7151 keyword or number of the desired output device. Hitting a RETURN in\n\
7152 response to the prompt is the same as selecting the first device. If\n\
7153 only one device is enabled when PLplot is installed, plstar will issue\n\
7154 no prompt. The output device is divided into nx by ny subpages, each\n\
7155 of which may be used independently. The subroutine pladv is used to\n\
7156 advance from one subpage to the next.\n\
7157\n\
7158 Redacted form: plstar(nx, ny)\n\
7159\n\
7160 This function is used in example 1.\n\
7161\n\
7162\n\
7163\n\
7164SYNOPSIS:\n\
7165\n\
7166plstar(nx, ny)\n\
7167\n\
7168ARGUMENTS:\n\
7169\n\
7170 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7171 x direction.\n\
7172\n\
7173 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7174 y direction.\n\
7175";
7176static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7177Get FCI (font characterization integer)\n\
7178\n\
7179DESCRIPTION:\n\
7180\n\
7181 Gets information about the current font using the FCI approach. See\n\
7182 the PLplot documentation for more information.\n\
7183\n\
7184 Redacted form: plgfci(p_fci)\n\
7185\n\
7186 This function is used in example 23.\n\
7187\n\
7188\n\
7189\n\
7190SYNOPSIS:\n\
7191\n\
7192plgfci(p_fci)\n\
7193\n\
7194ARGUMENTS:\n\
7195\n\
7196 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7197 FCI value.\n\
7198";
7199static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7200Set family file parameters\n\
7201\n\
7202DESCRIPTION:\n\
7203\n\
7204 Sets variables dealing with output file familying. Does nothing if\n\
7205 familying not supported by the driver. This routine, if used, must be\n\
7206 called before initializing PLplot. See the PLplot documentation for\n\
7207 more information.\n\
7208\n\
7209 Redacted form: plsfam(fam, num, bmax)\n\
7210\n\
7211 This function is used in examples 14 and 31.\n\
7212\n\
7213\n\
7214\n\
7215SYNOPSIS:\n\
7216\n\
7217plsfam(fam, num, bmax)\n\
7218\n\
7219ARGUMENTS:\n\
7220\n\
7221 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7222 is enabled.\n\
7223\n\
7224 num (PLINT, input) : Current family file number.\n\
7225\n\
7226 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7227 file.\n\
7228";
7229static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7230Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7231\n\
7232DESCRIPTION:\n\
7233\n\
7234 This is a variant of plscmap1l that supports alpha channel\n\
7235 transparency. It sets cmap1 colors using a piece-wise linear\n\
7236 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7237 HLS or RGB color space (see the PLplot documentation) with alpha\n\
7238 transparency value (0.0-1.0). It may be called at any time.\n\
7239\n\
7240 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7241 alpha, alt_hue_path)\n\
7242\n\
7243 This function is used in example 30.\n\
7244\n\
7245\n\
7246\n\
7247SYNOPSIS:\n\
7248\n\
7249plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7250\n\
7251ARGUMENTS:\n\
7252\n\
7253 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7254\n\
7255 npts (PLINT, input) : number of control points.\n\
7256\n\
7257 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7258 intensity index (0.0-1.0) in ascending order for each control\n\
7259 point.\n\
7260\n\
7261 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7262 coordinate (H or R) for each control point.\n\
7263\n\
7264 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7265 coordinate (L or G) for each control point.\n\
7266\n\
7267 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7268 coordinate (S or B) for each control point.\n\
7269\n\
7270 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7271 transparency value (0.0-1.0) for each control point.\n\
7272\n\
7273 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7274 npts - 1 elements) containing the alternative interpolation method\n\
7275 Boolean value for each control point interval. (alt_hue_path[i]\n\
7276 refers to the interpolation interval between the i and i + 1\n\
7277 control points).\n\
7278";
7279static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7280Set page parameters\n\
7281\n\
7282DESCRIPTION:\n\
7283\n\
7284 Sets the page configuration (optional). If an individual parameter is\n\
7285 zero then that parameter value is not updated. Not all parameters are\n\
7286 recognized by all drivers and the interpretation is device-dependent.\n\
7287 The X-window driver uses the length and offset parameters to determine\n\
7288 the window size and location. The length and offset values are\n\
7289 expressed in units that are specific to the current driver. For\n\
7290 instance: screen drivers will usually interpret them as number of\n\
7291 pixels, whereas printer drivers will usually use mm.\n\
7292\n\
7293 This routine, if used, must be called before initializing PLplot. It\n\
7294 may be called at later times for interactive drivers to change only\n\
7295 the dpi for subsequent redraws which you can force via a call to\n\
7296 plreplot. If this function is not called then the page size defaults\n\
7297 to landscape A4 for drivers which use real world page sizes and 744\n\
7298 pixels wide by 538 pixels high for raster drivers. The default value\n\
7299 for dx and dy is 90 pixels per inch for raster drivers.\n\
7300\n\
7301\n\
7302\n\
7303 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7304\n\
7305 This function is used in examples 14 and 31.\n\
7306\n\
7307\n\
7308\n\
7309SYNOPSIS:\n\
7310\n\
7311plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7312\n\
7313ARGUMENTS:\n\
7314\n\
7315 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7316 by raster drivers, ignored by drivers which use \"real world\" units\n\
7317 (e.g. mm).\n\
7318\n\
7319 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7320 by raster drivers, ignored by drivers which use \"real world\" units\n\
7321 (e.g. mm).\n\
7322\n\
7323 xleng (PLINT, input) : Page length, x.\n\
7324\n\
7325 yleng (PLINT, input) : Page length, y.\n\
7326\n\
7327 xoff (PLINT, input) : Page offset, x.\n\
7328\n\
7329 yoff (PLINT, input) : Page offset, y.\n\
7330";
7331static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7332Set precision in numeric labels\n\
7333\n\
7334DESCRIPTION:\n\
7335\n\
7336 Sets the number of places after the decimal point in numeric labels.\n\
7337\n\
7338 Redacted form: plprec(setp, prec)\n\
7339\n\
7340 This function is used in example 29.\n\
7341\n\
7342\n\
7343\n\
7344SYNOPSIS:\n\
7345\n\
7346plprec(setp, prec)\n\
7347\n\
7348ARGUMENTS:\n\
7349\n\
7350 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7351 automatically determines the number of places to use after the\n\
7352 decimal point in numeric labels (like those used to label axes).\n\
7353 If setp is 1 then prec sets the number of places.\n\
7354\n\
7355 prec (PLINT, input) : The number of characters to draw after the\n\
7356 decimal point in numeric labels.\n\
7357";
7358static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7359Copy state parameters from the reference stream to the current stream\n\
7360\n\
7361DESCRIPTION:\n\
7362\n\
7363 Copies state parameters from the reference stream to the current\n\
7364 stream. Tell driver interface to map device coordinates unless flags\n\
7365 == 1.\n\
7366\n\
7367 This function is used for making save files of selected plots (e.g.\n\
7368 from the TK driver). After initializing, you can get a copy of the\n\
7369 current plot to the specified device by switching to this stream and\n\
7370 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7371 appropriate. The plot buffer must have previously been enabled (done\n\
7372 automatically by some display drivers, such as X).\n\
7373\n\
7374 Redacted form: plcpstrm(iplsr, flags)\n\
7375\n\
7376 This function is used in example 1,20.\n\
7377\n\
7378\n\
7379\n\
7380SYNOPSIS:\n\
7381\n\
7382plcpstrm(iplsr, flags)\n\
7383\n\
7384ARGUMENTS:\n\
7385\n\
7386 iplsr (PLINT, input) : Number of reference stream.\n\
7387\n\
7388 flags (PLBOOL, input) : If flags is set to true the device\n\
7389 coordinates are not copied from the reference to current stream.\n\
7390";
7391static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7392Plot a glyph at the specified points\n\
7393\n\
7394DESCRIPTION:\n\
7395\n\
7396 Plot a glyph at the specified points. (This function is largely\n\
7397 superseded by plstring which gives access to many[!] more glyphs.)\n\
7398 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7399 and a draw at the same place. Not ideal, since a sufficiently\n\
7400 intelligent output device may optimize it away, or there may be faster\n\
7401 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7402 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7403 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7404 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7405 code <= 127 the corresponding printable ASCII character is plotted.\n\
7406\n\
7407 Redacted form: plpoin(x, y, code)\n\
7408\n\
7409 This function is used in examples 1, 6, 14, and 29.\n\
7410\n\
7411\n\
7412\n\
7413SYNOPSIS:\n\
7414\n\
7415plpoin(n, x, y, code)\n\
7416\n\
7417ARGUMENTS:\n\
7418\n\
7419 n (PLINT, input) : Number of points in the x and y vectors.\n\
7420\n\
7421 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7422 points.\n\
7423\n\
7424 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7425 points.\n\
7426\n\
7427 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7428 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7429 each of the n points.\n\
7430";
7431static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7432Enter or leave xor mode\n\
7433\n\
7434DESCRIPTION:\n\
7435\n\
7436 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7437 those drivers (e.g., the xwin driver) that support it. Enables\n\
7438 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7439 is not capable of xor operation it returns a status of false.\n\
7440\n\
7441 Redacted form: plxormod(mode, status)\n\
7442\n\
7443 This function is used in examples 1 and 20.\n\
7444\n\
7445\n\
7446\n\
7447SYNOPSIS:\n\
7448\n\
7449plxormod(mode, status)\n\
7450\n\
7451ARGUMENTS:\n\
7452\n\
7453 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7454 is false means leave xor mode.\n\
7455\n\
7456 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7457 modestatus of true (false) means driver is capable (incapable) of\n\
7458 xor mode.\n\
7459";
7460static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7461Get viewport limits in normalized device coordinates\n\
7462\n\
7463DESCRIPTION:\n\
7464\n\
7465 Get viewport limits in normalized device coordinates.\n\
7466\n\
7467 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7468\n\
7469\n\
7470 This function is used in example 31.\n\
7471\n\
7472\n\
7473\n\
7474SYNOPSIS:\n\
7475\n\
7476plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7477\n\
7478ARGUMENTS:\n\
7479\n\
7480 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7481 viewport limit of the normalized device coordinate in x.\n\
7482\n\
7483 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7484 viewport limit of the normalized device coordinate in x.\n\
7485\n\
7486 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7487 viewport limit of the normalized device coordinate in y.\n\
7488\n\
7489 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7490 viewport limit of the normalized device coordinate in y.\n\
7491";
7492static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7493Plot surface mesh\n\
7494\n\
7495DESCRIPTION:\n\
7496\n\
7497 Plots a surface mesh within the environment set up by plw3d. The\n\
7498 surface is defined by the matrix z[\n\
7499 nx][\n\
7500 ny] , the point z[i][j] being the value of the function at (\n\
7501 x[i],\n\
7502 y[j]). Note that the points in vectors x and y do not need to be\n\
7503 equally spaced, but must be stored in ascending order. The parameter\n\
7504 opt controls the way in which the surface is displayed. For further\n\
7505 details see the PLplot documentation.\n\
7506\n\
7507 Redacted form: plmesh(x, y, z, opt)\n\
7508\n\
7509 This function is used in example 11.\n\
7510\n\
7511\n\
7512\n\
7513SYNOPSIS:\n\
7514\n\
7515plmesh(x, y, z, nx, ny, opt)\n\
7516\n\
7517ARGUMENTS:\n\
7518\n\
7519 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7520 which the function is evaluated.\n\
7521\n\
7522 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7523 which the function is evaluated.\n\
7524\n\
7525 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7526 plot. Should have dimensions of\n\
7527 nx by\n\
7528 ny.\n\
7529\n\
7530 nx (PLINT, input) : Number of x values at which function has been\n\
7531 evaluated.\n\
7532\n\
7533 ny (PLINT, input) : Number of y values at which function has been\n\
7534 evaluated.\n\
7535\n\
7536 opt (PLINT, input) : Determines the way in which the surface is\n\
7537 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7538 function of x for each value of y[j] .\n\
7539 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7540 for each value of x[i] .\n\
7541 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7542 at which function is defined.\n\
7543";
7544static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7545Magnitude colored plot surface mesh with contour\n\
7546\n\
7547DESCRIPTION:\n\
7548\n\
7549 A more powerful form of plmesh: the surface mesh can be colored\n\
7550 accordingly to the current z value being plotted, a contour plot can\n\
7551 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7552 plotted function border and the base XY plane.\n\
7553\n\
7554 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7555\n\
7556 This function is used in example 11.\n\
7557\n\
7558\n\
7559\n\
7560SYNOPSIS:\n\
7561\n\
7562plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7563\n\
7564ARGUMENTS:\n\
7565\n\
7566 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7567 which the function is evaluated.\n\
7568\n\
7569 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7570 which the function is evaluated.\n\
7571\n\
7572 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7573 plot. Should have dimensions of\n\
7574 nx by\n\
7575 ny.\n\
7576\n\
7577 nx (PLINT, input) : Number of x values at which function is\n\
7578 evaluated.\n\
7579\n\
7580 ny (PLINT, input) : Number of y values at which function is\n\
7581 evaluated.\n\
7582\n\
7583 opt (PLINT, input) : Determines the way in which the surface is\n\
7584 represented. To specify more than one option just add the options,\n\
7585 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7586 showing z as a function of x for each value of y[j] .\n\
7587 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7588 for each value of x[i] .\n\
7589 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7590 at which function is defined.\n\
7591 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7592 the z value being plotted. The color is used from the current\n\
7593 cmap1.\n\
7594 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7595 using parameters\n\
7596 nlevel and\n\
7597 clevel.\n\
7598 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7599 the borders of the plotted function.\n\
7600\n\
7601\n\
7602 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7603 levels.\n\
7604\n\
7605 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7606";
7607static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7608End plotting session for current stream\n\
7609\n\
7610DESCRIPTION:\n\
7611\n\
7612 Ends a plotting session for the current output stream only. See\n\
7613 plsstrm for more info.\n\
7614\n\
7615 Redacted form: plend1()\n\
7616\n\
7617 This function is used in examples 1 and 20.\n\
7618\n\
7619\n\
7620\n\
7621SYNOPSIS:\n\
7622\n\
7623plend1()\n\
7624";
7625static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7626Get y axis parameters\n\
7627\n\
7628DESCRIPTION:\n\
7629\n\
7630 Identical to plgxax, except that arguments are flags for y axis. See\n\
7631 the description of plgxax for more detail.\n\
7632\n\
7633 Redacted form: plgyax(p_digmax, p_digits)\n\
7634\n\
7635 This function is used in example 31.\n\
7636\n\
7637\n\
7638\n\
7639SYNOPSIS:\n\
7640\n\
7641plgyax(p_digmax, p_digits)\n\
7642\n\
7643ARGUMENTS:\n\
7644\n\
7645 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7646 number of digits for the y axis. If nonzero, the printed label\n\
7647 has been switched to a floating-point representation when the\n\
7648 number of digits exceeds this value.\n\
7649\n\
7650 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7651 number of digits for the numeric labels (y axis) from the last\n\
7652 plot.\n\
7653";
7654static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7655Set plot orientation\n\
7656\n\
7657DESCRIPTION:\n\
7658\n\
7659 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7660 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7661 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7662 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7663 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7664 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7665 not called the default value of rot is 0.\n\
7666\n\
7667 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7668 probably want to change the aspect ratio to a value suitable for the\n\
7669 plot orientation using a call to plsdidev or the command-line options\n\
7670 -a or -freeaspect. For more documentation of those options see the\n\
7671 PLplot documentation. Such command-line options can be set internally\n\
7672 using plsetopt or set directly using the command line and parsed using\n\
7673 a call to plparseopts.\n\
7674\n\
7675 Redacted form: plsdiori(rot)\n\
7676\n\
7677 This function is not used in any examples.\n\
7678\n\
7679\n\
7680\n\
7681SYNOPSIS:\n\
7682\n\
7683plsdiori(rot)\n\
7684\n\
7685ARGUMENTS:\n\
7686\n\
7687 rot (PLFLT, input) : Plot orientation parameter.\n\
7688";
7689static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7690Plot a histogram from unbinned data\n\
7691\n\
7692DESCRIPTION:\n\
7693\n\
7694 Plots a histogram from n data points stored in the data vector. This\n\
7695 routine bins the data into nbin bins equally spaced between datmin and\n\
7696 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7697 opt allows, among other things, the histogram either to be plotted in\n\
7698 an existing window or causes plhist to call plenv with suitable limits\n\
7699 before plotting the histogram.\n\
7700\n\
7701 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7702\n\
7703 This function is used in example 5.\n\
7704\n\
7705\n\
7706\n\
7707SYNOPSIS:\n\
7708\n\
7709plhist(n, data, datmin, datmax, nbin, opt)\n\
7710\n\
7711ARGUMENTS:\n\
7712\n\
7713 n (PLINT, input) : Number of data points.\n\
7714\n\
7715 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7716 n data points.\n\
7717\n\
7718 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7719\n\
7720 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7721\n\
7722 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7723 divide the interval xmin to xmax.\n\
7724\n\
7725 opt (PLINT, input) : Is a combination of several flags:\n\
7726 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7727 the histogram data, the outer bins are expanded to fill up the\n\
7728 entire x-axis, data outside the given extremes are assigned to the\n\
7729 outer bins and bins of zero height are simply drawn.\n\
7730 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7731 to fit the histogram data, without this flag, plenv is called\n\
7732 to set the world coordinates.\n\
7733 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7734 extremes are not taken into account. This option should\n\
7735 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7736 properly present the data.\n\
7737 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7738 size as the ones inside.\n\
7739 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7740 (there is a gap for such bins).\n\
7741";
7742static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7743End plotting session\n\
7744\n\
7745DESCRIPTION:\n\
7746\n\
7747 Ends a plotting session, tidies up all the output files, switches\n\
7748 interactive devices back into text mode and frees up any memory that\n\
7749 was allocated. Must be called before end of program.\n\
7750\n\
7751 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7752 wait state after a call to plend or other functions which trigger the\n\
7753 end of a plot page. To avoid this, use the plspause function.\n\
7754\n\
7755 Redacted form: plend()\n\
7756\n\
7757 This function is used in all of the examples.\n\
7758\n\
7759\n\
7760\n\
7761SYNOPSIS:\n\
7762\n\
7763plend()\n\
7764";
7765static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7766Plot shaded 3-d surface plot\n\
7767\n\
7768DESCRIPTION:\n\
7769\n\
7770 Plots a three-dimensional shaded surface plot within the environment\n\
7771 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7772 z[\n\
7773 nx][\n\
7774 ny], the point z[i][j] being the value of the function at (\n\
7775 x[i],\n\
7776 y[j]). Note that the points in vectors x and y do not need to be\n\
7777 equally spaced, but must be stored in ascending order. For further\n\
7778 details see the PLplot documentation.\n\
7779\n\
7780 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7781\n\
7782 This function is not used in any examples.\n\
7783\n\
7784\n\
7785\n\
7786SYNOPSIS:\n\
7787\n\
7788plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7789\n\
7790ARGUMENTS:\n\
7791\n\
7792 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7793 which the function is evaluated.\n\
7794\n\
7795 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7796 which the function is evaluated.\n\
7797\n\
7798 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7799 plot. Should have dimensions of\n\
7800 nx by\n\
7801 ny.\n\
7802\n\
7803 nx (PLINT, input) : Number of x values at which function is\n\
7804 evaluated.\n\
7805\n\
7806 ny (PLINT, input) : Number of y values at which function is\n\
7807 evaluated.\n\
7808\n\
7809 opt (PLINT, input) : Determines the way in which the surface is\n\
7810 represented. To specify more than one option just add the options,\n\
7811 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7812 connecting points at which function is defined.\n\
7813 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7814 using parameters\n\
7815 nlevel and\n\
7816 clevel.\n\
7817 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7818 using parameters\n\
7819 nlevel and\n\
7820 clevel.\n\
7821 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7822 the borders of the plotted function.\n\
7823 opt=MAG_COLOR : the surface is colored according to the value\n\
7824 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7825 according to the intensity of the reflected light in the\n\
7826 surface from a light source whose position is set using\n\
7827 pllightsource.\n\
7828\n\
7829\n\
7830 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7831 levels.\n\
7832\n\
7833 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7834";
7835static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7836Set device-compression level\n\
7837\n\
7838DESCRIPTION:\n\
7839\n\
7840 Set device-compression level. Only used for drivers that provide\n\
7841 compression. This function, if used, should be invoked before a call\n\
7842 to plinit.\n\
7843\n\
7844 Redacted form: plscompression(compression)\n\
7845\n\
7846 This function is used in example 31.\n\
7847\n\
7848\n\
7849\n\
7850SYNOPSIS:\n\
7851\n\
7852plscompression(compression)\n\
7853\n\
7854ARGUMENTS:\n\
7855\n\
7856 compression (PLINT, input) : The desired compression level. This is\n\
7857 a device-dependent value. Currently only the jpeg and png devices\n\
7858 use these values. For jpeg value is the jpeg quality which should\n\
7859 normally be in the range 0-95. Higher values denote higher quality\n\
7860 and hence larger image sizes. For png values are in the range -1\n\
7861 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7862 A value of -1 denotes the default zlib compression level. Values\n\
7863 in the range 10-99 are divided by 10 and then used as the zlib\n\
7864 compression level. Higher compression levels correspond to greater\n\
7865 compression and small file sizes at the expense of more\n\
7866 computation.\n\
7867";
7868static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7869Get the current device-compression setting\n\
7870\n\
7871DESCRIPTION:\n\
7872\n\
7873 Get the current device-compression setting. This parameter is only\n\
7874 used for drivers that provide compression.\n\
7875\n\
7876 Redacted form: plgcompression(compression)\n\
7877\n\
7878 This function is used in example 31.\n\
7879\n\
7880\n\
7881\n\
7882SYNOPSIS:\n\
7883\n\
7884plgcompression(compression)\n\
7885\n\
7886ARGUMENTS:\n\
7887\n\
7888 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7889 compression setting for the current device.\n\
7890";
7891static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7892Advance the (sub-)page\n\
7893\n\
7894DESCRIPTION:\n\
7895\n\
7896 Advances to the next subpage if sub=0, performing a page advance if\n\
7897 there are no remaining subpages on the current page. If subpages\n\
7898 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7899 PLplot switches to the specified subpage. Note that this allows you\n\
7900 to overwrite a plot on the specified subpage; if this is not what you\n\
7901 intended, use pleop followed by plbop to first advance the page. This\n\
7902 routine is called automatically (with page=0) by plenv, but if plenv\n\
7903 is not used, pladv must be called after initializing PLplot but before\n\
7904 defining the viewport.\n\
7905\n\
7906 Redacted form: pladv(page)\n\
7907\n\
7908 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7909 29, and 31.\n\
7910\n\
7911\n\
7912\n\
7913SYNOPSIS:\n\
7914\n\
7915pladv(page)\n\
7916\n\
7917ARGUMENTS:\n\
7918\n\
7919 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7920 in the top left corner and increasing along the rows) to which to\n\
7921 advance. Set to zero to advance to the next subpage (or to the\n\
7922 next page if subpages are not being used).\n\
7923";
7924static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7925Set parameters of contour labelling other than format of numerical label\n\
7926\n\
7927DESCRIPTION:\n\
7928\n\
7929 Set parameters of contour labelling other than those handled by\n\
7930 pl_setcontlabelformat.\n\
7931\n\
7932 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7933\n\
7934 This function is used in example 9.\n\
7935\n\
7936\n\
7937\n\
7938SYNOPSIS:\n\
7939\n\
7940pl_setcontlabelparam(offset, size, spacing, active)\n\
7941\n\
7942ARGUMENTS:\n\
7943\n\
7944 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7945 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7946\n\
7947 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7948 Default value is 0.3.\n\
7949\n\
7950 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7951 Default value is 0.1.\n\
7952\n\
7953 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7954 contour labels on. Default is off (0).\n\
7955";
7956static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7957Set family, style and weight of the current font\n\
7958\n\
7959DESCRIPTION:\n\
7960\n\
7961 Sets the current font. See the PLplot documentation for more\n\
7962 information on font selection.\n\
7963\n\
7964 Redacted form: plsfont(family, style, weight)\n\
7965\n\
7966 This function is used in example 23.\n\
7967\n\
7968\n\
7969\n\
7970SYNOPSIS:\n\
7971\n\
7972plsfont(family, style, weight)\n\
7973\n\
7974ARGUMENTS:\n\
7975\n\
7976 family (PLINT, input) : Font family to select for the current font.\n\
7977 The available values are given by the PL_FCI_* constants in\n\
7978 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7979 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7980 signifies that the font family should not be altered.\n\
7981\n\
7982 style (PLINT, input) : Font style to select for the current font.\n\
7983 The available values are given by the PL_FCI_* constants in\n\
7984 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7985 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7986 should not be altered.\n\
7987\n\
7988 weight (PLINT, input) : Font weight to select for the current font.\n\
7989 The available values are given by the PL_FCI_* constants in\n\
7990 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7991 negative value signifies that the font weight should not be\n\
7992 altered.\n\
7993";
7994static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7995Sets the 3D position of the light source\n\
7996\n\
7997DESCRIPTION:\n\
7998\n\
7999 Sets the 3D position of the light source for use with plsurf3d and\n\
8000 plsurf3dl\n\
8001\n\
8002 Redacted form: pllightsource(x, y, z)\n\
8003\n\
8004 This function is used in example 8.\n\
8005\n\
8006\n\
8007\n\
8008SYNOPSIS:\n\
8009\n\
8010pllightsource(x, y, z)\n\
8011\n\
8012ARGUMENTS:\n\
8013\n\
8014 x (PLFLT, input) : X-coordinate of the light source.\n\
8015\n\
8016 y (PLFLT, input) : Y-coordinate of the light source.\n\
8017\n\
8018 z (PLFLT, input) : Z-coordinate of the light source.\n\
8019";
8020static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
8021Draw a line\n\
8022\n\
8023DESCRIPTION:\n\
8024\n\
8025 Draws line defined by n points in x and y.\n\
8026\n\
8027 Redacted form: plline(x, y)\n\
8028\n\
8029 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
8030 25-27, and 29.\n\
8031\n\
8032\n\
8033\n\
8034SYNOPSIS:\n\
8035\n\
8036plline(n, x, y)\n\
8037\n\
8038ARGUMENTS:\n\
8039\n\
8040 n (PLINT, input) : Number of points defining line.\n\
8041\n\
8042 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8043 points.\n\
8044\n\
8045 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8046 points.\n\
8047";
8048static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
8049Set pen width\n\
8050\n\
8051DESCRIPTION:\n\
8052\n\
8053 Sets the pen width.\n\
8054\n\
8055 Redacted form: plwidth(width)\n\
8056\n\
8057 This function is used in examples 1 and 2.\n\
8058\n\
8059\n\
8060\n\
8061SYNOPSIS:\n\
8062\n\
8063plwidth(width)\n\
8064\n\
8065ARGUMENTS:\n\
8066\n\
8067 width (PLFLT, input) : The desired pen width. If width is negative\n\
8068 or the same as the previous value no action is taken. width = 0.\n\
8069 should be interpreted as as the minimum valid pen width for the\n\
8070 device. The interpretation of positive width values is also\n\
8071 device dependent.\n\
8072";
8073static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
8074Draw linear gradient inside polygon\n\
8075\n\
8076DESCRIPTION:\n\
8077\n\
8078 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
8079 points (\n\
8080 x[i],\n\
8081 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
8082 polygon coordinates and the gradient angle are all expressed in world\n\
8083 coordinates. The angle from the x axis for both the rotated\n\
8084 coordinate system and the gradient vector is specified by angle. The\n\
8085 magnitude of the gradient vector is the difference between the maximum\n\
8086 and minimum values of x for the vertices in the rotated coordinate\n\
8087 system. The origin of the gradient vector can be interpreted as being\n\
8088 anywhere on the line corresponding to the minimum x value for the\n\
8089 vertices in the rotated coordinate system. The distance along the\n\
8090 gradient vector is linearly transformed to the independent variable of\n\
8091 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
8092 1. at the head of the gradient vector. What is drawn is the RGBA\n\
8093 color corresponding to the independent variable of cmap1. For more\n\
8094 information about cmap1 (see the PLplot documentation).\n\
8095\n\
8096 Redacted form: plgradient(x,y,angle)\n\
8097\n\
8098 This function is used in examples 25 and 30.\n\
8099\n\
8100\n\
8101\n\
8102SYNOPSIS:\n\
8103\n\
8104plgradient(n, x, y, angle)\n\
8105\n\
8106ARGUMENTS:\n\
8107\n\
8108 n (PLINT, input) : Number of vertices in polygon.\n\
8109\n\
8110 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8111 vertices.\n\
8112\n\
8113 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8114 vertices.\n\
8115\n\
8116 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8117 axis.\n\
8118";
8119static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8120Flushes the output stream\n\
8121\n\
8122DESCRIPTION:\n\
8123\n\
8124 Flushes the output stream. Use sparingly, if at all.\n\
8125\n\
8126 Redacted form: plflush()\n\
8127\n\
8128 This function is used in examples 1 and 14.\n\
8129\n\
8130\n\
8131\n\
8132SYNOPSIS:\n\
8133\n\
8134plflush()\n\
8135";
8136static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8137Get plot orientation\n\
8138\n\
8139DESCRIPTION:\n\
8140\n\
8141 Get plot orientation parameter which is multiplied by 90 degrees to\n\
8142 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8143 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8144 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8145 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8146 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8147 not been called the default value pointed to by p_rot will be 0.\n\
8148\n\
8149 Redacted form: plgdiori(p_rot)\n\
8150\n\
8151 This function is not used in any examples.\n\
8152\n\
8153\n\
8154\n\
8155SYNOPSIS:\n\
8156\n\
8157plgdiori(p_rot)\n\
8158\n\
8159ARGUMENTS:\n\
8160\n\
8161 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8162 parameter.\n\
8163";
8164static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8165Set x axis parameters\n\
8166\n\
8167DESCRIPTION:\n\
8168\n\
8169 Sets values of the digmax and digits flags for the x axis. See the\n\
8170 PLplot documentation for more information.\n\
8171\n\
8172 Redacted form: plsxax(digmax, digits)\n\
8173\n\
8174 This function is used in example 31.\n\
8175\n\
8176\n\
8177\n\
8178SYNOPSIS:\n\
8179\n\
8180plsxax(digmax, digits)\n\
8181\n\
8182ARGUMENTS:\n\
8183\n\
8184 digmax (PLINT, input) : Variable to set the maximum number of\n\
8185 digits for the x axis. If nonzero, the printed label will be\n\
8186 switched to a floating-point representation when the number of\n\
8187 digits exceeds digmax.\n\
8188\n\
8189 digits (PLINT, input) : Field digits value. Currently, changing\n\
8190 its value here has no effect since it is set only by plbox or\n\
8191 plbox3. However, the user may obtain its value after a call to\n\
8192 either of these functions by calling plgxax.\n\
8193";
8194static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8195Get viewport limits in world coordinates\n\
8196\n\
8197DESCRIPTION:\n\
8198\n\
8199 Get viewport limits in world coordinates.\n\
8200\n\
8201 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8202\n\
8203\n\
8204 This function is used in example 31.\n\
8205\n\
8206\n\
8207\n\
8208SYNOPSIS:\n\
8209\n\
8210plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8211\n\
8212ARGUMENTS:\n\
8213\n\
8214 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8215 viewport limit of the world coordinate in x.\n\
8216\n\
8217 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8218 viewport limit of the world coordinate in x.\n\
8219\n\
8220 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8221 viewport limit of the world coordinate in y.\n\
8222\n\
8223 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8224 viewport limit of the world coordinate in y.\n\
8225";
8226static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8227Shade regions on the basis of value\n\
8228\n\
8229DESCRIPTION:\n\
8230\n\
8231 Shade regions on the basis of value. This is the high-level routine\n\
8232 for making continuous color shaded plots with cmap1 while plshade\n\
8233 should be used to plot individual shaded regions using either cmap0 or\n\
8234 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8235 our supported languages.\n\
8236\n\
8237 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8238 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8239 pltr_data)\n\
8240\n\
8241\n\
8242 This function is used in examples 16, 21, and 22.\n\
8243\n\
8244\n\
8245\n\
8246SYNOPSIS:\n\
8247\n\
8248plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8249\n\
8250ARGUMENTS:\n\
8251\n\
8252 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8253 plot. Should have dimensions of\n\
8254 nx by\n\
8255 ny.\n\
8256\n\
8257 nx (PLINT, input) : First dimension of matrix \"a\".\n\
8258\n\
8259 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8260\n\
8261 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8262 the region that should be plotted in the shade plot. This\n\
8263 function accepts x and y coordinates as input arguments and must\n\
8264 return 1 if the point is to be included in the shade plot and 0\n\
8265 otherwise. If you want to plot the entire shade plot (the usual\n\
8266 case), this argument should be set to NULL.\n\
8267\n\
8268 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8269 pltr below for how these arguments are used (only for the special case\n\
8270 when the callback function\n\
8271 pltr is not supplied).\n\
8272\n\
8273 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8274 corresponding to the edges of each shaded region that will be\n\
8275 plotted by this function. To work properly the levels should be\n\
8276 monotonic.\n\
8277\n\
8278 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8279 of shade edge values in clevel).\n\
8280\n\
8281 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8282 pattern.\n\
8283\n\
8284 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8285 contours defining edges of shaded regions. The pen color is only\n\
8286 temporary set for the contour drawing. Set this value to zero or\n\
8287 less if no shade edge contours are wanted.\n\
8288\n\
8289 cont_width (PLFLT, input) : Defines line width used for contours\n\
8290 defining edges of shaded regions. This value may not be honored\n\
8291 by all drivers. The pen width is only temporary set for the\n\
8292 contour drawing. Set this value to zero or less if no shade edge\n\
8293 contours are wanted.\n\
8294\n\
8295 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8296 region. Use plfill for this purpose.\n\
8297\n\
8298 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8299 map to rectangles after coordinate transformation with pltrl.\n\
8300 Otherwise, set rectangular to false. If rectangular is set to\n\
8301 true, plshade tries to save time by filling large rectangles.\n\
8302 This optimization fails if the coordinate transformation distorts\n\
8303 the shape of rectangles. For example a plot in polar coordinates\n\
8304 has to have rectangular set to false.\n\
8305\n\
8306 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8307 defines the transformation between the zero-based indices of the\n\
8308 matrix a and world coordinates. If\n\
8309 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8310 indices of a are mapped to the range\n\
8311 xmin through\n\
8312 xmax and the y indices of a are mapped to the range\n\
8313 ymin through\n\
8314 ymax.For the C case, transformation functions are provided in the\n\
8315 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8316 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8317 matrices. In addition, C callback routines for the transformation\n\
8318 can be supplied by the user such as the mypltr function in\n\
8319 examples/c/x09c.c which provides a general linear transformation\n\
8320 between index coordinates and world coordinates.For languages\n\
8321 other than C you should consult the PLplot documentation for the\n\
8322 details concerning how PLTRANSFORM_callback arguments are\n\
8323 interfaced. However, in general, a particular pattern of\n\
8324 callback-associated arguments such as a tr vector with 6 elements;\n\
8325 xg and yg vectors; or xg and yg matrices are respectively\n\
8326 interfaced to a linear-transformation routine similar to the above\n\
8327 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8328 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8329 support native language callbacks for handling index to\n\
8330 world-coordinate transformations. Examples of these various\n\
8331 approaches are given in examples/<language>x09*,\n\
8332 examples/<language>x16*, examples/<language>x20*,\n\
8333 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8334 supported languages.\n\
8335\n\
8336 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8337 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8338 externally supplied.\n\
8339";
8340static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8341Plot color bar for image, shade or gradient plots\n\
8342\n\
8343DESCRIPTION:\n\
8344\n\
8345 Routine for creating a continuous color bar for image, shade, or\n\
8346 gradient plots. (See pllegend for similar functionality for creating\n\
8347 legends with discrete elements). The arguments of plcolorbar provide\n\
8348 control over the location and size of the color bar as well as the\n\
8349 location and characteristics of the elements (most of which are\n\
8350 optional) within that color bar. The resulting color bar is clipped\n\
8351 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8352 system used for some of the parameters is defined in the documentation\n\
8353 of the position parameter.)\n\
8354\n\
8355 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8356 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8357 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8358 labels, axis_opts, ticks, sub_ticks, values)\n\
8359\n\
8360 This function is used in examples 16 and 33.\n\
8361\n\
8362\n\
8363\n\
8364SYNOPSIS:\n\
8365\n\
8366plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n\
8367\n\
8368ARGUMENTS:\n\
8369\n\
8370 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8371 labelled and decorated color bar width in adopted coordinates.\n\
8372\n\
8373 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8374 labelled and decorated color bar height in adopted coordinates.\n\
8375\n\
8376 opt (PLINT, input) : opt contains bits controlling the overall\n\
8377 color bar. The orientation (direction of the maximum value) of\n\
8378 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8379 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8380 specified, the default orientation is toward the top if the\n\
8381 colorbar is placed on the left or right of the viewport or toward\n\
8382 the right if the colorbar is placed on the top or bottom of the\n\
8383 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8384 (semitransparent) background for the color bar. If the\n\
8385 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8386 color bar. The type of color bar must be specified with one of\n\
8387 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8388 more than one of those bits is set only the first one in the above\n\
8389 list is honored. The position of the (optional) label/title can be\n\
8390 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8391 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8392 will be drawn. If more than one of this list of bits is specified,\n\
8393 only the first one on the list is honored. End-caps for the color\n\
8394 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8395 If a particular color bar cap option is not specified then no cap\n\
8396 will be drawn for that end. As a special case for\n\
8397 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8398 specified. If this option is provided then any tick marks and tick\n\
8399 labels will be placed at the breaks between shaded segments. TODO:\n\
8400 This should be expanded to support custom placement of tick marks\n\
8401 and tick labels at custom value locations for any color bar type.\n\
8402\n\
8403 position (PLINT, input) : position contains bits which control the\n\
8404 overall position of the color bar and the definition of the\n\
8405 adopted coordinates used for positions just like what is done for\n\
8406 the position argument for pllegend. However, note that the\n\
8407 defaults for the position bits (see below) are different than the\n\
8408 pllegend case. The combination of the PL_POSITION_LEFT,\n\
8409 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8410 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8411 the 16 possible standard positions (the 4 corners and centers of\n\
8412 the 4 sides for both the inside and outside cases) of the color\n\
8413 bar relative to the adopted coordinate system. The corner\n\
8414 positions are specified by the appropriate combination of two of\n\
8415 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8416 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8417 value of one of those bits. The adopted coordinates are\n\
8418 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8419 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8420 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8421 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8422 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8423 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8424 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8425 PL_POSITION_VIEWPORT.\n\
8426\n\
8427 x (PLFLT, input) : X offset of the color bar position in adopted\n\
8428 coordinates from the specified standard position of the color bar.\n\
8429 For positive x, the direction of motion away from the standard\n\
8430 position is inward/outward from the standard corner positions or\n\
8431 standard left or right positions if the\n\
8432 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8433 For the standard top or bottom positions, the direction of motion\n\
8434 is toward positive X.\n\
8435\n\
8436 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8437 coordinates from the specified standard position of the color bar.\n\
8438 For positive y, the direction of motion away from the standard\n\
8439 position is inward/outward from the standard corner positions or\n\
8440 standard top or bottom positions if the\n\
8441 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8442 For the standard left or right positions, the direction of motion\n\
8443 is toward positive Y.\n\
8444\n\
8445 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8446 the X direction in adopted coordinates.\n\
8447\n\
8448 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8449 the Y direction in adopted coordinates.\n\
8450\n\
8451 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8452 color bar (PL_COLORBAR_BACKGROUND).\n\
8453\n\
8454 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8455 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8456\n\
8457 bb_style (PLINT, input) : The pllsty style number for the\n\
8458 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8459\n\
8460 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8461 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8462\n\
8463 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8464 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8465\n\
8466 cont_color (PLINT, input) : The cmap0 contour color for\n\
8467 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8468 it will be interpreted according to the design of plshades.\n\
8469\n\
8470 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8471 plots. This is passed directly to plshades, so it will be\n\
8472 interpreted according to the design of plshades.\n\
8473\n\
8474 n_labels (PLINT, input) : Number of labels to place around the\n\
8475 color bar.\n\
8476\n\
8477 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8478 n_labels labels.\n\
8479\n\
8480 labels (PLCHAR_MATRIX, input) : A vector of\n\
8481 n_labels UTF-8 character strings containing the labels for the color\n\
8482 bar. Ignored if no label position is specified with one of the\n\
8483 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8484 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8485 corresponding label_opts field.\n\
8486\n\
8487 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8488 value must be greater than 0. It is typically 1 (numerical axis\n\
8489 labels are provided for one of the long edges of the color bar),\n\
8490 but it can be larger if multiple numerical axis labels for the\n\
8491 long edges of the color bar are desired.\n\
8492\n\
8493 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8494 n_axes ascii character strings containing options (interpreted as for\n\
8495 plbox) for the color bar\'s axis definitions.\n\
8496\n\
8497 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8498 spacing of the major tick marks (interpreted as for plbox) for the\n\
8499 color bar\'s axis definitions.\n\
8500\n\
8501 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8502 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8503 axis definitions.\n\
8504\n\
8505 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8506 elements in each of the n_axes rows of the values matrix.\n\
8507\n\
8508 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8509 values for the data range represented by the color bar. For a row\n\
8510 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8511 elements in the row is specified by n_values[i_axis]. For\n\
8512 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8513 is 2, and the corresponding row elements of the values matrix are\n\
8514 the minimum and maximum value represented by the colorbar. For\n\
8515 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8516 of the values matrix is interpreted the same as the nlevel and\n\
8517 clevel arguments of plshades.\n\
8518";
8519static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8520Get current subpage parameters\n\
8521\n\
8522DESCRIPTION:\n\
8523\n\
8524 Gets the size of the current subpage in millimeters measured from the\n\
8525 bottom left hand corner of the output device page or screen. Can be\n\
8526 used in conjunction with plsvpa for setting the size of a viewport in\n\
8527 absolute coordinates (millimeters).\n\
8528\n\
8529 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8530\n\
8531 This function is used in example 23.\n\
8532\n\
8533\n\
8534\n\
8535SYNOPSIS:\n\
8536\n\
8537plgspa(xmin, xmax, ymin, ymax)\n\
8538\n\
8539ARGUMENTS:\n\
8540\n\
8541 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8542 the left hand edge of the subpage in millimeters.\n\
8543\n\
8544 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8545 the right hand edge of the subpage in millimeters.\n\
8546\n\
8547 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8548 the bottom edge of the subpage in millimeters.\n\
8549\n\
8550 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8551 the top edge of the subpage in millimeters.\n\
8552";
8553static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8554Shade individual region on the basis of value\n\
8555\n\
8556DESCRIPTION:\n\
8557\n\
8558 Shade individual region on the basis of value. Use plshades if you\n\
8559 want to shade a number of contiguous regions using continuous colors.\n\
8560 In particular the edge contours are treated properly in plshades. If\n\
8561 you attempt to do contiguous regions with plshade the contours at the\n\
8562 edge of the shade are partially obliterated by subsequent plots of\n\
8563 contiguous shaded regions.\n\
8564\n\
8565 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8566 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8567 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8568\n\
8569\n\
8570 This function is used in example 15.\n\
8571\n\
8572\n\
8573\n\
8574SYNOPSIS:\n\
8575\n\
8576plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8577\n\
8578ARGUMENTS:\n\
8579\n\
8580 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8581 plot. Should have dimensions of\n\
8582 nx by\n\
8583 ny.\n\
8584\n\
8585 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8586\n\
8587 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8588\n\
8589 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8590 the region that should be plotted in the shade plot. This\n\
8591 function accepts x and y coordinates as input arguments and must\n\
8592 return 1 if the point is to be included in the shade plot and 0\n\
8593 otherwise. If you want to plot the entire shade plot (the usual\n\
8594 case), this argument should be set to NULL.\n\
8595\n\
8596 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8597 pltr below for how these arguments are used (only for the special case\n\
8598 when the callback function\n\
8599 pltr is not supplied).\n\
8600\n\
8601 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8602 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8603\n\
8604 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8605 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8606\n\
8607 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8608 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8609 then sh_color is interpreted as a cmap1 argument in the range\n\
8610 (0.0-1.0).\n\
8611\n\
8612 sh_color (PLFLT, input) : Defines color map index with integer\n\
8613 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8614\n\
8615 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8616\n\
8617 min_color (PLINT, input) : Defines pen color, width used by the\n\
8618 boundary of shaded region. The min values are used for the\n\
8619 shade_min boundary, and the max values are used on the shade_max\n\
8620 boundary. Set color and width to zero for no plotted boundaries.\n\
8621\n\
8622 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8623 boundary of shaded region. The min values are used for the\n\
8624 shade_min boundary, and the max values are used on the shade_max\n\
8625 boundary. Set color and width to zero for no plotted boundaries.\n\
8626\n\
8627 max_color (PLINT, input) : Defines pen color, width used by the\n\
8628 boundary of shaded region. The min values are used for the\n\
8629 shade_min boundary, and the max values are used on the shade_max\n\
8630 boundary. Set color and width to zero for no plotted boundaries.\n\
8631\n\
8632 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8633 boundary of shaded region. The min values are used for the\n\
8634 shade_min boundary, and the max values are used on the shade_max\n\
8635 boundary. Set color and width to zero for no plotted boundaries.\n\
8636\n\
8637 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8638 Use plfill. Future version of PLplot may have other fill\n\
8639 routines.\n\
8640\n\
8641 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8642 map to rectangles after coordinate transformation with pltrl.\n\
8643 Otherwise, set rectangular to false. If rectangular is set to\n\
8644 true, plshade tries to save time by filling large rectangles.\n\
8645 This optimization fails if the coordinate transformation distorts\n\
8646 the shape of rectangles. For example a plot in polar coordinates\n\
8647 has to have rectangular set to false.\n\
8648\n\
8649 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8650 defines the transformation between the zero-based indices of the\n\
8651 matrix a and world coordinates. If\n\
8652 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8653 indices of a are mapped to the range\n\
8654 xmin through\n\
8655 xmax and the y indices of a are mapped to the range\n\
8656 ymin through\n\
8657 ymax.For the C case, transformation functions are provided in the\n\
8658 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8659 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8660 matrices. In addition, C callback routines for the transformation\n\
8661 can be supplied by the user such as the mypltr function in\n\
8662 examples/c/x09c.c which provides a general linear transformation\n\
8663 between index coordinates and world coordinates.For languages\n\
8664 other than C you should consult the PLplot documentation for the\n\
8665 details concerning how PLTRANSFORM_callback arguments are\n\
8666 interfaced. However, in general, a particular pattern of\n\
8667 callback-associated arguments such as a tr vector with 6 elements;\n\
8668 xg and yg vectors; or xg and yg matrices are respectively\n\
8669 interfaced to a linear-transformation routine similar to the above\n\
8670 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8671 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8672 support native language callbacks for handling index to\n\
8673 world-coordinate transformations. Examples of these various\n\
8674 approaches are given in examples/<language>x09*,\n\
8675 examples/<language>x16*, examples/<language>x20*,\n\
8676 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8677 supported languages.\n\
8678\n\
8679 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8680 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8681 externally supplied.\n\
8682";
8683static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8684Calculate world coordinates and corresponding window index from relative device coordinates\n\
8685\n\
8686DESCRIPTION:\n\
8687\n\
8688 Calculate world coordinates, wx and wy, and corresponding window index\n\
8689 from relative device coordinates, rx and ry.\n\
8690\n\
8691 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8692\n\
8693\n\
8694 This function is used in example 31.\n\
8695\n\
8696\n\
8697\n\
8698SYNOPSIS:\n\
8699\n\
8700plcalc_world(rx, ry, wx, wy, window)\n\
8701\n\
8702ARGUMENTS:\n\
8703\n\
8704 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8705 the x coordinate.\n\
8706\n\
8707 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8708 the y coordinate.\n\
8709\n\
8710 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8711 coordinate corresponding to the relative device coordinates rx and\n\
8712 ry.\n\
8713\n\
8714 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8715 coordinate corresponding to the relative device coordinates rx and\n\
8716 ry.\n\
8717\n\
8718 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8719 defined window index that corresponds to the input relative device\n\
8720 coordinates (and the returned world coordinates). To give some\n\
8721 background on the window index, for each page the initial window\n\
8722 index is set to zero, and each time plwind is called within the\n\
8723 page, world and device coordinates are stored for the window and\n\
8724 the window index is incremented. Thus, for a simple page layout\n\
8725 with non-overlapping viewports and one window per viewport, window\n\
8726 corresponds to the viewport index (in the order which the\n\
8727 viewport/windows were created) of the only viewport/window\n\
8728 corresponding to rx and ry. However, for more complicated layouts\n\
8729 with potentially overlapping viewports and possibly more than one\n\
8730 window (set of world coordinates) per viewport, window and the\n\
8731 corresponding output world coordinates corresponds to the last\n\
8732 window created that fulfills the criterion that the relative\n\
8733 device coordinates are inside it. Finally, in all cases where the\n\
8734 input relative device coordinates are not inside any\n\
8735 viewport/window, then the returned value of the last defined\n\
8736 window index is set to -1.\n\
8737";
8738static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8739Draw a box with axes, etc, in 3-d\n\
8740\n\
8741DESCRIPTION:\n\
8742\n\
8743 Draws axes, numeric and text labels for a three-dimensional surface\n\
8744 plot. For a more complete description of three-dimensional plotting\n\
8745 see the PLplot documentation.\n\
8746\n\
8747 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8748 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8749\n\
8750\n\
8751 This function is used in examples 8, 11, 18, and 21.\n\
8752\n\
8753\n\
8754\n\
8755SYNOPSIS:\n\
8756\n\
8757plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8758\n\
8759ARGUMENTS:\n\
8760\n\
8761 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8762 options for the x axis. The string can include any combination of\n\
8763 the following letters (upper or lower case) in any order: b: Draws\n\
8764 axis at base, at height z=\n\
8765 zmin where zmin is defined by call to plw3d. This character must be\n\
8766 specified in order to use any of the other options.\n\
8767 d: Plot labels as date / time. Values are assumed to be\n\
8768 seconds since the epoch (as used by gmtime).\n\
8769 f: Always use fixed point numeric labels.\n\
8770 i: Inverts tick marks, so they are drawn downwards, rather\n\
8771 than upwards.\n\
8772 l: Labels axis logarithmically. This only affects the labels,\n\
8773 not the data, and so it is necessary to compute the logarithms\n\
8774 of data points before passing them to any of the drawing\n\
8775 routines.\n\
8776 n: Writes numeric labels at major tick intervals.\n\
8777 o: Use custom labelling function to generate axis label text.\n\
8778 The custom labelling function can be defined with the\n\
8779 plslabelfunc command.\n\
8780 s: Enables subticks between major ticks, only valid if t is\n\
8781 also specified.\n\
8782 t: Draws major ticks.\n\
8783 u: If this is specified, the text label for the axis is\n\
8784 written under the axis.\n\
8785\n\
8786\n\
8787 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8788 the text label for the x axis. It is only drawn if u is in the\n\
8789 xopt string.\n\
8790\n\
8791 xtick (PLFLT, input) : World coordinate interval between major\n\
8792 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8793 generates a suitable tick interval.\n\
8794\n\
8795 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8796 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8797 generates a suitable minor tick interval.\n\
8798\n\
8799 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8800 options for the y axis. The string is interpreted in the same way\n\
8801 as xopt.\n\
8802\n\
8803 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8804 the text label for the y axis. It is only drawn if u is in the\n\
8805 yopt string.\n\
8806\n\
8807 ytick (PLFLT, input) : World coordinate interval between major\n\
8808 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8809 generates a suitable tick interval.\n\
8810\n\
8811 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8812 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8813 generates a suitable minor tick interval.\n\
8814\n\
8815 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8816 options for the z axis. The string can include any combination of\n\
8817 the following letters (upper or lower case) in any order: b: Draws\n\
8818 z axis to the left of the surface plot.\n\
8819 c: Draws z axis to the right of the surface plot.\n\
8820 d: Draws grid lines parallel to the x-y plane behind the\n\
8821 figure. These lines are not drawn until after plot3d or\n\
8822 plmesh are called because of the need for hidden line removal.\n\
8823 e: Plot labels as date / time. Values are assumed to be\n\
8824 seconds since the epoch (as used by gmtime). Note this\n\
8825 suboption is interpreted the same as the d suboption for xopt\n\
8826 and yopt, but it has to be identified as e for zopt since d\n\
8827 has already been used for the different purpose above.\n\
8828 f: Always use fixed point numeric labels.\n\
8829 i: Inverts tick marks, so they are drawn away from the center.\n\
8830 l: Labels axis logarithmically. This only affects the labels,\n\
8831 not the data, and so it is necessary to compute the logarithms\n\
8832 of data points before passing them to any of the drawing\n\
8833 routines.\n\
8834 m: Writes numeric labels at major tick intervals on the\n\
8835 right-hand z axis.\n\
8836 n: Writes numeric labels at major tick intervals on the\n\
8837 left-hand z axis.\n\
8838 o: Use custom labelling function to generate axis label text.\n\
8839 The custom labelling function can be defined with the\n\
8840 plslabelfunc command.\n\
8841 s: Enables subticks between major ticks, only valid if t is\n\
8842 also specified.\n\
8843 t: Draws major ticks.\n\
8844 u: If this is specified, the text label is written beside the\n\
8845 left-hand axis.\n\
8846 v: If this is specified, the text label is written beside the\n\
8847 right-hand axis.\n\
8848\n\
8849\n\
8850 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8851 the text label for the z axis. It is only drawn if u or v are in\n\
8852 the zopt string.\n\
8853\n\
8854 ztick (PLFLT, input) : World coordinate interval between major\n\
8855 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8856 generates a suitable tick interval.\n\
8857\n\
8858 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8859 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8860 generates a suitable minor tick interval.\n\
8861";
8862static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8863Get character default height and current (scaled) height\n\
8864\n\
8865DESCRIPTION:\n\
8866\n\
8867 Get character default height and current (scaled) height.\n\
8868\n\
8869 Redacted form: plgchr(p_def, p_ht)\n\
8870\n\
8871 This function is used in example 23.\n\
8872\n\
8873\n\
8874\n\
8875SYNOPSIS:\n\
8876\n\
8877plgchr(p_def, p_ht)\n\
8878\n\
8879ARGUMENTS:\n\
8880\n\
8881 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8882 character height (mm).\n\
8883\n\
8884 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8885 character height (mm).\n\
8886";
8887static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8888Set the escape character for text strings\n\
8889\n\
8890DESCRIPTION:\n\
8891\n\
8892 Set the escape character for text strings. From C (in contrast to\n\
8893 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8894 characters are allowed to prevent the user from shooting himself in\n\
8895 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8896 use of backslash as a character escape). Here are the allowed escape\n\
8897 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8898 #, ASCII 35\n\
8899 $, ASCII 36\n\
8900 %, ASCII 37\n\
8901 &, ASCII 38\n\
8902 *, ASCII 42\n\
8903 @, ASCII 64\n\
8904 ^, ASCII 94\n\
8905 ~, ASCII 126\n\
8906\n\
8907\n\
8908 Redacted form: General: plsesc(esc)\n\
8909\n\
8910\n\
8911 This function is used in example 29.\n\
8912\n\
8913\n\
8914\n\
8915SYNOPSIS:\n\
8916\n\
8917plsesc(esc)\n\
8918\n\
8919ARGUMENTS:\n\
8920\n\
8921 esc (char, input) : Escape character.\n\
8922";
8923static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8924Draw a line between two points, accounting for coordinate transforms\n\
8925\n\
8926DESCRIPTION:\n\
8927\n\
8928 Joins the point (\n\
8929 x1,\n\
8930 y1) to (\n\
8931 x2,\n\
8932 y2) . If a global coordinate transform is defined then the line is\n\
8933 broken in to n segments to approximate the path. If no transform is\n\
8934 defined then this simply acts like a call to pljoin.\n\
8935\n\
8936 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8937\n\
8938 This function is used in example 22.\n\
8939\n\
8940\n\
8941\n\
8942SYNOPSIS:\n\
8943\n\
8944plpath(n, x1, y1, x2, y2)\n\
8945\n\
8946ARGUMENTS:\n\
8947\n\
8948 n (PLINT, input) : number of points to use to approximate the path.\n\
8949\n\
8950 x1 (PLFLT, input) : x coordinate of first point.\n\
8951\n\
8952 y1 (PLFLT, input) : y coordinate of first point.\n\
8953\n\
8954 x2 (PLFLT, input) : x coordinate of second point.\n\
8955\n\
8956 y2 (PLFLT, input) : y coordinate of second point.\n\
8957";
8958static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8959Set up standard window and draw box\n\
8960\n\
8961DESCRIPTION:\n\
8962\n\
8963 Sets up plotter environment for simple graphs by calling pladv and\n\
8964 setting up viewport and window to sensible default values. plenv\n\
8965 leaves a standard margin (left-hand margin of eight character heights,\n\
8966 and a margin around the other three sides of five character heights)\n\
8967 around most graphs for axis labels and a title. When these defaults\n\
8968 are not suitable, use the individual routines plvpas, plvpor, or\n\
8969 plvasp for setting up the viewport, plwind for defining the window,\n\
8970 and plbox for drawing the box.\n\
8971\n\
8972 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8973\n\
8974 This function is used in example 1,3,9,13,14,19-22,29.\n\
8975\n\
8976\n\
8977\n\
8978SYNOPSIS:\n\
8979\n\
8980plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8981\n\
8982ARGUMENTS:\n\
8983\n\
8984 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8985 world coordinates).\n\
8986\n\
8987 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8988 world coordinates).\n\
8989\n\
8990 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8991 coordinates).\n\
8992\n\
8993 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8994 coordinates).\n\
8995\n\
8996 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8997 scales will not be set, the user must set up the scale before\n\
8998 calling plenv using plsvpa, plvasp or other.\n\
8999 0: the x and y axes are scaled independently to use as much of\n\
9000 the screen as possible.\n\
9001 1: the scales of the x and y axes are made equal.\n\
9002 2: the axis of the x and y axes are made equal, and the plot\n\
9003 box will be square.\n\
9004\n\
9005\n\
9006 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9007 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9008 -1: draw box only.\n\
9009 0: draw box, ticks, and numeric tick labels.\n\
9010 1: also draw coordinate axes at x=0 and y=0.\n\
9011 2: also draw a grid at major tick positions in both\n\
9012 coordinates.\n\
9013 3: also draw a grid at minor tick positions in both\n\
9014 coordinates.\n\
9015 10: same as 0 except logarithmic x tick marks. (The x data\n\
9016 have to be converted to logarithms separately.)\n\
9017 11: same as 1 except logarithmic x tick marks. (The x data\n\
9018 have to be converted to logarithms separately.)\n\
9019 12: same as 2 except logarithmic x tick marks. (The x data\n\
9020 have to be converted to logarithms separately.)\n\
9021 13: same as 3 except logarithmic x tick marks. (The x data\n\
9022 have to be converted to logarithms separately.)\n\
9023 20: same as 0 except logarithmic y tick marks. (The y data\n\
9024 have to be converted to logarithms separately.)\n\
9025 21: same as 1 except logarithmic y tick marks. (The y data\n\
9026 have to be converted to logarithms separately.)\n\
9027 22: same as 2 except logarithmic y tick marks. (The y data\n\
9028 have to be converted to logarithms separately.)\n\
9029 23: same as 3 except logarithmic y tick marks. (The y data\n\
9030 have to be converted to logarithms separately.)\n\
9031 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9032 and y data have to be converted to logarithms separately.)\n\
9033 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9034 and y data have to be converted to logarithms separately.)\n\
9035 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9036 and y data have to be converted to logarithms separately.)\n\
9037 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9038 and y data have to be converted to logarithms separately.)\n\
9039 40: same as 0 except date / time x labels.\n\
9040 41: same as 1 except date / time x labels.\n\
9041 42: same as 2 except date / time x labels.\n\
9042 43: same as 3 except date / time x labels.\n\
9043 50: same as 0 except date / time y labels.\n\
9044 51: same as 1 except date / time y labels.\n\
9045 52: same as 2 except date / time y labels.\n\
9046 53: same as 3 except date / time y labels.\n\
9047 60: same as 0 except date / time x and y labels.\n\
9048 61: same as 1 except date / time x and y labels.\n\
9049 62: same as 2 except date / time x and y labels.\n\
9050 63: same as 3 except date / time x and y labels.\n\
9051 70: same as 0 except custom x and y labels.\n\
9052 71: same as 1 except custom x and y labels.\n\
9053 72: same as 2 except custom x and y labels.\n\
9054 73: same as 3 except custom x and y labels.\n\
9055";
9056static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
9057Grid data from irregularly sampled data\n\
9058\n\
9059DESCRIPTION:\n\
9060\n\
9061 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
9062 require data organized as a grid, i.e., with x sample point values\n\
9063 independent of y coordinate and vice versa. This function takes\n\
9064 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
9065 vectors; reads the desired grid location from the input vectors\n\
9066 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
9067 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
9068 interpolate the data to the grid is specified with the argument type\n\
9069 which can have one parameter specified in argument data.\n\
9070\n\
9071 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
9072 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
9073\n\
9074\n\
9075 This function is used in example 21.\n\
9076\n\
9077\n\
9078\n\
9079SYNOPSIS:\n\
9080\n\
9081plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
9082\n\
9083ARGUMENTS:\n\
9084\n\
9085 x (PLFLT_VECTOR, input) : The input x vector.\n\
9086\n\
9087 y (PLFLT_VECTOR, input) : The input y vector.\n\
9088\n\
9089 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
9090 y[i], z[i] represents one data sample coordinate.\n\
9091\n\
9092 npts (PLINT, input) : The number of data samples in the x, y and z\n\
9093 vectors.\n\
9094\n\
9095 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9096 in the x direction. Usually xg has nptsx equally spaced values\n\
9097 from the minimum to the maximum values of the x input vector.\n\
9098\n\
9099 nptsx (PLINT, input) : The number of points in the xg vector.\n\
9100\n\
9101 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9102 in the y direction. Similar to the xg parameter.\n\
9103\n\
9104 nptsy (PLINT, input) : The number of points in the yg vector.\n\
9105\n\
9106 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
9107 where data lies in the grid specified by xg and yg. Therefore the\n\
9108 zg matrix must be dimensioned\n\
9109 nptsx by\n\
9110 nptsy.\n\
9111\n\
9112 type (PLINT, input) : The type of grid interpolation algorithm to\n\
9113 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9114 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9115 GRID_NNI: Natural Neighbors Interpolation\n\
9116 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9117 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9118 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9119 Weighted\n\
9120 For details of the algorithms read the source file plgridd.c.\n\
9121\n\
9122 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9123 which can be specified through this argument. Currently, for\n\
9124 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9125 use, the lower the value, the noisier (more local) the\n\
9126 approximation is.\n\
9127 GRID_NNLI, data specifies what a thin triangle is, in the\n\
9128 range [1. .. 2.]. High values enable the usage of very thin\n\
9129 triangles for interpolation, possibly resulting in error in\n\
9130 the approximation.\n\
9131 GRID_NNI, only weights greater than data will be accepted. If\n\
9132 0, all weights will be accepted.\n\
9133";
9134static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9135Clear current (sub)page\n\
9136\n\
9137DESCRIPTION:\n\
9138\n\
9139 Clears the current page, effectively erasing everything that have been\n\
9140 drawn. This command only works with interactive drivers; if the\n\
9141 driver does not support this, the page is filled with the background\n\
9142 color in use. If the current page is divided into subpages, only the\n\
9143 current subpage is erased. The nth subpage can be selected with\n\
9144 pladv(n).\n\
9145\n\
9146 Redacted form: General: plclear()\n\
9147\n\
9148\n\
9149 This function is not used in any examples.\n\
9150\n\
9151\n\
9152\n\
9153SYNOPSIS:\n\
9154\n\
9155plclear()\n\
9156";
9157static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9158Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9159\n\
9160DESCRIPTION:\n\
9161\n\
9162 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9163 and PLFLT alpha transparency value. This sets the entire color map --\n\
9164 only as many colors as specified will be allocated.\n\
9165\n\
9166 Redacted form: plscmap0a(r, g, b, alpha)\n\
9167\n\
9168 This function is used in examples 30.\n\
9169\n\
9170\n\
9171\n\
9172SYNOPSIS:\n\
9173\n\
9174plscmap0a(r, g, b, alpha, ncol0)\n\
9175\n\
9176ARGUMENTS:\n\
9177\n\
9178 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9179 integers (0-255) representing the degree of red in the color.\n\
9180\n\
9181 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9182 integers (0-255) representing the degree of green in the color.\n\
9183\n\
9184 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9185 integers (0-255) representing the degree of blue in the color.\n\
9186\n\
9187 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9188 representing the alpha transparency of the color.\n\
9189\n\
9190 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9191 vectors.\n\
9192";
9193static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9194Set 8-bit RGB values for given cmap0 color index\n\
9195\n\
9196DESCRIPTION:\n\
9197\n\
9198 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9199 index. Overwrites the previous color value for the given index and,\n\
9200 thus, does not result in any additional allocation of space for\n\
9201 colors.\n\
9202\n\
9203 Redacted form: plscol0(icol0, r, g, b)\n\
9204\n\
9205 This function is used in any example 31.\n\
9206\n\
9207\n\
9208\n\
9209SYNOPSIS:\n\
9210\n\
9211plscol0(icol0, r, g, b)\n\
9212\n\
9213ARGUMENTS:\n\
9214\n\
9215 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9216 number of colors (which is set by default, by plscmap0n, or even\n\
9217 by plscmap0).\n\
9218\n\
9219 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9220 degree of red in the color.\n\
9221\n\
9222 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9223 degree of green in the color.\n\
9224\n\
9225 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9226 degree of blue in the color.\n\
9227";
9228static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9229Set up transformation from metafile coordinates\n\
9230\n\
9231DESCRIPTION:\n\
9232\n\
9233 Set up transformation from metafile coordinates. The size of the plot\n\
9234 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9235 general-purpose facility just yet (not sure why the user would need\n\
9236 it, for one).\n\
9237\n\
9238 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9239 dimypmm)\n\
9240\n\
9241 This function is not used in any examples.\n\
9242\n\
9243\n\
9244\n\
9245SYNOPSIS:\n\
9246\n\
9247plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9248\n\
9249ARGUMENTS:\n\
9250\n\
9251 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9252\n\
9253 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9254\n\
9255 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9256\n\
9257 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9258\n\
9259 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9260\n\
9261 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9262";
9263static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9264Creates a new stream and makes it the default\n\
9265\n\
9266DESCRIPTION:\n\
9267\n\
9268 Creates a new stream and makes it the default. Differs from using\n\
9269 plsstrm, in that a free stream number is found, and returned.\n\
9270 Unfortunately, I have to start at stream 1 and work upward, since\n\
9271 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9272 that no initial, library-opening call is required. So stream 0 must\n\
9273 be preallocated, and there is no simple way of determining whether it\n\
9274 is already in use or not.\n\
9275\n\
9276 Redacted form: plmkstrm(p_strm)\n\
9277\n\
9278 This function is used in examples 1 and 20.\n\
9279\n\
9280\n\
9281\n\
9282SYNOPSIS:\n\
9283\n\
9284plmkstrm(p_strm)\n\
9285\n\
9286ARGUMENTS:\n\
9287\n\
9288 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9289 number of the created stream.\n\
9290";
9291static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9292Get page parameters\n\
9293\n\
9294DESCRIPTION:\n\
9295\n\
9296 Gets the current page configuration. The length and offset values are\n\
9297 expressed in units that are specific to the current driver. For\n\
9298 instance: screen drivers will usually interpret them as number of\n\
9299 pixels, whereas printer drivers will usually use mm.\n\
9300\n\
9301 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9302\n\
9303 This function is used in examples 14 and 31.\n\
9304\n\
9305\n\
9306\n\
9307SYNOPSIS:\n\
9308\n\
9309plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9310\n\
9311ARGUMENTS:\n\
9312\n\
9313 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9314 pixels/inch (DPI) in x.\n\
9315\n\
9316 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9317 pixels/inch (DPI) in y.\n\
9318\n\
9319 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9320 length.\n\
9321\n\
9322 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9323 length.\n\
9324\n\
9325 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9326 offset.\n\
9327\n\
9328 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9329 offset.\n\
9330";
9331static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9332Set format for date / time labels\n\
9333\n\
9334DESCRIPTION:\n\
9335\n\
9336 Sets the format for date / time labels. To enable date / time format\n\
9337 labels see the options to plbox, plbox3, and plenv.\n\
9338\n\
9339 Redacted form: pltimefmt(fmt)\n\
9340\n\
9341 This function is used in example 29.\n\
9342\n\
9343\n\
9344\n\
9345SYNOPSIS:\n\
9346\n\
9347pltimefmt(fmt)\n\
9348\n\
9349ARGUMENTS:\n\
9350\n\
9351 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9352 interpreted similarly to the format specifier of typical system\n\
9353 strftime routines except that PLplot ignores locale and also\n\
9354 supplies some useful extensions in the context of plotting. All\n\
9355 text in the string is printed as-is other than conversion\n\
9356 specifications which take the form of a \'%\' character followed by\n\
9357 further conversion specification character. The conversion\n\
9358 specifications which are similar to those provided by system\n\
9359 strftime routines are the following: %a: The abbreviated (English)\n\
9360 weekday name.\n\
9361 %A: The full (English) weekday name.\n\
9362 %b: The abbreviated (English) month name.\n\
9363 %B: The full (English) month name.\n\
9364 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9365 %C: The century number (year/100) as a 2-digit integer.\n\
9366 %d: The day of the month as a decimal number (range 01 to 31).\n\
9367 %D: Equivalent to %m/%d/%y (non-ISO).\n\
9368 %e: Like %d, but a leading zero is replaced by a space.\n\
9369 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9370 %h: Equivalent to %b.\n\
9371 %H: The hour as a decimal number using a 24-hour clock (range\n\
9372 00 to 23).\n\
9373 %I: The hour as a decimal number using a 12-hour clock (range\n\
9374 01 to 12).\n\
9375 %j: The day of the year as a decimal number (range 001 to\n\
9376 366).\n\
9377 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9378 23); single digits are preceded by a blank. (See also %H.)\n\
9379 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9380 12); single digits are preceded by a blank. (See also %I.)\n\
9381 %m: The month as a decimal number (range 01 to 12).\n\
9382 %M: The minute as a decimal number (range 00 to 59).\n\
9383 %n: A newline character.\n\
9384 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9385 Noon is treated as \"PM\" and midnight as \"AM\".\n\
9386 %r: Equivalent to %I:%M:%S %p.\n\
9387 %R: The time in 24-hour notation (%H:%M). For a version\n\
9388 including the seconds, see %T below.\n\
9389 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9390 +0000 (UTC).\n\
9391 %S: The second as a decimal number (range 00 to 60). (The\n\
9392 range is up to 60 to allow for occasional leap seconds.)\n\
9393 %t: A tab character.\n\
9394 %T: The time in 24-hour notation (%H:%M:%S).\n\
9395 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9396 being 1. See also %w.\n\
9397 %U: The week number of the current year as a decimal number,\n\
9398 range 00 to 53, starting with the first Sunday as the first\n\
9399 day of week 01. See also %V and %W.\n\
9400 %v: Equivalent to %e-%b-%Y.\n\
9401 %V: The ISO 8601 week number of the current year as a decimal\n\
9402 number, range 01 to 53, where week 1 is the first week that\n\
9403 has at least 4 days in the new year. See also %U and %W.\n\
9404 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9405 being 0. See also %u.\n\
9406 %W: The week number of the current year as a decimal number,\n\
9407 range 00 to 53, starting with the first Monday as the first\n\
9408 day of week 01.\n\
9409 %x: Equivalent to %a %b %d %Y.\n\
9410 %X: Equivalent to %T.\n\
9411 %y: The year as a decimal number without a century (range 00\n\
9412 to 99).\n\
9413 %Y: The year as a decimal number including a century.\n\
9414 %z: The UTC time-zone string = \"+0000\".\n\
9415 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9416 %+: The UTC date and time in default format of the Unix date\n\
9417 command which is equivalent to %a %b %d %T %Z %Y.\n\
9418 %%: A literal \"%\" character.\n\
9419 The conversion specifications which are extensions to those normally\n\
9420 provided by system strftime routines are the following: %(0-9):\n\
9421 The fractional part of the seconds field (including leading\n\
9422 decimal point) to the specified accuracy. Thus %S%3 would give\n\
9423 seconds to millisecond accuracy (00.000).\n\
9424 %.: The fractional part of the seconds field (including\n\
9425 leading decimal point) to the maximum available accuracy. Thus\n\
9426 %S%. would give seconds with fractional part up to 9 decimal\n\
9427 places if available.\n\
9428";
9429static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9430Specify viewport using aspect ratio only\n\
9431\n\
9432DESCRIPTION:\n\
9433\n\
9434 Selects the largest viewport with the given aspect ratio within the\n\
9435 subpage that leaves a standard margin (left-hand margin of eight\n\
9436 character heights, and a margin around the other three sides of five\n\
9437 character heights).\n\
9438\n\
9439 Redacted form: plvasp(aspect)\n\
9440\n\
9441 This function is used in example 13.\n\
9442\n\
9443\n\
9444\n\
9445SYNOPSIS:\n\
9446\n\
9447plvasp(aspect)\n\
9448\n\
9449ARGUMENTS:\n\
9450\n\
9451 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9452 axis of resulting viewport.\n\
9453";
9454static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9455Set output file name\n\
9456\n\
9457DESCRIPTION:\n\
9458\n\
9459 Sets the current output file name, if applicable. If the file name\n\
9460 has not been specified and is required by the driver, the user will be\n\
9461 prompted for it. If using the X-windows output driver, this sets the\n\
9462 display name. This routine, if used, must be called before\n\
9463 initializing PLplot.\n\
9464\n\
9465 Redacted form: plsfnam(fnam)\n\
9466\n\
9467 This function is used in examples 1 and 20.\n\
9468\n\
9469\n\
9470\n\
9471SYNOPSIS:\n\
9472\n\
9473plsfnam(fnam)\n\
9474\n\
9475ARGUMENTS:\n\
9476\n\
9477 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9478 the file name.\n\
9479";
9480static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9481Vector plot\n\
9482\n\
9483DESCRIPTION:\n\
9484\n\
9485 Draws a plot of vector data contained in the matrices (\n\
9486 u[\n\
9487 nx][\n\
9488 ny],\n\
9489 v[\n\
9490 nx][\n\
9491 ny]) . The scaling factor for the vectors is given by scale. A\n\
9492 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9493 additional data required by the transformation routine to map indices\n\
9494 within the matrices to the world coordinates. The style of the vector\n\
9495 arrow may be set using plsvect.\n\
9496\n\
9497 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9498 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9499 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9500 with either one or two dimensions.\n\
9501\n\
9502 This function is used in example 22.\n\
9503\n\
9504\n\
9505\n\
9506SYNOPSIS:\n\
9507\n\
9508plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9509\n\
9510ARGUMENTS:\n\
9511\n\
9512 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9513 and y components of the vector data to be plotted.\n\
9514\n\
9515 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9516\n\
9517 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9518 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9519 automatically calculated for the data. If scale < 0 then the\n\
9520 scaling factor is automatically calculated for the data and then\n\
9521 multiplied by -\n\
9522 scale. If scale > 0 then the scaling factor is set to scale.\n\
9523\n\
9524 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9525 defines the transformation between the zero-based indices of the\n\
9526 matrices u and v and world coordinates.For the C case,\n\
9527 transformation functions are provided in the PLplot library: pltr0\n\
9528 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9529 mappings respectively defined by vectors and matrices. In\n\
9530 addition, C callback routines for the transformation can be\n\
9531 supplied by the user such as the mypltr function in\n\
9532 examples/c/x09c.c which provides a general linear transformation\n\
9533 between index coordinates and world coordinates.For languages\n\
9534 other than C you should consult the PLplot documentation for the\n\
9535 details concerning how PLTRANSFORM_callback arguments are\n\
9536 interfaced. However, in general, a particular pattern of\n\
9537 callback-associated arguments such as a tr vector with 6 elements;\n\
9538 xg and yg vectors; or xg and yg matrices are respectively\n\
9539 interfaced to a linear-transformation routine similar to the above\n\
9540 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9541 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9542 support native language callbacks for handling index to\n\
9543 world-coordinate transformations. Examples of these various\n\
9544 approaches are given in examples/<language>x09*,\n\
9545 examples/<language>x16*, examples/<language>x20*,\n\
9546 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9547 supported languages.\n\
9548\n\
9549 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9550 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9551 that is externally supplied.\n\
9552";
9553static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9554Set parameters that define current plot-space window\n\
9555\n\
9556DESCRIPTION:\n\
9557\n\
9558 Set relative minima and maxima that define the current plot-space\n\
9559 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9560 xmax, and ymax are 0., 0., 1., and 1.\n\
9561\n\
9562 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9563\n\
9564 This function is used in example 31.\n\
9565\n\
9566\n\
9567\n\
9568SYNOPSIS:\n\
9569\n\
9570plsdiplt(xmin, ymin, xmax, ymax)\n\
9571\n\
9572ARGUMENTS:\n\
9573\n\
9574 xmin (PLFLT, input) : Relative minimum in x.\n\
9575\n\
9576 ymin (PLFLT, input) : Relative minimum in y.\n\
9577\n\
9578 xmax (PLFLT, input) : Relative maximum in x.\n\
9579\n\
9580 ymax (PLFLT, input) : Relative maximum in y.\n\
9581";
9582static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9583Select line style\n\
9584\n\
9585DESCRIPTION:\n\
9586\n\
9587 This sets the line style according to one of eight predefined patterns\n\
9588 (also see plstyl).\n\
9589\n\
9590 Redacted form: pllsty(lin)\n\
9591\n\
9592 This function is used in examples 9, 12, 22, and 25.\n\
9593\n\
9594\n\
9595\n\
9596SYNOPSIS:\n\
9597\n\
9598pllsty(lin)\n\
9599\n\
9600ARGUMENTS:\n\
9601\n\
9602 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9603 a continuous line, line style 2 is a line with short dashes and\n\
9604 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9605 4 has long dashes and short gaps and so on.\n\
9606";
9607static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9608Plot a glyph at the specified points\n\
9609\n\
9610DESCRIPTION:\n\
9611\n\
9612 Plot a glyph at the specified points. (This function is largely\n\
9613 superseded by plstring which gives access to many[!] more glyphs.)\n\
9614\n\
9615 Redacted form: plsym(x, y, code)\n\
9616\n\
9617 This function is used in example 7.\n\
9618\n\
9619\n\
9620\n\
9621SYNOPSIS:\n\
9622\n\
9623plsym(n, x, y, code)\n\
9624\n\
9625ARGUMENTS:\n\
9626\n\
9627 n (PLINT, input) : Number of points in the x and y vectors.\n\
9628\n\
9629 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9630 the points.\n\
9631\n\
9632 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9633 the points.\n\
9634\n\
9635 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9636 to be plotted at each of the n points.\n\
9637";
9638static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9639Set the device (keyword) name\n\
9640\n\
9641DESCRIPTION:\n\
9642\n\
9643 Set the device (keyword) name.\n\
9644\n\
9645 Redacted form: plsdev(devname)\n\
9646\n\
9647 This function is used in examples 1, 14, and 20.\n\
9648\n\
9649\n\
9650\n\
9651SYNOPSIS:\n\
9652\n\
9653plsdev(devname)\n\
9654\n\
9655ARGUMENTS:\n\
9656\n\
9657 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9658 containing the device name keyword of the required output device.\n\
9659 If\n\
9660 devname is NULL or if the first character of the string is a ``?\'\',\n\
9661 the normal (prompted) start up is used.\n\
9662";
9663static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9664Set the background color by 8-bit RGB value\n\
9665\n\
9666DESCRIPTION:\n\
9667\n\
9668 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9669 the PLplot documentation).\n\
9670\n\
9671 Redacted form: plscolbg(r, g, b)\n\
9672\n\
9673 This function is used in examples 15 and 31.\n\
9674\n\
9675\n\
9676\n\
9677SYNOPSIS:\n\
9678\n\
9679plscolbg(r, g, b)\n\
9680\n\
9681ARGUMENTS:\n\
9682\n\
9683 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9684 degree of red in the color.\n\
9685\n\
9686 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9687 degree of green in the color.\n\
9688\n\
9689 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9690 degree of blue in the color.\n\
9691";
9692static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9693Set parameters incrementally (zoom mode) that define current plot-space window\n\
9694\n\
9695DESCRIPTION:\n\
9696\n\
9697 Set relative minima and maxima incrementally (zoom mode) that define\n\
9698 the current plot-space window. This function has the same effect as\n\
9699 plsdiplt if that function has not been previously called. Otherwise,\n\
9700 this function implements zoom mode using the transformation min_used =\n\
9701 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9702 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9703 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9704\n\
9705 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9706\n\
9707 This function is used in example 31.\n\
9708\n\
9709\n\
9710\n\
9711SYNOPSIS:\n\
9712\n\
9713plsdiplz(xmin, ymin, xmax, ymax)\n\
9714\n\
9715ARGUMENTS:\n\
9716\n\
9717 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9718\n\
9719 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9720\n\
9721 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9722\n\
9723 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9724";
9725static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9726Advance to the next family file on the next new page\n\
9727\n\
9728DESCRIPTION:\n\
9729\n\
9730 Advance to the next family file on the next new page.\n\
9731\n\
9732 Redacted form: plfamadv()\n\
9733\n\
9734 This function is not used in any examples.\n\
9735\n\
9736\n\
9737\n\
9738SYNOPSIS:\n\
9739\n\
9740plfamadv()\n\
9741";
9742static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9743Set number of colors in cmap0\n\
9744\n\
9745DESCRIPTION:\n\
9746\n\
9747 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9748 (or reallocate) cmap0, and fill with default values for those colors\n\
9749 not previously allocated. The first 16 default colors are given in\n\
9750 the plcol0 documentation. For larger indices the default color is\n\
9751 red.\n\
9752\n\
9753 The drivers are not guaranteed to support more than 16 colors.\n\
9754\n\
9755 Redacted form: plscmap0n(ncol0)\n\
9756\n\
9757 This function is used in examples 15, 16, and 24.\n\
9758\n\
9759\n\
9760\n\
9761SYNOPSIS:\n\
9762\n\
9763plscmap0n(ncol0)\n\
9764\n\
9765ARGUMENTS:\n\
9766\n\
9767 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9768 the cmap0 palette. If this number is zero or less, then the value\n\
9769 from the previous call to plscmap0n is used and if there is no\n\
9770 previous call, then a default value is used.\n\
9771";
9772static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9773Plot latitude and longitude lines\n\
9774\n\
9775DESCRIPTION:\n\
9776\n\
9777 Displays latitude and longitude on the current plot. The lines are\n\
9778 plotted in the current color and line style.\n\
9779\n\
9780 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9781 minlat, maxlat)\n\
9782\n\
9783 This function is used in example 19.\n\
9784\n\
9785\n\
9786\n\
9787SYNOPSIS:\n\
9788\n\
9789plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9790\n\
9791ARGUMENTS:\n\
9792\n\
9793 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9794 transform the coordinate longitudes and latitudes to a plot\n\
9795 coordinate system. By using this transform, we can change from a\n\
9796 longitude, latitude coordinate to a polar stereographic project,\n\
9797 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9798 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9799 mapform(), x[] and y[] should be replaced by the corresponding\n\
9800 plot coordinates. If no transform is desired, mapform can be\n\
9801 replaced by NULL.\n\
9802\n\
9803 dlong (PLFLT, input) : The interval in degrees at which the\n\
9804 longitude lines are to be plotted.\n\
9805\n\
9806 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9807 lines are to be plotted.\n\
9808\n\
9809 minlong (PLFLT, input) : The value of the longitude on the left\n\
9810 side of the plot. The value of minlong must be less than the value\n\
9811 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9812 equal to 360.\n\
9813\n\
9814 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9815 side of the plot.\n\
9816\n\
9817 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9818 background. One can always use -90.0 as the boundary outside the\n\
9819 plot window will be automatically eliminated. However, the\n\
9820 program will be faster if one can reduce the size of the\n\
9821 background plotted.\n\
9822\n\
9823 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9824 background. One can always use 90.0 as the boundary outside the\n\
9825 plot window will be automatically eliminated.\n\
9826";
9827static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9828Convert RGB color to HLS\n\
9829\n\
9830DESCRIPTION:\n\
9831\n\
9832 Convert RGB color coordinates to HLS\n\
9833\n\
9834 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9835\n\
9836\n\
9837 This function is used in example 2.\n\
9838\n\
9839\n\
9840\n\
9841SYNOPSIS:\n\
9842\n\
9843plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9844\n\
9845ARGUMENTS:\n\
9846\n\
9847 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9848\n\
9849 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9850\n\
9851 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9852\n\
9853 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9854 degrees (0.0-360.0) on the color cylinder.\n\
9855\n\
9856 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9857 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9858 cylinder.\n\
9859\n\
9860 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9861 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9862 cylinder.\n\
9863";
9864static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9865Plot a glyph at the specified 3D points\n\
9866\n\
9867DESCRIPTION:\n\
9868\n\
9869 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9870 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9871 this function similar to what is done for plline3. The glyph is\n\
9872 specified with a PLplot user string. Note that the user string is not\n\
9873 actually limited to one glyph so it is possible (but not normally\n\
9874 useful) to plot more than one glyph at the specified points with this\n\
9875 function. As with plmtex and plptex, the user string can contain FCI\n\
9876 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9877 else PLplot escapes for Hershey or unicode text to determine the\n\
9878 glyph.\n\
9879\n\
9880 Redacted form: plstring3(x, y, z, string)\n\
9881\n\
9882 This function is used in example 18.\n\
9883\n\
9884\n\
9885\n\
9886SYNOPSIS:\n\
9887\n\
9888plstring3(n, x, y, z, string)\n\
9889\n\
9890ARGUMENTS:\n\
9891\n\
9892 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9893\n\
9894 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9895 the points.\n\
9896\n\
9897 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9898 the points.\n\
9899\n\
9900 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9901 the points.\n\
9902\n\
9903 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9904 the glyph(s) to be plotted at each of the n points. points.\n\
9905";
9906static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9907Switch to text screen\n\
9908\n\
9909DESCRIPTION:\n\
9910\n\
9911 Sets an interactive device to text mode, used in conjunction with\n\
9912 plgra to allow graphics and text to be interspersed. On a device\n\
9913 which supports separate text and graphics windows, this command causes\n\
9914 control to be switched to the text window. This can be useful for\n\
9915 printing diagnostic messages or getting user input, which would\n\
9916 otherwise interfere with the plots. The program must switch back to\n\
9917 the graphics window before issuing plot commands, as the text (or\n\
9918 console) device will probably become quite confused otherwise. If\n\
9919 already in text mode, this command is ignored. It is also ignored on\n\
9920 devices which only support a single window or use a different method\n\
9921 for shifting focus (see also plgra).\n\
9922\n\
9923 Redacted form: pltext()\n\
9924\n\
9925 This function is used in example 1.\n\
9926\n\
9927\n\
9928\n\
9929SYNOPSIS:\n\
9930\n\
9931pltext()\n\
9932";
9933static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9934Get parameters that define current plot-space window\n\
9935\n\
9936DESCRIPTION:\n\
9937\n\
9938 Get relative minima and maxima that define current plot-space window.\n\
9939 If plsdiplt has not been called the default values pointed to by\n\
9940 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9941\n\
9942 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9943\n\
9944 This function is used in example 31.\n\
9945\n\
9946\n\
9947\n\
9948SYNOPSIS:\n\
9949\n\
9950plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9951\n\
9952ARGUMENTS:\n\
9953\n\
9954 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9955 minimum in x.\n\
9956\n\
9957 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9958 minimum in y.\n\
9959\n\
9960 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9961 maximum in x.\n\
9962\n\
9963 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9964 maximum in y.\n\
9965";
9966static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9967Get the (current) run level\n\
9968\n\
9969DESCRIPTION:\n\
9970\n\
9971 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9972 1, initialized\n\
9973 2, viewport defined\n\
9974 3, world coordinates defined\n\
9975\n\
9976\n\
9977 Redacted form: plglevel(p_level)\n\
9978\n\
9979 This function is used in example 31.\n\
9980\n\
9981\n\
9982\n\
9983SYNOPSIS:\n\
9984\n\
9985plglevel(p_level)\n\
9986\n\
9987ARGUMENTS:\n\
9988\n\
9989 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9990 level.\n\
9991";
9992static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9993Plot a histogram from binned data\n\
9994\n\
9995DESCRIPTION:\n\
9996\n\
9997 Plots a histogram consisting of nbin bins. The value associated with\n\
9998 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9999 placed in y[i]. For proper operation, the values in x[i] must form a\n\
10000 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
10001 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
10002 placed midway between the values in the x vector. Also see plhist for\n\
10003 drawing histograms from unbinned data.\n\
10004\n\
10005 Redacted form: General: plbin(x, y, opt)\n\
10006 Python: plbin(nbin, x, y, opt)\n\
10007\n\
10008\n\
10009 This function is not used in any examples.\n\
10010\n\
10011\n\
10012\n\
10013SYNOPSIS:\n\
10014\n\
10015plbin(nbin, x, y, opt)\n\
10016\n\
10017ARGUMENTS:\n\
10018\n\
10019 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
10020 and y vectors.)\n\
10021\n\
10022 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
10023 with bins. These must form a strictly increasing sequence.\n\
10024\n\
10025 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
10026 proportional to the number of points in each bin. This is a PLFLT\n\
10027 (instead of PLINT) vector so as to allow histograms of\n\
10028 probabilities, etc.\n\
10029\n\
10030 opt (PLINT, input) : Is a combination of several flags:\n\
10031 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
10032 outer bins are expanded to fill up the entire x-axis and bins of\n\
10033 zero height are simply drawn.\n\
10034 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
10035 between the x values. If the values in x are equally spaced,\n\
10036 the values are the center values of the bins.\n\
10037 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
10038 size as the ones inside.\n\
10039 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
10040 (there is a gap for such bins).\n\
10041";
10042static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
10043Plot a 2D matrix using cmap1\n\
10044\n\
10045DESCRIPTION:\n\
10046\n\
10047 Plot a 2D matrix using cmap1.\n\
10048\n\
10049 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
10050 zmax, valuemin, valuemax, pltr, pltr_data)\n\
10051\n\
10052\n\
10053 This function is used in example 20.\n\
10054\n\
10055\n\
10056\n\
10057SYNOPSIS:\n\
10058\n\
10059plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
10060\n\
10061ARGUMENTS:\n\
10062\n\
10063 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
10064 plot. Should have dimensions of\n\
10065 nx by\n\
10066 ny.\n\
10067\n\
10068 nx, ny (PLINT, input) : Dimensions of idata\n\
10069\n\
10070 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10071 pltr below for how these arguments are used (only for the special case\n\
10072 when the callback function\n\
10073 pltr is not supplied).\n\
10074\n\
10075 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
10076 (inclusive) will be plotted.\n\
10077\n\
10078 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
10079 values to use for value to color mappings. A datum equal to or\n\
10080 less than valuemin will be plotted with color 0.0, while a datum\n\
10081 equal to or greater than valuemax will be plotted with color 1.0.\n\
10082 Data between valuemin and valuemax map linearly to colors in the\n\
10083 range (0.0-1.0).\n\
10084\n\
10085 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10086 defines the transformation between the zero-based indices of the\n\
10087 matrix idata and world coordinates. If\n\
10088 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10089 indices of idata are mapped to the range\n\
10090 xmin through\n\
10091 xmax and the y indices of idata are mapped to the range\n\
10092 ymin through\n\
10093 ymax.For the C case, transformation functions are provided in the\n\
10094 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10095 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10096 matrices. In addition, C callback routines for the transformation\n\
10097 can be supplied by the user such as the mypltr function in\n\
10098 examples/c/x09c.c which provides a general linear transformation\n\
10099 between index coordinates and world coordinates.For languages\n\
10100 other than C you should consult the PLplot documentation for the\n\
10101 details concerning how PLTRANSFORM_callback arguments are\n\
10102 interfaced. However, in general, a particular pattern of\n\
10103 callback-associated arguments such as a tr vector with 6 elements;\n\
10104 xg and yg vectors; or xg and yg matrices are respectively\n\
10105 interfaced to a linear-transformation routine similar to the above\n\
10106 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10107 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10108 support native language callbacks for handling index to\n\
10109 world-coordinate transformations. Examples of these various\n\
10110 approaches are given in examples/<language>x09*,\n\
10111 examples/<language>x16*, examples/<language>x20*,\n\
10112 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10113 supported languages.\n\
10114\n\
10115 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10116 information to pltr0, pltr1, pltr2, or whatever routine is\n\
10117 externally supplied.\n\
10118";
10119static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10120Get family, style and weight of the current font\n\
10121\n\
10122DESCRIPTION:\n\
10123\n\
10124 Gets information about current font. See the PLplot documentation for\n\
10125 more information on font selection.\n\
10126\n\
10127 Redacted form: plgfont(p_family, p_style, p_weight)\n\
10128\n\
10129 This function is used in example 23.\n\
10130\n\
10131\n\
10132\n\
10133SYNOPSIS:\n\
10134\n\
10135plgfont(p_family, p_style, p_weight)\n\
10136\n\
10137ARGUMENTS:\n\
10138\n\
10139 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10140 font family. The available values are given by the PL_FCI_*\n\
10141 constants in plplot.h. Current options are PL_FCI_SANS,\n\
10142 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10143 p_family is NULL then the font family is not returned.\n\
10144\n\
10145 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10146 font style. The available values are given by the PL_FCI_*\n\
10147 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10148 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10149 style is not returned.\n\
10150\n\
10151 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10152 font weight. The available values are given by the PL_FCI_*\n\
10153 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10154 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10155 returned.\n\
10156";
10157static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10158Get z axis parameters\n\
10159\n\
10160DESCRIPTION:\n\
10161\n\
10162 Identical to plgxax, except that arguments are flags for z axis. See\n\
10163 the description of plgxax for more detail.\n\
10164\n\
10165 Redacted form: plgzax(p_digmax, p_digits)\n\
10166\n\
10167 This function is used in example 31.\n\
10168\n\
10169\n\
10170\n\
10171SYNOPSIS:\n\
10172\n\
10173plgzax(p_digmax, p_digits)\n\
10174\n\
10175ARGUMENTS:\n\
10176\n\
10177 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10178 number of digits for the z axis. If nonzero, the printed label\n\
10179 has been switched to a floating-point representation when the\n\
10180 number of digits exceeds this value.\n\
10181\n\
10182 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10183 number of digits for the numeric labels (z axis) from the last\n\
10184 plot.\n\
10185";
10186static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10187Write text inside the viewport of a 3D plot\n\
10188\n\
10189DESCRIPTION:\n\
10190\n\
10191 Writes text at a specified position and inclination and with a\n\
10192 specified shear within the viewport. Text is clipped at the viewport\n\
10193 boundaries. The reference point of a string lies along a line passing\n\
10194 through the string at half the height of a capital letter. The\n\
10195 position of the reference point along this line is determined by just,\n\
10196 and the reference point is placed at world coordinates (\n\
10197 wx,\n\
10198 wy,\n\
10199 wz) within the viewport. The inclination and shear of the string is\n\
10200 specified in terms of differences of world coordinates making it easy\n\
10201 to write text parallel to a line in a graph.\n\
10202\n\
10203 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10204\n\
10205 This function is used in example 28.\n\
10206\n\
10207\n\
10208\n\
10209SYNOPSIS:\n\
10210\n\
10211plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10212\n\
10213ARGUMENTS:\n\
10214\n\
10215 wx (PLFLT, input) : x world coordinate of reference point of\n\
10216 string.\n\
10217\n\
10218 wy (PLFLT, input) : y world coordinate of reference point of\n\
10219 string.\n\
10220\n\
10221 wz (PLFLT, input) : z world coordinate of reference point of\n\
10222 string.\n\
10223\n\
10224 dx (PLFLT, input) : Together with dy and\n\
10225 dz , this specifies the inclination of the string. The baseline of\n\
10226 the string is parallel to a line joining (\n\
10227 x,\n\
10228 y,\n\
10229 z) to (\n\
10230 x+\n\
10231 dx,\n\
10232 y+\n\
10233 dy,\n\
10234 z+\n\
10235 dz) .\n\
10236\n\
10237 dy (PLFLT, input) : Together with dx and\n\
10238 dz, this specifies the inclination of the string.\n\
10239\n\
10240 dz (PLFLT, input) : Together with dx and\n\
10241 dy, this specifies the inclination of the string.\n\
10242\n\
10243 sx (PLFLT, input) : Together with sy and\n\
10244 sz , this specifies the shear of the string. The string is sheared so\n\
10245 that the characters are vertically parallel to a line joining (\n\
10246 x,\n\
10247 y,\n\
10248 z) to (\n\
10249 x+\n\
10250 sx,\n\
10251 y+\n\
10252 sy,\n\
10253 z+\n\
10254 sz) . If sx =\n\
10255 sy =\n\
10256 sz = 0.) then the text is not sheared.\n\
10257\n\
10258 sy (PLFLT, input) : Together with sx and\n\
10259 sz, this specifies shear of the string.\n\
10260\n\
10261 sz (PLFLT, input) : Together with sx and\n\
10262 sy, this specifies shear of the string.\n\
10263\n\
10264 just (PLFLT, input) : Specifies the position of the string relative\n\
10265 to its reference point. If just=0. , the reference point is at\n\
10266 the left and if just=1. , it is at the right of the string. Other\n\
10267 values of just give intermediate justifications.\n\
10268\n\
10269 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10270 written out.\n\
10271";
10272static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10273Draw a box with axes, etc. with arbitrary origin\n\
10274\n\
10275DESCRIPTION:\n\
10276\n\
10277 Draws a box around the currently defined viewport with arbitrary\n\
10278 world-coordinate origin specified by x0 and y0 and labels it with\n\
10279 world coordinate values appropriate to the window. Thus plaxes should\n\
10280 only be called after defining both viewport and window. The ascii\n\
10281 character strings xopt and yopt specify how the box should be drawn as\n\
10282 described below. If ticks and/or subticks are to be drawn for a\n\
10283 particular axis, the tick intervals and number of subintervals may be\n\
10284 specified explicitly, or they may be defaulted by setting the\n\
10285 appropriate arguments to zero.\n\
10286\n\
10287 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10288 ytick, nysub)\n\
10289\n\
10290\n\
10291 This function is not used in any examples.\n\
10292\n\
10293\n\
10294\n\
10295SYNOPSIS:\n\
10296\n\
10297plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10298\n\
10299ARGUMENTS:\n\
10300\n\
10301 x0 (PLFLT, input) : World X coordinate of origin.\n\
10302\n\
10303 y0 (PLFLT, input) : World Y coordinate of origin.\n\
10304\n\
10305 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10306 options for the x axis. The string can include any combination of\n\
10307 the following letters (upper or lower case) in any order: a: Draws\n\
10308 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10309 (x=0).\n\
10310 b: Draws bottom (X) or left (Y) edge of frame.\n\
10311 c: Draws top (X) or right (Y) edge of frame.\n\
10312 d: Plot labels as date / time. Values are assumed to be\n\
10313 seconds since the epoch (as used by gmtime).\n\
10314 f: Always use fixed point numeric labels.\n\
10315 g: Draws a grid at the major tick interval.\n\
10316 h: Draws a grid at the minor tick interval.\n\
10317 i: Inverts tick marks, so they are drawn outwards, rather than\n\
10318 inwards.\n\
10319 l: Labels axis logarithmically. This only affects the labels,\n\
10320 not the data, and so it is necessary to compute the logarithms\n\
10321 of data points before passing them to any of the drawing\n\
10322 routines.\n\
10323 m: Writes numeric labels at major tick intervals in the\n\
10324 unconventional location (above box for X, right of box for Y).\n\
10325 n: Writes numeric labels at major tick intervals in the\n\
10326 conventional location (below box for X, left of box for Y).\n\
10327 o: Use custom labelling function to generate axis label text.\n\
10328 The custom labelling function can be defined with the\n\
10329 plslabelfunc command.\n\
10330 s: Enables subticks between major ticks, only valid if t is\n\
10331 also specified.\n\
10332 t: Draws major ticks.\n\
10333 u: Exactly like \"b\" except don\'t draw edge line.\n\
10334 w: Exactly like \"c\" except don\'t draw edge line.\n\
10335 x: Exactly like \"t\" (including the side effect of the\n\
10336 numerical labels for the major ticks) except exclude drawing\n\
10337 the major and minor tick marks.\n\
10338\n\
10339\n\
10340 xtick (PLFLT, input) : World coordinate interval between major\n\
10341 ticks on the x axis. If it is set to zero, PLplot automatically\n\
10342 generates a suitable tick interval.\n\
10343\n\
10344 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10345 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10346 generates a suitable minor tick interval.\n\
10347\n\
10348 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10349 options for the y axis. The string can include any combination of\n\
10350 the letters defined above for xopt, and in addition may contain:\n\
10351 v: Write numeric labels for the y axis parallel to the base of the\n\
10352 graph, rather than parallel to the axis.\n\
10353\n\
10354\n\
10355 ytick (PLFLT, input) : World coordinate interval between major\n\
10356 ticks on the y axis. If it is set to zero, PLplot automatically\n\
10357 generates a suitable tick interval.\n\
10358\n\
10359 nysub (PLINT, input) : Number of subintervals between major y axis\n\
10360 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10361 generates a suitable minor tick interval.\n\
10362";
10363static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10364Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10365\n\
10366DESCRIPTION:\n\
10367\n\
10368 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10369\n\
10370 Redacted form: plgcolbg(r, g, b)\n\
10371\n\
10372 This function is used in example 31.\n\
10373\n\
10374\n\
10375\n\
10376SYNOPSIS:\n\
10377\n\
10378plgcolbg(r, g, b)\n\
10379\n\
10380ARGUMENTS:\n\
10381\n\
10382 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10383 in the range from 0 to 255.\n\
10384\n\
10385 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10386 in the range from 0 to 255.\n\
10387\n\
10388 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10389 in the range from 0 to 255.\n\
10390";
10391static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10392Plot a glyph at the specified 3D points\n\
10393\n\
10394DESCRIPTION:\n\
10395\n\
10396 Plot a glyph at the specified 3D points. (This function is largely\n\
10397 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10398 Set up the call to this function similar to what is done for plline3.\n\
10399 code=-1 means try to just draw a point. Right now it\'s just a move\n\
10400 and a draw at the same place. Not ideal, since a sufficiently\n\
10401 intelligent output device may optimize it away, or there may be faster\n\
10402 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10403 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10404 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10405 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10406 code <= 127 the corresponding printable ASCII character is plotted.\n\
10407\n\
10408 Redacted form: plpoin3(x, y, z, code)\n\
10409\n\
10410 This function is not used in any example.\n\
10411\n\
10412\n\
10413\n\
10414SYNOPSIS:\n\
10415\n\
10416plpoin3(n, x, y, z, code)\n\
10417\n\
10418ARGUMENTS:\n\
10419\n\
10420 n (PLINT, input) : Number of points in the x and y vectors.\n\
10421\n\
10422 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10423 points.\n\
10424\n\
10425 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10426 points.\n\
10427\n\
10428 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10429 points.\n\
10430\n\
10431 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10432 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10433 each of the n points.\n\
10434";
10435static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10436Draw a polygon in 3 space\n\
10437\n\
10438DESCRIPTION:\n\
10439\n\
10440 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10441 like plline3, but differs from that function in that plpoly3 attempts\n\
10442 to determine if the polygon is viewable depending on the order of the\n\
10443 points within the vector and the value of ifcc. If the back of\n\
10444 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10445 you want, then use plline3 instead.\n\
10446\n\
10447 The points are assumed to be in a plane, and the directionality of the\n\
10448 plane is determined from the first three points. Additional points do\n\
10449 not have to lie on the plane defined by the first three, but if they\n\
10450 do not, then the determination of visibility obviously can\'t be 100%\n\
10451 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10452 consider breaking them into smaller polygons. 3 points define a plane\n\
10453 :-).\n\
10454\n\
10455 Bugs: If one of the first two segments is of zero length, or if they\n\
10456 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10457 being correct. Avoid such situations :-). See x18c.c for an example\n\
10458 of this problem. (Search for 20.1).\n\
10459\n\
10460 Redacted form: plpoly3(x, y, z, code)\n\
10461\n\
10462 This function is used in example 18.\n\
10463\n\
10464\n\
10465\n\
10466SYNOPSIS:\n\
10467\n\
10468plpoly3(n, x, y, z, draw, ifcc)\n\
10469\n\
10470ARGUMENTS:\n\
10471\n\
10472 n (PLINT, input) : Number of points defining line.\n\
10473\n\
10474 x (PLFLT_VECTOR, input) : A vector containing\n\
10475 n x coordinates of points.\n\
10476\n\
10477 y (PLFLT_VECTOR, input) : A vector containing\n\
10478 n y coordinates of points.\n\
10479\n\
10480 z (PLFLT_VECTOR, input) : A vector containing\n\
10481 n z coordinates of points.\n\
10482\n\
10483 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10484 n-1 Boolean values which control drawing the segments of the polygon.\n\
10485 If draw[i] is true, then the polygon segment from index [i] to\n\
10486 [i+1] is drawn, otherwise, not.\n\
10487\n\
10488 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10489 polygon is determined by assuming the points are laid out in a\n\
10490 counter-clockwise order. Otherwise, the directionality of the\n\
10491 polygon is determined by assuming the points are laid out in a\n\
10492 clockwise order.\n\
10493";
10494static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10495Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10496\n\
10497DESCRIPTION:\n\
10498\n\
10499 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10500 PLFLT alpha transparency value (see the PLplot documentation).\n\
10501\n\
10502 This function is used in example 31.\n\
10503\n\
10504\n\
10505\n\
10506SYNOPSIS:\n\
10507\n\
10508plscolbga(r, g, b, alpha)\n\
10509\n\
10510ARGUMENTS:\n\
10511\n\
10512 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10513 degree of red in the color.\n\
10514\n\
10515 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10516 degree of green in the color.\n\
10517\n\
10518 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10519 degree of blue in the color.\n\
10520\n\
10521 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10522 (0.0-1.0).\n\
10523";
10524static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10525Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10526\n\
10527DESCRIPTION:\n\
10528\n\
10529 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10530 alpha transparency value.\n\
10531\n\
10532 This function is used in example 31.\n\
10533\n\
10534\n\
10535\n\
10536SYNOPSIS:\n\
10537\n\
10538plgcolbga(r, g, b, alpha)\n\
10539\n\
10540ARGUMENTS:\n\
10541\n\
10542 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10543 in the range from 0 to 255.\n\
10544\n\
10545 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10546 in the range from 0 to 255.\n\
10547\n\
10548 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10549 in the range from 0 to 255.\n\
10550\n\
10551 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10552 transparency in the range (0.0-1.0).\n\
10553";
10554static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10555Draw error bars in x direction\n\
10556\n\
10557DESCRIPTION:\n\
10558\n\
10559 Draws a set of n error bars in x direction, the i\'th error bar\n\
10560 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10561 of the error bars are of length equal to the minor tick length\n\
10562 (settable using plsmin).\n\
10563\n\
10564 Redacted form: General: plerrx(xmin, ymax, y)\n\
10565\n\
10566\n\
10567 This function is used in example 29.\n\
10568\n\
10569\n\
10570\n\
10571SYNOPSIS:\n\
10572\n\
10573plerrx(n, xmin, xmax, y)\n\
10574\n\
10575ARGUMENTS:\n\
10576\n\
10577 n (PLINT, input) : Number of error bars to draw.\n\
10578\n\
10579 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10580 of the left-hand endpoints of the error bars.\n\
10581\n\
10582 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10583 of the right-hand endpoints of the error bars.\n\
10584\n\
10585 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10586 the error bars.\n\
10587";
10588static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10589Eject current page\n\
10590\n\
10591DESCRIPTION:\n\
10592\n\
10593 Clears the graphics screen of an interactive device, or ejects a page\n\
10594 on a plotter. See plbop for more information.\n\
10595\n\
10596 Redacted form: pleop()\n\
10597\n\
10598 This function is used in example 2,14.\n\
10599\n\
10600\n\
10601\n\
10602SYNOPSIS:\n\
10603\n\
10604pleop()\n\
10605";
10606static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10607Convert HLS color to RGB\n\
10608\n\
10609DESCRIPTION:\n\
10610\n\
10611 Convert HLS color coordinates to RGB.\n\
10612\n\
10613 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10614\n\
10615\n\
10616 This function is used in example 2.\n\
10617\n\
10618\n\
10619\n\
10620SYNOPSIS:\n\
10621\n\
10622plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10623\n\
10624ARGUMENTS:\n\
10625\n\
10626 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10627 cylinder.\n\
10628\n\
10629 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10630 the axis of the color cylinder.\n\
10631\n\
10632 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10633 the radius of the color cylinder.\n\
10634\n\
10635 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10636 (0.0-1.0) of the color.\n\
10637\n\
10638 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10639 intensity (0.0-1.0) of the color.\n\
10640\n\
10641 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10642 intensity (0.0-1.0) of the color.\n\
10643";
10644static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10645Plot all or a subset of Shapefile data, filling the polygons\n\
10646\n\
10647DESCRIPTION:\n\
10648\n\
10649 As per plmapline, however the items are filled in the same way as\n\
10650 plfill.\n\
10651\n\
10652 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10653 plotentries)\n\
10654\n\
10655 This function is used in example 19.\n\
10656\n\
10657\n\
10658\n\
10659SYNOPSIS:\n\
10660\n\
10661plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10662\n\
10663ARGUMENTS:\n\
10664\n\
10665 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10666 transform the coordinates given in the shapefile into a plot\n\
10667 coordinate system. By using this transform, we can change from a\n\
10668 longitude, latitude coordinate to a polar stereographic project,\n\
10669 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10670 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10671 mapform(), x[] and y[] should be replaced by the corresponding\n\
10672 plot coordinates. If no transform is desired, mapform can be\n\
10673 replaced by NULL.\n\
10674\n\
10675 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10676 the file name of a set of Shapefile files without the file\n\
10677 extension.\n\
10678\n\
10679 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10680 be in the same units as used by the Shapefile. You could use a\n\
10681 very large negative number to plot everything, but you can improve\n\
10682 performance by limiting the area drawn. The units must match those\n\
10683 of the Shapefile projection, which may be for example longitude or\n\
10684 distance. The value of minx must be less than the value of maxx.\n\
10685\n\
10686 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10687 use a very large number to plot everything, but you can improve\n\
10688 performance by limiting the area drawn.\n\
10689\n\
10690 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10691 be in the same units as used by the Shapefile. You could use a\n\
10692 very large negative number to plot everything, but you can improve\n\
10693 performance by limiting the area drawn. The units must match those\n\
10694 of the Shapefile projection, which may be for example latitude or\n\
10695 distance. The value of miny must be less than the value of maxy.\n\
10696\n\
10697 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10698 use a very large number to plot everything, but you can improve\n\
10699 performance by limiting the area drawn.\n\
10700\n\
10701 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10702 zero-based indices of the Shapefile elements which will be drawn.\n\
10703 Setting\n\
10704 plotentries to NULL will plot all elements of the Shapefile.\n\
10705\n\
10706 nplotentries (PLINT, input) : The number of items in\n\
10707 plotentries. Ignored if\n\
10708 plotentries is NULL.\n\
10709";
10710static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10711Draw error bars in the y direction\n\
10712\n\
10713DESCRIPTION:\n\
10714\n\
10715 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10716 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10717 of the error bars are of length equal to the minor tick length\n\
10718 (settable using plsmin).\n\
10719\n\
10720 Redacted form: General: plerry(x, ymin, ymax)\n\
10721\n\
10722\n\
10723 This function is used in example 29.\n\
10724\n\
10725\n\
10726\n\
10727SYNOPSIS:\n\
10728\n\
10729plerry(n, x, ymin, ymax)\n\
10730\n\
10731ARGUMENTS:\n\
10732\n\
10733 n (PLINT, input) : Number of error bars to draw.\n\
10734\n\
10735 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10736 the error bars.\n\
10737\n\
10738 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10739 of the lower endpoints of the error bars.\n\
10740\n\
10741 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10742 of the upper endpoints of the error bars.\n\
10743";
10744static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10745Set FCI (font characterization integer)\n\
10746\n\
10747DESCRIPTION:\n\
10748\n\
10749 Sets font characteristics to be used at the start of the next string\n\
10750 using the FCI approach. See the PLplot documentation for more\n\
10751 information. Note, plsfont (which calls plsfci internally) provides a\n\
10752 more user-friendly API for setting the font characterisitics.\n\
10753\n\
10754 Redacted form: General: plsfci(fci)\n\
10755\n\
10756\n\
10757 This function is used in example 23.\n\
10758\n\
10759\n\
10760\n\
10761SYNOPSIS:\n\
10762\n\
10763plsfci(fci)\n\
10764\n\
10765ARGUMENTS:\n\
10766\n\
10767 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10768 of FCI.\n\
10769";
10770static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10771Select area fill pattern\n\
10772\n\
10773DESCRIPTION:\n\
10774\n\
10775 If\n\
10776 patt is zero or less use either a hardware solid fill if the drivers\n\
10777 have that capability (virtually all do) or fall back to a software\n\
10778 emulation of a solid fill using the eighth area line fill pattern. If\n\
10779 0 <\n\
10780 patt <= 8, then select one of eight predefined area line fill patterns\n\
10781 to use (see plpat if you desire other patterns).\n\
10782\n\
10783 Redacted form: plpsty(patt)\n\
10784\n\
10785 This function is used in examples 12, 13, 15, 16, and 25.\n\
10786\n\
10787\n\
10788\n\
10789SYNOPSIS:\n\
10790\n\
10791plpsty(patt)\n\
10792\n\
10793ARGUMENTS:\n\
10794\n\
10795 patt (PLINT, input) : The desired pattern index. If\n\
10796 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10797 above) used. For\n\
10798 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10799 line fill capability itself (most deliberately do not so that line\n\
10800 fill patterns look identical for those drivers), the patterns\n\
10801 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10802 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10803 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10804 (8) lines at both 45 degrees and -45 degrees.\n\
10805";
10806static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10807Set symbol size\n\
10808\n\
10809DESCRIPTION:\n\
10810\n\
10811 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10812 plsym. The actual height of a symbol is the product of the default\n\
10813 symbol size and a scaling factor as for the character height.\n\
10814\n\
10815 Redacted form: plssym(def, scale)\n\
10816\n\
10817 This function is used in example 29.\n\
10818\n\
10819\n\
10820\n\
10821SYNOPSIS:\n\
10822\n\
10823plssym(def, scale)\n\
10824\n\
10825ARGUMENTS:\n\
10826\n\
10827 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10828 should be set to zero if the default height is to remain\n\
10829 unchanged.\n\
10830\n\
10831 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10832 actual symbol height.\n\
10833";
10834static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10835Initialization\n\
10836\n\
10837DESCRIPTION:\n\
10838\n\
10839 Alternative to plstar for initializing the plotting package. The\n\
10840 device name keyword for the desired output device must be supplied as\n\
10841 an argument. These keywords are the same as those printed out by\n\
10842 plstar. If the requested device is not available, or if the input\n\
10843 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10844 is used. This routine also divides the output device page into nx by\n\
10845 ny subpages, each of which may be used independently. The subroutine\n\
10846 pladv is used to advance from one subpage to the next.\n\
10847\n\
10848 Redacted form: General: plstart(devname, nx, ny)\n\
10849\n\
10850\n\
10851 This function is not used in any examples.\n\
10852\n\
10853\n\
10854\n\
10855SYNOPSIS:\n\
10856\n\
10857plstart(devname, nx, ny)\n\
10858\n\
10859ARGUMENTS:\n\
10860\n\
10861 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10862 containing the device name keyword of the required output device.\n\
10863 If\n\
10864 devname is NULL or if the first character of the string is a ``?\'\',\n\
10865 the normal (prompted) start up is used.\n\
10866\n\
10867 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10868 x direction.\n\
10869\n\
10870 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10871 y direction.\n\
10872";
10873
10874SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10875 PLINT arg1 ;
10876 PLINT *arg2 = (PLINT *) 0 ;
10877 char **arg3 = (char **) 0 ;
10878 Matrix temp1 ;
10879 octave_value_list _out;
10880 octave_value_list *_outp=&_out;
10881 octave_value _outv;
10882
10883 try {
10884 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10885 SWIG_fail;
10886 }
10887 {
10888 if ( _n_dims( args(0) ) > 1 )
10889 {
10890 error( "argument must be a scalar or vector" ); SWIG_fail;
10891 }
10892 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10893 arg2 = new PLINT[Alen];
10894 temp1 = args(0).matrix_value();
10895 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10896 }
10897 {
10898 charMatrix temp_matrix;
10899 Cell temp_cell;
10900 char *tmp_cstring;
10901 std::string str;
10902 size_t max_length = 0, non_blank_length;
10903 int i, ifcell;
10904 if ( _n_dims( args(1) ) > 2 )
10905 {
10906 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10907 }
10908#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10909 if ( !args(1).isempty() )
10910#else
10911 if ( !args(1).is_empty() )
10912#endif
10913 {
10914 if ( _dim( args(1), 0 ) != Alen )
10915 {
10916 error( "first dimension must be same length as previous vector" ); SWIG_fail;
10917 }
10918 arg3 = new char*[Alen];
10919#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10920 ifcell = args(1).iscell();
10921#else
10922 ifcell = args(1).is_cell();
10923#endif
10924 if ( ifcell )
10925 {
10926 temp_cell = args(1).cell_value();
10927 }
10928 else
10929 {
10930 temp_matrix = args(1).char_matrix_value();
10931 // Allow one extra space for null termination.
10932 max_length = _dim( args(1), 1 ) + 1;
10933 }
10934
10935 for ( i = 0; i < Alen; i++ )
10936 {
10937 // Must copy string to "permanent" location because the string
10938 // location corresponding to tmp_cstring gets
10939 // overwritten for each iteration of loop.
10940 if ( ifcell )
10941 {
10942 if ( temp_cell.elem( i ).is_string() )
10943 {
10944 str = temp_cell.elem( i ).string_value();
10945 // leave room for null termination.
10946 max_length = str.size() + 1;
10947 tmp_cstring = (char *) str.c_str();
10948 }
10949 else
10950 {
10951 // Use null string if user attempts to pass a cell array
10952 // with a non-string element (likely an empty element
10953 // since that should be allowed by the PLplot interface
10954 // if that element is going to be unused).
10955 // leave room for null termination.
10956 max_length = 1;
10957 tmp_cstring = (char *) "";
10958 }
10959 }
10960 else
10961 {
10962 str = temp_matrix.row_as_string( i );
10963 tmp_cstring = (char *) str.c_str();
10964 }
10965 arg3[i] = new char[max_length];
10966 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10967 arg3[i][max_length - 1] = '\0';
10968 // All the trailing blank crapola should not be needed for
10969 // string cell arrays.
10970 if ( !ifcell )
10971 {
10972 // remove trailing-blank padding that is used by the
10973 // charMatrix class to insure all strings in a given
10974 // charMatrix instance have the same length.
10975 // This transformation also removes legitimate trailing
10976 // blanks but there is nothing we can do about that
10977 // for the charMatrix class.
10978
10979 // Look for trailing nulls first (just in case, although that
10980 // shouldn't happen if charMatrix implemented as documented)
10981 // before looking for trailing blanks.
10982 non_blank_length = max_length - 2;
10983 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10984 {
10985 non_blank_length--;
10986 }
10987 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10988 {
10989 non_blank_length--;
10990 }
10991 arg3[i][non_blank_length + 1] = '\0';
10992 }
10993 }
10994 }
10995 else
10996 {
10997 arg3 = NULL;
10998 }
10999 }
11000 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11001 _outv = octave_value();
11002 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11003 {
11004 delete [] arg2;
11005 }
11006 {
11007 int i;
11008 if ( arg3 != NULL )
11009 {
11010 for ( i = 0; i < Alen; i++ )
11011 {
11012 delete[] arg3[i];
11013 }
11014 delete[] arg3;
11015 }
11016 }
11017 return _out;
11018 fail:
11019 {
11020 delete [] arg2;
11021 }
11022 {
11023 int i;
11024 if ( arg3 != NULL )
11025 {
11026 for ( i = 0; i < Alen; i++ )
11027 {
11028 delete[] arg3[i];
11029 }
11030 delete[] arg3;
11031 }
11032 }
11033 return octave_value_list();
11034 }
11035 catch(...) {
11036 {
11037 delete [] arg2;
11038 }
11039 {
11040 int i;
11041 if ( arg3 != NULL )
11042 {
11043 for ( i = 0; i < Alen; i++ )
11044 {
11045 delete[] arg3[i];
11046 }
11047 delete[] arg3;
11048 }
11049 }
11050 throw;
11051 }
11052}
11053
11054
11056 int *arg1 = (int *) 0 ;
11057 int *arg2 = (int *) 0 ;
11058 int *arg3 = (int *) 0 ;
11059 char *arg4 = (char *) 0 ;
11060 int *arg5 = (int *) 0 ;
11061 int *arg6 = (int *) 0 ;
11062 PLFLT *arg7 = (PLFLT *) 0 ;
11063 PLFLT *arg8 = (PLFLT *) 0 ;
11064 PLFLT *arg9 = (PLFLT *) 0 ;
11065 PLFLT *arg10 = (PLFLT *) 0 ;
11066 int *arg11 = (int *) 0 ;
11067 int temp1 ;
11068 int res1 = SWIG_TMPOBJ ;
11069 int temp2 ;
11070 int res2 = SWIG_TMPOBJ ;
11071 int temp3 ;
11072 int res3 = SWIG_TMPOBJ ;
11073 char local_string4[80] ;
11074 int temp5 ;
11075 int res5 = SWIG_TMPOBJ ;
11076 int temp6 ;
11077 int res6 = SWIG_TMPOBJ ;
11078 PLFLT temp7 ;
11079 int res7 = SWIG_TMPOBJ ;
11080 PLFLT temp8 ;
11081 int res8 = SWIG_TMPOBJ ;
11082 PLFLT temp9 ;
11083 int res9 = SWIG_TMPOBJ ;
11084 PLFLT temp10 ;
11085 int res10 = SWIG_TMPOBJ ;
11086 int temp11 ;
11087 int res11 = SWIG_TMPOBJ ;
11088 size_t local_string_length4 ;
11089 charMatrix local_charMatrix4 ;
11090 octave_value_list retval4 ;
11091 octave_value_list _out;
11092 octave_value_list *_outp=&_out;
11093 octave_value _outv;
11094 int result;
11095
11096 try {
11097 arg1 = &temp1;
11098 arg2 = &temp2;
11099 arg3 = &temp3;
11100 {
11101 arg4 = local_string4;
11102 }
11103 arg5 = &temp5;
11104 arg6 = &temp6;
11105 arg7 = &temp7;
11106 arg8 = &temp8;
11107 arg9 = &temp9;
11108 arg10 = &temp10;
11109 arg11 = &temp11;
11110 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11111 SWIG_fail;
11112 }
11113 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11114 _outv = SWIG_From_int(static_cast< int >(result));
11115 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11116 if (SWIG_IsTmpObj(res1)) {
11117 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11118 } else {
11119 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11120 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11121 }
11122 if (SWIG_IsTmpObj(res2)) {
11123 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11124 } else {
11125 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11126 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11127 }
11128 if (SWIG_IsTmpObj(res3)) {
11129 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11130 } else {
11131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11132 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11133 }
11134 {
11135 local_string_length4 = strlen( local_string4 );
11136 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11137 local_charMatrix4.insert( local_string4, 0, 0 );
11138 retval4( 0 ) = octave_value( local_charMatrix4 );
11139 _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11140 }
11141 if (SWIG_IsTmpObj(res5)) {
11142 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11143 } else {
11144 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11145 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11146 }
11147 if (SWIG_IsTmpObj(res6)) {
11148 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11149 } else {
11150 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11151 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11152 }
11153 if (SWIG_IsTmpObj(res7)) {
11154 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11155 } else {
11156 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11157 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11158 }
11159 if (SWIG_IsTmpObj(res8)) {
11160 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11161 } else {
11162 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11163 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11164 }
11165 if (SWIG_IsTmpObj(res9)) {
11166 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11167 } else {
11168 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11169 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11170 }
11171 if (SWIG_IsTmpObj(res10)) {
11172 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11173 } else {
11174 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11175 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11176 }
11177 if (SWIG_IsTmpObj(res11)) {
11178 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11179 } else {
11180 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11181 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11182 }
11183 return _out;
11184 fail:
11185 return octave_value_list();
11186 }
11187 catch(...) {
11188 throw;
11189 }
11190}
11191
11192
11193SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11194 PLFLT *arg1 = (PLFLT *) 0 ;
11195 PLFLT *arg2 = (PLFLT *) 0 ;
11196 PLFLT arg3 ;
11197 PLFLT arg4 ;
11198 PLFLT temp1 ;
11199 int res1 = SWIG_TMPOBJ ;
11200 PLFLT temp2 ;
11201 int res2 = SWIG_TMPOBJ ;
11202 double val3 ;
11203 int ecode3 = 0 ;
11204 double val4 ;
11205 int ecode4 = 0 ;
11206 octave_value_list _out;
11207 octave_value_list *_outp=&_out;
11208 octave_value _outv;
11209 int result;
11210
11211 try {
11212 arg1 = &temp1;
11213 arg2 = &temp2;
11214 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11215 SWIG_fail;
11216 }
11217 ecode3 = SWIG_AsVal_double(args(0), &val3);
11218 if (!SWIG_IsOK(ecode3)) {
11219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11220 }
11221 arg3 = static_cast< PLFLT >(val3);
11222 ecode4 = SWIG_AsVal_double(args(1), &val4);
11223 if (!SWIG_IsOK(ecode4)) {
11224 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11225 }
11226 arg4 = static_cast< PLFLT >(val4);
11227 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11228 _outv = SWIG_From_int(static_cast< int >(result));
11229 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11230 if (SWIG_IsTmpObj(res1)) {
11231 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11232 } else {
11233 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11234 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11235 }
11236 if (SWIG_IsTmpObj(res2)) {
11237 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11238 } else {
11239 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11240 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11241 }
11242 return _out;
11243 fail:
11244 return octave_value_list();
11245 }
11246 catch(...) {
11247 throw;
11248 }
11249}
11250
11251
11253 PLINT *arg1 = (PLINT *) 0 ;
11254 char *arg2 = (char *) 0 ;
11255 char *arg3 = (char *) 0 ;
11256 PLFLT arg4 ;
11257 PLFLT arg5 ;
11258 PLFLT arg6 ;
11259 PLFLT arg7 ;
11260 PLFLT arg8 ;
11261 PLFLT arg9 ;
11262 PLFLT arg10 ;
11263 PLBOOL arg11 ;
11264 PLBOOL arg12 ;
11265 PLINT arg13 ;
11266 PLINT arg14 ;
11267 PLINT *arg15 = (PLINT *) 0 ;
11268 PLINT *arg16 = (PLINT *) 0 ;
11269 char *arg17 = (char *) 0 ;
11270 char *arg18 = (char *) 0 ;
11271 char *arg19 = (char *) 0 ;
11272 char *arg20 = (char *) 0 ;
11273 char *arg21 = (char *) 0 ;
11274 char *arg22 = (char *) 0 ;
11275 char *arg23 = (char *) 0 ;
11276 PLINT temp1 ;
11277 int res1 = SWIG_TMPOBJ ;
11278 int res2 ;
11279 char *buf2 = 0 ;
11280 int alloc2 = 0 ;
11281 int res3 ;
11282 char *buf3 = 0 ;
11283 int alloc3 = 0 ;
11284 double val4 ;
11285 int ecode4 = 0 ;
11286 double val5 ;
11287 int ecode5 = 0 ;
11288 double val6 ;
11289 int ecode6 = 0 ;
11290 double val7 ;
11291 int ecode7 = 0 ;
11292 double val8 ;
11293 int ecode8 = 0 ;
11294 double val9 ;
11295 int ecode9 = 0 ;
11296 double val10 ;
11297 int ecode10 = 0 ;
11298 int val11 ;
11299 int ecode11 = 0 ;
11300 int val12 ;
11301 int ecode12 = 0 ;
11302 int val13 ;
11303 int ecode13 = 0 ;
11304 int val14 ;
11305 int ecode14 = 0 ;
11306 Matrix temp15 ;
11307 Matrix temp16 ;
11308 int res17 ;
11309 char *buf17 = 0 ;
11310 int alloc17 = 0 ;
11311 int res18 ;
11312 char *buf18 = 0 ;
11313 int alloc18 = 0 ;
11314 int res19 ;
11315 char *buf19 = 0 ;
11316 int alloc19 = 0 ;
11317 int res20 ;
11318 char *buf20 = 0 ;
11319 int alloc20 = 0 ;
11320 int res21 ;
11321 char *buf21 = 0 ;
11322 int alloc21 = 0 ;
11323 int res22 ;
11324 char *buf22 = 0 ;
11325 int alloc22 = 0 ;
11326 int res23 ;
11327 char *buf23 = 0 ;
11328 int alloc23 = 0 ;
11329 octave_value_list _out;
11330 octave_value_list *_outp=&_out;
11331 octave_value _outv;
11332
11333 try {
11334 arg1 = &temp1;
11335 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11336 SWIG_fail;
11337 }
11338 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11341 }
11342 arg2 = reinterpret_cast< char * >(buf2);
11343 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11344 if (!SWIG_IsOK(res3)) {
11345 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11346 }
11347 arg3 = reinterpret_cast< char * >(buf3);
11348 ecode4 = SWIG_AsVal_double(args(2), &val4);
11349 if (!SWIG_IsOK(ecode4)) {
11350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11351 }
11352 arg4 = static_cast< PLFLT >(val4);
11353 ecode5 = SWIG_AsVal_double(args(3), &val5);
11354 if (!SWIG_IsOK(ecode5)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11356 }
11357 arg5 = static_cast< PLFLT >(val5);
11358 ecode6 = SWIG_AsVal_double(args(4), &val6);
11359 if (!SWIG_IsOK(ecode6)) {
11360 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11361 }
11362 arg6 = static_cast< PLFLT >(val6);
11363 ecode7 = SWIG_AsVal_double(args(5), &val7);
11364 if (!SWIG_IsOK(ecode7)) {
11365 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11366 }
11367 arg7 = static_cast< PLFLT >(val7);
11368 ecode8 = SWIG_AsVal_double(args(6), &val8);
11369 if (!SWIG_IsOK(ecode8)) {
11370 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11371 }
11372 arg8 = static_cast< PLFLT >(val8);
11373 ecode9 = SWIG_AsVal_double(args(7), &val9);
11374 if (!SWIG_IsOK(ecode9)) {
11375 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11376 }
11377 arg9 = static_cast< PLFLT >(val9);
11378 ecode10 = SWIG_AsVal_double(args(8), &val10);
11379 if (!SWIG_IsOK(ecode10)) {
11380 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11381 }
11382 arg10 = static_cast< PLFLT >(val10);
11383 ecode11 = SWIG_AsVal_int(args(9), &val11);
11384 if (!SWIG_IsOK(ecode11)) {
11385 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11386 }
11387 arg11 = static_cast< PLBOOL >(val11);
11388 ecode12 = SWIG_AsVal_int(args(10), &val12);
11389 if (!SWIG_IsOK(ecode12)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11391 }
11392 arg12 = static_cast< PLBOOL >(val12);
11393 ecode13 = SWIG_AsVal_int(args(11), &val13);
11394 if (!SWIG_IsOK(ecode13)) {
11395 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11396 }
11397 arg13 = static_cast< PLINT >(val13);
11398 ecode14 = SWIG_AsVal_int(args(12), &val14);
11399 if (!SWIG_IsOK(ecode14)) {
11400 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11401 }
11402 arg14 = static_cast< PLINT >(val14);
11403 {
11404 if ( _n_dims( args(13) ) > 1 )
11405 {
11406 error( "argument must be a scalar or vector" ); SWIG_fail;
11407 }
11408 Alen = (PLINT) ( _dim( args(13), 0 ) );
11409 temp15 = args(13).matrix_value();
11410 arg15 = new PLINT[Alen];
11411 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11412 }
11413 {
11414 if ( _n_dims( args(14) ) > 1 )
11415 {
11416 error( "argument must be a scalar or vector" ); SWIG_fail;
11417 }
11418 if ( _dim( args(14), 0 ) != Alen )
11419 {
11420 error( "argument vectors must be same length" ); SWIG_fail;
11421 }
11422 temp16 = args(14).matrix_value();
11423 arg16 = new PLINT[Alen];
11424 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11425 }
11426 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11427 if (!SWIG_IsOK(res17)) {
11428 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11429 }
11430 arg17 = reinterpret_cast< char * >(buf17);
11431 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11432 if (!SWIG_IsOK(res18)) {
11433 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11434 }
11435 arg18 = reinterpret_cast< char * >(buf18);
11436 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11437 if (!SWIG_IsOK(res19)) {
11438 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11439 }
11440 arg19 = reinterpret_cast< char * >(buf19);
11441 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11442 if (!SWIG_IsOK(res20)) {
11443 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11444 }
11445 arg20 = reinterpret_cast< char * >(buf20);
11446 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11447 if (!SWIG_IsOK(res21)) {
11448 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11449 }
11450 arg21 = reinterpret_cast< char * >(buf21);
11451 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11452 if (!SWIG_IsOK(res22)) {
11453 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11454 }
11455 arg22 = reinterpret_cast< char * >(buf22);
11456 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11457 if (!SWIG_IsOK(res23)) {
11458 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11459 }
11460 arg23 = reinterpret_cast< char * >(buf23);
11461 my_plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *)arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20,(char const *)arg21,(char const *)arg22,(char const *)arg23);
11462 _outv = octave_value();
11463 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11464 if (SWIG_IsTmpObj(res1)) {
11465 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11466 } else {
11467 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11468 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11469 }
11470 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11471 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11472 {
11473 delete [] arg15;
11474 }
11475 {
11476 delete [] arg16;
11477 }
11478 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11479 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11480 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11481 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11482 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11483 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11484 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11485 return _out;
11486 fail:
11487 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11488 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11489 {
11490 delete [] arg15;
11491 }
11492 {
11493 delete [] arg16;
11494 }
11495 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11496 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11497 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11498 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11499 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11500 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11501 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11502 return octave_value_list();
11503 }
11504 catch(...) {
11505 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11506 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11507 {
11508 delete [] arg15;
11509 }
11510 {
11511 delete [] arg16;
11512 }
11513 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11514 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11515 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11516 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11517 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11518 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11519 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11520 throw;
11521 }
11522}
11523
11524
11526 PLFLT *arg1 = (PLFLT *) 0 ;
11527 PLINT arg2 ;
11528 PLINT arg3 ;
11529 PLINT arg4 ;
11530 PLINT arg5 ;
11531 PLINT arg6 ;
11532 PLINT arg7 ;
11533 PLFLT *arg8 = (PLFLT *) 0 ;
11534 PLINT arg9 ;
11535 PLFLT *arg10 = (PLFLT *) 0 ;
11536 Matrix temp1 ;
11537 int val4 ;
11538 int ecode4 = 0 ;
11539 int val5 ;
11540 int ecode5 = 0 ;
11541 int val6 ;
11542 int ecode6 = 0 ;
11543 int val7 ;
11544 int ecode7 = 0 ;
11545 Matrix temp8 ;
11546 Matrix temp10 ;
11547 octave_value_list _out;
11548 octave_value_list *_outp=&_out;
11549 octave_value _outv;
11550
11551 try {
11552 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11553 SWIG_fail;
11554 }
11555 {
11556 if ( _n_dims( args(0) ) > 2 )
11557 {
11558 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11559 }
11560 temp1 = args(0).matrix_value();
11561 arg1 = &temp1( 0, 0 );
11562 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11563 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11564 }
11565 ecode4 = SWIG_AsVal_int(args(1), &val4);
11566 if (!SWIG_IsOK(ecode4)) {
11567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11568 }
11569 arg4 = static_cast< PLINT >(val4);
11570 ecode5 = SWIG_AsVal_int(args(2), &val5);
11571 if (!SWIG_IsOK(ecode5)) {
11572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11573 }
11574 arg5 = static_cast< PLINT >(val5);
11575 ecode6 = SWIG_AsVal_int(args(3), &val6);
11576 if (!SWIG_IsOK(ecode6)) {
11577 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11578 }
11579 arg6 = static_cast< PLINT >(val6);
11580 ecode7 = SWIG_AsVal_int(args(4), &val7);
11581 if (!SWIG_IsOK(ecode7)) {
11582 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11583 }
11584 arg7 = static_cast< PLINT >(val7);
11585 {
11586 if ( _n_dims( args(5) ) > 1 )
11587 {
11588 error( "argument must be a scalar or vector" ); SWIG_fail;
11589 }
11590 temp8 = args(5).matrix_value();
11591 arg8 = &temp8( 0, 0 );
11592 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11593 }
11594 {
11595 if ( _n_dims( args(6) ) > 1 )
11596 {
11597 error( "argument must be a scalar or vector" ); SWIG_fail;
11598 }
11599 if ( _dim( args(6), 0 ) != 6 )
11600 {
11601 error( "argument vectors must have length of 6" ); SWIG_fail;
11602 }
11603 temp10 = args(6).matrix_value();
11604 arg10 = &temp10( 0, 0 );
11605 }
11606 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11607 _outv = octave_value();
11608 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11609 {
11610
11611 }
11612 {
11613
11614 }
11615 {
11616
11617 }
11618 return _out;
11619 fail:
11620 {
11621
11622 }
11623 {
11624
11625 }
11626 {
11627
11628 }
11629 return octave_value_list();
11630 }
11631 catch(...) {
11632 {
11633
11634 }
11635 {
11636
11637 }
11638 {
11639
11640 }
11641 throw;
11642 }
11643}
11644
11645
11646SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11647 PLFLT *arg1 = (PLFLT *) 0 ;
11648 PLINT arg2 ;
11649 PLINT arg3 ;
11650 PLINT arg4 ;
11651 PLINT arg5 ;
11652 PLINT arg6 ;
11653 PLINT arg7 ;
11654 PLFLT *arg8 = (PLFLT *) 0 ;
11655 PLINT arg9 ;
11656 Matrix temp1 ;
11657 int val4 ;
11658 int ecode4 = 0 ;
11659 int val5 ;
11660 int ecode5 = 0 ;
11661 int val6 ;
11662 int ecode6 = 0 ;
11663 int val7 ;
11664 int ecode7 = 0 ;
11665 Matrix temp8 ;
11666 octave_value_list _out;
11667 octave_value_list *_outp=&_out;
11668 octave_value _outv;
11669
11670 try {
11671 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11672 SWIG_fail;
11673 }
11674 {
11675 if ( _n_dims( args(0) ) > 2 )
11676 {
11677 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11678 }
11679 temp1 = args(0).matrix_value();
11680 arg1 = &temp1( 0, 0 );
11681 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11682 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11683 }
11684 ecode4 = SWIG_AsVal_int(args(1), &val4);
11685 if (!SWIG_IsOK(ecode4)) {
11686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11687 }
11688 arg4 = static_cast< PLINT >(val4);
11689 ecode5 = SWIG_AsVal_int(args(2), &val5);
11690 if (!SWIG_IsOK(ecode5)) {
11691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11692 }
11693 arg5 = static_cast< PLINT >(val5);
11694 ecode6 = SWIG_AsVal_int(args(3), &val6);
11695 if (!SWIG_IsOK(ecode6)) {
11696 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11697 }
11698 arg6 = static_cast< PLINT >(val6);
11699 ecode7 = SWIG_AsVal_int(args(4), &val7);
11700 if (!SWIG_IsOK(ecode7)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11702 }
11703 arg7 = static_cast< PLINT >(val7);
11704 {
11705 if ( _n_dims( args(5) ) > 1 )
11706 {
11707 error( "argument must be a scalar or vector" ); SWIG_fail;
11708 }
11709 temp8 = args(5).matrix_value();
11710 arg8 = &temp8( 0, 0 );
11711 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11712 }
11713 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11714 _outv = octave_value();
11715 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11716 {
11717
11718 }
11719 {
11720
11721 }
11722 return _out;
11723 fail:
11724 {
11725
11726 }
11727 {
11728
11729 }
11730 return octave_value_list();
11731 }
11732 catch(...) {
11733 {
11734
11735 }
11736 {
11737
11738 }
11739 throw;
11740 }
11741}
11742
11743
11744SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11745 PLFLT *arg1 = (PLFLT *) 0 ;
11746 PLINT arg2 ;
11747 PLINT arg3 ;
11748 PLINT arg4 ;
11749 PLINT arg5 ;
11750 PLINT arg6 ;
11751 PLINT arg7 ;
11752 PLFLT *arg8 = (PLFLT *) 0 ;
11753 PLINT arg9 ;
11754 PLFLT *arg10 = (PLFLT *) 0 ;
11755 PLFLT *arg11 = (PLFLT *) 0 ;
11756 Matrix temp1 ;
11757 int val4 ;
11758 int ecode4 = 0 ;
11759 int val5 ;
11760 int ecode5 = 0 ;
11761 int val6 ;
11762 int ecode6 = 0 ;
11763 int val7 ;
11764 int ecode7 = 0 ;
11765 Matrix temp8 ;
11766 Matrix temp10 ;
11767 Matrix temp11 ;
11768 octave_value_list _out;
11769 octave_value_list *_outp=&_out;
11770 octave_value _outv;
11771
11772 try {
11773 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11774 SWIG_fail;
11775 }
11776 {
11777 if ( _n_dims( args(0) ) > 2 )
11778 {
11779 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11780 }
11781 temp1 = args(0).matrix_value();
11782 arg1 = &temp1( 0, 0 );
11783 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11784 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11785 }
11786 ecode4 = SWIG_AsVal_int(args(1), &val4);
11787 if (!SWIG_IsOK(ecode4)) {
11788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11789 }
11790 arg4 = static_cast< PLINT >(val4);
11791 ecode5 = SWIG_AsVal_int(args(2), &val5);
11792 if (!SWIG_IsOK(ecode5)) {
11793 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11794 }
11795 arg5 = static_cast< PLINT >(val5);
11796 ecode6 = SWIG_AsVal_int(args(3), &val6);
11797 if (!SWIG_IsOK(ecode6)) {
11798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11799 }
11800 arg6 = static_cast< PLINT >(val6);
11801 ecode7 = SWIG_AsVal_int(args(4), &val7);
11802 if (!SWIG_IsOK(ecode7)) {
11803 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11804 }
11805 arg7 = static_cast< PLINT >(val7);
11806 {
11807 if ( _n_dims( args(5) ) > 1 )
11808 {
11809 error( "argument must be a scalar or vector" ); SWIG_fail;
11810 }
11811 temp8 = args(5).matrix_value();
11812 arg8 = &temp8( 0, 0 );
11813 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11814 }
11815 {
11816 if ( _n_dims( args(6) ) > 1 )
11817 {
11818 error( "argument must be a scalar or vector" ); SWIG_fail;
11819 }
11820 if ( _dim( args(6), 0 ) != Xlen )
11821 {
11822 error( "argument vectors must be same length" ); SWIG_fail;
11823 }
11824 temp10 = args(6).matrix_value();
11825 arg10 = &temp10( 0, 0 );
11826 }
11827 {
11828 if ( _n_dims( args(7) ) > 1 )
11829 {
11830 error( "argument must be a scalar or vector" ); SWIG_fail;
11831 }
11832 if ( _dim( args(7), 0 ) != Ylen )
11833 {
11834 error( "argument vectors must be same length" ); SWIG_fail;
11835 }
11836 temp11 = args(7).matrix_value();
11837 arg11 = &temp11( 0, 0 );
11838 }
11839 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11840 _outv = octave_value();
11841 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11842 {
11843
11844 }
11845 {
11846
11847 }
11848 {
11849
11850 }
11851 {
11852
11853 }
11854 return _out;
11855 fail:
11856 {
11857
11858 }
11859 {
11860
11861 }
11862 {
11863
11864 }
11865 {
11866
11867 }
11868 return octave_value_list();
11869 }
11870 catch(...) {
11871 {
11872
11873 }
11874 {
11875
11876 }
11877 {
11878
11879 }
11880 {
11881
11882 }
11883 throw;
11884 }
11885}
11886
11887
11888SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11889 PLFLT *arg1 = (PLFLT *) 0 ;
11890 PLINT arg2 ;
11891 PLINT arg3 ;
11892 PLINT arg4 ;
11893 PLINT arg5 ;
11894 PLINT arg6 ;
11895 PLINT arg7 ;
11896 PLFLT *arg8 = (PLFLT *) 0 ;
11897 PLINT arg9 ;
11898 PLFLT *arg10 = (PLFLT *) 0 ;
11899 PLFLT *arg11 = (PLFLT *) 0 ;
11900 Matrix temp1 ;
11901 int val4 ;
11902 int ecode4 = 0 ;
11903 int val5 ;
11904 int ecode5 = 0 ;
11905 int val6 ;
11906 int ecode6 = 0 ;
11907 int val7 ;
11908 int ecode7 = 0 ;
11909 Matrix temp8 ;
11910 Matrix temp10 ;
11911 Matrix temp11 ;
11912 octave_value_list _out;
11913 octave_value_list *_outp=&_out;
11914 octave_value _outv;
11915
11916 try {
11917 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11918 SWIG_fail;
11919 }
11920 {
11921 if ( _n_dims( args(0) ) > 2 )
11922 {
11923 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11924 }
11925 temp1 = args(0).matrix_value();
11926 arg1 = &temp1( 0, 0 );
11927 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11928 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11929 }
11930 ecode4 = SWIG_AsVal_int(args(1), &val4);
11931 if (!SWIG_IsOK(ecode4)) {
11932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11933 }
11934 arg4 = static_cast< PLINT >(val4);
11935 ecode5 = SWIG_AsVal_int(args(2), &val5);
11936 if (!SWIG_IsOK(ecode5)) {
11937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11938 }
11939 arg5 = static_cast< PLINT >(val5);
11940 ecode6 = SWIG_AsVal_int(args(3), &val6);
11941 if (!SWIG_IsOK(ecode6)) {
11942 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11943 }
11944 arg6 = static_cast< PLINT >(val6);
11945 ecode7 = SWIG_AsVal_int(args(4), &val7);
11946 if (!SWIG_IsOK(ecode7)) {
11947 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11948 }
11949 arg7 = static_cast< PLINT >(val7);
11950 {
11951 if ( _n_dims( args(5) ) > 1 )
11952 {
11953 error( "argument must be a scalar or vector" ); SWIG_fail;
11954 }
11955 temp8 = args(5).matrix_value();
11956 arg8 = &temp8( 0, 0 );
11957 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11958 }
11959 {
11960 if ( _n_dims( args(6) ) > 2 )
11961 {
11962 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11963 }
11964 if ( _dim( args(6), 0 ) != Xlen )
11965 {
11966 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11967 }
11968 if ( _dim( args(6), 1 ) != Ylen )
11969 {
11970 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11971 }
11972 temp10 = args(6).matrix_value();
11973 arg10 = &temp10( 0, 0 );
11974 }
11975 {
11976 if ( _n_dims( args(7) ) > 2 )
11977 {
11978 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11979 }
11980 if ( _dim( args(7), 0 ) != Xlen )
11981 {
11982 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11983 }
11984 if ( _dim( args(7), 1 ) != Ylen )
11985 {
11986 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11987 }
11988 temp11 = args(7).matrix_value();
11989 arg11 = &temp11( 0, 0 );
11990 }
11991 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11992 _outv = octave_value();
11993 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11994 {
11995
11996 }
11997 {
11998
11999 }
12000 {
12001
12002 }
12003 {
12004
12005 }
12006 return _out;
12007 fail:
12008 {
12009
12010 }
12011 {
12012
12013 }
12014 {
12015
12016 }
12017 {
12018
12019 }
12020 return octave_value_list();
12021 }
12022 catch(...) {
12023 {
12024
12025 }
12026 {
12027
12028 }
12029 {
12030
12031 }
12032 {
12033
12034 }
12035 throw;
12036 }
12037}
12038
12039
12040SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12041 PLFLT *arg1 = (PLFLT *) 0 ;
12042 PLINT arg2 ;
12043 PLINT arg3 ;
12044 PLINT arg4 ;
12045 PLINT arg5 ;
12046 PLINT arg6 ;
12047 PLINT arg7 ;
12048 PLFLT *arg8 = (PLFLT *) 0 ;
12049 PLINT arg9 ;
12050 PLFLT *arg10 = (PLFLT *) 0 ;
12051 PLFLT *arg11 = (PLFLT *) 0 ;
12052 Matrix temp1 ;
12053 int val4 ;
12054 int ecode4 = 0 ;
12055 int val5 ;
12056 int ecode5 = 0 ;
12057 int val6 ;
12058 int ecode6 = 0 ;
12059 int val7 ;
12060 int ecode7 = 0 ;
12061 Matrix temp8 ;
12062 Matrix temp10 ;
12063 Matrix temp11 ;
12064 octave_value_list _out;
12065 octave_value_list *_outp=&_out;
12066 octave_value _outv;
12067
12068 try {
12069 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12070 SWIG_fail;
12071 }
12072 {
12073 if ( _n_dims( args(0) ) > 2 )
12074 {
12075 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12076 }
12077 temp1 = args(0).matrix_value();
12078 arg1 = &temp1( 0, 0 );
12079 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12080 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12081 }
12082 ecode4 = SWIG_AsVal_int(args(1), &val4);
12083 if (!SWIG_IsOK(ecode4)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12085 }
12086 arg4 = static_cast< PLINT >(val4);
12087 ecode5 = SWIG_AsVal_int(args(2), &val5);
12088 if (!SWIG_IsOK(ecode5)) {
12089 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12090 }
12091 arg5 = static_cast< PLINT >(val5);
12092 ecode6 = SWIG_AsVal_int(args(3), &val6);
12093 if (!SWIG_IsOK(ecode6)) {
12094 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12095 }
12096 arg6 = static_cast< PLINT >(val6);
12097 ecode7 = SWIG_AsVal_int(args(4), &val7);
12098 if (!SWIG_IsOK(ecode7)) {
12099 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12100 }
12101 arg7 = static_cast< PLINT >(val7);
12102 {
12103 if ( _n_dims( args(5) ) > 1 )
12104 {
12105 error( "argument must be a scalar or vector" ); SWIG_fail;
12106 }
12107 temp8 = args(5).matrix_value();
12108 arg8 = &temp8( 0, 0 );
12109 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12110 }
12111 {
12112 if ( _n_dims( args(6) ) > 2 )
12113 {
12114 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12115 }
12116 if ( _dim( args(6), 0 ) != Xlen )
12117 {
12118 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12119 }
12120 if ( _dim( args(6), 1 ) != Ylen )
12121 {
12122 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12123 }
12124 temp10 = args(6).matrix_value();
12125 arg10 = &temp10( 0, 0 );
12126 }
12127 {
12128 if ( _n_dims( args(7) ) > 2 )
12129 {
12130 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12131 }
12132 if ( _dim( args(7), 0 ) != Xlen )
12133 {
12134 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12135 }
12136 if ( _dim( args(7), 1 ) != Ylen )
12137 {
12138 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12139 }
12140 temp11 = args(7).matrix_value();
12141 arg11 = &temp11( 0, 0 );
12142 }
12143 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12144 _outv = octave_value();
12145 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12146 {
12147
12148 }
12149 {
12150
12151 }
12152 {
12153
12154 }
12155 {
12156
12157 }
12158 return _out;
12159 fail:
12160 {
12161
12162 }
12163 {
12164
12165 }
12166 {
12167
12168 }
12169 {
12170
12171 }
12172 return octave_value_list();
12173 }
12174 catch(...) {
12175 {
12176
12177 }
12178 {
12179
12180 }
12181 {
12182
12183 }
12184 {
12185
12186 }
12187 throw;
12188 }
12189}
12190
12191
12192SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12193 PLFLT *arg1 = (PLFLT *) 0 ;
12194 PLFLT *arg2 = (PLFLT *) 0 ;
12195 PLFLT *arg3 = (PLFLT *) 0 ;
12196 PLINT arg4 ;
12197 PLFLT *arg5 = (PLFLT *) 0 ;
12198 PLINT arg6 ;
12199 PLFLT *arg7 = (PLFLT *) 0 ;
12200 PLINT arg8 ;
12201 PLFLT *arg9 = (PLFLT *) 0 ;
12202 PLINT arg10 ;
12203 PLFLT arg11 ;
12204 Matrix temp1 ;
12205 Matrix temp2 ;
12206 Matrix temp3 ;
12207 Matrix temp5 ;
12208 Matrix temp7 ;
12209 octave_value_list retval7 ;
12210 int val10 ;
12211 int ecode10 = 0 ;
12212 double val11 ;
12213 int ecode11 = 0 ;
12214 octave_value_list _out;
12215 octave_value_list *_outp=&_out;
12216 octave_value _outv;
12217
12218 try {
12219 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12220 SWIG_fail;
12221 }
12222 {
12223 if ( _n_dims( args(0) ) > 1 )
12224 {
12225 error( "argument must be a scalar or vector" ); SWIG_fail;
12226 }
12227 Alen = (PLINT) ( _dim( args(0), 0 ) );
12228 temp1 = args(0).matrix_value();
12229 arg1 = &temp1( 0, 0 );
12230 }
12231 {
12232 if ( _n_dims( args(1) ) > 1 )
12233 {
12234 error( "argument must be a scalar or vector" ); SWIG_fail;
12235 }
12236 if ( _dim( args(1), 0 ) != Alen )
12237 {
12238 error( "argument vectors must be same length" ); SWIG_fail;
12239 }
12240 temp2 = args(1).matrix_value();
12241 arg2 = &temp2( 0, 0 );
12242 }
12243 {
12244 if ( _n_dims( args(2) ) > 1 )
12245 {
12246 error( "argument must be a scalar or vector" ); SWIG_fail;
12247 }
12248 if ( _dim( args(2), 0 ) != Alen )
12249 {
12250 error( "argument vectors must be same length" ); SWIG_fail;
12251 }
12252 temp3 = args(2).matrix_value();
12253 arg3 = &temp3( 0, 0 );
12254 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12255 }
12256 {
12257 if ( _n_dims( args(3) ) > 1 )
12258 {
12259 error( "argument must be a scalar or vector" ); SWIG_fail;
12260 }
12261 temp5 = args(3).matrix_value();
12262 arg5 = &temp5( 0, 0 );
12263 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12264 }
12265 {
12266 if ( _n_dims( args(4) ) > 1 )
12267 {
12268 error( "argument must be a scalar or vector" ); SWIG_fail;
12269 }
12270 temp7 = args(4).matrix_value();
12271 arg7 = &temp7( 0, 0 );
12272 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12273 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12274 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12275 }
12276 ecode10 = SWIG_AsVal_int(args(5), &val10);
12277 if (!SWIG_IsOK(ecode10)) {
12278 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12279 }
12280 arg10 = static_cast< PLINT >(val10);
12281 ecode11 = SWIG_AsVal_double(args(6), &val11);
12282 if (!SWIG_IsOK(ecode11)) {
12283 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12284 }
12285 arg11 = static_cast< PLFLT >(val11);
12286 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12287 _outv = octave_value();
12288 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12289 {
12290 _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12291 }
12292 {
12293
12294 }
12295 {
12296
12297 }
12298 {
12299
12300 }
12301 {
12302
12303 }
12304 {
12305
12306 }
12307 return _out;
12308 fail:
12309 {
12310
12311 }
12312 {
12313
12314 }
12315 {
12316
12317 }
12318 {
12319
12320 }
12321 {
12322
12323 }
12324 return octave_value_list();
12325 }
12326 catch(...) {
12327 {
12328
12329 }
12330 {
12331
12332 }
12333 {
12334
12335 }
12336 {
12337
12338 }
12339 {
12340
12341 }
12342 throw;
12343 }
12344}
12345
12346
12348 PLFLT *arg1 = (PLFLT *) 0 ;
12349 PLFLT *arg2 = (PLFLT *) 0 ;
12350 PLFLT *arg3 = (PLFLT *) 0 ;
12351 PLINT arg4 ;
12352 PLINT arg5 ;
12353 PLINT arg6 ;
12354 Matrix temp1 ;
12355 Matrix temp2 ;
12356 Matrix temp3 ;
12357 int val6 ;
12358 int ecode6 = 0 ;
12359 octave_value_list _out;
12360 octave_value_list *_outp=&_out;
12361 octave_value _outv;
12362
12363 try {
12364 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12365 SWIG_fail;
12366 }
12367 {
12368 if ( _n_dims( args(0) ) > 1 )
12369 {
12370 error( "argument must be a scalar or vector" ); SWIG_fail;
12371 }
12372 temp1 = args(0).matrix_value();
12373 arg1 = &temp1( 0, 0 );
12374 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12375 }
12376 {
12377 if ( _n_dims( args(1) ) > 1 )
12378 {
12379 error( "argument must be a scalar or vector" ); SWIG_fail;
12380 }
12381 temp2 = args(1).matrix_value();
12382 arg2 = &temp2( 0, 0 );
12383 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12384 }
12385 {
12386 if ( _n_dims( args(2) ) > 2 )
12387 {
12388 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12389 }
12390 if ( _dim( args(2), 0 ) != Xlen )
12391 {
12392 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12393 }
12394 if ( _dim( args(2), 1 ) != Ylen )
12395 {
12396 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12397 }
12398 temp3 = args(2).matrix_value();
12399 arg3 = &temp3( 0, 0 );
12400 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12401 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12402 }
12403 ecode6 = SWIG_AsVal_int(args(3), &val6);
12404 if (!SWIG_IsOK(ecode6)) {
12405 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12406 }
12407 arg6 = static_cast< PLINT >(val6);
12408 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12409 _outv = octave_value();
12410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12411 {
12412
12413 }
12414 {
12415
12416 }
12417 {
12418
12419 }
12420 return _out;
12421 fail:
12422 {
12423
12424 }
12425 {
12426
12427 }
12428 {
12429
12430 }
12431 return octave_value_list();
12432 }
12433 catch(...) {
12434 {
12435
12436 }
12437 {
12438
12439 }
12440 {
12441
12442 }
12443 throw;
12444 }
12445}
12446
12447
12449 PLFLT *arg1 = (PLFLT *) 0 ;
12450 PLFLT *arg2 = (PLFLT *) 0 ;
12451 PLFLT *arg3 = (PLFLT *) 0 ;
12452 PLINT arg4 ;
12453 PLINT arg5 ;
12454 PLINT arg6 ;
12455 PLFLT *arg7 = (PLFLT *) 0 ;
12456 PLINT arg8 ;
12457 Matrix temp1 ;
12458 Matrix temp2 ;
12459 Matrix temp3 ;
12460 int val6 ;
12461 int ecode6 = 0 ;
12462 Matrix temp7 ;
12463 octave_value_list _out;
12464 octave_value_list *_outp=&_out;
12465 octave_value _outv;
12466
12467 try {
12468 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12469 SWIG_fail;
12470 }
12471 {
12472 if ( _n_dims( args(0) ) > 1 )
12473 {
12474 error( "argument must be a scalar or vector" ); SWIG_fail;
12475 }
12476 temp1 = args(0).matrix_value();
12477 arg1 = &temp1( 0, 0 );
12478 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12479 }
12480 {
12481 if ( _n_dims( args(1) ) > 1 )
12482 {
12483 error( "argument must be a scalar or vector" ); SWIG_fail;
12484 }
12485 temp2 = args(1).matrix_value();
12486 arg2 = &temp2( 0, 0 );
12487 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12488 }
12489 {
12490 if ( _n_dims( args(2) ) > 2 )
12491 {
12492 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12493 }
12494 if ( _dim( args(2), 0 ) != Xlen )
12495 {
12496 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12497 }
12498 if ( _dim( args(2), 1 ) != Ylen )
12499 {
12500 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12501 }
12502 temp3 = args(2).matrix_value();
12503 arg3 = &temp3( 0, 0 );
12504 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12505 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12506 }
12507 ecode6 = SWIG_AsVal_int(args(3), &val6);
12508 if (!SWIG_IsOK(ecode6)) {
12509 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12510 }
12511 arg6 = static_cast< PLINT >(val6);
12512 {
12513 if ( _n_dims( args(4) ) > 1 )
12514 {
12515 error( "argument must be a scalar or vector" ); SWIG_fail;
12516 }
12517 temp7 = args(4).matrix_value();
12518 arg7 = &temp7( 0, 0 );
12519 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12520 }
12521 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12522 _outv = octave_value();
12523 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12524 {
12525
12526 }
12527 {
12528
12529 }
12530 {
12531
12532 }
12533 {
12534
12535 }
12536 return _out;
12537 fail:
12538 {
12539
12540 }
12541 {
12542
12543 }
12544 {
12545
12546 }
12547 {
12548
12549 }
12550 return octave_value_list();
12551 }
12552 catch(...) {
12553 {
12554
12555 }
12556 {
12557
12558 }
12559 {
12560
12561 }
12562 {
12563
12564 }
12565 throw;
12566 }
12567}
12568
12569
12571 PLFLT *arg1 = (PLFLT *) 0 ;
12572 PLFLT *arg2 = (PLFLT *) 0 ;
12573 PLFLT *arg3 = (PLFLT *) 0 ;
12574 PLINT arg4 ;
12575 PLINT arg5 ;
12576 PLINT arg6 ;
12577 PLBOOL arg7 ;
12578 Matrix temp1 ;
12579 Matrix temp2 ;
12580 Matrix temp3 ;
12581 int val6 ;
12582 int ecode6 = 0 ;
12583 int val7 ;
12584 int ecode7 = 0 ;
12585 octave_value_list _out;
12586 octave_value_list *_outp=&_out;
12587 octave_value _outv;
12588
12589 try {
12590 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12591 SWIG_fail;
12592 }
12593 {
12594 if ( _n_dims( args(0) ) > 1 )
12595 {
12596 error( "argument must be a scalar or vector" ); SWIG_fail;
12597 }
12598 temp1 = args(0).matrix_value();
12599 arg1 = &temp1( 0, 0 );
12600 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12601 }
12602 {
12603 if ( _n_dims( args(1) ) > 1 )
12604 {
12605 error( "argument must be a scalar or vector" ); SWIG_fail;
12606 }
12607 temp2 = args(1).matrix_value();
12608 arg2 = &temp2( 0, 0 );
12609 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12610 }
12611 {
12612 if ( _n_dims( args(2) ) > 2 )
12613 {
12614 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12615 }
12616 if ( _dim( args(2), 0 ) != Xlen )
12617 {
12618 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12619 }
12620 if ( _dim( args(2), 1 ) != Ylen )
12621 {
12622 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12623 }
12624 temp3 = args(2).matrix_value();
12625 arg3 = &temp3( 0, 0 );
12626 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12627 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12628 }
12629 ecode6 = SWIG_AsVal_int(args(3), &val6);
12630 if (!SWIG_IsOK(ecode6)) {
12631 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12632 }
12633 arg6 = static_cast< PLINT >(val6);
12634 ecode7 = SWIG_AsVal_int(args(4), &val7);
12635 if (!SWIG_IsOK(ecode7)) {
12636 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12637 }
12638 arg7 = static_cast< PLBOOL >(val7);
12639 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12640 _outv = octave_value();
12641 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12642 {
12643
12644 }
12645 {
12646
12647 }
12648 {
12649
12650 }
12651 return _out;
12652 fail:
12653 {
12654
12655 }
12656 {
12657
12658 }
12659 {
12660
12661 }
12662 return octave_value_list();
12663 }
12664 catch(...) {
12665 {
12666
12667 }
12668 {
12669
12670 }
12671 {
12672
12673 }
12674 throw;
12675 }
12676}
12677
12678
12680 PLFLT *arg1 = (PLFLT *) 0 ;
12681 PLFLT *arg2 = (PLFLT *) 0 ;
12682 PLFLT *arg3 = (PLFLT *) 0 ;
12683 PLINT arg4 ;
12684 PLINT arg5 ;
12685 PLINT arg6 ;
12686 PLFLT *arg7 = (PLFLT *) 0 ;
12687 PLINT arg8 ;
12688 Matrix temp1 ;
12689 Matrix temp2 ;
12690 Matrix temp3 ;
12691 int val6 ;
12692 int ecode6 = 0 ;
12693 Matrix temp7 ;
12694 octave_value_list _out;
12695 octave_value_list *_outp=&_out;
12696 octave_value _outv;
12697
12698 try {
12699 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12700 SWIG_fail;
12701 }
12702 {
12703 if ( _n_dims( args(0) ) > 1 )
12704 {
12705 error( "argument must be a scalar or vector" ); SWIG_fail;
12706 }
12707 temp1 = args(0).matrix_value();
12708 arg1 = &temp1( 0, 0 );
12709 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12710 }
12711 {
12712 if ( _n_dims( args(1) ) > 1 )
12713 {
12714 error( "argument must be a scalar or vector" ); SWIG_fail;
12715 }
12716 temp2 = args(1).matrix_value();
12717 arg2 = &temp2( 0, 0 );
12718 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12719 }
12720 {
12721 if ( _n_dims( args(2) ) > 2 )
12722 {
12723 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12724 }
12725 if ( _dim( args(2), 0 ) != Xlen )
12726 {
12727 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12728 }
12729 if ( _dim( args(2), 1 ) != Ylen )
12730 {
12731 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12732 }
12733 temp3 = args(2).matrix_value();
12734 arg3 = &temp3( 0, 0 );
12735 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12736 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12737 }
12738 ecode6 = SWIG_AsVal_int(args(3), &val6);
12739 if (!SWIG_IsOK(ecode6)) {
12740 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12741 }
12742 arg6 = static_cast< PLINT >(val6);
12743 {
12744 if ( _n_dims( args(4) ) > 1 )
12745 {
12746 error( "argument must be a scalar or vector" ); SWIG_fail;
12747 }
12748 temp7 = args(4).matrix_value();
12749 arg7 = &temp7( 0, 0 );
12750 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12751 }
12752 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12753 _outv = octave_value();
12754 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12755 {
12756
12757 }
12758 {
12759
12760 }
12761 {
12762
12763 }
12764 {
12765
12766 }
12767 return _out;
12768 fail:
12769 {
12770
12771 }
12772 {
12773
12774 }
12775 {
12776
12777 }
12778 {
12779
12780 }
12781 return octave_value_list();
12782 }
12783 catch(...) {
12784 {
12785
12786 }
12787 {
12788
12789 }
12790 {
12791
12792 }
12793 {
12794
12795 }
12796 throw;
12797 }
12798}
12799
12800
12802 PLFLT *arg1 = (PLFLT *) 0 ;
12803 PLFLT *arg2 = (PLFLT *) 0 ;
12804 PLFLT *arg3 = (PLFLT *) 0 ;
12805 PLINT arg4 ;
12806 PLINT arg5 ;
12807 PLINT arg6 ;
12808 PLFLT *arg7 = (PLFLT *) 0 ;
12809 PLINT arg8 ;
12810 PLINT arg9 ;
12811 PLINT arg10 ;
12812 PLINT *arg11 = (PLINT *) 0 ;
12813 PLINT *arg12 = (PLINT *) 0 ;
12814 Matrix temp1 ;
12815 Matrix temp2 ;
12816 Matrix temp3 ;
12817 int val6 ;
12818 int ecode6 = 0 ;
12819 Matrix temp7 ;
12820 int val9 ;
12821 int ecode9 = 0 ;
12822 Matrix temp10 ;
12823 Matrix temp12 ;
12824 octave_value_list _out;
12825 octave_value_list *_outp=&_out;
12826 octave_value _outv;
12827
12828 try {
12829 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12830 SWIG_fail;
12831 }
12832 {
12833 if ( _n_dims( args(0) ) > 1 )
12834 {
12835 error( "argument must be a scalar or vector" ); SWIG_fail;
12836 }
12837 temp1 = args(0).matrix_value();
12838 arg1 = &temp1( 0, 0 );
12839 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12840 }
12841 {
12842 if ( _n_dims( args(1) ) > 1 )
12843 {
12844 error( "argument must be a scalar or vector" ); SWIG_fail;
12845 }
12846 temp2 = args(1).matrix_value();
12847 arg2 = &temp2( 0, 0 );
12848 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12849 }
12850 {
12851 if ( _n_dims( args(2) ) > 2 )
12852 {
12853 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12854 }
12855 if ( _dim( args(2), 0 ) != Xlen )
12856 {
12857 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12858 }
12859 if ( _dim( args(2), 1 ) != Ylen )
12860 {
12861 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12862 }
12863 temp3 = args(2).matrix_value();
12864 arg3 = &temp3( 0, 0 );
12865 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12866 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12867 }
12868 ecode6 = SWIG_AsVal_int(args(3), &val6);
12869 if (!SWIG_IsOK(ecode6)) {
12870 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12871 }
12872 arg6 = static_cast< PLINT >(val6);
12873 {
12874 if ( _n_dims( args(4) ) > 1 )
12875 {
12876 error( "argument must be a scalar or vector" ); SWIG_fail;
12877 }
12878 temp7 = args(4).matrix_value();
12879 arg7 = &temp7( 0, 0 );
12880 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12881 }
12882 ecode9 = SWIG_AsVal_int(args(5), &val9);
12883 if (!SWIG_IsOK(ecode9)) {
12884 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12885 }
12886 arg9 = static_cast< PLINT >(val9);
12887 {
12888 if ( _n_dims( args(6) ) > 1 )
12889 {
12890 error( "argument must be a scalar or vector" ); SWIG_fail;
12891 }
12892 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12893 arg11 = new PLINT[Alen];
12894 temp10 = args(6).matrix_value();
12895 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12896 }
12897 {
12898 if ( _n_dims( args(7) ) > 1 )
12899 {
12900 error( "argument must be a scalar or vector" ); SWIG_fail;
12901 }
12902 if ( _dim( args(7), 0 ) != Alen )
12903 {
12904 error( "argument vectors must be same length" ); SWIG_fail;
12905 }
12906 temp12 = args(7).matrix_value();
12907 arg12 = new PLINT[Alen];
12908 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12909 }
12910 my_plot3dcl((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
12911 _outv = octave_value();
12912 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12913 {
12914
12915 }
12916 {
12917
12918 }
12919 {
12920
12921 }
12922 {
12923
12924 }
12925 {
12926 delete [] arg11;
12927 }
12928 {
12929 delete [] arg12;
12930 }
12931 return _out;
12932 fail:
12933 {
12934
12935 }
12936 {
12937
12938 }
12939 {
12940
12941 }
12942 {
12943
12944 }
12945 {
12946 delete [] arg11;
12947 }
12948 {
12949 delete [] arg12;
12950 }
12951 return octave_value_list();
12952 }
12953 catch(...) {
12954 {
12955
12956 }
12957 {
12958
12959 }
12960 {
12961
12962 }
12963 {
12964
12965 }
12966 {
12967 delete [] arg11;
12968 }
12969 {
12970 delete [] arg12;
12971 }
12972 throw;
12973 }
12974}
12975
12976
12978 PLFLT *arg1 = (PLFLT *) 0 ;
12979 PLFLT *arg2 = (PLFLT *) 0 ;
12980 PLFLT *arg3 = (PLFLT *) 0 ;
12981 PLINT arg4 ;
12982 PLINT arg5 ;
12983 PLINT arg6 ;
12984 PLFLT *arg7 = (PLFLT *) 0 ;
12985 PLINT arg8 ;
12986 Matrix temp1 ;
12987 Matrix temp2 ;
12988 Matrix temp3 ;
12989 int val6 ;
12990 int ecode6 = 0 ;
12991 Matrix temp7 ;
12992 octave_value_list _out;
12993 octave_value_list *_outp=&_out;
12994 octave_value _outv;
12995
12996 try {
12997 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12998 SWIG_fail;
12999 }
13000 {
13001 if ( _n_dims( args(0) ) > 1 )
13002 {
13003 error( "argument must be a scalar or vector" ); SWIG_fail;
13004 }
13005 temp1 = args(0).matrix_value();
13006 arg1 = &temp1( 0, 0 );
13007 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13008 }
13009 {
13010 if ( _n_dims( args(1) ) > 1 )
13011 {
13012 error( "argument must be a scalar or vector" ); SWIG_fail;
13013 }
13014 temp2 = args(1).matrix_value();
13015 arg2 = &temp2( 0, 0 );
13016 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13017 }
13018 {
13019 if ( _n_dims( args(2) ) > 2 )
13020 {
13021 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13022 }
13023 if ( _dim( args(2), 0 ) != Xlen )
13024 {
13025 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13026 }
13027 if ( _dim( args(2), 1 ) != Ylen )
13028 {
13029 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13030 }
13031 temp3 = args(2).matrix_value();
13032 arg3 = &temp3( 0, 0 );
13033 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13034 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13035 }
13036 ecode6 = SWIG_AsVal_int(args(3), &val6);
13037 if (!SWIG_IsOK(ecode6)) {
13038 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13039 }
13040 arg6 = static_cast< PLINT >(val6);
13041 {
13042 if ( _n_dims( args(4) ) > 1 )
13043 {
13044 error( "argument must be a scalar or vector" ); SWIG_fail;
13045 }
13046 temp7 = args(4).matrix_value();
13047 arg7 = &temp7( 0, 0 );
13048 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13049 }
13050 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13051 _outv = octave_value();
13052 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13053 {
13054
13055 }
13056 {
13057
13058 }
13059 {
13060
13061 }
13062 {
13063
13064 }
13065 return _out;
13066 fail:
13067 {
13068
13069 }
13070 {
13071
13072 }
13073 {
13074
13075 }
13076 {
13077
13078 }
13079 return octave_value_list();
13080 }
13081 catch(...) {
13082 {
13083
13084 }
13085 {
13086
13087 }
13088 {
13089
13090 }
13091 {
13092
13093 }
13094 throw;
13095 }
13096}
13097
13098
13100 PLFLT *arg1 = (PLFLT *) 0 ;
13101 PLFLT *arg2 = (PLFLT *) 0 ;
13102 PLFLT *arg3 = (PLFLT *) 0 ;
13103 PLINT arg4 ;
13104 PLINT arg5 ;
13105 PLINT arg6 ;
13106 PLFLT *arg7 = (PLFLT *) 0 ;
13107 PLINT arg8 ;
13108 PLINT arg9 ;
13109 PLINT arg10 ;
13110 PLINT *arg11 = (PLINT *) 0 ;
13111 PLINT *arg12 = (PLINT *) 0 ;
13112 Matrix temp1 ;
13113 Matrix temp2 ;
13114 Matrix temp3 ;
13115 int val6 ;
13116 int ecode6 = 0 ;
13117 Matrix temp7 ;
13118 int val9 ;
13119 int ecode9 = 0 ;
13120 Matrix temp10 ;
13121 Matrix temp12 ;
13122 octave_value_list _out;
13123 octave_value_list *_outp=&_out;
13124 octave_value _outv;
13125
13126 try {
13127 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13128 SWIG_fail;
13129 }
13130 {
13131 if ( _n_dims( args(0) ) > 1 )
13132 {
13133 error( "argument must be a scalar or vector" ); SWIG_fail;
13134 }
13135 temp1 = args(0).matrix_value();
13136 arg1 = &temp1( 0, 0 );
13137 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13138 }
13139 {
13140 if ( _n_dims( args(1) ) > 1 )
13141 {
13142 error( "argument must be a scalar or vector" ); SWIG_fail;
13143 }
13144 temp2 = args(1).matrix_value();
13145 arg2 = &temp2( 0, 0 );
13146 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13147 }
13148 {
13149 if ( _n_dims( args(2) ) > 2 )
13150 {
13151 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13152 }
13153 if ( _dim( args(2), 0 ) != Xlen )
13154 {
13155 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13156 }
13157 if ( _dim( args(2), 1 ) != Ylen )
13158 {
13159 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13160 }
13161 temp3 = args(2).matrix_value();
13162 arg3 = &temp3( 0, 0 );
13163 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13164 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13165 }
13166 ecode6 = SWIG_AsVal_int(args(3), &val6);
13167 if (!SWIG_IsOK(ecode6)) {
13168 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13169 }
13170 arg6 = static_cast< PLINT >(val6);
13171 {
13172 if ( _n_dims( args(4) ) > 1 )
13173 {
13174 error( "argument must be a scalar or vector" ); SWIG_fail;
13175 }
13176 temp7 = args(4).matrix_value();
13177 arg7 = &temp7( 0, 0 );
13178 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13179 }
13180 ecode9 = SWIG_AsVal_int(args(5), &val9);
13181 if (!SWIG_IsOK(ecode9)) {
13182 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13183 }
13184 arg9 = static_cast< PLINT >(val9);
13185 {
13186 if ( _n_dims( args(6) ) > 1 )
13187 {
13188 error( "argument must be a scalar or vector" ); SWIG_fail;
13189 }
13190 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13191 arg11 = new PLINT[Alen];
13192 temp10 = args(6).matrix_value();
13193 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13194 }
13195 {
13196 if ( _n_dims( args(7) ) > 1 )
13197 {
13198 error( "argument must be a scalar or vector" ); SWIG_fail;
13199 }
13200 if ( _dim( args(7), 0 ) != Alen )
13201 {
13202 error( "argument vectors must be same length" ); SWIG_fail;
13203 }
13204 temp12 = args(7).matrix_value();
13205 arg12 = new PLINT[Alen];
13206 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13207 }
13208 my_plsurf3dl((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
13209 _outv = octave_value();
13210 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13211 {
13212
13213 }
13214 {
13215
13216 }
13217 {
13218
13219 }
13220 {
13221
13222 }
13223 {
13224 delete [] arg11;
13225 }
13226 {
13227 delete [] arg12;
13228 }
13229 return _out;
13230 fail:
13231 {
13232
13233 }
13234 {
13235
13236 }
13237 {
13238
13239 }
13240 {
13241
13242 }
13243 {
13244 delete [] arg11;
13245 }
13246 {
13247 delete [] arg12;
13248 }
13249 return octave_value_list();
13250 }
13251 catch(...) {
13252 {
13253
13254 }
13255 {
13256
13257 }
13258 {
13259
13260 }
13261 {
13262
13263 }
13264 {
13265 delete [] arg11;
13266 }
13267 {
13268 delete [] arg12;
13269 }
13270 throw;
13271 }
13272}
13273
13274
13276 PLFLT *arg1 = (PLFLT *) 0 ;
13277 PLINT arg2 ;
13278 PLINT arg3 ;
13279 PLFLT *arg4 = (PLFLT *) 0 ;
13280 PLFLT arg5 ;
13281 PLFLT arg6 ;
13282 PLFLT arg7 ;
13283 PLFLT arg8 ;
13284 PLFLT arg9 ;
13285 PLFLT arg10 ;
13286 PLINT arg11 ;
13287 PLFLT arg12 ;
13288 PLINT arg13 ;
13289 PLINT arg14 ;
13290 PLINT arg15 ;
13291 PLINT arg16 ;
13292 PLINT arg17 ;
13293 PLBOOL arg18 ;
13294 PLFLT *arg19 = (PLFLT *) 0 ;
13295 Matrix temp1 ;
13296 Matrix temp4 ;
13297 double val5 ;
13298 int ecode5 = 0 ;
13299 double val6 ;
13300 int ecode6 = 0 ;
13301 double val7 ;
13302 int ecode7 = 0 ;
13303 double val8 ;
13304 int ecode8 = 0 ;
13305 double val9 ;
13306 int ecode9 = 0 ;
13307 double val10 ;
13308 int ecode10 = 0 ;
13309 int val11 ;
13310 int ecode11 = 0 ;
13311 double val12 ;
13312 int ecode12 = 0 ;
13313 int val13 ;
13314 int ecode13 = 0 ;
13315 int val14 ;
13316 int ecode14 = 0 ;
13317 int val15 ;
13318 int ecode15 = 0 ;
13319 int val16 ;
13320 int ecode16 = 0 ;
13321 int val17 ;
13322 int ecode17 = 0 ;
13323 int val18 ;
13324 int ecode18 = 0 ;
13325 Matrix temp19 ;
13326 octave_value_list _out;
13327 octave_value_list *_outp=&_out;
13328 octave_value _outv;
13329
13330 try {
13331 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13332 SWIG_fail;
13333 }
13334 {
13335 if ( _n_dims( args(0) ) > 2 )
13336 {
13337 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13338 }
13339 temp1 = args(0).matrix_value();
13340 arg1 = &temp1( 0, 0 );
13341 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13342 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13343 }
13344 {
13345 if ( _n_dims( args(1) ) > 1 )
13346 {
13347 error( "argument must be a scalar or vector" ); SWIG_fail;
13348 }
13349 Alen = (PLINT) ( _dim( args(1), 0 ) );
13350 temp4 = args(1).matrix_value();
13351 arg4 = &temp4( 0, 0 );
13352 }
13353 ecode5 = SWIG_AsVal_double(args(2), &val5);
13354 if (!SWIG_IsOK(ecode5)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13356 }
13357 arg5 = static_cast< PLFLT >(val5);
13358 ecode6 = SWIG_AsVal_double(args(3), &val6);
13359 if (!SWIG_IsOK(ecode6)) {
13360 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13361 }
13362 arg6 = static_cast< PLFLT >(val6);
13363 ecode7 = SWIG_AsVal_double(args(4), &val7);
13364 if (!SWIG_IsOK(ecode7)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13366 }
13367 arg7 = static_cast< PLFLT >(val7);
13368 ecode8 = SWIG_AsVal_double(args(5), &val8);
13369 if (!SWIG_IsOK(ecode8)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13371 }
13372 arg8 = static_cast< PLFLT >(val8);
13373 ecode9 = SWIG_AsVal_double(args(6), &val9);
13374 if (!SWIG_IsOK(ecode9)) {
13375 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13376 }
13377 arg9 = static_cast< PLFLT >(val9);
13378 ecode10 = SWIG_AsVal_double(args(7), &val10);
13379 if (!SWIG_IsOK(ecode10)) {
13380 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13381 }
13382 arg10 = static_cast< PLFLT >(val10);
13383 ecode11 = SWIG_AsVal_int(args(8), &val11);
13384 if (!SWIG_IsOK(ecode11)) {
13385 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13386 }
13387 arg11 = static_cast< PLINT >(val11);
13388 ecode12 = SWIG_AsVal_double(args(9), &val12);
13389 if (!SWIG_IsOK(ecode12)) {
13390 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13391 }
13392 arg12 = static_cast< PLFLT >(val12);
13393 ecode13 = SWIG_AsVal_int(args(10), &val13);
13394 if (!SWIG_IsOK(ecode13)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13396 }
13397 arg13 = static_cast< PLINT >(val13);
13398 ecode14 = SWIG_AsVal_int(args(11), &val14);
13399 if (!SWIG_IsOK(ecode14)) {
13400 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13401 }
13402 arg14 = static_cast< PLINT >(val14);
13403 ecode15 = SWIG_AsVal_int(args(12), &val15);
13404 if (!SWIG_IsOK(ecode15)) {
13405 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13406 }
13407 arg15 = static_cast< PLINT >(val15);
13408 ecode16 = SWIG_AsVal_int(args(13), &val16);
13409 if (!SWIG_IsOK(ecode16)) {
13410 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13411 }
13412 arg16 = static_cast< PLINT >(val16);
13413 ecode17 = SWIG_AsVal_int(args(14), &val17);
13414 if (!SWIG_IsOK(ecode17)) {
13415 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13416 }
13417 arg17 = static_cast< PLINT >(val17);
13418 ecode18 = SWIG_AsVal_int(args(15), &val18);
13419 if (!SWIG_IsOK(ecode18)) {
13420 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13421 }
13422 arg18 = static_cast< PLBOOL >(val18);
13423 {
13424 if ( _n_dims( args(16) ) > 1 )
13425 {
13426 error( "argument must be a scalar or vector" ); SWIG_fail;
13427 }
13428 if ( _dim( args(16), 0 ) != 6 )
13429 {
13430 error( "argument vectors must have length of 6" ); SWIG_fail;
13431 }
13432 temp19 = args(16).matrix_value();
13433 arg19 = &temp19( 0, 0 );
13434 }
13435 my_plshade((double const *)arg1,arg2,arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
13436 _outv = octave_value();
13437 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13438 {
13439
13440 }
13441 {
13442
13443 }
13444 {
13445
13446 }
13447 return _out;
13448 fail:
13449 {
13450
13451 }
13452 {
13453
13454 }
13455 {
13456
13457 }
13458 return octave_value_list();
13459 }
13460 catch(...) {
13461 {
13462
13463 }
13464 {
13465
13466 }
13467 {
13468
13469 }
13470 throw;
13471 }
13472}
13473
13474
13475SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13476 PLFLT *arg1 = (PLFLT *) 0 ;
13477 PLINT arg2 ;
13478 PLINT arg3 ;
13479 char *arg4 = (char *) 0 ;
13480 PLFLT arg5 ;
13481 PLFLT arg6 ;
13482 PLFLT arg7 ;
13483 PLFLT arg8 ;
13484 PLFLT arg9 ;
13485 PLFLT arg10 ;
13486 PLINT arg11 ;
13487 PLFLT arg12 ;
13488 PLINT arg13 ;
13489 PLINT arg14 ;
13490 PLINT arg15 ;
13491 PLINT arg16 ;
13492 PLINT arg17 ;
13493 PLBOOL arg18 ;
13494 PLFLT *arg19 = (PLFLT *) 0 ;
13495 PLFLT *arg20 = (PLFLT *) 0 ;
13496 Matrix temp1 ;
13497 int res4 ;
13498 char *buf4 = 0 ;
13499 int alloc4 = 0 ;
13500 double val5 ;
13501 int ecode5 = 0 ;
13502 double val6 ;
13503 int ecode6 = 0 ;
13504 double val7 ;
13505 int ecode7 = 0 ;
13506 double val8 ;
13507 int ecode8 = 0 ;
13508 double val9 ;
13509 int ecode9 = 0 ;
13510 double val10 ;
13511 int ecode10 = 0 ;
13512 int val11 ;
13513 int ecode11 = 0 ;
13514 double val12 ;
13515 int ecode12 = 0 ;
13516 int val13 ;
13517 int ecode13 = 0 ;
13518 int val14 ;
13519 int ecode14 = 0 ;
13520 int val15 ;
13521 int ecode15 = 0 ;
13522 int val16 ;
13523 int ecode16 = 0 ;
13524 int val17 ;
13525 int ecode17 = 0 ;
13526 int val18 ;
13527 int ecode18 = 0 ;
13528 Matrix temp19 ;
13529 Matrix temp20 ;
13530 octave_value_list _out;
13531 octave_value_list *_outp=&_out;
13532 octave_value _outv;
13533
13534 try {
13535 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13536 SWIG_fail;
13537 }
13538 {
13539 if ( _n_dims( args(0) ) > 2 )
13540 {
13541 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13542 }
13543 temp1 = args(0).matrix_value();
13544 arg1 = &temp1( 0, 0 );
13545 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13546 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13547 }
13548 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13549 if (!SWIG_IsOK(res4)) {
13550 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13551 }
13552 arg4 = reinterpret_cast< char * >(buf4);
13553 ecode5 = SWIG_AsVal_double(args(2), &val5);
13554 if (!SWIG_IsOK(ecode5)) {
13555 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13556 }
13557 arg5 = static_cast< PLFLT >(val5);
13558 ecode6 = SWIG_AsVal_double(args(3), &val6);
13559 if (!SWIG_IsOK(ecode6)) {
13560 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13561 }
13562 arg6 = static_cast< PLFLT >(val6);
13563 ecode7 = SWIG_AsVal_double(args(4), &val7);
13564 if (!SWIG_IsOK(ecode7)) {
13565 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13566 }
13567 arg7 = static_cast< PLFLT >(val7);
13568 ecode8 = SWIG_AsVal_double(args(5), &val8);
13569 if (!SWIG_IsOK(ecode8)) {
13570 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13571 }
13572 arg8 = static_cast< PLFLT >(val8);
13573 ecode9 = SWIG_AsVal_double(args(6), &val9);
13574 if (!SWIG_IsOK(ecode9)) {
13575 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13576 }
13577 arg9 = static_cast< PLFLT >(val9);
13578 ecode10 = SWIG_AsVal_double(args(7), &val10);
13579 if (!SWIG_IsOK(ecode10)) {
13580 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13581 }
13582 arg10 = static_cast< PLFLT >(val10);
13583 ecode11 = SWIG_AsVal_int(args(8), &val11);
13584 if (!SWIG_IsOK(ecode11)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13586 }
13587 arg11 = static_cast< PLINT >(val11);
13588 ecode12 = SWIG_AsVal_double(args(9), &val12);
13589 if (!SWIG_IsOK(ecode12)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13591 }
13592 arg12 = static_cast< PLFLT >(val12);
13593 ecode13 = SWIG_AsVal_int(args(10), &val13);
13594 if (!SWIG_IsOK(ecode13)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13596 }
13597 arg13 = static_cast< PLINT >(val13);
13598 ecode14 = SWIG_AsVal_int(args(11), &val14);
13599 if (!SWIG_IsOK(ecode14)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13601 }
13602 arg14 = static_cast< PLINT >(val14);
13603 ecode15 = SWIG_AsVal_int(args(12), &val15);
13604 if (!SWIG_IsOK(ecode15)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13606 }
13607 arg15 = static_cast< PLINT >(val15);
13608 ecode16 = SWIG_AsVal_int(args(13), &val16);
13609 if (!SWIG_IsOK(ecode16)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13611 }
13612 arg16 = static_cast< PLINT >(val16);
13613 ecode17 = SWIG_AsVal_int(args(14), &val17);
13614 if (!SWIG_IsOK(ecode17)) {
13615 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13616 }
13617 arg17 = static_cast< PLINT >(val17);
13618 ecode18 = SWIG_AsVal_int(args(15), &val18);
13619 if (!SWIG_IsOK(ecode18)) {
13620 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13621 }
13622 arg18 = static_cast< PLBOOL >(val18);
13623 {
13624 if ( _n_dims( args(16) ) > 1 )
13625 {
13626 error( "argument must be a scalar or vector" ); SWIG_fail;
13627 }
13628 if ( _dim( args(16), 0 ) != Xlen )
13629 {
13630 error( "argument vectors must be same length" ); SWIG_fail;
13631 }
13632 temp19 = args(16).matrix_value();
13633 arg19 = &temp19( 0, 0 );
13634 }
13635 {
13636 if ( _n_dims( args(17) ) > 1 )
13637 {
13638 error( "argument must be a scalar or vector" ); SWIG_fail;
13639 }
13640 if ( _dim( args(17), 0 ) != Ylen )
13641 {
13642 error( "argument vectors must be same length" ); SWIG_fail;
13643 }
13644 temp20 = args(17).matrix_value();
13645 arg20 = &temp20( 0, 0 );
13646 }
13647 my_plshade1((double const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(double const *)arg19,(double const *)arg20);
13648 _outv = octave_value();
13649 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13650 {
13651
13652 }
13653 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13654 {
13655
13656 }
13657 {
13658
13659 }
13660 return _out;
13661 fail:
13662 {
13663
13664 }
13665 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13666 {
13667
13668 }
13669 {
13670
13671 }
13672 return octave_value_list();
13673 }
13674 catch(...) {
13675 {
13676
13677 }
13678 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13679 {
13680
13681 }
13682 {
13683
13684 }
13685 throw;
13686 }
13687}
13688
13689
13690SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13691 PLFLT *arg1 = (PLFLT *) 0 ;
13692 PLINT arg2 ;
13693 PLINT arg3 ;
13694 char *arg4 = (char *) 0 ;
13695 PLFLT arg5 ;
13696 PLFLT arg6 ;
13697 PLFLT arg7 ;
13698 PLFLT arg8 ;
13699 PLFLT arg9 ;
13700 PLFLT arg10 ;
13701 PLINT arg11 ;
13702 PLFLT arg12 ;
13703 PLINT arg13 ;
13704 PLINT arg14 ;
13705 PLINT arg15 ;
13706 PLINT arg16 ;
13707 PLINT arg17 ;
13708 PLBOOL arg18 ;
13709 PLFLT *arg19 = (PLFLT *) 0 ;
13710 PLFLT *arg20 = (PLFLT *) 0 ;
13711 Matrix temp1 ;
13712 int res4 ;
13713 char *buf4 = 0 ;
13714 int alloc4 = 0 ;
13715 double val5 ;
13716 int ecode5 = 0 ;
13717 double val6 ;
13718 int ecode6 = 0 ;
13719 double val7 ;
13720 int ecode7 = 0 ;
13721 double val8 ;
13722 int ecode8 = 0 ;
13723 double val9 ;
13724 int ecode9 = 0 ;
13725 double val10 ;
13726 int ecode10 = 0 ;
13727 int val11 ;
13728 int ecode11 = 0 ;
13729 double val12 ;
13730 int ecode12 = 0 ;
13731 int val13 ;
13732 int ecode13 = 0 ;
13733 int val14 ;
13734 int ecode14 = 0 ;
13735 int val15 ;
13736 int ecode15 = 0 ;
13737 int val16 ;
13738 int ecode16 = 0 ;
13739 int val17 ;
13740 int ecode17 = 0 ;
13741 int val18 ;
13742 int ecode18 = 0 ;
13743 Matrix temp19 ;
13744 Matrix temp20 ;
13745 octave_value_list _out;
13746 octave_value_list *_outp=&_out;
13747 octave_value _outv;
13748
13749 try {
13750 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13751 SWIG_fail;
13752 }
13753 {
13754 if ( _n_dims( args(0) ) > 2 )
13755 {
13756 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13757 }
13758 temp1 = args(0).matrix_value();
13759 arg1 = &temp1( 0, 0 );
13760 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13761 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13762 }
13763 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13764 if (!SWIG_IsOK(res4)) {
13765 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13766 }
13767 arg4 = reinterpret_cast< char * >(buf4);
13768 ecode5 = SWIG_AsVal_double(args(2), &val5);
13769 if (!SWIG_IsOK(ecode5)) {
13770 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13771 }
13772 arg5 = static_cast< PLFLT >(val5);
13773 ecode6 = SWIG_AsVal_double(args(3), &val6);
13774 if (!SWIG_IsOK(ecode6)) {
13775 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13776 }
13777 arg6 = static_cast< PLFLT >(val6);
13778 ecode7 = SWIG_AsVal_double(args(4), &val7);
13779 if (!SWIG_IsOK(ecode7)) {
13780 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13781 }
13782 arg7 = static_cast< PLFLT >(val7);
13783 ecode8 = SWIG_AsVal_double(args(5), &val8);
13784 if (!SWIG_IsOK(ecode8)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13786 }
13787 arg8 = static_cast< PLFLT >(val8);
13788 ecode9 = SWIG_AsVal_double(args(6), &val9);
13789 if (!SWIG_IsOK(ecode9)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13791 }
13792 arg9 = static_cast< PLFLT >(val9);
13793 ecode10 = SWIG_AsVal_double(args(7), &val10);
13794 if (!SWIG_IsOK(ecode10)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13796 }
13797 arg10 = static_cast< PLFLT >(val10);
13798 ecode11 = SWIG_AsVal_int(args(8), &val11);
13799 if (!SWIG_IsOK(ecode11)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13801 }
13802 arg11 = static_cast< PLINT >(val11);
13803 ecode12 = SWIG_AsVal_double(args(9), &val12);
13804 if (!SWIG_IsOK(ecode12)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13806 }
13807 arg12 = static_cast< PLFLT >(val12);
13808 ecode13 = SWIG_AsVal_int(args(10), &val13);
13809 if (!SWIG_IsOK(ecode13)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13811 }
13812 arg13 = static_cast< PLINT >(val13);
13813 ecode14 = SWIG_AsVal_int(args(11), &val14);
13814 if (!SWIG_IsOK(ecode14)) {
13815 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13816 }
13817 arg14 = static_cast< PLINT >(val14);
13818 ecode15 = SWIG_AsVal_int(args(12), &val15);
13819 if (!SWIG_IsOK(ecode15)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13821 }
13822 arg15 = static_cast< PLINT >(val15);
13823 ecode16 = SWIG_AsVal_int(args(13), &val16);
13824 if (!SWIG_IsOK(ecode16)) {
13825 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13826 }
13827 arg16 = static_cast< PLINT >(val16);
13828 ecode17 = SWIG_AsVal_int(args(14), &val17);
13829 if (!SWIG_IsOK(ecode17)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13831 }
13832 arg17 = static_cast< PLINT >(val17);
13833 ecode18 = SWIG_AsVal_int(args(15), &val18);
13834 if (!SWIG_IsOK(ecode18)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13836 }
13837 arg18 = static_cast< PLBOOL >(val18);
13838 {
13839 if ( _n_dims( args(16) ) > 2 )
13840 {
13841 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13842 }
13843 temp19 = args(16).matrix_value();
13844 arg19 = &temp19( 0, 0 );
13845 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13846 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13847 }
13848 {
13849 if ( _n_dims( args(17) ) > 2 )
13850 {
13851 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13852 }
13853 temp20 = args(17).matrix_value();
13854 arg20 = &temp20( 0, 0 );
13855 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13856 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13857 }
13858 my_plshade2((double const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(double const *)arg19,(double const *)arg20);
13859 _outv = octave_value();
13860 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13861 {
13862
13863 }
13864 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13865 {
13866
13867 }
13868 {
13869
13870 }
13871 return _out;
13872 fail:
13873 {
13874
13875 }
13876 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13877 {
13878
13879 }
13880 {
13881
13882 }
13883 return octave_value_list();
13884 }
13885 catch(...) {
13886 {
13887
13888 }
13889 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13890 {
13891
13892 }
13893 {
13894
13895 }
13896 throw;
13897 }
13898}
13899
13900
13902 PLFLT *arg1 = (PLFLT *) 0 ;
13903 PLINT arg2 ;
13904 PLINT arg3 ;
13905 PLFLT arg4 ;
13906 PLFLT arg5 ;
13907 PLFLT arg6 ;
13908 PLFLT arg7 ;
13909 PLFLT *arg8 = (PLFLT *) 0 ;
13910 PLINT arg9 ;
13911 PLINT arg10 ;
13912 PLINT arg11 ;
13913 PLINT arg12 ;
13914 PLBOOL arg13 ;
13915 Matrix temp1 ;
13916 double val4 ;
13917 int ecode4 = 0 ;
13918 double val5 ;
13919 int ecode5 = 0 ;
13920 double val6 ;
13921 int ecode6 = 0 ;
13922 double val7 ;
13923 int ecode7 = 0 ;
13924 Matrix temp8 ;
13925 int val10 ;
13926 int ecode10 = 0 ;
13927 int val11 ;
13928 int ecode11 = 0 ;
13929 int val12 ;
13930 int ecode12 = 0 ;
13931 int val13 ;
13932 int ecode13 = 0 ;
13933 octave_value_list _out;
13934 octave_value_list *_outp=&_out;
13935 octave_value _outv;
13936
13937 try {
13938 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13939 SWIG_fail;
13940 }
13941 {
13942 if ( _n_dims( args(0) ) > 2 )
13943 {
13944 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13945 }
13946 temp1 = args(0).matrix_value();
13947 arg1 = &temp1( 0, 0 );
13948 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13949 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13950 }
13951 ecode4 = SWIG_AsVal_double(args(1), &val4);
13952 if (!SWIG_IsOK(ecode4)) {
13953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13954 }
13955 arg4 = static_cast< PLFLT >(val4);
13956 ecode5 = SWIG_AsVal_double(args(2), &val5);
13957 if (!SWIG_IsOK(ecode5)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13959 }
13960 arg5 = static_cast< PLFLT >(val5);
13961 ecode6 = SWIG_AsVal_double(args(3), &val6);
13962 if (!SWIG_IsOK(ecode6)) {
13963 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13964 }
13965 arg6 = static_cast< PLFLT >(val6);
13966 ecode7 = SWIG_AsVal_double(args(4), &val7);
13967 if (!SWIG_IsOK(ecode7)) {
13968 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13969 }
13970 arg7 = static_cast< PLFLT >(val7);
13971 {
13972 if ( _n_dims( args(5) ) > 1 )
13973 {
13974 error( "argument must be a scalar or vector" ); SWIG_fail;
13975 }
13976 temp8 = args(5).matrix_value();
13977 arg8 = &temp8( 0, 0 );
13978 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13979 }
13980 ecode10 = SWIG_AsVal_int(args(6), &val10);
13981 if (!SWIG_IsOK(ecode10)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13983 }
13984 arg10 = static_cast< PLINT >(val10);
13985 ecode11 = SWIG_AsVal_int(args(7), &val11);
13986 if (!SWIG_IsOK(ecode11)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13988 }
13989 arg11 = static_cast< PLINT >(val11);
13990 ecode12 = SWIG_AsVal_int(args(8), &val12);
13991 if (!SWIG_IsOK(ecode12)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13993 }
13994 arg12 = static_cast< PLINT >(val12);
13995 ecode13 = SWIG_AsVal_int(args(9), &val13);
13996 if (!SWIG_IsOK(ecode13)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13998 }
13999 arg13 = static_cast< PLBOOL >(val13);
14000 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14001 _outv = octave_value();
14002 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14003 {
14004
14005 }
14006 {
14007
14008 }
14009 return _out;
14010 fail:
14011 {
14012
14013 }
14014 {
14015
14016 }
14017 return octave_value_list();
14018 }
14019 catch(...) {
14020 {
14021
14022 }
14023 {
14024
14025 }
14026 throw;
14027 }
14028}
14029
14030
14031SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14032 PLFLT *arg1 = (PLFLT *) 0 ;
14033 PLINT arg2 ;
14034 PLINT arg3 ;
14035 PLFLT arg4 ;
14036 PLFLT arg5 ;
14037 PLFLT arg6 ;
14038 PLFLT arg7 ;
14039 PLFLT *arg8 = (PLFLT *) 0 ;
14040 PLINT arg9 ;
14041 PLINT arg10 ;
14042 PLINT arg11 ;
14043 PLINT arg12 ;
14044 PLBOOL arg13 ;
14045 PLFLT *arg14 = (PLFLT *) 0 ;
14046 Matrix temp1 ;
14047 double val4 ;
14048 int ecode4 = 0 ;
14049 double val5 ;
14050 int ecode5 = 0 ;
14051 double val6 ;
14052 int ecode6 = 0 ;
14053 double val7 ;
14054 int ecode7 = 0 ;
14055 Matrix temp8 ;
14056 int val10 ;
14057 int ecode10 = 0 ;
14058 int val11 ;
14059 int ecode11 = 0 ;
14060 int val12 ;
14061 int ecode12 = 0 ;
14062 int val13 ;
14063 int ecode13 = 0 ;
14064 Matrix temp14 ;
14065 octave_value_list _out;
14066 octave_value_list *_outp=&_out;
14067 octave_value _outv;
14068
14069 try {
14070 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14071 SWIG_fail;
14072 }
14073 {
14074 if ( _n_dims( args(0) ) > 2 )
14075 {
14076 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14077 }
14078 temp1 = args(0).matrix_value();
14079 arg1 = &temp1( 0, 0 );
14080 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14081 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14082 }
14083 ecode4 = SWIG_AsVal_double(args(1), &val4);
14084 if (!SWIG_IsOK(ecode4)) {
14085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14086 }
14087 arg4 = static_cast< PLFLT >(val4);
14088 ecode5 = SWIG_AsVal_double(args(2), &val5);
14089 if (!SWIG_IsOK(ecode5)) {
14090 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14091 }
14092 arg5 = static_cast< PLFLT >(val5);
14093 ecode6 = SWIG_AsVal_double(args(3), &val6);
14094 if (!SWIG_IsOK(ecode6)) {
14095 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14096 }
14097 arg6 = static_cast< PLFLT >(val6);
14098 ecode7 = SWIG_AsVal_double(args(4), &val7);
14099 if (!SWIG_IsOK(ecode7)) {
14100 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14101 }
14102 arg7 = static_cast< PLFLT >(val7);
14103 {
14104 if ( _n_dims( args(5) ) > 1 )
14105 {
14106 error( "argument must be a scalar or vector" ); SWIG_fail;
14107 }
14108 temp8 = args(5).matrix_value();
14109 arg8 = &temp8( 0, 0 );
14110 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14111 }
14112 ecode10 = SWIG_AsVal_int(args(6), &val10);
14113 if (!SWIG_IsOK(ecode10)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14115 }
14116 arg10 = static_cast< PLINT >(val10);
14117 ecode11 = SWIG_AsVal_int(args(7), &val11);
14118 if (!SWIG_IsOK(ecode11)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14120 }
14121 arg11 = static_cast< PLINT >(val11);
14122 ecode12 = SWIG_AsVal_int(args(8), &val12);
14123 if (!SWIG_IsOK(ecode12)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14125 }
14126 arg12 = static_cast< PLINT >(val12);
14127 ecode13 = SWIG_AsVal_int(args(9), &val13);
14128 if (!SWIG_IsOK(ecode13)) {
14129 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14130 }
14131 arg13 = static_cast< PLBOOL >(val13);
14132 {
14133 if ( _n_dims( args(10) ) > 1 )
14134 {
14135 error( "argument must be a scalar or vector" ); SWIG_fail;
14136 }
14137 if ( _dim( args(10), 0 ) != 6 )
14138 {
14139 error( "argument vectors must have length of 6" ); SWIG_fail;
14140 }
14141 temp14 = args(10).matrix_value();
14142 arg14 = &temp14( 0, 0 );
14143 }
14144 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14145 _outv = octave_value();
14146 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14147 {
14148
14149 }
14150 {
14151
14152 }
14153 {
14154
14155 }
14156 return _out;
14157 fail:
14158 {
14159
14160 }
14161 {
14162
14163 }
14164 {
14165
14166 }
14167 return octave_value_list();
14168 }
14169 catch(...) {
14170 {
14171
14172 }
14173 {
14174
14175 }
14176 {
14177
14178 }
14179 throw;
14180 }
14181}
14182
14183
14184SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14185 PLFLT *arg1 = (PLFLT *) 0 ;
14186 PLINT arg2 ;
14187 PLINT arg3 ;
14188 PLFLT arg4 ;
14189 PLFLT arg5 ;
14190 PLFLT arg6 ;
14191 PLFLT arg7 ;
14192 PLFLT *arg8 = (PLFLT *) 0 ;
14193 PLINT arg9 ;
14194 PLINT arg10 ;
14195 PLINT arg11 ;
14196 PLINT arg12 ;
14197 PLBOOL arg13 ;
14198 PLFLT *arg14 = (PLFLT *) 0 ;
14199 PLFLT *arg15 = (PLFLT *) 0 ;
14200 Matrix temp1 ;
14201 double val4 ;
14202 int ecode4 = 0 ;
14203 double val5 ;
14204 int ecode5 = 0 ;
14205 double val6 ;
14206 int ecode6 = 0 ;
14207 double val7 ;
14208 int ecode7 = 0 ;
14209 Matrix temp8 ;
14210 int val10 ;
14211 int ecode10 = 0 ;
14212 int val11 ;
14213 int ecode11 = 0 ;
14214 int val12 ;
14215 int ecode12 = 0 ;
14216 int val13 ;
14217 int ecode13 = 0 ;
14218 Matrix temp14 ;
14219 Matrix temp15 ;
14220 octave_value_list _out;
14221 octave_value_list *_outp=&_out;
14222 octave_value _outv;
14223
14224 try {
14225 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14226 SWIG_fail;
14227 }
14228 {
14229 if ( _n_dims( args(0) ) > 2 )
14230 {
14231 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14232 }
14233 temp1 = args(0).matrix_value();
14234 arg1 = &temp1( 0, 0 );
14235 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14236 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14237 }
14238 ecode4 = SWIG_AsVal_double(args(1), &val4);
14239 if (!SWIG_IsOK(ecode4)) {
14240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14241 }
14242 arg4 = static_cast< PLFLT >(val4);
14243 ecode5 = SWIG_AsVal_double(args(2), &val5);
14244 if (!SWIG_IsOK(ecode5)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14246 }
14247 arg5 = static_cast< PLFLT >(val5);
14248 ecode6 = SWIG_AsVal_double(args(3), &val6);
14249 if (!SWIG_IsOK(ecode6)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14251 }
14252 arg6 = static_cast< PLFLT >(val6);
14253 ecode7 = SWIG_AsVal_double(args(4), &val7);
14254 if (!SWIG_IsOK(ecode7)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14256 }
14257 arg7 = static_cast< PLFLT >(val7);
14258 {
14259 if ( _n_dims( args(5) ) > 1 )
14260 {
14261 error( "argument must be a scalar or vector" ); SWIG_fail;
14262 }
14263 temp8 = args(5).matrix_value();
14264 arg8 = &temp8( 0, 0 );
14265 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14266 }
14267 ecode10 = SWIG_AsVal_int(args(6), &val10);
14268 if (!SWIG_IsOK(ecode10)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14270 }
14271 arg10 = static_cast< PLINT >(val10);
14272 ecode11 = SWIG_AsVal_int(args(7), &val11);
14273 if (!SWIG_IsOK(ecode11)) {
14274 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14275 }
14276 arg11 = static_cast< PLINT >(val11);
14277 ecode12 = SWIG_AsVal_int(args(8), &val12);
14278 if (!SWIG_IsOK(ecode12)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14280 }
14281 arg12 = static_cast< PLINT >(val12);
14282 ecode13 = SWIG_AsVal_int(args(9), &val13);
14283 if (!SWIG_IsOK(ecode13)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14285 }
14286 arg13 = static_cast< PLBOOL >(val13);
14287 {
14288 if ( _n_dims( args(10) ) > 1 )
14289 {
14290 error( "argument must be a scalar or vector" ); SWIG_fail;
14291 }
14292 if ( _dim( args(10), 0 ) != Xlen )
14293 {
14294 error( "argument vectors must be same length" ); SWIG_fail;
14295 }
14296 temp14 = args(10).matrix_value();
14297 arg14 = &temp14( 0, 0 );
14298 }
14299 {
14300 if ( _n_dims( args(11) ) > 1 )
14301 {
14302 error( "argument must be a scalar or vector" ); SWIG_fail;
14303 }
14304 if ( _dim( args(11), 0 ) != Ylen )
14305 {
14306 error( "argument vectors must be same length" ); SWIG_fail;
14307 }
14308 temp15 = args(11).matrix_value();
14309 arg15 = &temp15( 0, 0 );
14310 }
14311 my_plshades1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,(double const *)arg14,(double const *)arg15);
14312 _outv = octave_value();
14313 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14314 {
14315
14316 }
14317 {
14318
14319 }
14320 {
14321
14322 }
14323 {
14324
14325 }
14326 return _out;
14327 fail:
14328 {
14329
14330 }
14331 {
14332
14333 }
14334 {
14335
14336 }
14337 {
14338
14339 }
14340 return octave_value_list();
14341 }
14342 catch(...) {
14343 {
14344
14345 }
14346 {
14347
14348 }
14349 {
14350
14351 }
14352 {
14353
14354 }
14355 throw;
14356 }
14357}
14358
14359
14360SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14361 PLFLT *arg1 = (PLFLT *) 0 ;
14362 PLINT arg2 ;
14363 PLINT arg3 ;
14364 PLFLT arg4 ;
14365 PLFLT arg5 ;
14366 PLFLT arg6 ;
14367 PLFLT arg7 ;
14368 PLFLT *arg8 = (PLFLT *) 0 ;
14369 PLINT arg9 ;
14370 PLINT arg10 ;
14371 PLINT arg11 ;
14372 PLINT arg12 ;
14373 PLBOOL arg13 ;
14374 PLFLT *arg14 = (PLFLT *) 0 ;
14375 PLFLT *arg15 = (PLFLT *) 0 ;
14376 Matrix temp1 ;
14377 double val4 ;
14378 int ecode4 = 0 ;
14379 double val5 ;
14380 int ecode5 = 0 ;
14381 double val6 ;
14382 int ecode6 = 0 ;
14383 double val7 ;
14384 int ecode7 = 0 ;
14385 Matrix temp8 ;
14386 int val10 ;
14387 int ecode10 = 0 ;
14388 int val11 ;
14389 int ecode11 = 0 ;
14390 int val12 ;
14391 int ecode12 = 0 ;
14392 int val13 ;
14393 int ecode13 = 0 ;
14394 Matrix temp14 ;
14395 Matrix temp15 ;
14396 octave_value_list _out;
14397 octave_value_list *_outp=&_out;
14398 octave_value _outv;
14399
14400 try {
14401 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14402 SWIG_fail;
14403 }
14404 {
14405 if ( _n_dims( args(0) ) > 2 )
14406 {
14407 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14408 }
14409 temp1 = args(0).matrix_value();
14410 arg1 = &temp1( 0, 0 );
14411 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14412 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14413 }
14414 ecode4 = SWIG_AsVal_double(args(1), &val4);
14415 if (!SWIG_IsOK(ecode4)) {
14416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14417 }
14418 arg4 = static_cast< PLFLT >(val4);
14419 ecode5 = SWIG_AsVal_double(args(2), &val5);
14420 if (!SWIG_IsOK(ecode5)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14422 }
14423 arg5 = static_cast< PLFLT >(val5);
14424 ecode6 = SWIG_AsVal_double(args(3), &val6);
14425 if (!SWIG_IsOK(ecode6)) {
14426 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14427 }
14428 arg6 = static_cast< PLFLT >(val6);
14429 ecode7 = SWIG_AsVal_double(args(4), &val7);
14430 if (!SWIG_IsOK(ecode7)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14432 }
14433 arg7 = static_cast< PLFLT >(val7);
14434 {
14435 if ( _n_dims( args(5) ) > 1 )
14436 {
14437 error( "argument must be a scalar or vector" ); SWIG_fail;
14438 }
14439 temp8 = args(5).matrix_value();
14440 arg8 = &temp8( 0, 0 );
14441 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14442 }
14443 ecode10 = SWIG_AsVal_int(args(6), &val10);
14444 if (!SWIG_IsOK(ecode10)) {
14445 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14446 }
14447 arg10 = static_cast< PLINT >(val10);
14448 ecode11 = SWIG_AsVal_int(args(7), &val11);
14449 if (!SWIG_IsOK(ecode11)) {
14450 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14451 }
14452 arg11 = static_cast< PLINT >(val11);
14453 ecode12 = SWIG_AsVal_int(args(8), &val12);
14454 if (!SWIG_IsOK(ecode12)) {
14455 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14456 }
14457 arg12 = static_cast< PLINT >(val12);
14458 ecode13 = SWIG_AsVal_int(args(9), &val13);
14459 if (!SWIG_IsOK(ecode13)) {
14460 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14461 }
14462 arg13 = static_cast< PLBOOL >(val13);
14463 {
14464 if ( _n_dims( args(10) ) > 2 )
14465 {
14466 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14467 }
14468 temp14 = args(10).matrix_value();
14469 arg14 = &temp14( 0, 0 );
14470 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14471 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14472 }
14473 {
14474 if ( _n_dims( args(11) ) > 2 )
14475 {
14476 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14477 }
14478 temp15 = args(11).matrix_value();
14479 arg15 = &temp15( 0, 0 );
14480 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14481 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14482 }
14483 my_plshades2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,(double const *)arg14,(double const *)arg15);
14484 _outv = octave_value();
14485 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14486 {
14487
14488 }
14489 {
14490
14491 }
14492 {
14493
14494 }
14495 {
14496
14497 }
14498 return _out;
14499 fail:
14500 {
14501
14502 }
14503 {
14504
14505 }
14506 {
14507
14508 }
14509 {
14510
14511 }
14512 return octave_value_list();
14513 }
14514 catch(...) {
14515 {
14516
14517 }
14518 {
14519
14520 }
14521 {
14522
14523 }
14524 {
14525
14526 }
14527 throw;
14528 }
14529}
14530
14531
14533 PLFLT *arg1 = (PLFLT *) 0 ;
14534 PLFLT *arg2 = (PLFLT *) 0 ;
14535 PLINT arg3 ;
14536 PLINT arg4 ;
14537 PLFLT arg5 ;
14538 PLFLT *arg6 = (PLFLT *) 0 ;
14539 Matrix temp1 ;
14540 Matrix temp2 ;
14541 double val5 ;
14542 int ecode5 = 0 ;
14543 Matrix temp6 ;
14544 octave_value_list _out;
14545 octave_value_list *_outp=&_out;
14546 octave_value _outv;
14547
14548 try {
14549 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14550 SWIG_fail;
14551 }
14552 {
14553 if ( _n_dims( args(0) ) > 2 )
14554 {
14555 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14556 }
14557 temp1 = args(0).matrix_value();
14558 arg1 = &temp1( 0, 0 );
14559 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14560 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14561 }
14562 {
14563 if ( _n_dims( args(1) ) > 2 )
14564 {
14565 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14566 }
14567 if ( _dim( args(1), 0 ) != Xlen )
14568 {
14569 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14570 }
14571 if ( _dim( args(1), 1 ) != Ylen )
14572 {
14573 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14574 }
14575 temp2 = args(1).matrix_value();
14576 arg2 = &temp2( 0, 0 );
14577 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14578 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14579 }
14580 ecode5 = SWIG_AsVal_double(args(2), &val5);
14581 if (!SWIG_IsOK(ecode5)) {
14582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14583 }
14584 arg5 = static_cast< PLFLT >(val5);
14585 {
14586 if ( _n_dims( args(3) ) > 1 )
14587 {
14588 error( "argument must be a scalar or vector" ); SWIG_fail;
14589 }
14590 if ( _dim( args(3), 0 ) != 6 )
14591 {
14592 error( "argument vectors must have length of 6" ); SWIG_fail;
14593 }
14594 temp6 = args(3).matrix_value();
14595 arg6 = &temp6( 0, 0 );
14596 }
14597 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14598 _outv = octave_value();
14599 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14600 {
14601
14602 }
14603 {
14604
14605 }
14606 {
14607
14608 }
14609 return _out;
14610 fail:
14611 {
14612
14613 }
14614 {
14615
14616 }
14617 {
14618
14619 }
14620 return octave_value_list();
14621 }
14622 catch(...) {
14623 {
14624
14625 }
14626 {
14627
14628 }
14629 {
14630
14631 }
14632 throw;
14633 }
14634}
14635
14636
14637SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14638 PLFLT *arg1 = (PLFLT *) 0 ;
14639 PLFLT *arg2 = (PLFLT *) 0 ;
14640 PLINT arg3 ;
14641 PLINT arg4 ;
14642 PLFLT arg5 ;
14643 PLFLT *arg6 = (PLFLT *) 0 ;
14644 PLFLT *arg7 = (PLFLT *) 0 ;
14645 Matrix temp1 ;
14646 Matrix temp2 ;
14647 double val5 ;
14648 int ecode5 = 0 ;
14649 Matrix temp6 ;
14650 Matrix temp7 ;
14651 octave_value_list _out;
14652 octave_value_list *_outp=&_out;
14653 octave_value _outv;
14654
14655 try {
14656 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14657 SWIG_fail;
14658 }
14659 {
14660 if ( _n_dims( args(0) ) > 2 )
14661 {
14662 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14663 }
14664 temp1 = args(0).matrix_value();
14665 arg1 = &temp1( 0, 0 );
14666 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14667 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14668 }
14669 {
14670 if ( _n_dims( args(1) ) > 2 )
14671 {
14672 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14673 }
14674 if ( _dim( args(1), 0 ) != Xlen )
14675 {
14676 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14677 }
14678 if ( _dim( args(1), 1 ) != Ylen )
14679 {
14680 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14681 }
14682 temp2 = args(1).matrix_value();
14683 arg2 = &temp2( 0, 0 );
14684 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14685 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14686 }
14687 ecode5 = SWIG_AsVal_double(args(2), &val5);
14688 if (!SWIG_IsOK(ecode5)) {
14689 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14690 }
14691 arg5 = static_cast< PLFLT >(val5);
14692 {
14693 if ( _n_dims( args(3) ) > 1 )
14694 {
14695 error( "argument must be a scalar or vector" ); SWIG_fail;
14696 }
14697 if ( _dim( args(3), 0 ) != Xlen )
14698 {
14699 error( "argument vectors must be same length" ); SWIG_fail;
14700 }
14701 temp6 = args(3).matrix_value();
14702 arg6 = &temp6( 0, 0 );
14703 }
14704 {
14705 if ( _n_dims( args(4) ) > 1 )
14706 {
14707 error( "argument must be a scalar or vector" ); SWIG_fail;
14708 }
14709 if ( _dim( args(4), 0 ) != Ylen )
14710 {
14711 error( "argument vectors must be same length" ); SWIG_fail;
14712 }
14713 temp7 = args(4).matrix_value();
14714 arg7 = &temp7( 0, 0 );
14715 }
14716 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14717 _outv = octave_value();
14718 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14719 {
14720
14721 }
14722 {
14723
14724 }
14725 {
14726
14727 }
14728 {
14729
14730 }
14731 return _out;
14732 fail:
14733 {
14734
14735 }
14736 {
14737
14738 }
14739 {
14740
14741 }
14742 {
14743
14744 }
14745 return octave_value_list();
14746 }
14747 catch(...) {
14748 {
14749
14750 }
14751 {
14752
14753 }
14754 {
14755
14756 }
14757 {
14758
14759 }
14760 throw;
14761 }
14762}
14763
14764
14765SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14766 PLFLT *arg1 = (PLFLT *) 0 ;
14767 PLFLT *arg2 = (PLFLT *) 0 ;
14768 PLINT arg3 ;
14769 PLINT arg4 ;
14770 PLFLT arg5 ;
14771 PLFLT *arg6 = (PLFLT *) 0 ;
14772 PLFLT *arg7 = (PLFLT *) 0 ;
14773 Matrix temp1 ;
14774 Matrix temp2 ;
14775 double val5 ;
14776 int ecode5 = 0 ;
14777 Matrix temp6 ;
14778 Matrix temp7 ;
14779 octave_value_list _out;
14780 octave_value_list *_outp=&_out;
14781 octave_value _outv;
14782
14783 try {
14784 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14785 SWIG_fail;
14786 }
14787 {
14788 if ( _n_dims( args(0) ) > 2 )
14789 {
14790 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14791 }
14792 temp1 = args(0).matrix_value();
14793 arg1 = &temp1( 0, 0 );
14794 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14795 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14796 }
14797 {
14798 if ( _n_dims( args(1) ) > 2 )
14799 {
14800 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14801 }
14802 if ( _dim( args(1), 0 ) != Xlen )
14803 {
14804 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14805 }
14806 if ( _dim( args(1), 1 ) != Ylen )
14807 {
14808 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14809 }
14810 temp2 = args(1).matrix_value();
14811 arg2 = &temp2( 0, 0 );
14812 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14813 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14814 }
14815 ecode5 = SWIG_AsVal_double(args(2), &val5);
14816 if (!SWIG_IsOK(ecode5)) {
14817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14818 }
14819 arg5 = static_cast< PLFLT >(val5);
14820 {
14821 if ( _n_dims( args(3) ) > 2 )
14822 {
14823 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14824 }
14825 temp6 = args(3).matrix_value();
14826 arg6 = &temp6( 0, 0 );
14827 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14828 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14829 }
14830 {
14831 if ( _n_dims( args(4) ) > 2 )
14832 {
14833 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14834 }
14835 temp7 = args(4).matrix_value();
14836 arg7 = &temp7( 0, 0 );
14837 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14838 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14839 }
14840 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14841 _outv = octave_value();
14842 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14843 {
14844
14845 }
14846 {
14847
14848 }
14849 {
14850
14851 }
14852 {
14853
14854 }
14855 return _out;
14856 fail:
14857 {
14858
14859 }
14860 {
14861
14862 }
14863 {
14864
14865 }
14866 {
14867
14868 }
14869 return octave_value_list();
14870 }
14871 catch(...) {
14872 {
14873
14874 }
14875 {
14876
14877 }
14878 {
14879
14880 }
14881 {
14882
14883 }
14884 throw;
14885 }
14886}
14887
14888
14889SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14890 PLFLT *arg1 = (PLFLT *) 0 ;
14891 PLINT arg2 ;
14892 PLINT arg3 ;
14893 PLFLT arg4 ;
14894 PLFLT arg5 ;
14895 PLFLT arg6 ;
14896 PLFLT arg7 ;
14897 PLFLT arg8 ;
14898 PLFLT arg9 ;
14899 PLFLT arg10 ;
14900 PLFLT arg11 ;
14901 PLFLT arg12 ;
14902 PLFLT arg13 ;
14903 Matrix temp1 ;
14904 double val4 ;
14905 int ecode4 = 0 ;
14906 double val5 ;
14907 int ecode5 = 0 ;
14908 double val6 ;
14909 int ecode6 = 0 ;
14910 double val7 ;
14911 int ecode7 = 0 ;
14912 double val8 ;
14913 int ecode8 = 0 ;
14914 double val9 ;
14915 int ecode9 = 0 ;
14916 double val10 ;
14917 int ecode10 = 0 ;
14918 double val11 ;
14919 int ecode11 = 0 ;
14920 double val12 ;
14921 int ecode12 = 0 ;
14922 double val13 ;
14923 int ecode13 = 0 ;
14924 octave_value_list _out;
14925 octave_value_list *_outp=&_out;
14926 octave_value _outv;
14927
14928 try {
14929 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14930 SWIG_fail;
14931 }
14932 {
14933 if ( _n_dims( args(0) ) > 2 )
14934 {
14935 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14936 }
14937 temp1 = args(0).matrix_value();
14938 arg1 = &temp1( 0, 0 );
14939 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14940 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14941 }
14942 ecode4 = SWIG_AsVal_double(args(1), &val4);
14943 if (!SWIG_IsOK(ecode4)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14945 }
14946 arg4 = static_cast< PLFLT >(val4);
14947 ecode5 = SWIG_AsVal_double(args(2), &val5);
14948 if (!SWIG_IsOK(ecode5)) {
14949 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14950 }
14951 arg5 = static_cast< PLFLT >(val5);
14952 ecode6 = SWIG_AsVal_double(args(3), &val6);
14953 if (!SWIG_IsOK(ecode6)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14955 }
14956 arg6 = static_cast< PLFLT >(val6);
14957 ecode7 = SWIG_AsVal_double(args(4), &val7);
14958 if (!SWIG_IsOK(ecode7)) {
14959 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14960 }
14961 arg7 = static_cast< PLFLT >(val7);
14962 ecode8 = SWIG_AsVal_double(args(5), &val8);
14963 if (!SWIG_IsOK(ecode8)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14965 }
14966 arg8 = static_cast< PLFLT >(val8);
14967 ecode9 = SWIG_AsVal_double(args(6), &val9);
14968 if (!SWIG_IsOK(ecode9)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14970 }
14971 arg9 = static_cast< PLFLT >(val9);
14972 ecode10 = SWIG_AsVal_double(args(7), &val10);
14973 if (!SWIG_IsOK(ecode10)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14975 }
14976 arg10 = static_cast< PLFLT >(val10);
14977 ecode11 = SWIG_AsVal_double(args(8), &val11);
14978 if (!SWIG_IsOK(ecode11)) {
14979 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14980 }
14981 arg11 = static_cast< PLFLT >(val11);
14982 ecode12 = SWIG_AsVal_double(args(9), &val12);
14983 if (!SWIG_IsOK(ecode12)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14985 }
14986 arg12 = static_cast< PLFLT >(val12);
14987 ecode13 = SWIG_AsVal_double(args(10), &val13);
14988 if (!SWIG_IsOK(ecode13)) {
14989 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14990 }
14991 arg13 = static_cast< PLFLT >(val13);
14992 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14993 _outv = octave_value();
14994 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14995 {
14996
14997 }
14998 return _out;
14999 fail:
15000 {
15001
15002 }
15003 return octave_value_list();
15004 }
15005 catch(...) {
15006 {
15007
15008 }
15009 throw;
15010 }
15011}
15012
15013
15015 PLFLT *arg1 = (PLFLT *) 0 ;
15016 PLINT arg2 ;
15017 PLINT arg3 ;
15018 PLFLT arg4 ;
15019 PLFLT arg5 ;
15020 PLFLT arg6 ;
15021 PLFLT arg7 ;
15022 PLFLT arg8 ;
15023 PLFLT arg9 ;
15024 PLFLT arg10 ;
15025 PLFLT arg11 ;
15026 Matrix temp1 ;
15027 double val4 ;
15028 int ecode4 = 0 ;
15029 double val5 ;
15030 int ecode5 = 0 ;
15031 double val6 ;
15032 int ecode6 = 0 ;
15033 double val7 ;
15034 int ecode7 = 0 ;
15035 double val8 ;
15036 int ecode8 = 0 ;
15037 double val9 ;
15038 int ecode9 = 0 ;
15039 double val10 ;
15040 int ecode10 = 0 ;
15041 double val11 ;
15042 int ecode11 = 0 ;
15043 octave_value_list _out;
15044 octave_value_list *_outp=&_out;
15045 octave_value _outv;
15046
15047 try {
15048 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15049 SWIG_fail;
15050 }
15051 {
15052 if ( _n_dims( args(0) ) > 2 )
15053 {
15054 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15055 }
15056 temp1 = args(0).matrix_value();
15057 arg1 = &temp1( 0, 0 );
15058 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15059 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15060 }
15061 ecode4 = SWIG_AsVal_double(args(1), &val4);
15062 if (!SWIG_IsOK(ecode4)) {
15063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15064 }
15065 arg4 = static_cast< PLFLT >(val4);
15066 ecode5 = SWIG_AsVal_double(args(2), &val5);
15067 if (!SWIG_IsOK(ecode5)) {
15068 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15069 }
15070 arg5 = static_cast< PLFLT >(val5);
15071 ecode6 = SWIG_AsVal_double(args(3), &val6);
15072 if (!SWIG_IsOK(ecode6)) {
15073 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15074 }
15075 arg6 = static_cast< PLFLT >(val6);
15076 ecode7 = SWIG_AsVal_double(args(4), &val7);
15077 if (!SWIG_IsOK(ecode7)) {
15078 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15079 }
15080 arg7 = static_cast< PLFLT >(val7);
15081 ecode8 = SWIG_AsVal_double(args(5), &val8);
15082 if (!SWIG_IsOK(ecode8)) {
15083 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15084 }
15085 arg8 = static_cast< PLFLT >(val8);
15086 ecode9 = SWIG_AsVal_double(args(6), &val9);
15087 if (!SWIG_IsOK(ecode9)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15089 }
15090 arg9 = static_cast< PLFLT >(val9);
15091 ecode10 = SWIG_AsVal_double(args(7), &val10);
15092 if (!SWIG_IsOK(ecode10)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15094 }
15095 arg10 = static_cast< PLFLT >(val10);
15096 ecode11 = SWIG_AsVal_double(args(8), &val11);
15097 if (!SWIG_IsOK(ecode11)) {
15098 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15099 }
15100 arg11 = static_cast< PLFLT >(val11);
15101 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15102 _outv = octave_value();
15103 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15104 {
15105
15106 }
15107 return _out;
15108 fail:
15109 {
15110
15111 }
15112 return octave_value_list();
15113 }
15114 catch(...) {
15115 {
15116
15117 }
15118 throw;
15119 }
15120}
15121
15122
15123SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15124 PLFLT *arg1 = (PLFLT *) 0 ;
15125 PLINT arg2 ;
15126 PLINT arg3 ;
15127 PLFLT arg4 ;
15128 PLFLT arg5 ;
15129 PLFLT arg6 ;
15130 PLFLT arg7 ;
15131 PLFLT arg8 ;
15132 PLFLT arg9 ;
15133 PLFLT arg10 ;
15134 PLFLT arg11 ;
15135 PLFLT *arg12 = (PLFLT *) 0 ;
15136 Matrix temp1 ;
15137 double val4 ;
15138 int ecode4 = 0 ;
15139 double val5 ;
15140 int ecode5 = 0 ;
15141 double val6 ;
15142 int ecode6 = 0 ;
15143 double val7 ;
15144 int ecode7 = 0 ;
15145 double val8 ;
15146 int ecode8 = 0 ;
15147 double val9 ;
15148 int ecode9 = 0 ;
15149 double val10 ;
15150 int ecode10 = 0 ;
15151 double val11 ;
15152 int ecode11 = 0 ;
15153 Matrix temp12 ;
15154 octave_value_list _out;
15155 octave_value_list *_outp=&_out;
15156 octave_value _outv;
15157
15158 try {
15159 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15160 SWIG_fail;
15161 }
15162 {
15163 if ( _n_dims( args(0) ) > 2 )
15164 {
15165 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15166 }
15167 temp1 = args(0).matrix_value();
15168 arg1 = &temp1( 0, 0 );
15169 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15170 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15171 }
15172 ecode4 = SWIG_AsVal_double(args(1), &val4);
15173 if (!SWIG_IsOK(ecode4)) {
15174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15175 }
15176 arg4 = static_cast< PLFLT >(val4);
15177 ecode5 = SWIG_AsVal_double(args(2), &val5);
15178 if (!SWIG_IsOK(ecode5)) {
15179 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15180 }
15181 arg5 = static_cast< PLFLT >(val5);
15182 ecode6 = SWIG_AsVal_double(args(3), &val6);
15183 if (!SWIG_IsOK(ecode6)) {
15184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15185 }
15186 arg6 = static_cast< PLFLT >(val6);
15187 ecode7 = SWIG_AsVal_double(args(4), &val7);
15188 if (!SWIG_IsOK(ecode7)) {
15189 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15190 }
15191 arg7 = static_cast< PLFLT >(val7);
15192 ecode8 = SWIG_AsVal_double(args(5), &val8);
15193 if (!SWIG_IsOK(ecode8)) {
15194 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15195 }
15196 arg8 = static_cast< PLFLT >(val8);
15197 ecode9 = SWIG_AsVal_double(args(6), &val9);
15198 if (!SWIG_IsOK(ecode9)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15200 }
15201 arg9 = static_cast< PLFLT >(val9);
15202 ecode10 = SWIG_AsVal_double(args(7), &val10);
15203 if (!SWIG_IsOK(ecode10)) {
15204 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15205 }
15206 arg10 = static_cast< PLFLT >(val10);
15207 ecode11 = SWIG_AsVal_double(args(8), &val11);
15208 if (!SWIG_IsOK(ecode11)) {
15209 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15210 }
15211 arg11 = static_cast< PLFLT >(val11);
15212 {
15213 if ( _n_dims( args(9) ) > 1 )
15214 {
15215 error( "argument must be a scalar or vector" ); SWIG_fail;
15216 }
15217 if ( _dim( args(9), 0 ) != 6 )
15218 {
15219 error( "argument vectors must have length of 6" ); SWIG_fail;
15220 }
15221 temp12 = args(9).matrix_value();
15222 arg12 = &temp12( 0, 0 );
15223 }
15224 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15225 _outv = octave_value();
15226 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15227 {
15228
15229 }
15230 {
15231
15232 }
15233 return _out;
15234 fail:
15235 {
15236
15237 }
15238 {
15239
15240 }
15241 return octave_value_list();
15242 }
15243 catch(...) {
15244 {
15245
15246 }
15247 {
15248
15249 }
15250 throw;
15251 }
15252}
15253
15254
15255SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15256 PLFLT *arg1 = (PLFLT *) 0 ;
15257 PLINT arg2 ;
15258 PLINT arg3 ;
15259 PLFLT arg4 ;
15260 PLFLT arg5 ;
15261 PLFLT arg6 ;
15262 PLFLT arg7 ;
15263 PLFLT arg8 ;
15264 PLFLT arg9 ;
15265 PLFLT arg10 ;
15266 PLFLT arg11 ;
15267 PLFLT *arg12 = (PLFLT *) 0 ;
15268 PLFLT *arg13 = (PLFLT *) 0 ;
15269 Matrix temp1 ;
15270 double val4 ;
15271 int ecode4 = 0 ;
15272 double val5 ;
15273 int ecode5 = 0 ;
15274 double val6 ;
15275 int ecode6 = 0 ;
15276 double val7 ;
15277 int ecode7 = 0 ;
15278 double val8 ;
15279 int ecode8 = 0 ;
15280 double val9 ;
15281 int ecode9 = 0 ;
15282 double val10 ;
15283 int ecode10 = 0 ;
15284 double val11 ;
15285 int ecode11 = 0 ;
15286 Matrix temp12 ;
15287 Matrix temp13 ;
15288 octave_value_list _out;
15289 octave_value_list *_outp=&_out;
15290 octave_value _outv;
15291
15292 try {
15293 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15294 SWIG_fail;
15295 }
15296 {
15297 if ( _n_dims( args(0) ) > 2 )
15298 {
15299 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15300 }
15301 temp1 = args(0).matrix_value();
15302 arg1 = &temp1( 0, 0 );
15303 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15304 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15305 }
15306 ecode4 = SWIG_AsVal_double(args(1), &val4);
15307 if (!SWIG_IsOK(ecode4)) {
15308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15309 }
15310 arg4 = static_cast< PLFLT >(val4);
15311 ecode5 = SWIG_AsVal_double(args(2), &val5);
15312 if (!SWIG_IsOK(ecode5)) {
15313 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15314 }
15315 arg5 = static_cast< PLFLT >(val5);
15316 ecode6 = SWIG_AsVal_double(args(3), &val6);
15317 if (!SWIG_IsOK(ecode6)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15319 }
15320 arg6 = static_cast< PLFLT >(val6);
15321 ecode7 = SWIG_AsVal_double(args(4), &val7);
15322 if (!SWIG_IsOK(ecode7)) {
15323 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15324 }
15325 arg7 = static_cast< PLFLT >(val7);
15326 ecode8 = SWIG_AsVal_double(args(5), &val8);
15327 if (!SWIG_IsOK(ecode8)) {
15328 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15329 }
15330 arg8 = static_cast< PLFLT >(val8);
15331 ecode9 = SWIG_AsVal_double(args(6), &val9);
15332 if (!SWIG_IsOK(ecode9)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15334 }
15335 arg9 = static_cast< PLFLT >(val9);
15336 ecode10 = SWIG_AsVal_double(args(7), &val10);
15337 if (!SWIG_IsOK(ecode10)) {
15338 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15339 }
15340 arg10 = static_cast< PLFLT >(val10);
15341 ecode11 = SWIG_AsVal_double(args(8), &val11);
15342 if (!SWIG_IsOK(ecode11)) {
15343 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15344 }
15345 arg11 = static_cast< PLFLT >(val11);
15346 {
15347 if ( _n_dims( args(9) ) > 1 )
15348 {
15349 error( "argument must be a scalar or vector" ); SWIG_fail;
15350 }
15351 if ( _dim( args(9), 0 ) != Xlen )
15352 {
15353 error( "argument vectors must be same length" ); SWIG_fail;
15354 }
15355 temp12 = args(9).matrix_value();
15356 arg12 = &temp12( 0, 0 );
15357 }
15358 {
15359 if ( _n_dims( args(10) ) > 1 )
15360 {
15361 error( "argument must be a scalar or vector" ); SWIG_fail;
15362 }
15363 if ( _dim( args(10), 0 ) != Ylen )
15364 {
15365 error( "argument vectors must be same length" ); SWIG_fail;
15366 }
15367 temp13 = args(10).matrix_value();
15368 arg13 = &temp13( 0, 0 );
15369 }
15370 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15371 _outv = octave_value();
15372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15373 {
15374
15375 }
15376 {
15377
15378 }
15379 {
15380
15381 }
15382 return _out;
15383 fail:
15384 {
15385
15386 }
15387 {
15388
15389 }
15390 {
15391
15392 }
15393 return octave_value_list();
15394 }
15395 catch(...) {
15396 {
15397
15398 }
15399 {
15400
15401 }
15402 {
15403
15404 }
15405 throw;
15406 }
15407}
15408
15409
15410SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15411 PLFLT *arg1 = (PLFLT *) 0 ;
15412 PLINT arg2 ;
15413 PLINT arg3 ;
15414 PLFLT arg4 ;
15415 PLFLT arg5 ;
15416 PLFLT arg6 ;
15417 PLFLT arg7 ;
15418 PLFLT arg8 ;
15419 PLFLT arg9 ;
15420 PLFLT arg10 ;
15421 PLFLT arg11 ;
15422 PLFLT *arg12 = (PLFLT *) 0 ;
15423 PLFLT *arg13 = (PLFLT *) 0 ;
15424 Matrix temp1 ;
15425 double val4 ;
15426 int ecode4 = 0 ;
15427 double val5 ;
15428 int ecode5 = 0 ;
15429 double val6 ;
15430 int ecode6 = 0 ;
15431 double val7 ;
15432 int ecode7 = 0 ;
15433 double val8 ;
15434 int ecode8 = 0 ;
15435 double val9 ;
15436 int ecode9 = 0 ;
15437 double val10 ;
15438 int ecode10 = 0 ;
15439 double val11 ;
15440 int ecode11 = 0 ;
15441 Matrix temp12 ;
15442 Matrix temp13 ;
15443 octave_value_list _out;
15444 octave_value_list *_outp=&_out;
15445 octave_value _outv;
15446
15447 try {
15448 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15449 SWIG_fail;
15450 }
15451 {
15452 if ( _n_dims( args(0) ) > 2 )
15453 {
15454 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15455 }
15456 temp1 = args(0).matrix_value();
15457 arg1 = &temp1( 0, 0 );
15458 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15459 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15460 }
15461 ecode4 = SWIG_AsVal_double(args(1), &val4);
15462 if (!SWIG_IsOK(ecode4)) {
15463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15464 }
15465 arg4 = static_cast< PLFLT >(val4);
15466 ecode5 = SWIG_AsVal_double(args(2), &val5);
15467 if (!SWIG_IsOK(ecode5)) {
15468 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15469 }
15470 arg5 = static_cast< PLFLT >(val5);
15471 ecode6 = SWIG_AsVal_double(args(3), &val6);
15472 if (!SWIG_IsOK(ecode6)) {
15473 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15474 }
15475 arg6 = static_cast< PLFLT >(val6);
15476 ecode7 = SWIG_AsVal_double(args(4), &val7);
15477 if (!SWIG_IsOK(ecode7)) {
15478 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15479 }
15480 arg7 = static_cast< PLFLT >(val7);
15481 ecode8 = SWIG_AsVal_double(args(5), &val8);
15482 if (!SWIG_IsOK(ecode8)) {
15483 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15484 }
15485 arg8 = static_cast< PLFLT >(val8);
15486 ecode9 = SWIG_AsVal_double(args(6), &val9);
15487 if (!SWIG_IsOK(ecode9)) {
15488 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15489 }
15490 arg9 = static_cast< PLFLT >(val9);
15491 ecode10 = SWIG_AsVal_double(args(7), &val10);
15492 if (!SWIG_IsOK(ecode10)) {
15493 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15494 }
15495 arg10 = static_cast< PLFLT >(val10);
15496 ecode11 = SWIG_AsVal_double(args(8), &val11);
15497 if (!SWIG_IsOK(ecode11)) {
15498 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15499 }
15500 arg11 = static_cast< PLFLT >(val11);
15501 {
15502 if ( _n_dims( args(9) ) > 2 )
15503 {
15504 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15505 }
15506 temp12 = args(9).matrix_value();
15507 arg12 = &temp12( 0, 0 );
15508 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15509 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15510 }
15511 {
15512 if ( _n_dims( args(10) ) > 2 )
15513 {
15514 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15515 }
15516 temp13 = args(10).matrix_value();
15517 arg13 = &temp13( 0, 0 );
15518 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15519 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15520 }
15521 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15522 _outv = octave_value();
15523 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15524 {
15525
15526 }
15527 {
15528
15529 }
15530 {
15531
15532 }
15533 return _out;
15534 fail:
15535 {
15536
15537 }
15538 {
15539
15540 }
15541 {
15542
15543 }
15544 return octave_value_list();
15545 }
15546 catch(...) {
15547 {
15548
15549 }
15550 {
15551
15552 }
15553 {
15554
15555 }
15556 throw;
15557 }
15558}
15559
15560
15562 PLFLT *arg1 = (PLFLT *) 0 ;
15563 PLFLT *arg2 = (PLFLT *) 0 ;
15564 PLINT arg3 ;
15565 PLINT arg4 ;
15566 PLFLT arg5 ;
15567 PLFLT arg6 ;
15568 PLFLT arg7 ;
15569 PLFLT arg8 ;
15570 PLINT arg9 ;
15571 PLINT arg10 ;
15572 PLINT arg11 ;
15573 PLFLT arg12 ;
15574 PLFLT arg13 ;
15575 PLINT arg14 ;
15576 PLFLT arg15 ;
15577 PLINT arg16 ;
15578 PLINT *arg17 = (PLINT *) 0 ;
15579 char **arg18 = (char **) 0 ;
15580 PLINT arg19 ;
15581 char **arg20 = (char **) 0 ;
15582 PLFLT *arg21 = (PLFLT *) 0 ;
15583 PLINT *arg22 = (PLINT *) 0 ;
15584 PLINT *arg23 = (PLINT *) 0 ;
15585 PLFLT *arg24 = (PLFLT *) 0 ;
15586 PLFLT temp1 ;
15587 int res1 = SWIG_TMPOBJ ;
15588 PLFLT temp2 ;
15589 int res2 = SWIG_TMPOBJ ;
15590 int val3 ;
15591 int ecode3 = 0 ;
15592 int val4 ;
15593 int ecode4 = 0 ;
15594 double val5 ;
15595 int ecode5 = 0 ;
15596 double val6 ;
15597 int ecode6 = 0 ;
15598 double val7 ;
15599 int ecode7 = 0 ;
15600 double val8 ;
15601 int ecode8 = 0 ;
15602 int val9 ;
15603 int ecode9 = 0 ;
15604 int val10 ;
15605 int ecode10 = 0 ;
15606 int val11 ;
15607 int ecode11 = 0 ;
15608 double val12 ;
15609 int ecode12 = 0 ;
15610 double val13 ;
15611 int ecode13 = 0 ;
15612 int val14 ;
15613 int ecode14 = 0 ;
15614 double val15 ;
15615 int ecode15 = 0 ;
15616 Matrix temp16 ;
15617 Matrix temp21 ;
15618 Matrix temp22 ;
15619 Matrix temp23 ;
15620 Matrix temp24 ;
15621 octave_value_list _out;
15622 octave_value_list *_outp=&_out;
15623 octave_value _outv;
15624
15625 try {
15626 arg1 = &temp1;
15627 arg2 = &temp2;
15628 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15629 SWIG_fail;
15630 }
15631 ecode3 = SWIG_AsVal_int(args(0), &val3);
15632 if (!SWIG_IsOK(ecode3)) {
15633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15634 }
15635 arg3 = static_cast< PLINT >(val3);
15636 ecode4 = SWIG_AsVal_int(args(1), &val4);
15637 if (!SWIG_IsOK(ecode4)) {
15638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15639 }
15640 arg4 = static_cast< PLINT >(val4);
15641 ecode5 = SWIG_AsVal_double(args(2), &val5);
15642 if (!SWIG_IsOK(ecode5)) {
15643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15644 }
15645 arg5 = static_cast< PLFLT >(val5);
15646 ecode6 = SWIG_AsVal_double(args(3), &val6);
15647 if (!SWIG_IsOK(ecode6)) {
15648 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15649 }
15650 arg6 = static_cast< PLFLT >(val6);
15651 ecode7 = SWIG_AsVal_double(args(4), &val7);
15652 if (!SWIG_IsOK(ecode7)) {
15653 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15654 }
15655 arg7 = static_cast< PLFLT >(val7);
15656 ecode8 = SWIG_AsVal_double(args(5), &val8);
15657 if (!SWIG_IsOK(ecode8)) {
15658 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15659 }
15660 arg8 = static_cast< PLFLT >(val8);
15661 ecode9 = SWIG_AsVal_int(args(6), &val9);
15662 if (!SWIG_IsOK(ecode9)) {
15663 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15664 }
15665 arg9 = static_cast< PLINT >(val9);
15666 ecode10 = SWIG_AsVal_int(args(7), &val10);
15667 if (!SWIG_IsOK(ecode10)) {
15668 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15669 }
15670 arg10 = static_cast< PLINT >(val10);
15671 ecode11 = SWIG_AsVal_int(args(8), &val11);
15672 if (!SWIG_IsOK(ecode11)) {
15673 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15674 }
15675 arg11 = static_cast< PLINT >(val11);
15676 ecode12 = SWIG_AsVal_double(args(9), &val12);
15677 if (!SWIG_IsOK(ecode12)) {
15678 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15679 }
15680 arg12 = static_cast< PLFLT >(val12);
15681 ecode13 = SWIG_AsVal_double(args(10), &val13);
15682 if (!SWIG_IsOK(ecode13)) {
15683 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15684 }
15685 arg13 = static_cast< PLFLT >(val13);
15686 ecode14 = SWIG_AsVal_int(args(11), &val14);
15687 if (!SWIG_IsOK(ecode14)) {
15688 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15689 }
15690 arg14 = static_cast< PLINT >(val14);
15691 ecode15 = SWIG_AsVal_double(args(12), &val15);
15692 if (!SWIG_IsOK(ecode15)) {
15693 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15694 }
15695 arg15 = static_cast< PLFLT >(val15);
15696 {
15697 if ( _n_dims( args(13) ) > 1 )
15698 {
15699 error( "argument must be a scalar or vector" ); SWIG_fail;
15700 }
15701 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15702 arg17 = new PLINT[Alen];
15703 temp16 = args(13).matrix_value();
15704 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15705 }
15706 {
15707 charMatrix temp_matrix;
15708 Cell temp_cell;
15709 char *tmp_cstring;
15710 std::string str;
15711 size_t max_length = 0, non_blank_length;
15712 int i, ifcell;
15713 if ( _n_dims( args(14) ) > 2 )
15714 {
15715 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15716 }
15717#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15718 if ( !args(14).isempty() )
15719#else
15720 if ( !args(14).is_empty() )
15721#endif
15722 {
15723 if ( _dim( args(14), 0 ) != Alen )
15724 {
15725 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15726 }
15727 arg18 = new char*[Alen];
15728#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15729 ifcell = args(14).iscell();
15730#else
15731 ifcell = args(14).is_cell();
15732#endif
15733 if ( ifcell )
15734 {
15735 temp_cell = args(14).cell_value();
15736 }
15737 else
15738 {
15739 temp_matrix = args(14).char_matrix_value();
15740 // Allow one extra space for null termination.
15741 max_length = _dim( args(14), 1 ) + 1;
15742 }
15743
15744 for ( i = 0; i < Alen; i++ )
15745 {
15746 // Must copy string to "permanent" location because the string
15747 // location corresponding to tmp_cstring gets
15748 // overwritten for each iteration of loop.
15749 if ( ifcell )
15750 {
15751 if ( temp_cell.elem( i ).is_string() )
15752 {
15753 str = temp_cell.elem( i ).string_value();
15754 // leave room for null termination.
15755 max_length = str.size() + 1;
15756 tmp_cstring = (char *) str.c_str();
15757 }
15758 else
15759 {
15760 // Use null string if user attempts to pass a cell array
15761 // with a non-string element (likely an empty element
15762 // since that should be allowed by the PLplot interface
15763 // if that element is going to be unused).
15764 // leave room for null termination.
15765 max_length = 1;
15766 tmp_cstring = (char *) "";
15767 }
15768 }
15769 else
15770 {
15771 str = temp_matrix.row_as_string( i );
15772 tmp_cstring = (char *) str.c_str();
15773 }
15774 arg18[i] = new char[max_length];
15775 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15776 arg18[i][max_length - 1] = '\0';
15777 // All the trailing blank crapola should not be needed for
15778 // string cell arrays.
15779 if ( !ifcell )
15780 {
15781 // remove trailing-blank padding that is used by the
15782 // charMatrix class to insure all strings in a given
15783 // charMatrix instance have the same length.
15784 // This transformation also removes legitimate trailing
15785 // blanks but there is nothing we can do about that
15786 // for the charMatrix class.
15787
15788 // Look for trailing nulls first (just in case, although that
15789 // shouldn't happen if charMatrix implemented as documented)
15790 // before looking for trailing blanks.
15791 non_blank_length = max_length - 2;
15792 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15793 {
15794 non_blank_length--;
15795 }
15796 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15797 {
15798 non_blank_length--;
15799 }
15800 arg18[i][non_blank_length + 1] = '\0';
15801 }
15802 }
15803 }
15804 else
15805 {
15806 arg18 = NULL;
15807 }
15808 }
15809 {
15810 charMatrix temp_matrix;
15811 Cell temp_cell;
15812 char *tmp_cstring;
15813 std::string str;
15814 size_t max_length = 0, non_blank_length;
15815 int i, ifcell;
15816 if ( _n_dims( args(15) ) > 2 )
15817 {
15818 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15819 }
15820#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15821 if ( !args(15).isempty() )
15822#else
15823 if ( !args(15).is_empty() )
15824#endif
15825 {
15826 Alen = _dim( args(15), 0 );
15827 arg19 = Alen;
15828 arg20 = new char*[Alen];
15829#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15830 ifcell = args(15).iscell();
15831#else
15832 ifcell = args(15).is_cell();
15833#endif
15834 if ( ifcell )
15835 {
15836 temp_cell = args(15).cell_value();
15837 }
15838 else
15839 {
15840 temp_matrix = args(15).char_matrix_value();
15841 // Allow one extra space for null termination.
15842 max_length = _dim( args(15), 1 ) + 1;
15843 }
15844
15845 for ( i = 0; i < Alen; i++ )
15846 {
15847 // Must copy string to "permanent" location because the string
15848 // location corresponding to tmp_cstring gets
15849 // overwritten for each iteration of loop.
15850 if ( ifcell )
15851 {
15852 if ( temp_cell.elem( i ).is_string() )
15853 {
15854 str = temp_cell.elem( i ).string_value();
15855 // leave room for null termination.
15856 max_length = str.size() + 1;
15857 tmp_cstring = (char *) str.c_str();
15858 }
15859 else
15860 {
15861 // Use null string if user attempts to pass a cell array
15862 // with a non-string element (likely an empty element
15863 // since that should be allowed by the PLplot interface
15864 // if that element is going to be unused).
15865 // leave room for null termination.
15866 max_length = 1;
15867 tmp_cstring = (char *) "";
15868 }
15869 }
15870 else
15871 {
15872 str = temp_matrix.row_as_string( i );
15873 tmp_cstring = (char *) str.c_str();
15874 }
15875 arg20[i] = new char[max_length];
15876 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15877 arg20[i][max_length - 1] = '\0';
15878 // All the trailing blank crapola should not be needed for
15879 // string cell arrays.
15880 if ( !ifcell )
15881 {
15882 // remove trailing-blank padding that is used by the
15883 // charMatrix class to insure all strings in a given
15884 // charMatrix instance have the same length.
15885 // This transformation also removes legitimate trailing
15886 // blanks but there is nothing we can do about that
15887 // for the charMatrix class.
15888
15889 // Look for trailing nulls first (just in case, although that
15890 // shouldn't happen if charMatrix implemented as documented)
15891 // before looking for trailing blanks.
15892 non_blank_length = max_length - 2;
15893 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15894 {
15895 non_blank_length--;
15896 }
15897 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15898 {
15899 non_blank_length--;
15900 }
15901 arg20[i][non_blank_length + 1] = '\0';
15902 }
15903 }
15904 }
15905 else
15906 {
15907 arg19 = 0;
15908 arg20 = NULL;
15909 }
15910 }
15911 {
15912 if ( _n_dims( args(16) ) > 1 )
15913 {
15914 error( "argument must be a scalar or vector" ); SWIG_fail;
15915 }
15916 if ( _dim( args(16), 0 ) != Alen )
15917 {
15918 error( "argument vectors must be same length" ); SWIG_fail;
15919 }
15920 temp21 = args(16).matrix_value();
15921 arg21 = &temp21( 0, 0 );
15922 }
15923 {
15924 if ( _n_dims( args(17) ) > 1 )
15925 {
15926 error( "argument must be a scalar or vector" ); SWIG_fail;
15927 }
15928 if ( _dim( args(17), 0 ) != Alen )
15929 {
15930 error( "argument vectors must be same length" ); SWIG_fail;
15931 }
15932 temp22 = args(17).matrix_value();
15933 arg22 = new PLINT[Alen];
15934 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15935 }
15936 {
15937 int i;
15938 if ( _n_dims( args(18) ) > 1 )
15939 {
15940 error( "argument must be a scalar or vector" ); SWIG_fail;
15941 }
15942 if ( _dim( args(18), 0 ) != Alen )
15943 {
15944 error( "argument vectors must be same length" ); SWIG_fail;
15945 }
15946 Xlen = Alen;
15947 temp23 = args(18).matrix_value();
15948 arg23 = new PLINT[Alen];
15949 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15950 Ylen = -1;
15951 for ( i = 0; i < Xlen; i++ )
15952 if ( arg23[i] > Ylen )
15953 Ylen = arg23[i];
15954 }
15955 {
15956 if ( _n_dims( args(19) ) > 2 )
15957 {
15958 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15959 }
15960 if ( _dim( args(19), 0 ) != Xlen )
15961 {
15962 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15963 }
15964 if ( _dim( args(19), 1 ) != Ylen )
15965 {
15966 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15967 }
15968 temp24 = args(19).matrix_value();
15969 arg24 = &temp24( 0, 0 );
15970 }
15971 my_plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const *)arg24);
15972 _outv = octave_value();
15973 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15974 if (SWIG_IsTmpObj(res1)) {
15975 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15976 } else {
15977 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15978 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15979 }
15980 if (SWIG_IsTmpObj(res2)) {
15981 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15982 } else {
15983 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15984 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15985 }
15986 {
15987 delete [] arg17;
15988 }
15989 {
15990 int i;
15991 if ( arg18 != NULL )
15992 {
15993 for ( i = 0; i < Alen; i++ )
15994 {
15995 delete[] arg18[i];
15996 }
15997 delete[] arg18;
15998 }
15999 }
16000 {
16001 int i;
16002 if ( arg20 != NULL )
16003 {
16004 for ( i = 0; i < Alen; i++ )
16005 {
16006 delete[] arg20[i];
16007 }
16008 delete[] arg20;
16009 }
16010 }
16011 {
16012
16013 }
16014 {
16015 delete [] arg22;
16016 }
16017 {
16018 delete [] arg23;
16019 }
16020 {
16021
16022 }
16023 return _out;
16024 fail:
16025 {
16026 delete [] arg17;
16027 }
16028 {
16029 int i;
16030 if ( arg18 != NULL )
16031 {
16032 for ( i = 0; i < Alen; i++ )
16033 {
16034 delete[] arg18[i];
16035 }
16036 delete[] arg18;
16037 }
16038 }
16039 {
16040 int i;
16041 if ( arg20 != NULL )
16042 {
16043 for ( i = 0; i < Alen; i++ )
16044 {
16045 delete[] arg20[i];
16046 }
16047 delete[] arg20;
16048 }
16049 }
16050 {
16051
16052 }
16053 {
16054 delete [] arg22;
16055 }
16056 {
16057 delete [] arg23;
16058 }
16059 {
16060
16061 }
16062 return octave_value_list();
16063 }
16064 catch(...) {
16065 {
16066 delete [] arg17;
16067 }
16068 {
16069 int i;
16070 if ( arg18 != NULL )
16071 {
16072 for ( i = 0; i < Alen; i++ )
16073 {
16074 delete[] arg18[i];
16075 }
16076 delete[] arg18;
16077 }
16078 }
16079 {
16080 int i;
16081 if ( arg20 != NULL )
16082 {
16083 for ( i = 0; i < Alen; i++ )
16084 {
16085 delete[] arg20[i];
16086 }
16087 delete[] arg20;
16088 }
16089 }
16090 {
16091
16092 }
16093 {
16094 delete [] arg22;
16095 }
16096 {
16097 delete [] arg23;
16098 }
16099 {
16100
16101 }
16102 throw;
16103 }
16104}
16105
16106
16107SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16108 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16109 int arg2 ;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 int val2 ;
16113 int ecode2 = 0 ;
16114 octave_value_list _out;
16115 octave_value_list *_outp=&_out;
16116 octave_value _outv;
16117
16118 try {
16119 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16120 SWIG_fail;
16121 }
16122 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16125 }
16126 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16127 ecode2 = SWIG_AsVal_int(args(1), &val2);
16128 if (!SWIG_IsOK(ecode2)) {
16129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16130 }
16131 arg2 = static_cast< int >(val2);
16132 if (arg1) (arg1)->type = arg2;
16133 _outv = octave_value();
16134 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16135 return _out;
16136 fail:
16137 return octave_value_list();
16138 }
16139 catch(...) {
16140 throw;
16141 }
16142}
16143
16144
16145SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16146 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16147 void *argp1 = 0 ;
16148 int res1 = 0 ;
16149 octave_value_list _out;
16150 octave_value_list *_outp=&_out;
16151 octave_value _outv;
16152 int result;
16153
16154 try {
16155 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16156 SWIG_fail;
16157 }
16158 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16161 }
16162 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16163 result = (int) ((arg1)->type);
16164 _outv = SWIG_From_int(static_cast< int >(result));
16165 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16166 return _out;
16167 fail:
16168 return octave_value_list();
16169 }
16170 catch(...) {
16171 throw;
16172 }
16173}
16174
16175
16176SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16177 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16178 unsigned int arg2 ;
16179 void *argp1 = 0 ;
16180 int res1 = 0 ;
16181 unsigned int val2 ;
16182 int ecode2 = 0 ;
16183 octave_value_list _out;
16184 octave_value_list *_outp=&_out;
16185 octave_value _outv;
16186
16187 try {
16188 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16189 SWIG_fail;
16190 }
16191 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16192 if (!SWIG_IsOK(res1)) {
16193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16194 }
16195 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16196 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16197 if (!SWIG_IsOK(ecode2)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16199 }
16200 arg2 = static_cast< unsigned int >(val2);
16201 if (arg1) (arg1)->state = arg2;
16202 _outv = octave_value();
16203 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16204 return _out;
16205 fail:
16206 return octave_value_list();
16207 }
16208 catch(...) {
16209 throw;
16210 }
16211}
16212
16213
16214SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16215 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16216 void *argp1 = 0 ;
16217 int res1 = 0 ;
16218 octave_value_list _out;
16219 octave_value_list *_outp=&_out;
16220 octave_value _outv;
16221 unsigned int result;
16222
16223 try {
16224 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16225 SWIG_fail;
16226 }
16227 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16228 if (!SWIG_IsOK(res1)) {
16229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16230 }
16231 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16232 result = (unsigned int) ((arg1)->state);
16233 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16234 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16235 return _out;
16236 fail:
16237 return octave_value_list();
16238 }
16239 catch(...) {
16240 throw;
16241 }
16242}
16243
16244
16245SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16246 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16247 unsigned int arg2 ;
16248 void *argp1 = 0 ;
16249 int res1 = 0 ;
16250 unsigned int val2 ;
16251 int ecode2 = 0 ;
16252 octave_value_list _out;
16253 octave_value_list *_outp=&_out;
16254 octave_value _outv;
16255
16256 try {
16257 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16258 SWIG_fail;
16259 }
16260 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16261 if (!SWIG_IsOK(res1)) {
16262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16263 }
16264 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16265 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16266 if (!SWIG_IsOK(ecode2)) {
16267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16268 }
16269 arg2 = static_cast< unsigned int >(val2);
16270 if (arg1) (arg1)->keysym = arg2;
16271 _outv = octave_value();
16272 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16273 return _out;
16274 fail:
16275 return octave_value_list();
16276 }
16277 catch(...) {
16278 throw;
16279 }
16280}
16281
16282
16283SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16284 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 octave_value_list _out;
16288 octave_value_list *_outp=&_out;
16289 octave_value _outv;
16290 unsigned int result;
16291
16292 try {
16293 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16294 SWIG_fail;
16295 }
16296 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16299 }
16300 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16301 result = (unsigned int) ((arg1)->keysym);
16302 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16303 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16304 return _out;
16305 fail:
16306 return octave_value_list();
16307 }
16308 catch(...) {
16309 throw;
16310 }
16311}
16312
16313
16314SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16315 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16316 unsigned int arg2 ;
16317 void *argp1 = 0 ;
16318 int res1 = 0 ;
16319 unsigned int val2 ;
16320 int ecode2 = 0 ;
16321 octave_value_list _out;
16322 octave_value_list *_outp=&_out;
16323 octave_value _outv;
16324
16325 try {
16326 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16327 SWIG_fail;
16328 }
16329 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16332 }
16333 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16334 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16335 if (!SWIG_IsOK(ecode2)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16337 }
16338 arg2 = static_cast< unsigned int >(val2);
16339 if (arg1) (arg1)->button = arg2;
16340 _outv = octave_value();
16341 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16342 return _out;
16343 fail:
16344 return octave_value_list();
16345 }
16346 catch(...) {
16347 throw;
16348 }
16349}
16350
16351
16352SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16353 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16354 void *argp1 = 0 ;
16355 int res1 = 0 ;
16356 octave_value_list _out;
16357 octave_value_list *_outp=&_out;
16358 octave_value _outv;
16359 unsigned int result;
16360
16361 try {
16362 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16363 SWIG_fail;
16364 }
16365 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16366 if (!SWIG_IsOK(res1)) {
16367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16368 }
16369 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16370 result = (unsigned int) ((arg1)->button);
16371 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16373 return _out;
16374 fail:
16375 return octave_value_list();
16376 }
16377 catch(...) {
16378 throw;
16379 }
16380}
16381
16382
16383SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16384 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16385 PLINT arg2 ;
16386 void *argp1 = 0 ;
16387 int res1 = 0 ;
16388 int val2 ;
16389 int ecode2 = 0 ;
16390 octave_value_list _out;
16391 octave_value_list *_outp=&_out;
16392 octave_value _outv;
16393
16394 try {
16395 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16396 SWIG_fail;
16397 }
16398 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16399 if (!SWIG_IsOK(res1)) {
16400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16401 }
16402 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16403 ecode2 = SWIG_AsVal_int(args(1), &val2);
16404 if (!SWIG_IsOK(ecode2)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16406 }
16407 arg2 = static_cast< PLINT >(val2);
16408 if (arg1) (arg1)->subwindow = arg2;
16409 _outv = octave_value();
16410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16411 return _out;
16412 fail:
16413 return octave_value_list();
16414 }
16415 catch(...) {
16416 throw;
16417 }
16418}
16419
16420
16421SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16422 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16423 void *argp1 = 0 ;
16424 int res1 = 0 ;
16425 octave_value_list _out;
16426 octave_value_list *_outp=&_out;
16427 octave_value _outv;
16428 PLINT result;
16429
16430 try {
16431 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16432 SWIG_fail;
16433 }
16434 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16435 if (!SWIG_IsOK(res1)) {
16436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16437 }
16438 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16439 result = (PLINT) ((arg1)->subwindow);
16440 _outv = SWIG_From_int(static_cast< int >(result));
16441 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16442 return _out;
16443 fail:
16444 return octave_value_list();
16445 }
16446 catch(...) {
16447 throw;
16448 }
16449}
16450
16451
16452SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16453 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16454 char *arg2 ;
16455 void *argp1 = 0 ;
16456 int res1 = 0 ;
16457 char temp2[16] ;
16458 int res2 ;
16459 octave_value_list _out;
16460 octave_value_list *_outp=&_out;
16461 octave_value _outv;
16462
16463 try {
16464 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16465 SWIG_fail;
16466 }
16467 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16468 if (!SWIG_IsOK(res1)) {
16469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16470 }
16471 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16472 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16473 if (!SWIG_IsOK(res2)) {
16474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16475 }
16476 arg2 = reinterpret_cast< char * >(temp2);
16477 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16478 else memset(arg1->string,0,16*sizeof(char));
16479 _outv = octave_value();
16480 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16481 return _out;
16482 fail:
16483 return octave_value_list();
16484 }
16485 catch(...) {
16486 throw;
16487 }
16488}
16489
16490
16491SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16492 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16493 void *argp1 = 0 ;
16494 int res1 = 0 ;
16495 octave_value_list _out;
16496 octave_value_list *_outp=&_out;
16497 octave_value _outv;
16498 char *result = 0 ;
16499
16500 try {
16501 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16502 SWIG_fail;
16503 }
16504 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16505 if (!SWIG_IsOK(res1)) {
16506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16507 }
16508 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16509 result = (char *)(char *) ((arg1)->string);
16510 {
16511 size_t size = SWIG_strnlen(result, 16);
16512
16513
16514
16515 _outv = SWIG_FromCharPtrAndSize(result, size);
16516 }
16517 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16518 return _out;
16519 fail:
16520 return octave_value_list();
16521 }
16522 catch(...) {
16523 throw;
16524 }
16525}
16526
16527
16528SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16529 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16530 int arg2 ;
16531 void *argp1 = 0 ;
16532 int res1 = 0 ;
16533 int val2 ;
16534 int ecode2 = 0 ;
16535 octave_value_list _out;
16536 octave_value_list *_outp=&_out;
16537 octave_value _outv;
16538
16539 try {
16540 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16541 SWIG_fail;
16542 }
16543 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16544 if (!SWIG_IsOK(res1)) {
16545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16546 }
16547 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16548 ecode2 = SWIG_AsVal_int(args(1), &val2);
16549 if (!SWIG_IsOK(ecode2)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16551 }
16552 arg2 = static_cast< int >(val2);
16553 if (arg1) (arg1)->pX = arg2;
16554 _outv = octave_value();
16555 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16556 return _out;
16557 fail:
16558 return octave_value_list();
16559 }
16560 catch(...) {
16561 throw;
16562 }
16563}
16564
16565
16566SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16567 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16568 void *argp1 = 0 ;
16569 int res1 = 0 ;
16570 octave_value_list _out;
16571 octave_value_list *_outp=&_out;
16572 octave_value _outv;
16573 int result;
16574
16575 try {
16576 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16577 SWIG_fail;
16578 }
16579 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16580 if (!SWIG_IsOK(res1)) {
16581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16582 }
16583 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16584 result = (int) ((arg1)->pX);
16585 _outv = SWIG_From_int(static_cast< int >(result));
16586 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16587 return _out;
16588 fail:
16589 return octave_value_list();
16590 }
16591 catch(...) {
16592 throw;
16593 }
16594}
16595
16596
16597SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16598 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16599 int arg2 ;
16600 void *argp1 = 0 ;
16601 int res1 = 0 ;
16602 int val2 ;
16603 int ecode2 = 0 ;
16604 octave_value_list _out;
16605 octave_value_list *_outp=&_out;
16606 octave_value _outv;
16607
16608 try {
16609 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16610 SWIG_fail;
16611 }
16612 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16613 if (!SWIG_IsOK(res1)) {
16614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16615 }
16616 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16617 ecode2 = SWIG_AsVal_int(args(1), &val2);
16618 if (!SWIG_IsOK(ecode2)) {
16619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16620 }
16621 arg2 = static_cast< int >(val2);
16622 if (arg1) (arg1)->pY = arg2;
16623 _outv = octave_value();
16624 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16625 return _out;
16626 fail:
16627 return octave_value_list();
16628 }
16629 catch(...) {
16630 throw;
16631 }
16632}
16633
16634
16635SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16636 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16637 void *argp1 = 0 ;
16638 int res1 = 0 ;
16639 octave_value_list _out;
16640 octave_value_list *_outp=&_out;
16641 octave_value _outv;
16642 int result;
16643
16644 try {
16645 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16646 SWIG_fail;
16647 }
16648 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16649 if (!SWIG_IsOK(res1)) {
16650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16651 }
16652 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16653 result = (int) ((arg1)->pY);
16654 _outv = SWIG_From_int(static_cast< int >(result));
16655 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16656 return _out;
16657 fail:
16658 return octave_value_list();
16659 }
16660 catch(...) {
16661 throw;
16662 }
16663}
16664
16665
16666SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16667 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16668 PLFLT arg2 ;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 double val2 ;
16672 int ecode2 = 0 ;
16673 octave_value_list _out;
16674 octave_value_list *_outp=&_out;
16675 octave_value _outv;
16676
16677 try {
16678 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16679 SWIG_fail;
16680 }
16681 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16684 }
16685 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16686 ecode2 = SWIG_AsVal_double(args(1), &val2);
16687 if (!SWIG_IsOK(ecode2)) {
16688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16689 }
16690 arg2 = static_cast< PLFLT >(val2);
16691 if (arg1) (arg1)->dX = arg2;
16692 _outv = octave_value();
16693 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16694 return _out;
16695 fail:
16696 return octave_value_list();
16697 }
16698 catch(...) {
16699 throw;
16700 }
16701}
16702
16703
16704SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16705 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 octave_value_list _out;
16709 octave_value_list *_outp=&_out;
16710 octave_value _outv;
16711 PLFLT result;
16712
16713 try {
16714 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16715 SWIG_fail;
16716 }
16717 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16718 if (!SWIG_IsOK(res1)) {
16719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16720 }
16721 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16722 result = (PLFLT) ((arg1)->dX);
16723 _outv = SWIG_From_double(static_cast< double >(result));
16724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16725 return _out;
16726 fail:
16727 return octave_value_list();
16728 }
16729 catch(...) {
16730 throw;
16731 }
16732}
16733
16734
16735SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16736 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16737 PLFLT arg2 ;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 double val2 ;
16741 int ecode2 = 0 ;
16742 octave_value_list _out;
16743 octave_value_list *_outp=&_out;
16744 octave_value _outv;
16745
16746 try {
16747 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16748 SWIG_fail;
16749 }
16750 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16751 if (!SWIG_IsOK(res1)) {
16752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16753 }
16754 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16755 ecode2 = SWIG_AsVal_double(args(1), &val2);
16756 if (!SWIG_IsOK(ecode2)) {
16757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16758 }
16759 arg2 = static_cast< PLFLT >(val2);
16760 if (arg1) (arg1)->dY = arg2;
16761 _outv = octave_value();
16762 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16763 return _out;
16764 fail:
16765 return octave_value_list();
16766 }
16767 catch(...) {
16768 throw;
16769 }
16770}
16771
16772
16773SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16774 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16775 void *argp1 = 0 ;
16776 int res1 = 0 ;
16777 octave_value_list _out;
16778 octave_value_list *_outp=&_out;
16779 octave_value _outv;
16780 PLFLT result;
16781
16782 try {
16783 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16784 SWIG_fail;
16785 }
16786 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16787 if (!SWIG_IsOK(res1)) {
16788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16789 }
16790 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16791 result = (PLFLT) ((arg1)->dY);
16792 _outv = SWIG_From_double(static_cast< double >(result));
16793 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16794 return _out;
16795 fail:
16796 return octave_value_list();
16797 }
16798 catch(...) {
16799 throw;
16800 }
16801}
16802
16803
16804SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16805 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16806 PLFLT arg2 ;
16807 void *argp1 = 0 ;
16808 int res1 = 0 ;
16809 double val2 ;
16810 int ecode2 = 0 ;
16811 octave_value_list _out;
16812 octave_value_list *_outp=&_out;
16813 octave_value _outv;
16814
16815 try {
16816 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16817 SWIG_fail;
16818 }
16819 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16822 }
16823 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16824 ecode2 = SWIG_AsVal_double(args(1), &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16827 }
16828 arg2 = static_cast< PLFLT >(val2);
16829 if (arg1) (arg1)->wX = arg2;
16830 _outv = octave_value();
16831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16832 return _out;
16833 fail:
16834 return octave_value_list();
16835 }
16836 catch(...) {
16837 throw;
16838 }
16839}
16840
16841
16842SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16843 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 octave_value_list _out;
16847 octave_value_list *_outp=&_out;
16848 octave_value _outv;
16849 PLFLT result;
16850
16851 try {
16852 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16853 SWIG_fail;
16854 }
16855 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16856 if (!SWIG_IsOK(res1)) {
16857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16858 }
16859 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16860 result = (PLFLT) ((arg1)->wX);
16861 _outv = SWIG_From_double(static_cast< double >(result));
16862 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16863 return _out;
16864 fail:
16865 return octave_value_list();
16866 }
16867 catch(...) {
16868 throw;
16869 }
16870}
16871
16872
16873SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16874 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16875 PLFLT arg2 ;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 double val2 ;
16879 int ecode2 = 0 ;
16880 octave_value_list _out;
16881 octave_value_list *_outp=&_out;
16882 octave_value _outv;
16883
16884 try {
16885 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16886 SWIG_fail;
16887 }
16888 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16889 if (!SWIG_IsOK(res1)) {
16890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16891 }
16892 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16893 ecode2 = SWIG_AsVal_double(args(1), &val2);
16894 if (!SWIG_IsOK(ecode2)) {
16895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16896 }
16897 arg2 = static_cast< PLFLT >(val2);
16898 if (arg1) (arg1)->wY = arg2;
16899 _outv = octave_value();
16900 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16901 return _out;
16902 fail:
16903 return octave_value_list();
16904 }
16905 catch(...) {
16906 throw;
16907 }
16908}
16909
16910
16911SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16912 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 octave_value_list _out;
16916 octave_value_list *_outp=&_out;
16917 octave_value _outv;
16918 PLFLT result;
16919
16920 try {
16921 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16922 SWIG_fail;
16923 }
16924 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16925 if (!SWIG_IsOK(res1)) {
16926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16927 }
16928 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16929 result = (PLFLT) ((arg1)->wY);
16930 _outv = SWIG_From_double(static_cast< double >(result));
16931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16932 return _out;
16933 fail:
16934 return octave_value_list();
16935 }
16936 catch(...) {
16937 throw;
16938 }
16939}
16940
16941
16942SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16943 octave_value_list _out;
16944 octave_value_list *_outp=&_out;
16945 octave_value _outv;
16946 PLGraphicsIn *result = 0 ;
16947
16948 try {
16949 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16950 SWIG_fail;
16951 }
16952 result = (PLGraphicsIn *)new PLGraphicsIn();
16954 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16955 return _out;
16956 fail:
16957 return octave_value_list();
16958 }
16959 catch(...) {
16960 throw;
16961 }
16962}
16963
16964
16965SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
16966 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16967 void *argp1 = 0 ;
16968 int res1 = 0 ;
16969 octave_value_list _out;
16970 octave_value_list *_outp=&_out;
16971 octave_value _outv;
16972
16973 try {
16974 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16975 SWIG_fail;
16976 }
16977 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16980 }
16981 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16982 delete arg1;
16983 _outv = octave_value();
16984 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16985 return _out;
16986 fail:
16987 return octave_value_list();
16988 }
16989 catch(...) {
16990 throw;
16991 }
16992}
16993
16994
17008{0,0,0,0,0,0}
17009};
17010static const char *swig_PLGraphicsIn_base_names[] = {0};
17013
17015 PLINT arg1 ;
17016 PLINT arg2 ;
17017 int val1 ;
17018 int ecode1 = 0 ;
17019 int val2 ;
17020 int ecode2 = 0 ;
17021 octave_value_list _out;
17022 octave_value_list *_outp=&_out;
17023 octave_value _outv;
17024
17025 try {
17026 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17027 SWIG_fail;
17028 }
17029 ecode1 = SWIG_AsVal_int(args(0), &val1);
17030 if (!SWIG_IsOK(ecode1)) {
17031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17032 }
17033 arg1 = static_cast< PLINT >(val1);
17034 ecode2 = SWIG_AsVal_int(args(1), &val2);
17035 if (!SWIG_IsOK(ecode2)) {
17036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17037 }
17038 arg2 = static_cast< PLINT >(val2);
17039 pl_setcontlabelformat(arg1,arg2);
17040 _outv = octave_value();
17041 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17042 return _out;
17043 fail:
17044 return octave_value_list();
17045 }
17046 catch(...) {
17047 throw;
17048 }
17049}
17050
17051
17053 PLFLT arg1 ;
17054 PLFLT arg2 ;
17055 PLFLT arg3 ;
17056 PLINT arg4 ;
17057 double val1 ;
17058 int ecode1 = 0 ;
17059 double val2 ;
17060 int ecode2 = 0 ;
17061 double val3 ;
17062 int ecode3 = 0 ;
17063 int val4 ;
17064 int ecode4 = 0 ;
17065 octave_value_list _out;
17066 octave_value_list *_outp=&_out;
17067 octave_value _outv;
17068
17069 try {
17070 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17071 SWIG_fail;
17072 }
17073 ecode1 = SWIG_AsVal_double(args(0), &val1);
17074 if (!SWIG_IsOK(ecode1)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17076 }
17077 arg1 = static_cast< PLFLT >(val1);
17078 ecode2 = SWIG_AsVal_double(args(1), &val2);
17079 if (!SWIG_IsOK(ecode2)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17081 }
17082 arg2 = static_cast< PLFLT >(val2);
17083 ecode3 = SWIG_AsVal_double(args(2), &val3);
17084 if (!SWIG_IsOK(ecode3)) {
17085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17086 }
17087 arg3 = static_cast< PLFLT >(val3);
17088 ecode4 = SWIG_AsVal_int(args(3), &val4);
17089 if (!SWIG_IsOK(ecode4)) {
17090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17091 }
17092 arg4 = static_cast< PLINT >(val4);
17093 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17094 _outv = octave_value();
17095 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17096 return _out;
17097 fail:
17098 return octave_value_list();
17099 }
17100 catch(...) {
17101 throw;
17102 }
17103}
17104
17105
17107 PLINT arg1 ;
17108 int val1 ;
17109 int ecode1 = 0 ;
17110 octave_value_list _out;
17111 octave_value_list *_outp=&_out;
17112 octave_value _outv;
17113
17114 try {
17115 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17116 SWIG_fail;
17117 }
17118 ecode1 = SWIG_AsVal_int(args(0), &val1);
17119 if (!SWIG_IsOK(ecode1)) {
17120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17121 }
17122 arg1 = static_cast< PLINT >(val1);
17123 pladv(arg1);
17124 _outv = octave_value();
17125 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17126 return _out;
17127 fail:
17128 return octave_value_list();
17129 }
17130 catch(...) {
17131 throw;
17132 }
17133}
17134
17135
17137 PLFLT arg1 ;
17138 PLFLT arg2 ;
17139 PLFLT arg3 ;
17140 PLFLT arg4 ;
17141 PLFLT arg5 ;
17142 PLFLT arg6 ;
17143 PLFLT arg7 ;
17144 PLBOOL arg8 ;
17145 double val1 ;
17146 int ecode1 = 0 ;
17147 double val2 ;
17148 int ecode2 = 0 ;
17149 double val3 ;
17150 int ecode3 = 0 ;
17151 double val4 ;
17152 int ecode4 = 0 ;
17153 double val5 ;
17154 int ecode5 = 0 ;
17155 double val6 ;
17156 int ecode6 = 0 ;
17157 double val7 ;
17158 int ecode7 = 0 ;
17159 int val8 ;
17160 int ecode8 = 0 ;
17161 octave_value_list _out;
17162 octave_value_list *_outp=&_out;
17163 octave_value _outv;
17164
17165 try {
17166 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17167 SWIG_fail;
17168 }
17169 ecode1 = SWIG_AsVal_double(args(0), &val1);
17170 if (!SWIG_IsOK(ecode1)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17172 }
17173 arg1 = static_cast< PLFLT >(val1);
17174 ecode2 = SWIG_AsVal_double(args(1), &val2);
17175 if (!SWIG_IsOK(ecode2)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17177 }
17178 arg2 = static_cast< PLFLT >(val2);
17179 ecode3 = SWIG_AsVal_double(args(2), &val3);
17180 if (!SWIG_IsOK(ecode3)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17182 }
17183 arg3 = static_cast< PLFLT >(val3);
17184 ecode4 = SWIG_AsVal_double(args(3), &val4);
17185 if (!SWIG_IsOK(ecode4)) {
17186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17187 }
17188 arg4 = static_cast< PLFLT >(val4);
17189 ecode5 = SWIG_AsVal_double(args(4), &val5);
17190 if (!SWIG_IsOK(ecode5)) {
17191 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17192 }
17193 arg5 = static_cast< PLFLT >(val5);
17194 ecode6 = SWIG_AsVal_double(args(5), &val6);
17195 if (!SWIG_IsOK(ecode6)) {
17196 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17197 }
17198 arg6 = static_cast< PLFLT >(val6);
17199 ecode7 = SWIG_AsVal_double(args(6), &val7);
17200 if (!SWIG_IsOK(ecode7)) {
17201 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17202 }
17203 arg7 = static_cast< PLFLT >(val7);
17204 ecode8 = SWIG_AsVal_int(args(7), &val8);
17205 if (!SWIG_IsOK(ecode8)) {
17206 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17207 }
17208 arg8 = static_cast< PLBOOL >(val8);
17209 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17210 _outv = octave_value();
17211 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17212 return _out;
17213 fail:
17214 return octave_value_list();
17215 }
17216 catch(...) {
17217 throw;
17218 }
17219}
17220
17221
17223 PLFLT arg1 ;
17224 PLFLT arg2 ;
17225 char *arg3 = (char *) 0 ;
17226 PLFLT arg4 ;
17227 PLINT arg5 ;
17228 char *arg6 = (char *) 0 ;
17229 PLFLT arg7 ;
17230 PLINT arg8 ;
17231 double val1 ;
17232 int ecode1 = 0 ;
17233 double val2 ;
17234 int ecode2 = 0 ;
17235 int res3 ;
17236 char *buf3 = 0 ;
17237 int alloc3 = 0 ;
17238 double val4 ;
17239 int ecode4 = 0 ;
17240 int val5 ;
17241 int ecode5 = 0 ;
17242 int res6 ;
17243 char *buf6 = 0 ;
17244 int alloc6 = 0 ;
17245 double val7 ;
17246 int ecode7 = 0 ;
17247 int val8 ;
17248 int ecode8 = 0 ;
17249 octave_value_list _out;
17250 octave_value_list *_outp=&_out;
17251 octave_value _outv;
17252
17253 try {
17254 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17255 SWIG_fail;
17256 }
17257 ecode1 = SWIG_AsVal_double(args(0), &val1);
17258 if (!SWIG_IsOK(ecode1)) {
17259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17260 }
17261 arg1 = static_cast< PLFLT >(val1);
17262 ecode2 = SWIG_AsVal_double(args(1), &val2);
17263 if (!SWIG_IsOK(ecode2)) {
17264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17265 }
17266 arg2 = static_cast< PLFLT >(val2);
17267 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17268 if (!SWIG_IsOK(res3)) {
17269 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17270 }
17271 arg3 = reinterpret_cast< char * >(buf3);
17272 ecode4 = SWIG_AsVal_double(args(3), &val4);
17273 if (!SWIG_IsOK(ecode4)) {
17274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17275 }
17276 arg4 = static_cast< PLFLT >(val4);
17277 ecode5 = SWIG_AsVal_int(args(4), &val5);
17278 if (!SWIG_IsOK(ecode5)) {
17279 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17280 }
17281 arg5 = static_cast< PLINT >(val5);
17282 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17283 if (!SWIG_IsOK(res6)) {
17284 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17285 }
17286 arg6 = reinterpret_cast< char * >(buf6);
17287 ecode7 = SWIG_AsVal_double(args(6), &val7);
17288 if (!SWIG_IsOK(ecode7)) {
17289 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17290 }
17291 arg7 = static_cast< PLFLT >(val7);
17292 ecode8 = SWIG_AsVal_int(args(7), &val8);
17293 if (!SWIG_IsOK(ecode8)) {
17294 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17295 }
17296 arg8 = static_cast< PLINT >(val8);
17297 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17298 _outv = octave_value();
17299 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17300 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17301 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17302 return _out;
17303 fail:
17304 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17305 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17306 return octave_value_list();
17307 }
17308 catch(...) {
17309 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17310 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17311 throw;
17312 }
17313}
17314
17315
17317 PLINT arg1 ;
17318 PLFLT *arg2 = (PLFLT *) 0 ;
17319 PLFLT *arg3 = (PLFLT *) 0 ;
17320 PLINT arg4 ;
17321 Matrix temp1 ;
17322 Matrix temp3 ;
17323 int val4 ;
17324 int ecode4 = 0 ;
17325 octave_value_list _out;
17326 octave_value_list *_outp=&_out;
17327 octave_value _outv;
17328
17329 try {
17330 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17331 SWIG_fail;
17332 }
17333 {
17334 if ( _n_dims( args(0) ) > 1 )
17335 {
17336 error( "argument must be a scalar or vector" ); SWIG_fail;
17337 }
17338 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17339 temp1 = args(0).matrix_value();
17340 arg2 = &temp1( 0, 0 );
17341 }
17342 {
17343 if ( _n_dims( args(1) ) > 1 )
17344 {
17345 error( "argument must be a scalar or vector" ); SWIG_fail;
17346 }
17347 if ( _dim( args(1), 0 ) != Alen )
17348 {
17349 error( "argument vectors must be same length" ); SWIG_fail;
17350 }
17351 temp3 = args(1).matrix_value();
17352 arg3 = &temp3( 0, 0 );
17353 }
17354 ecode4 = SWIG_AsVal_int(args(2), &val4);
17355 if (!SWIG_IsOK(ecode4)) {
17356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17357 }
17358 arg4 = static_cast< PLINT >(val4);
17359 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17360 _outv = octave_value();
17361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17362 {
17363
17364 }
17365 {
17366
17367 }
17368 return _out;
17369 fail:
17370 {
17371
17372 }
17373 {
17374
17375 }
17376 return octave_value_list();
17377 }
17378 catch(...) {
17379 {
17380
17381 }
17382 {
17383
17384 }
17385 throw;
17386 }
17387}
17388
17389
17391 PLINT *arg1 = (PLINT *) 0 ;
17392 PLINT *arg2 = (PLINT *) 0 ;
17393 PLINT *arg3 = (PLINT *) 0 ;
17394 PLINT *arg4 = (PLINT *) 0 ;
17395 PLINT *arg5 = (PLINT *) 0 ;
17396 PLFLT *arg6 = (PLFLT *) 0 ;
17397 PLFLT arg7 ;
17398 PLINT temp1 ;
17399 int res1 = SWIG_TMPOBJ ;
17400 PLINT temp2 ;
17401 int res2 = SWIG_TMPOBJ ;
17402 PLINT temp3 ;
17403 int res3 = SWIG_TMPOBJ ;
17404 PLINT temp4 ;
17405 int res4 = SWIG_TMPOBJ ;
17406 PLINT temp5 ;
17407 int res5 = SWIG_TMPOBJ ;
17408 PLFLT temp6 ;
17409 int res6 = SWIG_TMPOBJ ;
17410 double val7 ;
17411 int ecode7 = 0 ;
17412 octave_value_list _out;
17413 octave_value_list *_outp=&_out;
17414 octave_value _outv;
17415
17416 try {
17417 arg1 = &temp1;
17418 arg2 = &temp2;
17419 arg3 = &temp3;
17420 arg4 = &temp4;
17421 arg5 = &temp5;
17422 arg6 = &temp6;
17423 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17424 SWIG_fail;
17425 }
17426 ecode7 = SWIG_AsVal_double(args(0), &val7);
17427 if (!SWIG_IsOK(ecode7)) {
17428 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17429 }
17430 arg7 = static_cast< PLFLT >(val7);
17431 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17432 _outv = octave_value();
17433 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17434 if (SWIG_IsTmpObj(res1)) {
17435 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17436 } else {
17437 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17438 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17439 }
17440 if (SWIG_IsTmpObj(res2)) {
17441 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17442 } else {
17443 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17444 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17445 }
17446 if (SWIG_IsTmpObj(res3)) {
17447 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17448 } else {
17449 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17450 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17451 }
17452 if (SWIG_IsTmpObj(res4)) {
17453 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17454 } else {
17455 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17456 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17457 }
17458 if (SWIG_IsTmpObj(res5)) {
17459 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17460 } else {
17461 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17462 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17463 }
17464 if (SWIG_IsTmpObj(res6)) {
17465 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17466 } else {
17467 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17468 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17469 }
17470 return _out;
17471 fail:
17472 return octave_value_list();
17473 }
17474 catch(...) {
17475 throw;
17476 }
17477}
17478
17479
17481 octave_value_list _out;
17482 octave_value_list *_outp=&_out;
17483 octave_value _outv;
17484
17485 try {
17486 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17487 SWIG_fail;
17488 }
17489 plbop();
17490 _outv = octave_value();
17491 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17492 return _out;
17493 fail:
17494 return octave_value_list();
17495 }
17496 catch(...) {
17497 throw;
17498 }
17499}
17500
17501
17503 char *arg1 = (char *) 0 ;
17504 PLFLT arg2 ;
17505 PLINT arg3 ;
17506 char *arg4 = (char *) 0 ;
17507 PLFLT arg5 ;
17508 PLINT arg6 ;
17509 int res1 ;
17510 char *buf1 = 0 ;
17511 int alloc1 = 0 ;
17512 double val2 ;
17513 int ecode2 = 0 ;
17514 int val3 ;
17515 int ecode3 = 0 ;
17516 int res4 ;
17517 char *buf4 = 0 ;
17518 int alloc4 = 0 ;
17519 double val5 ;
17520 int ecode5 = 0 ;
17521 int val6 ;
17522 int ecode6 = 0 ;
17523 octave_value_list _out;
17524 octave_value_list *_outp=&_out;
17525 octave_value _outv;
17526
17527 try {
17528 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17529 SWIG_fail;
17530 }
17531 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17532 if (!SWIG_IsOK(res1)) {
17533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17534 }
17535 arg1 = reinterpret_cast< char * >(buf1);
17536 ecode2 = SWIG_AsVal_double(args(1), &val2);
17537 if (!SWIG_IsOK(ecode2)) {
17538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17539 }
17540 arg2 = static_cast< PLFLT >(val2);
17541 ecode3 = SWIG_AsVal_int(args(2), &val3);
17542 if (!SWIG_IsOK(ecode3)) {
17543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17544 }
17545 arg3 = static_cast< PLINT >(val3);
17546 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17547 if (!SWIG_IsOK(res4)) {
17548 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17549 }
17550 arg4 = reinterpret_cast< char * >(buf4);
17551 ecode5 = SWIG_AsVal_double(args(4), &val5);
17552 if (!SWIG_IsOK(ecode5)) {
17553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17554 }
17555 arg5 = static_cast< PLFLT >(val5);
17556 ecode6 = SWIG_AsVal_int(args(5), &val6);
17557 if (!SWIG_IsOK(ecode6)) {
17558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17559 }
17560 arg6 = static_cast< PLINT >(val6);
17561 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17562 _outv = octave_value();
17563 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17564 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17565 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17566 return _out;
17567 fail:
17568 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17569 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17570 return octave_value_list();
17571 }
17572 catch(...) {
17573 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17574 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17575 throw;
17576 }
17577}
17578
17579
17581 char *arg1 = (char *) 0 ;
17582 char *arg2 = (char *) 0 ;
17583 PLFLT arg3 ;
17584 PLINT arg4 ;
17585 char *arg5 = (char *) 0 ;
17586 char *arg6 = (char *) 0 ;
17587 PLFLT arg7 ;
17588 PLINT arg8 ;
17589 char *arg9 = (char *) 0 ;
17590 char *arg10 = (char *) 0 ;
17591 PLFLT arg11 ;
17592 PLINT arg12 ;
17593 int res1 ;
17594 char *buf1 = 0 ;
17595 int alloc1 = 0 ;
17596 int res2 ;
17597 char *buf2 = 0 ;
17598 int alloc2 = 0 ;
17599 double val3 ;
17600 int ecode3 = 0 ;
17601 int val4 ;
17602 int ecode4 = 0 ;
17603 int res5 ;
17604 char *buf5 = 0 ;
17605 int alloc5 = 0 ;
17606 int res6 ;
17607 char *buf6 = 0 ;
17608 int alloc6 = 0 ;
17609 double val7 ;
17610 int ecode7 = 0 ;
17611 int val8 ;
17612 int ecode8 = 0 ;
17613 int res9 ;
17614 char *buf9 = 0 ;
17615 int alloc9 = 0 ;
17616 int res10 ;
17617 char *buf10 = 0 ;
17618 int alloc10 = 0 ;
17619 double val11 ;
17620 int ecode11 = 0 ;
17621 int val12 ;
17622 int ecode12 = 0 ;
17623 octave_value_list _out;
17624 octave_value_list *_outp=&_out;
17625 octave_value _outv;
17626
17627 try {
17628 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17629 SWIG_fail;
17630 }
17631 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17634 }
17635 arg1 = reinterpret_cast< char * >(buf1);
17636 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17637 if (!SWIG_IsOK(res2)) {
17638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17639 }
17640 arg2 = reinterpret_cast< char * >(buf2);
17641 ecode3 = SWIG_AsVal_double(args(2), &val3);
17642 if (!SWIG_IsOK(ecode3)) {
17643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17644 }
17645 arg3 = static_cast< PLFLT >(val3);
17646 ecode4 = SWIG_AsVal_int(args(3), &val4);
17647 if (!SWIG_IsOK(ecode4)) {
17648 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17649 }
17650 arg4 = static_cast< PLINT >(val4);
17651 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17652 if (!SWIG_IsOK(res5)) {
17653 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17654 }
17655 arg5 = reinterpret_cast< char * >(buf5);
17656 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17657 if (!SWIG_IsOK(res6)) {
17658 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17659 }
17660 arg6 = reinterpret_cast< char * >(buf6);
17661 ecode7 = SWIG_AsVal_double(args(6), &val7);
17662 if (!SWIG_IsOK(ecode7)) {
17663 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17664 }
17665 arg7 = static_cast< PLFLT >(val7);
17666 ecode8 = SWIG_AsVal_int(args(7), &val8);
17667 if (!SWIG_IsOK(ecode8)) {
17668 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17669 }
17670 arg8 = static_cast< PLINT >(val8);
17671 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17672 if (!SWIG_IsOK(res9)) {
17673 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17674 }
17675 arg9 = reinterpret_cast< char * >(buf9);
17676 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17677 if (!SWIG_IsOK(res10)) {
17678 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17679 }
17680 arg10 = reinterpret_cast< char * >(buf10);
17681 ecode11 = SWIG_AsVal_double(args(10), &val11);
17682 if (!SWIG_IsOK(ecode11)) {
17683 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17684 }
17685 arg11 = static_cast< PLFLT >(val11);
17686 ecode12 = SWIG_AsVal_int(args(11), &val12);
17687 if (!SWIG_IsOK(ecode12)) {
17688 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17689 }
17690 arg12 = static_cast< PLINT >(val12);
17691 plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
17692 _outv = octave_value();
17693 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17694 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17695 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17696 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17697 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17698 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17699 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17700 return _out;
17701 fail:
17702 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17703 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17704 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17705 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17706 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17707 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17708 return octave_value_list();
17709 }
17710 catch(...) {
17711 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17712 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17713 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17714 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17715 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17716 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17717 throw;
17718 }
17719}
17720
17721
17723 PLFLT arg1 ;
17724 PLFLT arg2 ;
17725 PLFLT *arg3 = (PLFLT *) 0 ;
17726 PLFLT *arg4 = (PLFLT *) 0 ;
17727 PLINT *arg5 = (PLINT *) 0 ;
17728 double val1 ;
17729 int ecode1 = 0 ;
17730 double val2 ;
17731 int ecode2 = 0 ;
17732 PLFLT temp3 ;
17733 int res3 = SWIG_TMPOBJ ;
17734 PLFLT temp4 ;
17735 int res4 = SWIG_TMPOBJ ;
17736 PLINT temp5 ;
17737 int res5 = SWIG_TMPOBJ ;
17738 octave_value_list _out;
17739 octave_value_list *_outp=&_out;
17740 octave_value _outv;
17741
17742 try {
17743 arg3 = &temp3;
17744 arg4 = &temp4;
17745 arg5 = &temp5;
17746 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17747 SWIG_fail;
17748 }
17749 ecode1 = SWIG_AsVal_double(args(0), &val1);
17750 if (!SWIG_IsOK(ecode1)) {
17751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17752 }
17753 arg1 = static_cast< PLFLT >(val1);
17754 ecode2 = SWIG_AsVal_double(args(1), &val2);
17755 if (!SWIG_IsOK(ecode2)) {
17756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17757 }
17758 arg2 = static_cast< PLFLT >(val2);
17759 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17760 _outv = octave_value();
17761 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17762 if (SWIG_IsTmpObj(res3)) {
17763 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17764 } else {
17765 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17766 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17767 }
17768 if (SWIG_IsTmpObj(res4)) {
17769 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17770 } else {
17771 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17772 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17773 }
17774 if (SWIG_IsTmpObj(res5)) {
17775 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17776 } else {
17777 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17778 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17779 }
17780 return _out;
17781 fail:
17782 return octave_value_list();
17783 }
17784 catch(...) {
17785 throw;
17786 }
17787}
17788
17789
17791 octave_value_list _out;
17792 octave_value_list *_outp=&_out;
17793 octave_value _outv;
17794
17795 try {
17796 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17797 SWIG_fail;
17798 }
17799 plclear();
17800 _outv = octave_value();
17801 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17802 return _out;
17803 fail:
17804 return octave_value_list();
17805 }
17806 catch(...) {
17807 throw;
17808 }
17809}
17810
17811
17813 PLINT arg1 ;
17814 int val1 ;
17815 int ecode1 = 0 ;
17816 octave_value_list _out;
17817 octave_value_list *_outp=&_out;
17818 octave_value _outv;
17819
17820 try {
17821 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17822 SWIG_fail;
17823 }
17824 ecode1 = SWIG_AsVal_int(args(0), &val1);
17825 if (!SWIG_IsOK(ecode1)) {
17826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17827 }
17828 arg1 = static_cast< PLINT >(val1);
17829 plcol0(arg1);
17830 _outv = octave_value();
17831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17832 return _out;
17833 fail:
17834 return octave_value_list();
17835 }
17836 catch(...) {
17837 throw;
17838 }
17839}
17840
17841
17843 PLFLT arg1 ;
17844 double val1 ;
17845 int ecode1 = 0 ;
17846 octave_value_list _out;
17847 octave_value_list *_outp=&_out;
17848 octave_value _outv;
17849
17850 try {
17851 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17852 SWIG_fail;
17853 }
17854 ecode1 = SWIG_AsVal_double(args(0), &val1);
17855 if (!SWIG_IsOK(ecode1)) {
17856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17857 }
17858 arg1 = static_cast< PLFLT >(val1);
17859 plcol1(arg1);
17860 _outv = octave_value();
17861 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17862 return _out;
17863 fail:
17864 return octave_value_list();
17865 }
17866 catch(...) {
17867 throw;
17868 }
17869}
17870
17871
17873 PLFLT arg1 ;
17874 PLFLT arg2 ;
17875 PLFLT arg3 ;
17876 PLINT arg4 ;
17877 PLBOOL arg5 ;
17878 PLINT arg6 ;
17879 PLINT arg7 ;
17880 PLINT arg8 ;
17881 PLINT arg9 ;
17882 PLINT arg10 ;
17883 PLFLT arg11 ;
17884 double val1 ;
17885 int ecode1 = 0 ;
17886 double val2 ;
17887 int ecode2 = 0 ;
17888 double val3 ;
17889 int ecode3 = 0 ;
17890 int val4 ;
17891 int ecode4 = 0 ;
17892 int val5 ;
17893 int ecode5 = 0 ;
17894 int val6 ;
17895 int ecode6 = 0 ;
17896 int val7 ;
17897 int ecode7 = 0 ;
17898 int val8 ;
17899 int ecode8 = 0 ;
17900 int val9 ;
17901 int ecode9 = 0 ;
17902 int val10 ;
17903 int ecode10 = 0 ;
17904 double val11 ;
17905 int ecode11 = 0 ;
17906 octave_value_list _out;
17907 octave_value_list *_outp=&_out;
17908 octave_value _outv;
17909
17910 try {
17911 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17912 SWIG_fail;
17913 }
17914 ecode1 = SWIG_AsVal_double(args(0), &val1);
17915 if (!SWIG_IsOK(ecode1)) {
17916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17917 }
17918 arg1 = static_cast< PLFLT >(val1);
17919 ecode2 = SWIG_AsVal_double(args(1), &val2);
17920 if (!SWIG_IsOK(ecode2)) {
17921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17922 }
17923 arg2 = static_cast< PLFLT >(val2);
17924 ecode3 = SWIG_AsVal_double(args(2), &val3);
17925 if (!SWIG_IsOK(ecode3)) {
17926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17927 }
17928 arg3 = static_cast< PLFLT >(val3);
17929 ecode4 = SWIG_AsVal_int(args(3), &val4);
17930 if (!SWIG_IsOK(ecode4)) {
17931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17932 }
17933 arg4 = static_cast< PLINT >(val4);
17934 ecode5 = SWIG_AsVal_int(args(4), &val5);
17935 if (!SWIG_IsOK(ecode5)) {
17936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17937 }
17938 arg5 = static_cast< PLBOOL >(val5);
17939 ecode6 = SWIG_AsVal_int(args(5), &val6);
17940 if (!SWIG_IsOK(ecode6)) {
17941 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17942 }
17943 arg6 = static_cast< PLINT >(val6);
17944 ecode7 = SWIG_AsVal_int(args(6), &val7);
17945 if (!SWIG_IsOK(ecode7)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17947 }
17948 arg7 = static_cast< PLINT >(val7);
17949 ecode8 = SWIG_AsVal_int(args(7), &val8);
17950 if (!SWIG_IsOK(ecode8)) {
17951 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17952 }
17953 arg8 = static_cast< PLINT >(val8);
17954 ecode9 = SWIG_AsVal_int(args(8), &val9);
17955 if (!SWIG_IsOK(ecode9)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17957 }
17958 arg9 = static_cast< PLINT >(val9);
17959 ecode10 = SWIG_AsVal_int(args(9), &val10);
17960 if (!SWIG_IsOK(ecode10)) {
17961 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17962 }
17963 arg10 = static_cast< PLINT >(val10);
17964 ecode11 = SWIG_AsVal_double(args(10), &val11);
17965 if (!SWIG_IsOK(ecode11)) {
17966 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17967 }
17968 arg11 = static_cast< PLFLT >(val11);
17969 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17970 _outv = octave_value();
17971 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17972 return _out;
17973 fail:
17974 return octave_value_list();
17975 }
17976 catch(...) {
17977 throw;
17978 }
17979}
17980
17981
17983 PLINT arg1 ;
17984 PLINT arg2 ;
17985 PLINT arg3 ;
17986 PLINT arg4 ;
17987 PLINT arg5 ;
17988 PLFLT arg6 ;
17989 PLFLT *arg7 = (PLFLT *) 0 ;
17990 int val1 ;
17991 int ecode1 = 0 ;
17992 int val2 ;
17993 int ecode2 = 0 ;
17994 int val3 ;
17995 int ecode3 = 0 ;
17996 int val4 ;
17997 int ecode4 = 0 ;
17998 int val5 ;
17999 int ecode5 = 0 ;
18000 double val6 ;
18001 int ecode6 = 0 ;
18002 PLFLT temp7 ;
18003 int res7 = SWIG_TMPOBJ ;
18004 octave_value_list _out;
18005 octave_value_list *_outp=&_out;
18006 octave_value _outv;
18007
18008 try {
18009 arg7 = &temp7;
18010 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18011 SWIG_fail;
18012 }
18013 ecode1 = SWIG_AsVal_int(args(0), &val1);
18014 if (!SWIG_IsOK(ecode1)) {
18015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18016 }
18017 arg1 = static_cast< PLINT >(val1);
18018 ecode2 = SWIG_AsVal_int(args(1), &val2);
18019 if (!SWIG_IsOK(ecode2)) {
18020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18021 }
18022 arg2 = static_cast< PLINT >(val2);
18023 ecode3 = SWIG_AsVal_int(args(2), &val3);
18024 if (!SWIG_IsOK(ecode3)) {
18025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18026 }
18027 arg3 = static_cast< PLINT >(val3);
18028 ecode4 = SWIG_AsVal_int(args(3), &val4);
18029 if (!SWIG_IsOK(ecode4)) {
18030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18031 }
18032 arg4 = static_cast< PLINT >(val4);
18033 ecode5 = SWIG_AsVal_int(args(4), &val5);
18034 if (!SWIG_IsOK(ecode5)) {
18035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18036 }
18037 arg5 = static_cast< PLINT >(val5);
18038 ecode6 = SWIG_AsVal_double(args(5), &val6);
18039 if (!SWIG_IsOK(ecode6)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18041 }
18042 arg6 = static_cast< PLFLT >(val6);
18043 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18044 _outv = octave_value();
18045 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18046 if (SWIG_IsTmpObj(res7)) {
18047 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18048 } else {
18049 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18050 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18051 }
18052 return _out;
18053 fail:
18054 return octave_value_list();
18055 }
18056 catch(...) {
18057 throw;
18058 }
18059}
18060
18061
18063 PLINT arg1 ;
18064 PLBOOL arg2 ;
18065 int val1 ;
18066 int ecode1 = 0 ;
18067 int val2 ;
18068 int ecode2 = 0 ;
18069 octave_value_list _out;
18070 octave_value_list *_outp=&_out;
18071 octave_value _outv;
18072
18073 try {
18074 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18075 SWIG_fail;
18076 }
18077 ecode1 = SWIG_AsVal_int(args(0), &val1);
18078 if (!SWIG_IsOK(ecode1)) {
18079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18080 }
18081 arg1 = static_cast< PLINT >(val1);
18082 ecode2 = SWIG_AsVal_int(args(1), &val2);
18083 if (!SWIG_IsOK(ecode2)) {
18084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18085 }
18086 arg2 = static_cast< PLBOOL >(val2);
18087 plcpstrm(arg1,arg2);
18088 _outv = octave_value();
18089 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18090 return _out;
18091 fail:
18092 return octave_value_list();
18093 }
18094 catch(...) {
18095 throw;
18096 }
18097}
18098
18099
18101 octave_value_list _out;
18102 octave_value_list *_outp=&_out;
18103 octave_value _outv;
18104
18105 try {
18106 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18107 SWIG_fail;
18108 }
18109 plend();
18110 _outv = octave_value();
18111 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18112 return _out;
18113 fail:
18114 return octave_value_list();
18115 }
18116 catch(...) {
18117 throw;
18118 }
18119}
18120
18121
18123 octave_value_list _out;
18124 octave_value_list *_outp=&_out;
18125 octave_value _outv;
18126
18127 try {
18128 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18129 SWIG_fail;
18130 }
18131 plend1();
18132 _outv = octave_value();
18133 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18134 return _out;
18135 fail:
18136 return octave_value_list();
18137 }
18138 catch(...) {
18139 throw;
18140 }
18141}
18142
18143
18144SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
18145 PLFLT arg1 ;
18146 PLFLT arg2 ;
18147 PLFLT arg3 ;
18148 PLFLT arg4 ;
18149 PLINT arg5 ;
18150 PLINT arg6 ;
18151 double val1 ;
18152 int ecode1 = 0 ;
18153 double val2 ;
18154 int ecode2 = 0 ;
18155 double val3 ;
18156 int ecode3 = 0 ;
18157 double val4 ;
18158 int ecode4 = 0 ;
18159 int val5 ;
18160 int ecode5 = 0 ;
18161 int val6 ;
18162 int ecode6 = 0 ;
18163 octave_value_list _out;
18164 octave_value_list *_outp=&_out;
18165 octave_value _outv;
18166
18167 try {
18168 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18169 SWIG_fail;
18170 }
18171 ecode1 = SWIG_AsVal_double(args(0), &val1);
18172 if (!SWIG_IsOK(ecode1)) {
18173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18174 }
18175 arg1 = static_cast< PLFLT >(val1);
18176 ecode2 = SWIG_AsVal_double(args(1), &val2);
18177 if (!SWIG_IsOK(ecode2)) {
18178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18179 }
18180 arg2 = static_cast< PLFLT >(val2);
18181 ecode3 = SWIG_AsVal_double(args(2), &val3);
18182 if (!SWIG_IsOK(ecode3)) {
18183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18184 }
18185 arg3 = static_cast< PLFLT >(val3);
18186 ecode4 = SWIG_AsVal_double(args(3), &val4);
18187 if (!SWIG_IsOK(ecode4)) {
18188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18189 }
18190 arg4 = static_cast< PLFLT >(val4);
18191 ecode5 = SWIG_AsVal_int(args(4), &val5);
18192 if (!SWIG_IsOK(ecode5)) {
18193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18194 }
18195 arg5 = static_cast< PLINT >(val5);
18196 ecode6 = SWIG_AsVal_int(args(5), &val6);
18197 if (!SWIG_IsOK(ecode6)) {
18198 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18199 }
18200 arg6 = static_cast< PLINT >(val6);
18201 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18202 _outv = octave_value();
18203 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18204 return _out;
18205 fail:
18206 return octave_value_list();
18207 }
18208 catch(...) {
18209 throw;
18210 }
18211}
18212
18213
18215 PLFLT arg1 ;
18216 PLFLT arg2 ;
18217 PLFLT arg3 ;
18218 PLFLT arg4 ;
18219 PLINT arg5 ;
18220 PLINT arg6 ;
18221 double val1 ;
18222 int ecode1 = 0 ;
18223 double val2 ;
18224 int ecode2 = 0 ;
18225 double val3 ;
18226 int ecode3 = 0 ;
18227 double val4 ;
18228 int ecode4 = 0 ;
18229 int val5 ;
18230 int ecode5 = 0 ;
18231 int val6 ;
18232 int ecode6 = 0 ;
18233 octave_value_list _out;
18234 octave_value_list *_outp=&_out;
18235 octave_value _outv;
18236
18237 try {
18238 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18239 SWIG_fail;
18240 }
18241 ecode1 = SWIG_AsVal_double(args(0), &val1);
18242 if (!SWIG_IsOK(ecode1)) {
18243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18244 }
18245 arg1 = static_cast< PLFLT >(val1);
18246 ecode2 = SWIG_AsVal_double(args(1), &val2);
18247 if (!SWIG_IsOK(ecode2)) {
18248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18249 }
18250 arg2 = static_cast< PLFLT >(val2);
18251 ecode3 = SWIG_AsVal_double(args(2), &val3);
18252 if (!SWIG_IsOK(ecode3)) {
18253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18254 }
18255 arg3 = static_cast< PLFLT >(val3);
18256 ecode4 = SWIG_AsVal_double(args(3), &val4);
18257 if (!SWIG_IsOK(ecode4)) {
18258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18259 }
18260 arg4 = static_cast< PLFLT >(val4);
18261 ecode5 = SWIG_AsVal_int(args(4), &val5);
18262 if (!SWIG_IsOK(ecode5)) {
18263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18264 }
18265 arg5 = static_cast< PLINT >(val5);
18266 ecode6 = SWIG_AsVal_int(args(5), &val6);
18267 if (!SWIG_IsOK(ecode6)) {
18268 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18269 }
18270 arg6 = static_cast< PLINT >(val6);
18271 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18272 _outv = octave_value();
18273 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18274 return _out;
18275 fail:
18276 return octave_value_list();
18277 }
18278 catch(...) {
18279 throw;
18280 }
18281}
18282
18283
18285 octave_value_list _out;
18286 octave_value_list *_outp=&_out;
18287 octave_value _outv;
18288
18289 try {
18290 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18291 SWIG_fail;
18292 }
18293 pleop();
18294 _outv = octave_value();
18295 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18296 return _out;
18297 fail:
18298 return octave_value_list();
18299 }
18300 catch(...) {
18301 throw;
18302 }
18303}
18304
18305
18307 PLINT arg1 ;
18308 PLFLT *arg2 = (PLFLT *) 0 ;
18309 PLFLT *arg3 = (PLFLT *) 0 ;
18310 PLFLT *arg4 = (PLFLT *) 0 ;
18311 Matrix temp1 ;
18312 Matrix temp3 ;
18313 Matrix temp4 ;
18314 octave_value_list _out;
18315 octave_value_list *_outp=&_out;
18316 octave_value _outv;
18317
18318 try {
18319 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18320 SWIG_fail;
18321 }
18322 {
18323 if ( _n_dims( args(0) ) > 1 )
18324 {
18325 error( "argument must be a scalar or vector" ); SWIG_fail;
18326 }
18327 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18328 temp1 = args(0).matrix_value();
18329 arg2 = &temp1( 0, 0 );
18330 }
18331 {
18332 if ( _n_dims( args(1) ) > 1 )
18333 {
18334 error( "argument must be a scalar or vector" ); SWIG_fail;
18335 }
18336 if ( _dim( args(1), 0 ) != Alen )
18337 {
18338 error( "argument vectors must be same length" ); SWIG_fail;
18339 }
18340 temp3 = args(1).matrix_value();
18341 arg3 = &temp3( 0, 0 );
18342 }
18343 {
18344 if ( _n_dims( args(2) ) > 1 )
18345 {
18346 error( "argument must be a scalar or vector" ); SWIG_fail;
18347 }
18348 if ( _dim( args(2), 0 ) != Alen )
18349 {
18350 error( "argument vectors must be same length" ); SWIG_fail;
18351 }
18352 temp4 = args(2).matrix_value();
18353 arg4 = &temp4( 0, 0 );
18354 }
18355 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18356 _outv = octave_value();
18357 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18358 {
18359
18360 }
18361 {
18362
18363 }
18364 {
18365
18366 }
18367 return _out;
18368 fail:
18369 {
18370
18371 }
18372 {
18373
18374 }
18375 {
18376
18377 }
18378 return octave_value_list();
18379 }
18380 catch(...) {
18381 {
18382
18383 }
18384 {
18385
18386 }
18387 {
18388
18389 }
18390 throw;
18391 }
18392}
18393
18394
18396 PLINT arg1 ;
18397 PLFLT *arg2 = (PLFLT *) 0 ;
18398 PLFLT *arg3 = (PLFLT *) 0 ;
18399 PLFLT *arg4 = (PLFLT *) 0 ;
18400 Matrix temp1 ;
18401 Matrix temp3 ;
18402 Matrix temp4 ;
18403 octave_value_list _out;
18404 octave_value_list *_outp=&_out;
18405 octave_value _outv;
18406
18407 try {
18408 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18409 SWIG_fail;
18410 }
18411 {
18412 if ( _n_dims( args(0) ) > 1 )
18413 {
18414 error( "argument must be a scalar or vector" ); SWIG_fail;
18415 }
18416 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18417 temp1 = args(0).matrix_value();
18418 arg2 = &temp1( 0, 0 );
18419 }
18420 {
18421 if ( _n_dims( args(1) ) > 1 )
18422 {
18423 error( "argument must be a scalar or vector" ); SWIG_fail;
18424 }
18425 if ( _dim( args(1), 0 ) != Alen )
18426 {
18427 error( "argument vectors must be same length" ); SWIG_fail;
18428 }
18429 temp3 = args(1).matrix_value();
18430 arg3 = &temp3( 0, 0 );
18431 }
18432 {
18433 if ( _n_dims( args(2) ) > 1 )
18434 {
18435 error( "argument must be a scalar or vector" ); SWIG_fail;
18436 }
18437 if ( _dim( args(2), 0 ) != Alen )
18438 {
18439 error( "argument vectors must be same length" ); SWIG_fail;
18440 }
18441 temp4 = args(2).matrix_value();
18442 arg4 = &temp4( 0, 0 );
18443 }
18444 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18445 _outv = octave_value();
18446 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18447 {
18448
18449 }
18450 {
18451
18452 }
18453 {
18454
18455 }
18456 return _out;
18457 fail:
18458 {
18459
18460 }
18461 {
18462
18463 }
18464 {
18465
18466 }
18467 return octave_value_list();
18468 }
18469 catch(...) {
18470 {
18471
18472 }
18473 {
18474
18475 }
18476 {
18477
18478 }
18479 throw;
18480 }
18481}
18482
18483
18485 octave_value_list _out;
18486 octave_value_list *_outp=&_out;
18487 octave_value _outv;
18488
18489 try {
18490 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18491 SWIG_fail;
18492 }
18493 plfamadv();
18494 _outv = octave_value();
18495 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18496 return _out;
18497 fail:
18498 return octave_value_list();
18499 }
18500 catch(...) {
18501 throw;
18502 }
18503}
18504
18505
18507 PLINT arg1 ;
18508 PLFLT *arg2 = (PLFLT *) 0 ;
18509 PLFLT *arg3 = (PLFLT *) 0 ;
18510 Matrix temp1 ;
18511 Matrix temp3 ;
18512 octave_value_list _out;
18513 octave_value_list *_outp=&_out;
18514 octave_value _outv;
18515
18516 try {
18517 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18518 SWIG_fail;
18519 }
18520 {
18521 if ( _n_dims( args(0) ) > 1 )
18522 {
18523 error( "argument must be a scalar or vector" ); SWIG_fail;
18524 }
18525 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18526 temp1 = args(0).matrix_value();
18527 arg2 = &temp1( 0, 0 );
18528 }
18529 {
18530 if ( _n_dims( args(1) ) > 1 )
18531 {
18532 error( "argument must be a scalar or vector" ); SWIG_fail;
18533 }
18534 if ( _dim( args(1), 0 ) != Alen )
18535 {
18536 error( "argument vectors must be same length" ); SWIG_fail;
18537 }
18538 temp3 = args(1).matrix_value();
18539 arg3 = &temp3( 0, 0 );
18540 }
18541 plfill(arg1,(double const *)arg2,(double const *)arg3);
18542 _outv = octave_value();
18543 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18544 {
18545
18546 }
18547 {
18548
18549 }
18550 return _out;
18551 fail:
18552 {
18553
18554 }
18555 {
18556
18557 }
18558 return octave_value_list();
18559 }
18560 catch(...) {
18561 {
18562
18563 }
18564 {
18565
18566 }
18567 throw;
18568 }
18569}
18570
18571
18573 PLINT arg1 ;
18574 PLFLT *arg2 = (PLFLT *) 0 ;
18575 PLFLT *arg3 = (PLFLT *) 0 ;
18576 PLFLT *arg4 = (PLFLT *) 0 ;
18577 Matrix temp1 ;
18578 Matrix temp3 ;
18579 Matrix temp4 ;
18580 octave_value_list _out;
18581 octave_value_list *_outp=&_out;
18582 octave_value _outv;
18583
18584 try {
18585 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18586 SWIG_fail;
18587 }
18588 {
18589 if ( _n_dims( args(0) ) > 1 )
18590 {
18591 error( "argument must be a scalar or vector" ); SWIG_fail;
18592 }
18593 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18594 temp1 = args(0).matrix_value();
18595 arg2 = &temp1( 0, 0 );
18596 }
18597 {
18598 if ( _n_dims( args(1) ) > 1 )
18599 {
18600 error( "argument must be a scalar or vector" ); SWIG_fail;
18601 }
18602 if ( _dim( args(1), 0 ) != Alen )
18603 {
18604 error( "argument vectors must be same length" ); SWIG_fail;
18605 }
18606 temp3 = args(1).matrix_value();
18607 arg3 = &temp3( 0, 0 );
18608 }
18609 {
18610 if ( _n_dims( args(2) ) > 1 )
18611 {
18612 error( "argument must be a scalar or vector" ); SWIG_fail;
18613 }
18614 if ( _dim( args(2), 0 ) != Alen )
18615 {
18616 error( "argument vectors must be same length" ); SWIG_fail;
18617 }
18618 temp4 = args(2).matrix_value();
18619 arg4 = &temp4( 0, 0 );
18620 }
18621 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18622 _outv = octave_value();
18623 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18624 {
18625
18626 }
18627 {
18628
18629 }
18630 {
18631
18632 }
18633 return _out;
18634 fail:
18635 {
18636
18637 }
18638 {
18639
18640 }
18641 {
18642
18643 }
18644 return octave_value_list();
18645 }
18646 catch(...) {
18647 {
18648
18649 }
18650 {
18651
18652 }
18653 {
18654
18655 }
18656 throw;
18657 }
18658}
18659
18660
18662 PLINT arg1 ;
18663 PLFLT *arg2 = (PLFLT *) 0 ;
18664 PLFLT *arg3 = (PLFLT *) 0 ;
18665 PLFLT arg4 ;
18666 Matrix temp1 ;
18667 Matrix temp3 ;
18668 double val4 ;
18669 int ecode4 = 0 ;
18670 octave_value_list _out;
18671 octave_value_list *_outp=&_out;
18672 octave_value _outv;
18673
18674 try {
18675 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18676 SWIG_fail;
18677 }
18678 {
18679 if ( _n_dims( args(0) ) > 1 )
18680 {
18681 error( "argument must be a scalar or vector" ); SWIG_fail;
18682 }
18683 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18684 temp1 = args(0).matrix_value();
18685 arg2 = &temp1( 0, 0 );
18686 }
18687 {
18688 if ( _n_dims( args(1) ) > 1 )
18689 {
18690 error( "argument must be a scalar or vector" ); SWIG_fail;
18691 }
18692 if ( _dim( args(1), 0 ) != Alen )
18693 {
18694 error( "argument vectors must be same length" ); SWIG_fail;
18695 }
18696 temp3 = args(1).matrix_value();
18697 arg3 = &temp3( 0, 0 );
18698 }
18699 ecode4 = SWIG_AsVal_double(args(2), &val4);
18700 if (!SWIG_IsOK(ecode4)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18702 }
18703 arg4 = static_cast< PLFLT >(val4);
18704 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18705 _outv = octave_value();
18706 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18707 {
18708
18709 }
18710 {
18711
18712 }
18713 return _out;
18714 fail:
18715 {
18716
18717 }
18718 {
18719
18720 }
18721 return octave_value_list();
18722 }
18723 catch(...) {
18724 {
18725
18726 }
18727 {
18728
18729 }
18730 throw;
18731 }
18732}
18733
18734
18736 octave_value_list _out;
18737 octave_value_list *_outp=&_out;
18738 octave_value _outv;
18739
18740 try {
18741 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18742 SWIG_fail;
18743 }
18744 plflush();
18745 _outv = octave_value();
18746 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18747 return _out;
18748 fail:
18749 return octave_value_list();
18750 }
18751 catch(...) {
18752 throw;
18753 }
18754}
18755
18756
18758 PLINT arg1 ;
18759 int val1 ;
18760 int ecode1 = 0 ;
18761 octave_value_list _out;
18762 octave_value_list *_outp=&_out;
18763 octave_value _outv;
18764
18765 try {
18766 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18767 SWIG_fail;
18768 }
18769 ecode1 = SWIG_AsVal_int(args(0), &val1);
18770 if (!SWIG_IsOK(ecode1)) {
18771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18772 }
18773 arg1 = static_cast< PLINT >(val1);
18774 plfont(arg1);
18775 _outv = octave_value();
18776 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18777 return _out;
18778 fail:
18779 return octave_value_list();
18780 }
18781 catch(...) {
18782 throw;
18783 }
18784}
18785
18786
18788 PLINT arg1 ;
18789 int val1 ;
18790 int ecode1 = 0 ;
18791 octave_value_list _out;
18792 octave_value_list *_outp=&_out;
18793 octave_value _outv;
18794
18795 try {
18796 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18797 SWIG_fail;
18798 }
18799 ecode1 = SWIG_AsVal_int(args(0), &val1);
18800 if (!SWIG_IsOK(ecode1)) {
18801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18802 }
18803 arg1 = static_cast< PLINT >(val1);
18804 plfontld(arg1);
18805 _outv = octave_value();
18806 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18807 return _out;
18808 fail:
18809 return octave_value_list();
18810 }
18811 catch(...) {
18812 throw;
18813 }
18814}
18815
18816
18818 PLFLT *arg1 = (PLFLT *) 0 ;
18819 PLFLT *arg2 = (PLFLT *) 0 ;
18820 PLFLT temp1 ;
18821 int res1 = SWIG_TMPOBJ ;
18822 PLFLT temp2 ;
18823 int res2 = SWIG_TMPOBJ ;
18824 octave_value_list _out;
18825 octave_value_list *_outp=&_out;
18826 octave_value _outv;
18827
18828 try {
18829 arg1 = &temp1;
18830 arg2 = &temp2;
18831 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18832 SWIG_fail;
18833 }
18834 plgchr(arg1,arg2);
18835 _outv = octave_value();
18836 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18837 if (SWIG_IsTmpObj(res1)) {
18838 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18839 } else {
18840 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18841 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18842 }
18843 if (SWIG_IsTmpObj(res2)) {
18844 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18845 } else {
18846 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18847 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18848 }
18849 return _out;
18850 fail:
18851 return octave_value_list();
18852 }
18853 catch(...) {
18854 throw;
18855 }
18856}
18857
18858
18860 PLINT arg1 ;
18861 PLINT *arg2 = (PLINT *) 0 ;
18862 PLINT *arg3 = (PLINT *) 0 ;
18863 PLINT *arg4 = (PLINT *) 0 ;
18864 int val1 ;
18865 int ecode1 = 0 ;
18866 PLINT temp2 ;
18867 int res2 = SWIG_TMPOBJ ;
18868 PLINT temp3 ;
18869 int res3 = SWIG_TMPOBJ ;
18870 PLINT temp4 ;
18871 int res4 = SWIG_TMPOBJ ;
18872 octave_value_list _out;
18873 octave_value_list *_outp=&_out;
18874 octave_value _outv;
18875
18876 try {
18877 arg2 = &temp2;
18878 arg3 = &temp3;
18879 arg4 = &temp4;
18880 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
18881 SWIG_fail;
18882 }
18883 ecode1 = SWIG_AsVal_int(args(0), &val1);
18884 if (!SWIG_IsOK(ecode1)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
18886 }
18887 arg1 = static_cast< PLINT >(val1);
18888 plgcol0(arg1,arg2,arg3,arg4);
18889 _outv = octave_value();
18890 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18891 if (SWIG_IsTmpObj(res2)) {
18892 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18893 } else {
18894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18895 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18896 }
18897 if (SWIG_IsTmpObj(res3)) {
18898 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18899 } else {
18900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18901 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18902 }
18903 if (SWIG_IsTmpObj(res4)) {
18904 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18905 } else {
18906 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18907 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18908 }
18909 return _out;
18910 fail:
18911 return octave_value_list();
18912 }
18913 catch(...) {
18914 throw;
18915 }
18916}
18917
18918
18920 PLINT arg1 ;
18921 PLINT *arg2 = (PLINT *) 0 ;
18922 PLINT *arg3 = (PLINT *) 0 ;
18923 PLINT *arg4 = (PLINT *) 0 ;
18924 PLFLT *arg5 = (PLFLT *) 0 ;
18925 int val1 ;
18926 int ecode1 = 0 ;
18927 PLINT temp2 ;
18928 int res2 = SWIG_TMPOBJ ;
18929 PLINT temp3 ;
18930 int res3 = SWIG_TMPOBJ ;
18931 PLINT temp4 ;
18932 int res4 = SWIG_TMPOBJ ;
18933 PLFLT temp5 ;
18934 int res5 = SWIG_TMPOBJ ;
18935 octave_value_list _out;
18936 octave_value_list *_outp=&_out;
18937 octave_value _outv;
18938
18939 try {
18940 arg2 = &temp2;
18941 arg3 = &temp3;
18942 arg4 = &temp4;
18943 arg5 = &temp5;
18944 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
18945 SWIG_fail;
18946 }
18947 ecode1 = SWIG_AsVal_int(args(0), &val1);
18948 if (!SWIG_IsOK(ecode1)) {
18949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
18950 }
18951 arg1 = static_cast< PLINT >(val1);
18952 plgcol0a(arg1,arg2,arg3,arg4,arg5);
18953 _outv = octave_value();
18954 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18955 if (SWIG_IsTmpObj(res2)) {
18956 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18957 } else {
18958 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18959 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18960 }
18961 if (SWIG_IsTmpObj(res3)) {
18962 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18963 } else {
18964 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18965 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18966 }
18967 if (SWIG_IsTmpObj(res4)) {
18968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18969 } else {
18970 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18971 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18972 }
18973 if (SWIG_IsTmpObj(res5)) {
18974 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
18975 } else {
18976 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18977 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
18978 }
18979 return _out;
18980 fail:
18981 return octave_value_list();
18982 }
18983 catch(...) {
18984 throw;
18985 }
18986}
18987
18988
18990 PLINT *arg1 = (PLINT *) 0 ;
18991 PLINT *arg2 = (PLINT *) 0 ;
18992 PLINT *arg3 = (PLINT *) 0 ;
18993 PLINT temp1 ;
18994 int res1 = SWIG_TMPOBJ ;
18995 PLINT temp2 ;
18996 int res2 = SWIG_TMPOBJ ;
18997 PLINT temp3 ;
18998 int res3 = SWIG_TMPOBJ ;
18999 octave_value_list _out;
19000 octave_value_list *_outp=&_out;
19001 octave_value _outv;
19002
19003 try {
19004 arg1 = &temp1;
19005 arg2 = &temp2;
19006 arg3 = &temp3;
19007 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19008 SWIG_fail;
19009 }
19010 plgcolbg(arg1,arg2,arg3);
19011 _outv = octave_value();
19012 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19013 if (SWIG_IsTmpObj(res1)) {
19014 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19015 } else {
19016 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19017 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19018 }
19019 if (SWIG_IsTmpObj(res2)) {
19020 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19021 } else {
19022 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19023 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19024 }
19025 if (SWIG_IsTmpObj(res3)) {
19026 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19027 } else {
19028 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19029 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19030 }
19031 return _out;
19032 fail:
19033 return octave_value_list();
19034 }
19035 catch(...) {
19036 throw;
19037 }
19038}
19039
19040
19042 PLINT *arg1 = (PLINT *) 0 ;
19043 PLINT *arg2 = (PLINT *) 0 ;
19044 PLINT *arg3 = (PLINT *) 0 ;
19045 PLFLT *arg4 = (PLFLT *) 0 ;
19046 PLINT temp1 ;
19047 int res1 = SWIG_TMPOBJ ;
19048 PLINT temp2 ;
19049 int res2 = SWIG_TMPOBJ ;
19050 PLINT temp3 ;
19051 int res3 = SWIG_TMPOBJ ;
19052 PLFLT temp4 ;
19053 int res4 = SWIG_TMPOBJ ;
19054 octave_value_list _out;
19055 octave_value_list *_outp=&_out;
19056 octave_value _outv;
19057
19058 try {
19059 arg1 = &temp1;
19060 arg2 = &temp2;
19061 arg3 = &temp3;
19062 arg4 = &temp4;
19063 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19064 SWIG_fail;
19065 }
19066 plgcolbga(arg1,arg2,arg3,arg4);
19067 _outv = octave_value();
19068 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19069 if (SWIG_IsTmpObj(res1)) {
19070 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19071 } else {
19072 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19073 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19074 }
19075 if (SWIG_IsTmpObj(res2)) {
19076 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19077 } else {
19078 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19079 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19080 }
19081 if (SWIG_IsTmpObj(res3)) {
19082 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19083 } else {
19084 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19085 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19086 }
19087 if (SWIG_IsTmpObj(res4)) {
19088 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19089 } else {
19090 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19091 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19092 }
19093 return _out;
19094 fail:
19095 return octave_value_list();
19096 }
19097 catch(...) {
19098 throw;
19099 }
19100}
19101
19102
19104 PLINT *arg1 = (PLINT *) 0 ;
19105 PLINT temp1 ;
19106 int res1 = SWIG_TMPOBJ ;
19107 octave_value_list _out;
19108 octave_value_list *_outp=&_out;
19109 octave_value _outv;
19110
19111 try {
19112 arg1 = &temp1;
19113 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19114 SWIG_fail;
19115 }
19116 plgcompression(arg1);
19117 _outv = octave_value();
19118 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19119 if (SWIG_IsTmpObj(res1)) {
19120 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19121 } else {
19122 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19123 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19124 }
19125 return _out;
19126 fail:
19127 return octave_value_list();
19128 }
19129 catch(...) {
19130 throw;
19131 }
19132}
19133
19134
19136 char *arg1 = (char *) 0 ;
19137 char local_string1[80] ;
19138 size_t local_string_length1 ;
19139 charMatrix local_charMatrix1 ;
19140 octave_value_list retval1 ;
19141 octave_value_list _out;
19142 octave_value_list *_outp=&_out;
19143 octave_value _outv;
19144
19145 try {
19146 {
19147 arg1 = local_string1;
19148 }
19149 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19150 SWIG_fail;
19151 }
19152 plgdev(arg1);
19153 _outv = octave_value();
19154 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19155 {
19156 local_string_length1 = strlen( local_string1 );
19157 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19158 local_charMatrix1.insert( local_string1, 0, 0 );
19159 retval1( 0 ) = octave_value( local_charMatrix1 );
19160 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19161 }
19162 return _out;
19163 fail:
19164 return octave_value_list();
19165 }
19166 catch(...) {
19167 throw;
19168 }
19169}
19170
19171
19173 PLFLT *arg1 = (PLFLT *) 0 ;
19174 PLFLT *arg2 = (PLFLT *) 0 ;
19175 PLFLT *arg3 = (PLFLT *) 0 ;
19176 PLFLT *arg4 = (PLFLT *) 0 ;
19177 PLFLT temp1 ;
19178 int res1 = SWIG_TMPOBJ ;
19179 PLFLT temp2 ;
19180 int res2 = SWIG_TMPOBJ ;
19181 PLFLT temp3 ;
19182 int res3 = SWIG_TMPOBJ ;
19183 PLFLT temp4 ;
19184 int res4 = SWIG_TMPOBJ ;
19185 octave_value_list _out;
19186 octave_value_list *_outp=&_out;
19187 octave_value _outv;
19188
19189 try {
19190 arg1 = &temp1;
19191 arg2 = &temp2;
19192 arg3 = &temp3;
19193 arg4 = &temp4;
19194 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19195 SWIG_fail;
19196 }
19197 plgdidev(arg1,arg2,arg3,arg4);
19198 _outv = octave_value();
19199 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19200 if (SWIG_IsTmpObj(res1)) {
19201 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19202 } else {
19203 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19204 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19205 }
19206 if (SWIG_IsTmpObj(res2)) {
19207 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19208 } else {
19209 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19210 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19211 }
19212 if (SWIG_IsTmpObj(res3)) {
19213 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19214 } else {
19215 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19216 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19217 }
19218 if (SWIG_IsTmpObj(res4)) {
19219 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19220 } else {
19221 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19222 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19223 }
19224 return _out;
19225 fail:
19226 return octave_value_list();
19227 }
19228 catch(...) {
19229 throw;
19230 }
19231}
19232
19233
19235 PLFLT *arg1 = (PLFLT *) 0 ;
19236 PLFLT temp1 ;
19237 int res1 = SWIG_TMPOBJ ;
19238 octave_value_list _out;
19239 octave_value_list *_outp=&_out;
19240 octave_value _outv;
19241
19242 try {
19243 arg1 = &temp1;
19244 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19245 SWIG_fail;
19246 }
19247 plgdiori(arg1);
19248 _outv = octave_value();
19249 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19250 if (SWIG_IsTmpObj(res1)) {
19251 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19252 } else {
19253 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19254 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19255 }
19256 return _out;
19257 fail:
19258 return octave_value_list();
19259 }
19260 catch(...) {
19261 throw;
19262 }
19263}
19264
19265
19267 PLFLT *arg1 = (PLFLT *) 0 ;
19268 PLFLT *arg2 = (PLFLT *) 0 ;
19269 PLFLT *arg3 = (PLFLT *) 0 ;
19270 PLFLT *arg4 = (PLFLT *) 0 ;
19271 PLFLT temp1 ;
19272 int res1 = SWIG_TMPOBJ ;
19273 PLFLT temp2 ;
19274 int res2 = SWIG_TMPOBJ ;
19275 PLFLT temp3 ;
19276 int res3 = SWIG_TMPOBJ ;
19277 PLFLT temp4 ;
19278 int res4 = SWIG_TMPOBJ ;
19279 octave_value_list _out;
19280 octave_value_list *_outp=&_out;
19281 octave_value _outv;
19282
19283 try {
19284 arg1 = &temp1;
19285 arg2 = &temp2;
19286 arg3 = &temp3;
19287 arg4 = &temp4;
19288 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19289 SWIG_fail;
19290 }
19291 plgdiplt(arg1,arg2,arg3,arg4);
19292 _outv = octave_value();
19293 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19294 if (SWIG_IsTmpObj(res1)) {
19295 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19296 } else {
19297 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19298 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19299 }
19300 if (SWIG_IsTmpObj(res2)) {
19301 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19302 } else {
19303 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19304 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19305 }
19306 if (SWIG_IsTmpObj(res3)) {
19307 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19308 } else {
19309 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19310 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19311 }
19312 if (SWIG_IsTmpObj(res4)) {
19313 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19314 } else {
19315 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19316 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19317 }
19318 return _out;
19319 fail:
19320 return octave_value_list();
19321 }
19322 catch(...) {
19323 throw;
19324 }
19325}
19326
19327
19329 PLINT *arg1 = (PLINT *) 0 ;
19330 PLINT *arg2 = (PLINT *) 0 ;
19331 PLINT *arg3 = (PLINT *) 0 ;
19332 PLINT temp1 ;
19333 int res1 = SWIG_TMPOBJ ;
19334 PLINT temp2 ;
19335 int res2 = SWIG_TMPOBJ ;
19336 PLINT temp3 ;
19337 int res3 = SWIG_TMPOBJ ;
19338 octave_value_list _out;
19339 octave_value_list *_outp=&_out;
19340 octave_value _outv;
19341
19342 try {
19343 arg1 = &temp1;
19344 arg2 = &temp2;
19345 arg3 = &temp3;
19346 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19347 SWIG_fail;
19348 }
19349 plgfam(arg1,arg2,arg3);
19350 _outv = octave_value();
19351 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19352 if (SWIG_IsTmpObj(res1)) {
19353 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19354 } else {
19355 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19356 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19357 }
19358 if (SWIG_IsTmpObj(res2)) {
19359 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19360 } else {
19361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19362 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19363 }
19364 if (SWIG_IsTmpObj(res3)) {
19365 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19366 } else {
19367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19368 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19369 }
19370 return _out;
19371 fail:
19372 return octave_value_list();
19373 }
19374 catch(...) {
19375 throw;
19376 }
19377}
19378
19379
19381 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19382 PLUNICODE temp1 ;
19383 int res1 = SWIG_TMPOBJ ;
19384 octave_value_list _out;
19385 octave_value_list *_outp=&_out;
19386 octave_value _outv;
19387
19388 try {
19389 arg1 = &temp1;
19390 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19391 SWIG_fail;
19392 }
19393 plgfci(arg1);
19394 _outv = octave_value();
19395 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19396 if (SWIG_IsTmpObj(res1)) {
19397 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19398 } else {
19399 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19400 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19401 }
19402 return _out;
19403 fail:
19404 return octave_value_list();
19405 }
19406 catch(...) {
19407 throw;
19408 }
19409}
19410
19411
19413 char *arg1 = (char *) 0 ;
19414 char local_string1[80] ;
19415 size_t local_string_length1 ;
19416 charMatrix local_charMatrix1 ;
19417 octave_value_list retval1 ;
19418 octave_value_list _out;
19419 octave_value_list *_outp=&_out;
19420 octave_value _outv;
19421
19422 try {
19423 {
19424 arg1 = local_string1;
19425 }
19426 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19427 SWIG_fail;
19428 }
19429 plgfnam(arg1);
19430 _outv = octave_value();
19431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19432 {
19433 local_string_length1 = strlen( local_string1 );
19434 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19435 local_charMatrix1.insert( local_string1, 0, 0 );
19436 retval1( 0 ) = octave_value( local_charMatrix1 );
19437 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19438 }
19439 return _out;
19440 fail:
19441 return octave_value_list();
19442 }
19443 catch(...) {
19444 throw;
19445 }
19446}
19447
19448
19450 PLINT *arg1 = (PLINT *) 0 ;
19451 PLINT *arg2 = (PLINT *) 0 ;
19452 PLINT *arg3 = (PLINT *) 0 ;
19453 PLINT temp1 ;
19454 int res1 = SWIG_TMPOBJ ;
19455 PLINT temp2 ;
19456 int res2 = SWIG_TMPOBJ ;
19457 PLINT temp3 ;
19458 int res3 = SWIG_TMPOBJ ;
19459 octave_value_list _out;
19460 octave_value_list *_outp=&_out;
19461 octave_value _outv;
19462
19463 try {
19464 arg1 = &temp1;
19465 arg2 = &temp2;
19466 arg3 = &temp3;
19467 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19468 SWIG_fail;
19469 }
19470 plgfont(arg1,arg2,arg3);
19471 _outv = octave_value();
19472 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19473 if (SWIG_IsTmpObj(res1)) {
19474 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19475 } else {
19476 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19477 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19478 }
19479 if (SWIG_IsTmpObj(res2)) {
19480 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19481 } else {
19482 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19483 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19484 }
19485 if (SWIG_IsTmpObj(res3)) {
19486 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19487 } else {
19488 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19489 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19490 }
19491 return _out;
19492 fail:
19493 return octave_value_list();
19494 }
19495 catch(...) {
19496 throw;
19497 }
19498}
19499
19500
19502 PLINT *arg1 = (PLINT *) 0 ;
19503 PLINT temp1 ;
19504 int res1 = SWIG_TMPOBJ ;
19505 octave_value_list _out;
19506 octave_value_list *_outp=&_out;
19507 octave_value _outv;
19508
19509 try {
19510 arg1 = &temp1;
19511 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19512 SWIG_fail;
19513 }
19514 plglevel(arg1);
19515 _outv = octave_value();
19516 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19517 if (SWIG_IsTmpObj(res1)) {
19518 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19519 } else {
19520 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19521 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19522 }
19523 return _out;
19524 fail:
19525 return octave_value_list();
19526 }
19527 catch(...) {
19528 throw;
19529 }
19530}
19531
19532
19534 PLFLT *arg1 = (PLFLT *) 0 ;
19535 PLFLT *arg2 = (PLFLT *) 0 ;
19536 PLINT *arg3 = (PLINT *) 0 ;
19537 PLINT *arg4 = (PLINT *) 0 ;
19538 PLINT *arg5 = (PLINT *) 0 ;
19539 PLINT *arg6 = (PLINT *) 0 ;
19540 PLFLT temp1 ;
19541 int res1 = SWIG_TMPOBJ ;
19542 PLFLT temp2 ;
19543 int res2 = SWIG_TMPOBJ ;
19544 PLINT temp3 ;
19545 int res3 = SWIG_TMPOBJ ;
19546 PLINT temp4 ;
19547 int res4 = SWIG_TMPOBJ ;
19548 PLINT temp5 ;
19549 int res5 = SWIG_TMPOBJ ;
19550 PLINT temp6 ;
19551 int res6 = SWIG_TMPOBJ ;
19552 octave_value_list _out;
19553 octave_value_list *_outp=&_out;
19554 octave_value _outv;
19555
19556 try {
19557 arg1 = &temp1;
19558 arg2 = &temp2;
19559 arg3 = &temp3;
19560 arg4 = &temp4;
19561 arg5 = &temp5;
19562 arg6 = &temp6;
19563 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19564 SWIG_fail;
19565 }
19566 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19567 _outv = octave_value();
19568 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19569 if (SWIG_IsTmpObj(res1)) {
19570 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19571 } else {
19572 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19573 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19574 }
19575 if (SWIG_IsTmpObj(res2)) {
19576 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19577 } else {
19578 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19579 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19580 }
19581 if (SWIG_IsTmpObj(res3)) {
19582 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19583 } else {
19584 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19585 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19586 }
19587 if (SWIG_IsTmpObj(res4)) {
19588 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19589 } else {
19590 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19591 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19592 }
19593 if (SWIG_IsTmpObj(res5)) {
19594 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19595 } else {
19596 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19597 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19598 }
19599 if (SWIG_IsTmpObj(res6)) {
19600 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19601 } else {
19602 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19603 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19604 }
19605 return _out;
19606 fail:
19607 return octave_value_list();
19608 }
19609 catch(...) {
19610 throw;
19611 }
19612}
19613
19614
19616 octave_value_list _out;
19617 octave_value_list *_outp=&_out;
19618 octave_value _outv;
19619
19620 try {
19621 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19622 SWIG_fail;
19623 }
19624 plgra();
19625 _outv = octave_value();
19626 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19627 return _out;
19628 fail:
19629 return octave_value_list();
19630 }
19631 catch(...) {
19632 throw;
19633 }
19634}
19635
19636
19638 PLFLT *arg1 = (PLFLT *) 0 ;
19639 PLFLT *arg2 = (PLFLT *) 0 ;
19640 PLFLT *arg3 = (PLFLT *) 0 ;
19641 PLFLT *arg4 = (PLFLT *) 0 ;
19642 PLFLT temp1 ;
19643 int res1 = SWIG_TMPOBJ ;
19644 PLFLT temp2 ;
19645 int res2 = SWIG_TMPOBJ ;
19646 PLFLT temp3 ;
19647 int res3 = SWIG_TMPOBJ ;
19648 PLFLT temp4 ;
19649 int res4 = SWIG_TMPOBJ ;
19650 octave_value_list _out;
19651 octave_value_list *_outp=&_out;
19652 octave_value _outv;
19653
19654 try {
19655 arg1 = &temp1;
19656 arg2 = &temp2;
19657 arg3 = &temp3;
19658 arg4 = &temp4;
19659 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19660 SWIG_fail;
19661 }
19662 plgspa(arg1,arg2,arg3,arg4);
19663 _outv = octave_value();
19664 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19665 if (SWIG_IsTmpObj(res1)) {
19666 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19667 } else {
19668 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19669 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19670 }
19671 if (SWIG_IsTmpObj(res2)) {
19672 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19673 } else {
19674 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19675 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19676 }
19677 if (SWIG_IsTmpObj(res3)) {
19678 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19679 } else {
19680 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19681 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19682 }
19683 if (SWIG_IsTmpObj(res4)) {
19684 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19685 } else {
19686 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19687 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19688 }
19689 return _out;
19690 fail:
19691 return octave_value_list();
19692 }
19693 catch(...) {
19694 throw;
19695 }
19696}
19697
19698
19700 PLINT *arg1 = (PLINT *) 0 ;
19701 PLINT temp1 ;
19702 int res1 = SWIG_TMPOBJ ;
19703 octave_value_list _out;
19704 octave_value_list *_outp=&_out;
19705 octave_value _outv;
19706
19707 try {
19708 arg1 = &temp1;
19709 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19710 SWIG_fail;
19711 }
19712 plgstrm(arg1);
19713 _outv = octave_value();
19714 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19715 if (SWIG_IsTmpObj(res1)) {
19716 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19717 } else {
19718 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19719 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19720 }
19721 return _out;
19722 fail:
19723 return octave_value_list();
19724 }
19725 catch(...) {
19726 throw;
19727 }
19728}
19729
19730
19732 char *arg1 = (char *) 0 ;
19733 char local_string1[80] ;
19734 size_t local_string_length1 ;
19735 charMatrix local_charMatrix1 ;
19736 octave_value_list retval1 ;
19737 octave_value_list _out;
19738 octave_value_list *_outp=&_out;
19739 octave_value _outv;
19740
19741 try {
19742 {
19743 arg1 = local_string1;
19744 }
19745 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19746 SWIG_fail;
19747 }
19748 plgver(arg1);
19749 _outv = octave_value();
19750 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19751 {
19752 local_string_length1 = strlen( local_string1 );
19753 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19754 local_charMatrix1.insert( local_string1, 0, 0 );
19755 retval1( 0 ) = octave_value( local_charMatrix1 );
19756 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19757 }
19758 return _out;
19759 fail:
19760 return octave_value_list();
19761 }
19762 catch(...) {
19763 throw;
19764 }
19765}
19766
19767
19769 PLFLT *arg1 = (PLFLT *) 0 ;
19770 PLFLT *arg2 = (PLFLT *) 0 ;
19771 PLFLT *arg3 = (PLFLT *) 0 ;
19772 PLFLT *arg4 = (PLFLT *) 0 ;
19773 PLFLT temp1 ;
19774 int res1 = SWIG_TMPOBJ ;
19775 PLFLT temp2 ;
19776 int res2 = SWIG_TMPOBJ ;
19777 PLFLT temp3 ;
19778 int res3 = SWIG_TMPOBJ ;
19779 PLFLT temp4 ;
19780 int res4 = SWIG_TMPOBJ ;
19781 octave_value_list _out;
19782 octave_value_list *_outp=&_out;
19783 octave_value _outv;
19784
19785 try {
19786 arg1 = &temp1;
19787 arg2 = &temp2;
19788 arg3 = &temp3;
19789 arg4 = &temp4;
19790 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19791 SWIG_fail;
19792 }
19793 plgvpd(arg1,arg2,arg3,arg4);
19794 _outv = octave_value();
19795 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19796 if (SWIG_IsTmpObj(res1)) {
19797 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19798 } else {
19799 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19800 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19801 }
19802 if (SWIG_IsTmpObj(res2)) {
19803 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19804 } else {
19805 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19806 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19807 }
19808 if (SWIG_IsTmpObj(res3)) {
19809 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19810 } else {
19811 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19812 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19813 }
19814 if (SWIG_IsTmpObj(res4)) {
19815 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19816 } else {
19817 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19818 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19819 }
19820 return _out;
19821 fail:
19822 return octave_value_list();
19823 }
19824 catch(...) {
19825 throw;
19826 }
19827}
19828
19829
19831 PLFLT *arg1 = (PLFLT *) 0 ;
19832 PLFLT *arg2 = (PLFLT *) 0 ;
19833 PLFLT *arg3 = (PLFLT *) 0 ;
19834 PLFLT *arg4 = (PLFLT *) 0 ;
19835 PLFLT temp1 ;
19836 int res1 = SWIG_TMPOBJ ;
19837 PLFLT temp2 ;
19838 int res2 = SWIG_TMPOBJ ;
19839 PLFLT temp3 ;
19840 int res3 = SWIG_TMPOBJ ;
19841 PLFLT temp4 ;
19842 int res4 = SWIG_TMPOBJ ;
19843 octave_value_list _out;
19844 octave_value_list *_outp=&_out;
19845 octave_value _outv;
19846
19847 try {
19848 arg1 = &temp1;
19849 arg2 = &temp2;
19850 arg3 = &temp3;
19851 arg4 = &temp4;
19852 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19853 SWIG_fail;
19854 }
19855 plgvpw(arg1,arg2,arg3,arg4);
19856 _outv = octave_value();
19857 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19858 if (SWIG_IsTmpObj(res1)) {
19859 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19860 } else {
19861 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19862 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19863 }
19864 if (SWIG_IsTmpObj(res2)) {
19865 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19866 } else {
19867 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19868 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19869 }
19870 if (SWIG_IsTmpObj(res3)) {
19871 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19872 } else {
19873 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19874 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19875 }
19876 if (SWIG_IsTmpObj(res4)) {
19877 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19878 } else {
19879 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19880 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19881 }
19882 return _out;
19883 fail:
19884 return octave_value_list();
19885 }
19886 catch(...) {
19887 throw;
19888 }
19889}
19890
19891
19893 PLINT *arg1 = (PLINT *) 0 ;
19894 PLINT *arg2 = (PLINT *) 0 ;
19895 PLINT temp1 ;
19896 int res1 = SWIG_TMPOBJ ;
19897 PLINT temp2 ;
19898 int res2 = SWIG_TMPOBJ ;
19899 octave_value_list _out;
19900 octave_value_list *_outp=&_out;
19901 octave_value _outv;
19902
19903 try {
19904 arg1 = &temp1;
19905 arg2 = &temp2;
19906 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
19907 SWIG_fail;
19908 }
19909 plgxax(arg1,arg2);
19910 _outv = octave_value();
19911 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19912 if (SWIG_IsTmpObj(res1)) {
19913 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19914 } else {
19915 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19916 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19917 }
19918 if (SWIG_IsTmpObj(res2)) {
19919 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19920 } else {
19921 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19922 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19923 }
19924 return _out;
19925 fail:
19926 return octave_value_list();
19927 }
19928 catch(...) {
19929 throw;
19930 }
19931}
19932
19933
19935 PLINT *arg1 = (PLINT *) 0 ;
19936 PLINT *arg2 = (PLINT *) 0 ;
19937 PLINT temp1 ;
19938 int res1 = SWIG_TMPOBJ ;
19939 PLINT temp2 ;
19940 int res2 = SWIG_TMPOBJ ;
19941 octave_value_list _out;
19942 octave_value_list *_outp=&_out;
19943 octave_value _outv;
19944
19945 try {
19946 arg1 = &temp1;
19947 arg2 = &temp2;
19948 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
19949 SWIG_fail;
19950 }
19951 plgyax(arg1,arg2);
19952 _outv = octave_value();
19953 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19954 if (SWIG_IsTmpObj(res1)) {
19955 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19956 } else {
19957 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19958 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19959 }
19960 if (SWIG_IsTmpObj(res2)) {
19961 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19962 } else {
19963 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19964 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19965 }
19966 return _out;
19967 fail:
19968 return octave_value_list();
19969 }
19970 catch(...) {
19971 throw;
19972 }
19973}
19974
19975
19977 PLINT *arg1 = (PLINT *) 0 ;
19978 PLINT *arg2 = (PLINT *) 0 ;
19979 PLINT temp1 ;
19980 int res1 = SWIG_TMPOBJ ;
19981 PLINT temp2 ;
19982 int res2 = SWIG_TMPOBJ ;
19983 octave_value_list _out;
19984 octave_value_list *_outp=&_out;
19985 octave_value _outv;
19986
19987 try {
19988 arg1 = &temp1;
19989 arg2 = &temp2;
19990 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
19991 SWIG_fail;
19992 }
19993 plgzax(arg1,arg2);
19994 _outv = octave_value();
19995 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19996 if (SWIG_IsTmpObj(res1)) {
19997 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19998 } else {
19999 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20000 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20001 }
20002 if (SWIG_IsTmpObj(res2)) {
20003 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20004 } else {
20005 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20006 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20007 }
20008 return _out;
20009 fail:
20010 return octave_value_list();
20011 }
20012 catch(...) {
20013 throw;
20014 }
20015}
20016
20017
20019 PLINT arg1 ;
20020 PLFLT *arg2 = (PLFLT *) 0 ;
20021 PLFLT arg3 ;
20022 PLFLT arg4 ;
20023 PLINT arg5 ;
20024 PLINT arg6 ;
20025 Matrix temp1 ;
20026 double val3 ;
20027 int ecode3 = 0 ;
20028 double val4 ;
20029 int ecode4 = 0 ;
20030 int val5 ;
20031 int ecode5 = 0 ;
20032 int val6 ;
20033 int ecode6 = 0 ;
20034 octave_value_list _out;
20035 octave_value_list *_outp=&_out;
20036 octave_value _outv;
20037
20038 try {
20039 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20040 SWIG_fail;
20041 }
20042 {
20043 if ( _n_dims( args(0) ) > 1 )
20044 {
20045 error( "argument must be a scalar or vector" ); SWIG_fail;
20046 }
20047 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20048 temp1 = args(0).matrix_value();
20049 arg2 = &temp1( 0, 0 );
20050 }
20051 ecode3 = SWIG_AsVal_double(args(1), &val3);
20052 if (!SWIG_IsOK(ecode3)) {
20053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20054 }
20055 arg3 = static_cast< PLFLT >(val3);
20056 ecode4 = SWIG_AsVal_double(args(2), &val4);
20057 if (!SWIG_IsOK(ecode4)) {
20058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20059 }
20060 arg4 = static_cast< PLFLT >(val4);
20061 ecode5 = SWIG_AsVal_int(args(3), &val5);
20062 if (!SWIG_IsOK(ecode5)) {
20063 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20064 }
20065 arg5 = static_cast< PLINT >(val5);
20066 ecode6 = SWIG_AsVal_int(args(4), &val6);
20067 if (!SWIG_IsOK(ecode6)) {
20068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20069 }
20070 arg6 = static_cast< PLINT >(val6);
20071 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20072 _outv = octave_value();
20073 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20074 {
20075
20076 }
20077 return _out;
20078 fail:
20079 {
20080
20081 }
20082 return octave_value_list();
20083 }
20084 catch(...) {
20085 {
20086
20087 }
20088 throw;
20089 }
20090}
20091
20092
20094 PLFLT arg1 ;
20095 PLFLT arg2 ;
20096 PLFLT arg3 ;
20097 PLFLT *arg4 = (PLFLT *) 0 ;
20098 PLFLT *arg5 = (PLFLT *) 0 ;
20099 PLFLT *arg6 = (PLFLT *) 0 ;
20100 double val1 ;
20101 int ecode1 = 0 ;
20102 double val2 ;
20103 int ecode2 = 0 ;
20104 double val3 ;
20105 int ecode3 = 0 ;
20106 PLFLT temp4 ;
20107 int res4 = SWIG_TMPOBJ ;
20108 PLFLT temp5 ;
20109 int res5 = SWIG_TMPOBJ ;
20110 PLFLT temp6 ;
20111 int res6 = SWIG_TMPOBJ ;
20112 octave_value_list _out;
20113 octave_value_list *_outp=&_out;
20114 octave_value _outv;
20115
20116 try {
20117 arg4 = &temp4;
20118 arg5 = &temp5;
20119 arg6 = &temp6;
20120 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20121 SWIG_fail;
20122 }
20123 ecode1 = SWIG_AsVal_double(args(0), &val1);
20124 if (!SWIG_IsOK(ecode1)) {
20125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20126 }
20127 arg1 = static_cast< PLFLT >(val1);
20128 ecode2 = SWIG_AsVal_double(args(1), &val2);
20129 if (!SWIG_IsOK(ecode2)) {
20130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20131 }
20132 arg2 = static_cast< PLFLT >(val2);
20133 ecode3 = SWIG_AsVal_double(args(2), &val3);
20134 if (!SWIG_IsOK(ecode3)) {
20135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20136 }
20137 arg3 = static_cast< PLFLT >(val3);
20138 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20139 _outv = octave_value();
20140 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20141 if (SWIG_IsTmpObj(res4)) {
20142 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20143 } else {
20144 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20145 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20146 }
20147 if (SWIG_IsTmpObj(res5)) {
20148 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20149 } else {
20150 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20151 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20152 }
20153 if (SWIG_IsTmpObj(res6)) {
20154 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20155 } else {
20156 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20157 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20158 }
20159 return _out;
20160 fail:
20161 return octave_value_list();
20162 }
20163 catch(...) {
20164 throw;
20165 }
20166}
20167
20168
20170 octave_value_list _out;
20171 octave_value_list *_outp=&_out;
20172 octave_value _outv;
20173
20174 try {
20175 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20176 SWIG_fail;
20177 }
20178 plinit();
20179 _outv = octave_value();
20180 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20181 return _out;
20182 fail:
20183 return octave_value_list();
20184 }
20185 catch(...) {
20186 throw;
20187 }
20188}
20189
20190
20192 PLFLT arg1 ;
20193 PLFLT arg2 ;
20194 PLFLT arg3 ;
20195 PLFLT arg4 ;
20196 double val1 ;
20197 int ecode1 = 0 ;
20198 double val2 ;
20199 int ecode2 = 0 ;
20200 double val3 ;
20201 int ecode3 = 0 ;
20202 double val4 ;
20203 int ecode4 = 0 ;
20204 octave_value_list _out;
20205 octave_value_list *_outp=&_out;
20206 octave_value _outv;
20207
20208 try {
20209 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20210 SWIG_fail;
20211 }
20212 ecode1 = SWIG_AsVal_double(args(0), &val1);
20213 if (!SWIG_IsOK(ecode1)) {
20214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20215 }
20216 arg1 = static_cast< PLFLT >(val1);
20217 ecode2 = SWIG_AsVal_double(args(1), &val2);
20218 if (!SWIG_IsOK(ecode2)) {
20219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20220 }
20221 arg2 = static_cast< PLFLT >(val2);
20222 ecode3 = SWIG_AsVal_double(args(2), &val3);
20223 if (!SWIG_IsOK(ecode3)) {
20224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20225 }
20226 arg3 = static_cast< PLFLT >(val3);
20227 ecode4 = SWIG_AsVal_double(args(3), &val4);
20228 if (!SWIG_IsOK(ecode4)) {
20229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20230 }
20231 arg4 = static_cast< PLFLT >(val4);
20232 pljoin(arg1,arg2,arg3,arg4);
20233 _outv = octave_value();
20234 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20235 return _out;
20236 fail:
20237 return octave_value_list();
20238 }
20239 catch(...) {
20240 throw;
20241 }
20242}
20243
20244
20246 char *arg1 = (char *) 0 ;
20247 char *arg2 = (char *) 0 ;
20248 char *arg3 = (char *) 0 ;
20249 int res1 ;
20250 char *buf1 = 0 ;
20251 int alloc1 = 0 ;
20252 int res2 ;
20253 char *buf2 = 0 ;
20254 int alloc2 = 0 ;
20255 int res3 ;
20256 char *buf3 = 0 ;
20257 int alloc3 = 0 ;
20258 octave_value_list _out;
20259 octave_value_list *_outp=&_out;
20260 octave_value _outv;
20261
20262 try {
20263 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20264 SWIG_fail;
20265 }
20266 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20267 if (!SWIG_IsOK(res1)) {
20268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20269 }
20270 arg1 = reinterpret_cast< char * >(buf1);
20271 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20272 if (!SWIG_IsOK(res2)) {
20273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20274 }
20275 arg2 = reinterpret_cast< char * >(buf2);
20276 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20277 if (!SWIG_IsOK(res3)) {
20278 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20279 }
20280 arg3 = reinterpret_cast< char * >(buf3);
20281 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20282 _outv = octave_value();
20283 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20284 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20285 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20286 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20287 return _out;
20288 fail:
20289 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20290 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20291 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20292 return octave_value_list();
20293 }
20294 catch(...) {
20295 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20296 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20297 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20298 throw;
20299 }
20300}
20301
20302
20304 PLFLT *arg1 = (PLFLT *) 0 ;
20305 PLFLT *arg2 = (PLFLT *) 0 ;
20306 PLINT arg3 ;
20307 PLINT arg4 ;
20308 PLFLT arg5 ;
20309 PLFLT arg6 ;
20310 PLFLT arg7 ;
20311 PLINT arg8 ;
20312 PLINT arg9 ;
20313 PLINT arg10 ;
20314 PLINT arg11 ;
20315 PLINT arg12 ;
20316 PLINT arg13 ;
20317 PLINT *arg14 = (PLINT *) 0 ;
20318 PLFLT arg15 ;
20319 PLFLT arg16 ;
20320 PLFLT arg17 ;
20321 PLFLT arg18 ;
20322 PLINT *arg19 = (PLINT *) 0 ;
20323 char **arg20 = (char **) 0 ;
20324 PLINT *arg21 = (PLINT *) 0 ;
20325 PLINT *arg22 = (PLINT *) 0 ;
20326 PLFLT *arg23 = (PLFLT *) 0 ;
20327 PLFLT *arg24 = (PLFLT *) 0 ;
20328 PLINT *arg25 = (PLINT *) 0 ;
20329 PLINT *arg26 = (PLINT *) 0 ;
20330 PLFLT *arg27 = (PLFLT *) 0 ;
20331 PLINT *arg28 = (PLINT *) 0 ;
20332 PLFLT *arg29 = (PLFLT *) 0 ;
20333 PLINT *arg30 = (PLINT *) 0 ;
20334 char **arg31 = (char **) 0 ;
20335 PLFLT temp1 ;
20336 int res1 = SWIG_TMPOBJ ;
20337 PLFLT temp2 ;
20338 int res2 = SWIG_TMPOBJ ;
20339 int val3 ;
20340 int ecode3 = 0 ;
20341 int val4 ;
20342 int ecode4 = 0 ;
20343 double val5 ;
20344 int ecode5 = 0 ;
20345 double val6 ;
20346 int ecode6 = 0 ;
20347 double val7 ;
20348 int ecode7 = 0 ;
20349 int val8 ;
20350 int ecode8 = 0 ;
20351 int val9 ;
20352 int ecode9 = 0 ;
20353 int val10 ;
20354 int ecode10 = 0 ;
20355 int val11 ;
20356 int ecode11 = 0 ;
20357 int val12 ;
20358 int ecode12 = 0 ;
20359 Matrix temp13 ;
20360 double val15 ;
20361 int ecode15 = 0 ;
20362 double val16 ;
20363 int ecode16 = 0 ;
20364 double val17 ;
20365 int ecode17 = 0 ;
20366 double val18 ;
20367 int ecode18 = 0 ;
20368 Matrix temp19 ;
20369 Matrix temp21 ;
20370 Matrix temp22 ;
20371 Matrix temp23 ;
20372 Matrix temp24 ;
20373 Matrix temp25 ;
20374 Matrix temp26 ;
20375 Matrix temp27 ;
20376 Matrix temp28 ;
20377 Matrix temp29 ;
20378 Matrix temp30 ;
20379 octave_value_list _out;
20380 octave_value_list *_outp=&_out;
20381 octave_value _outv;
20382
20383 try {
20384 arg1 = &temp1;
20385 arg2 = &temp2;
20386 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20387 SWIG_fail;
20388 }
20389 ecode3 = SWIG_AsVal_int(args(0), &val3);
20390 if (!SWIG_IsOK(ecode3)) {
20391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20392 }
20393 arg3 = static_cast< PLINT >(val3);
20394 ecode4 = SWIG_AsVal_int(args(1), &val4);
20395 if (!SWIG_IsOK(ecode4)) {
20396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20397 }
20398 arg4 = static_cast< PLINT >(val4);
20399 ecode5 = SWIG_AsVal_double(args(2), &val5);
20400 if (!SWIG_IsOK(ecode5)) {
20401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20402 }
20403 arg5 = static_cast< PLFLT >(val5);
20404 ecode6 = SWIG_AsVal_double(args(3), &val6);
20405 if (!SWIG_IsOK(ecode6)) {
20406 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20407 }
20408 arg6 = static_cast< PLFLT >(val6);
20409 ecode7 = SWIG_AsVal_double(args(4), &val7);
20410 if (!SWIG_IsOK(ecode7)) {
20411 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20412 }
20413 arg7 = static_cast< PLFLT >(val7);
20414 ecode8 = SWIG_AsVal_int(args(5), &val8);
20415 if (!SWIG_IsOK(ecode8)) {
20416 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20417 }
20418 arg8 = static_cast< PLINT >(val8);
20419 ecode9 = SWIG_AsVal_int(args(6), &val9);
20420 if (!SWIG_IsOK(ecode9)) {
20421 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20422 }
20423 arg9 = static_cast< PLINT >(val9);
20424 ecode10 = SWIG_AsVal_int(args(7), &val10);
20425 if (!SWIG_IsOK(ecode10)) {
20426 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20427 }
20428 arg10 = static_cast< PLINT >(val10);
20429 ecode11 = SWIG_AsVal_int(args(8), &val11);
20430 if (!SWIG_IsOK(ecode11)) {
20431 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20432 }
20433 arg11 = static_cast< PLINT >(val11);
20434 ecode12 = SWIG_AsVal_int(args(9), &val12);
20435 if (!SWIG_IsOK(ecode12)) {
20436 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20437 }
20438 arg12 = static_cast< PLINT >(val12);
20439 {
20440 if ( _n_dims( args(10) ) > 1 )
20441 {
20442 error( "argument must be a scalar or vector" ); SWIG_fail;
20443 }
20444 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20445 arg14 = new PLINT[Alen];
20446 temp13 = args(10).matrix_value();
20447 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20448 }
20449 ecode15 = SWIG_AsVal_double(args(11), &val15);
20450 if (!SWIG_IsOK(ecode15)) {
20451 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20452 }
20453 arg15 = static_cast< PLFLT >(val15);
20454 ecode16 = SWIG_AsVal_double(args(12), &val16);
20455 if (!SWIG_IsOK(ecode16)) {
20456 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20457 }
20458 arg16 = static_cast< PLFLT >(val16);
20459 ecode17 = SWIG_AsVal_double(args(13), &val17);
20460 if (!SWIG_IsOK(ecode17)) {
20461 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20462 }
20463 arg17 = static_cast< PLFLT >(val17);
20464 ecode18 = SWIG_AsVal_double(args(14), &val18);
20465 if (!SWIG_IsOK(ecode18)) {
20466 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20467 }
20468 arg18 = static_cast< PLFLT >(val18);
20469 {
20470 if ( _n_dims( args(15) ) > 1 )
20471 {
20472 error( "argument must be a scalar or vector" ); SWIG_fail;
20473 }
20474 if ( _dim( args(15), 0 ) != Alen )
20475 {
20476 error( "argument vectors must be same length" ); SWIG_fail;
20477 }
20478 temp19 = args(15).matrix_value();
20479 arg19 = new PLINT[Alen];
20480 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20481 }
20482 {
20483 charMatrix temp_matrix;
20484 Cell temp_cell;
20485 char *tmp_cstring;
20486 std::string str;
20487 size_t max_length = 0, non_blank_length;
20488 int i, ifcell;
20489 if ( _n_dims( args(16) ) > 2 )
20490 {
20491 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20492 }
20493#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20494 if ( !args(16).isempty() )
20495#else
20496 if ( !args(16).is_empty() )
20497#endif
20498 {
20499 if ( _dim( args(16), 0 ) != Alen )
20500 {
20501 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20502 }
20503 arg20 = new char*[Alen];
20504#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20505 ifcell = args(16).iscell();
20506#else
20507 ifcell = args(16).is_cell();
20508#endif
20509 if ( ifcell )
20510 {
20511 temp_cell = args(16).cell_value();
20512 }
20513 else
20514 {
20515 temp_matrix = args(16).char_matrix_value();
20516 // Allow one extra space for null termination.
20517 max_length = _dim( args(16), 1 ) + 1;
20518 }
20519
20520 for ( i = 0; i < Alen; i++ )
20521 {
20522 // Must copy string to "permanent" location because the string
20523 // location corresponding to tmp_cstring gets
20524 // overwritten for each iteration of loop.
20525 if ( ifcell )
20526 {
20527 if ( temp_cell.elem( i ).is_string() )
20528 {
20529 str = temp_cell.elem( i ).string_value();
20530 // leave room for null termination.
20531 max_length = str.size() + 1;
20532 tmp_cstring = (char *) str.c_str();
20533 }
20534 else
20535 {
20536 // Use null string if user attempts to pass a cell array
20537 // with a non-string element (likely an empty element
20538 // since that should be allowed by the PLplot interface
20539 // if that element is going to be unused).
20540 // leave room for null termination.
20541 max_length = 1;
20542 tmp_cstring = (char *) "";
20543 }
20544 }
20545 else
20546 {
20547 str = temp_matrix.row_as_string( i );
20548 tmp_cstring = (char *) str.c_str();
20549 }
20550 arg20[i] = new char[max_length];
20551 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20552 arg20[i][max_length - 1] = '\0';
20553 // All the trailing blank crapola should not be needed for
20554 // string cell arrays.
20555 if ( !ifcell )
20556 {
20557 // remove trailing-blank padding that is used by the
20558 // charMatrix class to insure all strings in a given
20559 // charMatrix instance have the same length.
20560 // This transformation also removes legitimate trailing
20561 // blanks but there is nothing we can do about that
20562 // for the charMatrix class.
20563
20564 // Look for trailing nulls first (just in case, although that
20565 // shouldn't happen if charMatrix implemented as documented)
20566 // before looking for trailing blanks.
20567 non_blank_length = max_length - 2;
20568 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20569 {
20570 non_blank_length--;
20571 }
20572 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20573 {
20574 non_blank_length--;
20575 }
20576 arg20[i][non_blank_length + 1] = '\0';
20577 }
20578 }
20579 }
20580 else
20581 {
20582 arg20 = NULL;
20583 }
20584 }
20585 {
20586 if ( _n_dims( args(17) ) > 1 )
20587 {
20588 error( "argument must be a scalar or vector" ); SWIG_fail;
20589 }
20590#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20591 if ( !args(17).isempty() )
20592#else
20593 if ( !args(17).is_empty() )
20594#endif
20595 {
20596 if ( _dim( args(17), 0 ) != Alen )
20597 {
20598 error( "argument vectors must be same length" ); SWIG_fail;
20599 }
20600 temp21 = args(17).matrix_value();
20601 arg21 = new PLINT[Alen];
20602 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20603 }
20604 else
20605 {
20606 arg21 = NULL;
20607 }
20608 }
20609 {
20610 if ( _n_dims( args(18) ) > 1 )
20611 {
20612 error( "argument must be a scalar or vector" ); SWIG_fail;
20613 }
20614#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20615 if ( !args(18).isempty() )
20616#else
20617 if ( !args(18).is_empty() )
20618#endif
20619 {
20620 if ( _dim( args(18), 0 ) != Alen )
20621 {
20622 error( "argument vectors must be same length" ); SWIG_fail;
20623 }
20624 temp22 = args(18).matrix_value();
20625 arg22 = new PLINT[Alen];
20626 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20627 }
20628 else
20629 {
20630 arg22 = NULL;
20631 }
20632 }
20633 {
20634 if ( _n_dims( args(19) ) > 1 )
20635 {
20636 error( "argument must be a scalar or vector" ); SWIG_fail;
20637 }
20638#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20639 if ( !args(19).isempty() )
20640#else
20641 if ( !args(19).is_empty() )
20642#endif
20643 {
20644 if ( _dim( args(19), 0 ) != Alen )
20645 {
20646 error( "argument vectors must be same length" ); SWIG_fail;
20647 }
20648 temp23 = args(19).matrix_value();
20649 arg23 = &temp23( 0, 0 );
20650 }
20651 else
20652 {
20653 arg23 = NULL;
20654 }
20655 }
20656 {
20657 if ( _n_dims( args(20) ) > 1 )
20658 {
20659 error( "argument must be a scalar or vector" ); SWIG_fail;
20660 }
20661#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20662 if ( !args(20).isempty() )
20663#else
20664 if ( !args(20).is_empty() )
20665#endif
20666 {
20667 if ( _dim( args(20), 0 ) != Alen )
20668 {
20669 error( "argument vectors must be same length" ); SWIG_fail;
20670 }
20671 temp24 = args(20).matrix_value();
20672 arg24 = &temp24( 0, 0 );
20673 }
20674 else
20675 {
20676 arg24 = NULL;
20677 }
20678 }
20679 {
20680 if ( _n_dims( args(21) ) > 1 )
20681 {
20682 error( "argument must be a scalar or vector" ); SWIG_fail;
20683 }
20684#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20685 if ( !args(21).isempty() )
20686#else
20687 if ( !args(21).is_empty() )
20688#endif
20689 {
20690 if ( _dim( args(21), 0 ) != Alen )
20691 {
20692 error( "argument vectors must be same length" ); SWIG_fail;
20693 }
20694 temp25 = args(21).matrix_value();
20695 arg25 = new PLINT[Alen];
20696 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20697 }
20698 else
20699 {
20700 arg25 = NULL;
20701 }
20702 }
20703 {
20704 if ( _n_dims( args(22) ) > 1 )
20705 {
20706 error( "argument must be a scalar or vector" ); SWIG_fail;
20707 }
20708#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20709 if ( !args(22).isempty() )
20710#else
20711 if ( !args(22).is_empty() )
20712#endif
20713 {
20714 if ( _dim( args(22), 0 ) != Alen )
20715 {
20716 error( "argument vectors must be same length" ); SWIG_fail;
20717 }
20718 temp26 = args(22).matrix_value();
20719 arg26 = new PLINT[Alen];
20720 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20721 }
20722 else
20723 {
20724 arg26 = NULL;
20725 }
20726 }
20727 {
20728 if ( _n_dims( args(23) ) > 1 )
20729 {
20730 error( "argument must be a scalar or vector" ); SWIG_fail;
20731 }
20732#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20733 if ( !args(23).isempty() )
20734#else
20735 if ( !args(23).is_empty() )
20736#endif
20737 {
20738 if ( _dim( args(23), 0 ) != Alen )
20739 {
20740 error( "argument vectors must be same length" ); SWIG_fail;
20741 }
20742 temp27 = args(23).matrix_value();
20743 arg27 = &temp27( 0, 0 );
20744 }
20745 else
20746 {
20747 arg27 = NULL;
20748 }
20749 }
20750 {
20751 if ( _n_dims( args(24) ) > 1 )
20752 {
20753 error( "argument must be a scalar or vector" ); SWIG_fail;
20754 }
20755#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20756 if ( !args(24).isempty() )
20757#else
20758 if ( !args(24).is_empty() )
20759#endif
20760 {
20761 if ( _dim( args(24), 0 ) != Alen )
20762 {
20763 error( "argument vectors must be same length" ); SWIG_fail;
20764 }
20765 temp28 = args(24).matrix_value();
20766 arg28 = new PLINT[Alen];
20767 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20768 }
20769 else
20770 {
20771 arg28 = NULL;
20772 }
20773 }
20774 {
20775 if ( _n_dims( args(25) ) > 1 )
20776 {
20777 error( "argument must be a scalar or vector" ); SWIG_fail;
20778 }
20779#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20780 if ( !args(25).isempty() )
20781#else
20782 if ( !args(25).is_empty() )
20783#endif
20784 {
20785 if ( _dim( args(25), 0 ) != Alen )
20786 {
20787 error( "argument vectors must be same length" ); SWIG_fail;
20788 }
20789 temp29 = args(25).matrix_value();
20790 arg29 = &temp29( 0, 0 );
20791 }
20792 else
20793 {
20794 arg29 = NULL;
20795 }
20796 }
20797 {
20798 if ( _n_dims( args(26) ) > 1 )
20799 {
20800 error( "argument must be a scalar or vector" ); SWIG_fail;
20801 }
20802#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20803 if ( !args(26).isempty() )
20804#else
20805 if ( !args(26).is_empty() )
20806#endif
20807 {
20808 if ( _dim( args(26), 0 ) != Alen )
20809 {
20810 error( "argument vectors must be same length" ); SWIG_fail;
20811 }
20812 temp30 = args(26).matrix_value();
20813 arg30 = new PLINT[Alen];
20814 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20815 }
20816 else
20817 {
20818 arg30 = NULL;
20819 }
20820 }
20821 {
20822 charMatrix temp_matrix;
20823 Cell temp_cell;
20824 char *tmp_cstring;
20825 std::string str;
20826 size_t max_length = 0, non_blank_length;
20827 int i, ifcell;
20828 if ( _n_dims( args(27) ) > 2 )
20829 {
20830 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20831 }
20832#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20833 if ( !args(27).isempty() )
20834#else
20835 if ( !args(27).is_empty() )
20836#endif
20837 {
20838 if ( _dim( args(27), 0 ) != Alen )
20839 {
20840 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20841 }
20842 arg31 = new char*[Alen];
20843#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20844 ifcell = args(27).iscell();
20845#else
20846 ifcell = args(27).is_cell();
20847#endif
20848 if ( ifcell )
20849 {
20850 temp_cell = args(27).cell_value();
20851 }
20852 else
20853 {
20854 temp_matrix = args(27).char_matrix_value();
20855 // Allow one extra space for null termination.
20856 max_length = _dim( args(27), 1 ) + 1;
20857 }
20858
20859 for ( i = 0; i < Alen; i++ )
20860 {
20861 // Must copy string to "permanent" location because the string
20862 // location corresponding to tmp_cstring gets
20863 // overwritten for each iteration of loop.
20864 if ( ifcell )
20865 {
20866 if ( temp_cell.elem( i ).is_string() )
20867 {
20868 str = temp_cell.elem( i ).string_value();
20869 // leave room for null termination.
20870 max_length = str.size() + 1;
20871 tmp_cstring = (char *) str.c_str();
20872 }
20873 else
20874 {
20875 // Use null string if user attempts to pass a cell array
20876 // with a non-string element (likely an empty element
20877 // since that should be allowed by the PLplot interface
20878 // if that element is going to be unused).
20879 // leave room for null termination.
20880 max_length = 1;
20881 tmp_cstring = (char *) "";
20882 }
20883 }
20884 else
20885 {
20886 str = temp_matrix.row_as_string( i );
20887 tmp_cstring = (char *) str.c_str();
20888 }
20889 arg31[i] = new char[max_length];
20890 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20891 arg31[i][max_length - 1] = '\0';
20892 // All the trailing blank crapola should not be needed for
20893 // string cell arrays.
20894 if ( !ifcell )
20895 {
20896 // remove trailing-blank padding that is used by the
20897 // charMatrix class to insure all strings in a given
20898 // charMatrix instance have the same length.
20899 // This transformation also removes legitimate trailing
20900 // blanks but there is nothing we can do about that
20901 // for the charMatrix class.
20902
20903 // Look for trailing nulls first (just in case, although that
20904 // shouldn't happen if charMatrix implemented as documented)
20905 // before looking for trailing blanks.
20906 non_blank_length = max_length - 2;
20907 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
20908 {
20909 non_blank_length--;
20910 }
20911 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
20912 {
20913 non_blank_length--;
20914 }
20915 arg31[i][non_blank_length + 1] = '\0';
20916 }
20917 }
20918 }
20919 else
20920 {
20921 arg31 = NULL;
20922 }
20923 }
20924 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
20925 _outv = octave_value();
20926 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20927 if (SWIG_IsTmpObj(res1)) {
20928 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20929 } else {
20930 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20931 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20932 }
20933 if (SWIG_IsTmpObj(res2)) {
20934 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20935 } else {
20936 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20937 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20938 }
20939 {
20940 delete [] arg14;
20941 }
20942 {
20943 delete [] arg19;
20944 }
20945 {
20946 int i;
20947 if ( arg20 != NULL )
20948 {
20949 for ( i = 0; i < Alen; i++ )
20950 {
20951 delete[] arg20[i];
20952 }
20953 delete[] arg20;
20954 }
20955 }
20956 {
20957 if ( arg21 != NULL )
20958 delete [] arg21;
20959 }
20960 {
20961 if ( arg22 != NULL )
20962 delete [] arg22;
20963 }
20964 {
20965
20966 }
20967 {
20968
20969 }
20970 {
20971 if ( arg25 != NULL )
20972 delete [] arg25;
20973 }
20974 {
20975 if ( arg26 != NULL )
20976 delete [] arg26;
20977 }
20978 {
20979
20980 }
20981 {
20982 if ( arg28 != NULL )
20983 delete [] arg28;
20984 }
20985 {
20986
20987 }
20988 {
20989 if ( arg30 != NULL )
20990 delete [] arg30;
20991 }
20992 {
20993 int i;
20994 if ( arg31 != NULL )
20995 {
20996 for ( i = 0; i < Alen; i++ )
20997 {
20998 delete[] arg31[i];
20999 }
21000 delete[] arg31;
21001 }
21002 }
21003 return _out;
21004 fail:
21005 {
21006 delete [] arg14;
21007 }
21008 {
21009 delete [] arg19;
21010 }
21011 {
21012 int i;
21013 if ( arg20 != NULL )
21014 {
21015 for ( i = 0; i < Alen; i++ )
21016 {
21017 delete[] arg20[i];
21018 }
21019 delete[] arg20;
21020 }
21021 }
21022 {
21023 if ( arg21 != NULL )
21024 delete [] arg21;
21025 }
21026 {
21027 if ( arg22 != NULL )
21028 delete [] arg22;
21029 }
21030 {
21031
21032 }
21033 {
21034
21035 }
21036 {
21037 if ( arg25 != NULL )
21038 delete [] arg25;
21039 }
21040 {
21041 if ( arg26 != NULL )
21042 delete [] arg26;
21043 }
21044 {
21045
21046 }
21047 {
21048 if ( arg28 != NULL )
21049 delete [] arg28;
21050 }
21051 {
21052
21053 }
21054 {
21055 if ( arg30 != NULL )
21056 delete [] arg30;
21057 }
21058 {
21059 int i;
21060 if ( arg31 != NULL )
21061 {
21062 for ( i = 0; i < Alen; i++ )
21063 {
21064 delete[] arg31[i];
21065 }
21066 delete[] arg31;
21067 }
21068 }
21069 return octave_value_list();
21070 }
21071 catch(...) {
21072 {
21073 delete [] arg14;
21074 }
21075 {
21076 delete [] arg19;
21077 }
21078 {
21079 int i;
21080 if ( arg20 != NULL )
21081 {
21082 for ( i = 0; i < Alen; i++ )
21083 {
21084 delete[] arg20[i];
21085 }
21086 delete[] arg20;
21087 }
21088 }
21089 {
21090 if ( arg21 != NULL )
21091 delete [] arg21;
21092 }
21093 {
21094 if ( arg22 != NULL )
21095 delete [] arg22;
21096 }
21097 {
21098
21099 }
21100 {
21101
21102 }
21103 {
21104 if ( arg25 != NULL )
21105 delete [] arg25;
21106 }
21107 {
21108 if ( arg26 != NULL )
21109 delete [] arg26;
21110 }
21111 {
21112
21113 }
21114 {
21115 if ( arg28 != NULL )
21116 delete [] arg28;
21117 }
21118 {
21119
21120 }
21121 {
21122 if ( arg30 != NULL )
21123 delete [] arg30;
21124 }
21125 {
21126 int i;
21127 if ( arg31 != NULL )
21128 {
21129 for ( i = 0; i < Alen; i++ )
21130 {
21131 delete[] arg31[i];
21132 }
21133 delete[] arg31;
21134 }
21135 }
21136 throw;
21137 }
21138}
21139
21140
21142 PLFLT arg1 ;
21143 PLFLT arg2 ;
21144 PLFLT arg3 ;
21145 double val1 ;
21146 int ecode1 = 0 ;
21147 double val2 ;
21148 int ecode2 = 0 ;
21149 double val3 ;
21150 int ecode3 = 0 ;
21151 octave_value_list _out;
21152 octave_value_list *_outp=&_out;
21153 octave_value _outv;
21154
21155 try {
21156 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21157 SWIG_fail;
21158 }
21159 ecode1 = SWIG_AsVal_double(args(0), &val1);
21160 if (!SWIG_IsOK(ecode1)) {
21161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21162 }
21163 arg1 = static_cast< PLFLT >(val1);
21164 ecode2 = SWIG_AsVal_double(args(1), &val2);
21165 if (!SWIG_IsOK(ecode2)) {
21166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21167 }
21168 arg2 = static_cast< PLFLT >(val2);
21169 ecode3 = SWIG_AsVal_double(args(2), &val3);
21170 if (!SWIG_IsOK(ecode3)) {
21171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21172 }
21173 arg3 = static_cast< PLFLT >(val3);
21174 pllightsource(arg1,arg2,arg3);
21175 _outv = octave_value();
21176 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21177 return _out;
21178 fail:
21179 return octave_value_list();
21180 }
21181 catch(...) {
21182 throw;
21183 }
21184}
21185
21186
21188 PLINT arg1 ;
21189 PLFLT *arg2 = (PLFLT *) 0 ;
21190 PLFLT *arg3 = (PLFLT *) 0 ;
21191 Matrix temp1 ;
21192 Matrix temp3 ;
21193 octave_value_list _out;
21194 octave_value_list *_outp=&_out;
21195 octave_value _outv;
21196
21197 try {
21198 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21199 SWIG_fail;
21200 }
21201 {
21202 if ( _n_dims( args(0) ) > 1 )
21203 {
21204 error( "argument must be a scalar or vector" ); SWIG_fail;
21205 }
21206 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21207 temp1 = args(0).matrix_value();
21208 arg2 = &temp1( 0, 0 );
21209 }
21210 {
21211 if ( _n_dims( args(1) ) > 1 )
21212 {
21213 error( "argument must be a scalar or vector" ); SWIG_fail;
21214 }
21215 if ( _dim( args(1), 0 ) != Alen )
21216 {
21217 error( "argument vectors must be same length" ); SWIG_fail;
21218 }
21219 temp3 = args(1).matrix_value();
21220 arg3 = &temp3( 0, 0 );
21221 }
21222 plline(arg1,(double const *)arg2,(double const *)arg3);
21223 _outv = octave_value();
21224 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21225 {
21226
21227 }
21228 {
21229
21230 }
21231 return _out;
21232 fail:
21233 {
21234
21235 }
21236 {
21237
21238 }
21239 return octave_value_list();
21240 }
21241 catch(...) {
21242 {
21243
21244 }
21245 {
21246
21247 }
21248 throw;
21249 }
21250}
21251
21252
21254 PLINT arg1 ;
21255 PLFLT *arg2 = (PLFLT *) 0 ;
21256 PLFLT *arg3 = (PLFLT *) 0 ;
21257 PLFLT *arg4 = (PLFLT *) 0 ;
21258 Matrix temp1 ;
21259 Matrix temp3 ;
21260 Matrix temp4 ;
21261 octave_value_list _out;
21262 octave_value_list *_outp=&_out;
21263 octave_value _outv;
21264
21265 try {
21266 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21267 SWIG_fail;
21268 }
21269 {
21270 if ( _n_dims( args(0) ) > 1 )
21271 {
21272 error( "argument must be a scalar or vector" ); SWIG_fail;
21273 }
21274 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21275 temp1 = args(0).matrix_value();
21276 arg2 = &temp1( 0, 0 );
21277 }
21278 {
21279 if ( _n_dims( args(1) ) > 1 )
21280 {
21281 error( "argument must be a scalar or vector" ); SWIG_fail;
21282 }
21283 if ( _dim( args(1), 0 ) != Alen )
21284 {
21285 error( "argument vectors must be same length" ); SWIG_fail;
21286 }
21287 temp3 = args(1).matrix_value();
21288 arg3 = &temp3( 0, 0 );
21289 }
21290 {
21291 if ( _n_dims( args(2) ) > 1 )
21292 {
21293 error( "argument must be a scalar or vector" ); SWIG_fail;
21294 }
21295 if ( _dim( args(2), 0 ) != Alen )
21296 {
21297 error( "argument vectors must be same length" ); SWIG_fail;
21298 }
21299 temp4 = args(2).matrix_value();
21300 arg4 = &temp4( 0, 0 );
21301 }
21302 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21303 _outv = octave_value();
21304 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21305 {
21306
21307 }
21308 {
21309
21310 }
21311 {
21312
21313 }
21314 return _out;
21315 fail:
21316 {
21317
21318 }
21319 {
21320
21321 }
21322 {
21323
21324 }
21325 return octave_value_list();
21326 }
21327 catch(...) {
21328 {
21329
21330 }
21331 {
21332
21333 }
21334 {
21335
21336 }
21337 throw;
21338 }
21339}
21340
21341
21343 PLINT arg1 ;
21344 int val1 ;
21345 int ecode1 = 0 ;
21346 octave_value_list _out;
21347 octave_value_list *_outp=&_out;
21348 octave_value _outv;
21349
21350 try {
21351 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21352 SWIG_fail;
21353 }
21354 ecode1 = SWIG_AsVal_int(args(0), &val1);
21355 if (!SWIG_IsOK(ecode1)) {
21356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21357 }
21358 arg1 = static_cast< PLINT >(val1);
21359 pllsty(arg1);
21360 _outv = octave_value();
21361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21362 return _out;
21363 fail:
21364 return octave_value_list();
21365 }
21366 catch(...) {
21367 throw;
21368 }
21369}
21370
21371
21373 PLINT *arg1 = (PLINT *) 0 ;
21374 PLINT temp1 ;
21375 int res1 = SWIG_TMPOBJ ;
21376 octave_value_list _out;
21377 octave_value_list *_outp=&_out;
21378 octave_value _outv;
21379
21380 try {
21381 arg1 = &temp1;
21382 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21383 SWIG_fail;
21384 }
21385 plmkstrm(arg1);
21386 _outv = octave_value();
21387 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21388 if (SWIG_IsTmpObj(res1)) {
21389 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21390 } else {
21391 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21392 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21393 }
21394 return _out;
21395 fail:
21396 return octave_value_list();
21397 }
21398 catch(...) {
21399 throw;
21400 }
21401}
21402
21403
21405 char *arg1 = (char *) 0 ;
21406 PLFLT arg2 ;
21407 PLFLT arg3 ;
21408 PLFLT arg4 ;
21409 char *arg5 = (char *) 0 ;
21410 int res1 ;
21411 char *buf1 = 0 ;
21412 int alloc1 = 0 ;
21413 double val2 ;
21414 int ecode2 = 0 ;
21415 double val3 ;
21416 int ecode3 = 0 ;
21417 double val4 ;
21418 int ecode4 = 0 ;
21419 int res5 ;
21420 char *buf5 = 0 ;
21421 int alloc5 = 0 ;
21422 octave_value_list _out;
21423 octave_value_list *_outp=&_out;
21424 octave_value _outv;
21425
21426 try {
21427 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21428 SWIG_fail;
21429 }
21430 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21431 if (!SWIG_IsOK(res1)) {
21432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21433 }
21434 arg1 = reinterpret_cast< char * >(buf1);
21435 ecode2 = SWIG_AsVal_double(args(1), &val2);
21436 if (!SWIG_IsOK(ecode2)) {
21437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21438 }
21439 arg2 = static_cast< PLFLT >(val2);
21440 ecode3 = SWIG_AsVal_double(args(2), &val3);
21441 if (!SWIG_IsOK(ecode3)) {
21442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21443 }
21444 arg3 = static_cast< PLFLT >(val3);
21445 ecode4 = SWIG_AsVal_double(args(3), &val4);
21446 if (!SWIG_IsOK(ecode4)) {
21447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21448 }
21449 arg4 = static_cast< PLFLT >(val4);
21450 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21451 if (!SWIG_IsOK(res5)) {
21452 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21453 }
21454 arg5 = reinterpret_cast< char * >(buf5);
21455 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21456 _outv = octave_value();
21457 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21458 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21459 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21460 return _out;
21461 fail:
21462 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21463 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21464 return octave_value_list();
21465 }
21466 catch(...) {
21467 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21468 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21469 throw;
21470 }
21471}
21472
21473
21475 char *arg1 = (char *) 0 ;
21476 PLFLT arg2 ;
21477 PLFLT arg3 ;
21478 PLFLT arg4 ;
21479 char *arg5 = (char *) 0 ;
21480 int res1 ;
21481 char *buf1 = 0 ;
21482 int alloc1 = 0 ;
21483 double val2 ;
21484 int ecode2 = 0 ;
21485 double val3 ;
21486 int ecode3 = 0 ;
21487 double val4 ;
21488 int ecode4 = 0 ;
21489 int res5 ;
21490 char *buf5 = 0 ;
21491 int alloc5 = 0 ;
21492 octave_value_list _out;
21493 octave_value_list *_outp=&_out;
21494 octave_value _outv;
21495
21496 try {
21497 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21498 SWIG_fail;
21499 }
21500 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21501 if (!SWIG_IsOK(res1)) {
21502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21503 }
21504 arg1 = reinterpret_cast< char * >(buf1);
21505 ecode2 = SWIG_AsVal_double(args(1), &val2);
21506 if (!SWIG_IsOK(ecode2)) {
21507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21508 }
21509 arg2 = static_cast< PLFLT >(val2);
21510 ecode3 = SWIG_AsVal_double(args(2), &val3);
21511 if (!SWIG_IsOK(ecode3)) {
21512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21513 }
21514 arg3 = static_cast< PLFLT >(val3);
21515 ecode4 = SWIG_AsVal_double(args(3), &val4);
21516 if (!SWIG_IsOK(ecode4)) {
21517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21518 }
21519 arg4 = static_cast< PLFLT >(val4);
21520 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21521 if (!SWIG_IsOK(res5)) {
21522 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21523 }
21524 arg5 = reinterpret_cast< char * >(buf5);
21525 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21526 _outv = octave_value();
21527 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21528 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21529 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21530 return _out;
21531 fail:
21532 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21533 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21534 return octave_value_list();
21535 }
21536 catch(...) {
21537 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21538 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21539 throw;
21540 }
21541}
21542
21543
21545 int *arg1 = (int *) 0 ;
21546 char **arg2 = (char **) 0 ;
21547 PLINT arg3 ;
21548 void *argp1 = 0 ;
21549 int res1 = 0 ;
21550 void *argp2 = 0 ;
21551 int res2 = 0 ;
21552 int val3 ;
21553 int ecode3 = 0 ;
21554 octave_value_list _out;
21555 octave_value_list *_outp=&_out;
21556 octave_value _outv;
21557 PLINT result;
21558
21559 try {
21560 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21561 SWIG_fail;
21562 }
21563 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21564 if (!SWIG_IsOK(res1)) {
21565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21566 }
21567 arg1 = reinterpret_cast< int * >(argp1);
21568 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21569 if (!SWIG_IsOK(res2)) {
21570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21571 }
21572 arg2 = reinterpret_cast< char ** >(argp2);
21573 ecode3 = SWIG_AsVal_int(args(2), &val3);
21574 if (!SWIG_IsOK(ecode3)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21576 }
21577 arg3 = static_cast< PLINT >(val3);
21578 result = (PLINT)plparseopts(arg1,arg2,arg3);
21579 _outv = SWIG_From_int(static_cast< int >(result));
21580 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21581 return _out;
21582 fail:
21583 return octave_value_list();
21584 }
21585 catch(...) {
21586 throw;
21587 }
21588}
21589
21590
21592 PLINT arg1 ;
21593 PLINT *arg2 = (PLINT *) 0 ;
21594 PLINT *arg3 = (PLINT *) 0 ;
21595 Matrix temp1 ;
21596 Matrix temp3 ;
21597 octave_value_list _out;
21598 octave_value_list *_outp=&_out;
21599 octave_value _outv;
21600
21601 try {
21602 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21603 SWIG_fail;
21604 }
21605 {
21606 if ( _n_dims( args(0) ) > 1 )
21607 {
21608 error( "argument must be a scalar or vector" ); SWIG_fail;
21609 }
21610 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21611 arg2 = new PLINT[Alen];
21612 temp1 = args(0).matrix_value();
21613 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21614 }
21615 {
21616 if ( _n_dims( args(1) ) > 1 )
21617 {
21618 error( "argument must be a scalar or vector" ); SWIG_fail;
21619 }
21620 if ( _dim( args(1), 0 ) != Alen )
21621 {
21622 error( "argument vectors must be same length" ); SWIG_fail;
21623 }
21624 temp3 = args(1).matrix_value();
21625 arg3 = new PLINT[Alen];
21626 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21627 }
21628 plpat(arg1,(int const *)arg2,(int const *)arg3);
21629 _outv = octave_value();
21630 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21631 {
21632 delete [] arg2;
21633 }
21634 {
21635 delete [] arg3;
21636 }
21637 return _out;
21638 fail:
21639 {
21640 delete [] arg2;
21641 }
21642 {
21643 delete [] arg3;
21644 }
21645 return octave_value_list();
21646 }
21647 catch(...) {
21648 {
21649 delete [] arg2;
21650 }
21651 {
21652 delete [] arg3;
21653 }
21654 throw;
21655 }
21656}
21657
21658
21659SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
21660 PLINT arg1 ;
21661 PLFLT arg2 ;
21662 PLFLT arg3 ;
21663 PLFLT arg4 ;
21664 PLFLT arg5 ;
21665 int val1 ;
21666 int ecode1 = 0 ;
21667 double val2 ;
21668 int ecode2 = 0 ;
21669 double val3 ;
21670 int ecode3 = 0 ;
21671 double val4 ;
21672 int ecode4 = 0 ;
21673 double val5 ;
21674 int ecode5 = 0 ;
21675 octave_value_list _out;
21676 octave_value_list *_outp=&_out;
21677 octave_value _outv;
21678
21679 try {
21680 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21681 SWIG_fail;
21682 }
21683 ecode1 = SWIG_AsVal_int(args(0), &val1);
21684 if (!SWIG_IsOK(ecode1)) {
21685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21686 }
21687 arg1 = static_cast< PLINT >(val1);
21688 ecode2 = SWIG_AsVal_double(args(1), &val2);
21689 if (!SWIG_IsOK(ecode2)) {
21690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21691 }
21692 arg2 = static_cast< PLFLT >(val2);
21693 ecode3 = SWIG_AsVal_double(args(2), &val3);
21694 if (!SWIG_IsOK(ecode3)) {
21695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21696 }
21697 arg3 = static_cast< PLFLT >(val3);
21698 ecode4 = SWIG_AsVal_double(args(3), &val4);
21699 if (!SWIG_IsOK(ecode4)) {
21700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21701 }
21702 arg4 = static_cast< PLFLT >(val4);
21703 ecode5 = SWIG_AsVal_double(args(4), &val5);
21704 if (!SWIG_IsOK(ecode5)) {
21705 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21706 }
21707 arg5 = static_cast< PLFLT >(val5);
21708 plpath(arg1,arg2,arg3,arg4,arg5);
21709 _outv = octave_value();
21710 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21711 return _out;
21712 fail:
21713 return octave_value_list();
21714 }
21715 catch(...) {
21716 throw;
21717 }
21718}
21719
21720
21722 PLINT arg1 ;
21723 PLFLT *arg2 = (PLFLT *) 0 ;
21724 PLFLT *arg3 = (PLFLT *) 0 ;
21725 PLINT arg4 ;
21726 Matrix temp1 ;
21727 Matrix temp3 ;
21728 int val4 ;
21729 int ecode4 = 0 ;
21730 octave_value_list _out;
21731 octave_value_list *_outp=&_out;
21732 octave_value _outv;
21733
21734 try {
21735 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21736 SWIG_fail;
21737 }
21738 {
21739 if ( _n_dims( args(0) ) > 1 )
21740 {
21741 error( "argument must be a scalar or vector" ); SWIG_fail;
21742 }
21743 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21744 temp1 = args(0).matrix_value();
21745 arg2 = &temp1( 0, 0 );
21746 }
21747 {
21748 if ( _n_dims( args(1) ) > 1 )
21749 {
21750 error( "argument must be a scalar or vector" ); SWIG_fail;
21751 }
21752 if ( _dim( args(1), 0 ) != Alen )
21753 {
21754 error( "argument vectors must be same length" ); SWIG_fail;
21755 }
21756 temp3 = args(1).matrix_value();
21757 arg3 = &temp3( 0, 0 );
21758 }
21759 ecode4 = SWIG_AsVal_int(args(2), &val4);
21760 if (!SWIG_IsOK(ecode4)) {
21761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21762 }
21763 arg4 = static_cast< PLINT >(val4);
21764 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21765 _outv = octave_value();
21766 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21767 {
21768
21769 }
21770 {
21771
21772 }
21773 return _out;
21774 fail:
21775 {
21776
21777 }
21778 {
21779
21780 }
21781 return octave_value_list();
21782 }
21783 catch(...) {
21784 {
21785
21786 }
21787 {
21788
21789 }
21790 throw;
21791 }
21792}
21793
21794
21796 PLINT arg1 ;
21797 PLFLT *arg2 = (PLFLT *) 0 ;
21798 PLFLT *arg3 = (PLFLT *) 0 ;
21799 PLFLT *arg4 = (PLFLT *) 0 ;
21800 PLINT arg5 ;
21801 Matrix temp1 ;
21802 Matrix temp3 ;
21803 Matrix temp4 ;
21804 int val5 ;
21805 int ecode5 = 0 ;
21806 octave_value_list _out;
21807 octave_value_list *_outp=&_out;
21808 octave_value _outv;
21809
21810 try {
21811 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21812 SWIG_fail;
21813 }
21814 {
21815 if ( _n_dims( args(0) ) > 1 )
21816 {
21817 error( "argument must be a scalar or vector" ); SWIG_fail;
21818 }
21819 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21820 temp1 = args(0).matrix_value();
21821 arg2 = &temp1( 0, 0 );
21822 }
21823 {
21824 if ( _n_dims( args(1) ) > 1 )
21825 {
21826 error( "argument must be a scalar or vector" ); SWIG_fail;
21827 }
21828 if ( _dim( args(1), 0 ) != Alen )
21829 {
21830 error( "argument vectors must be same length" ); SWIG_fail;
21831 }
21832 temp3 = args(1).matrix_value();
21833 arg3 = &temp3( 0, 0 );
21834 }
21835 {
21836 if ( _n_dims( args(2) ) > 1 )
21837 {
21838 error( "argument must be a scalar or vector" ); SWIG_fail;
21839 }
21840 if ( _dim( args(2), 0 ) != Alen )
21841 {
21842 error( "argument vectors must be same length" ); SWIG_fail;
21843 }
21844 temp4 = args(2).matrix_value();
21845 arg4 = &temp4( 0, 0 );
21846 }
21847 ecode5 = SWIG_AsVal_int(args(3), &val5);
21848 if (!SWIG_IsOK(ecode5)) {
21849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21850 }
21851 arg5 = static_cast< PLINT >(val5);
21852 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21853 _outv = octave_value();
21854 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21855 {
21856
21857 }
21858 {
21859
21860 }
21861 {
21862
21863 }
21864 return _out;
21865 fail:
21866 {
21867
21868 }
21869 {
21870
21871 }
21872 {
21873
21874 }
21875 return octave_value_list();
21876 }
21877 catch(...) {
21878 {
21879
21880 }
21881 {
21882
21883 }
21884 {
21885
21886 }
21887 throw;
21888 }
21889}
21890
21891
21893 PLINT arg1 ;
21894 PLFLT *arg2 = (PLFLT *) 0 ;
21895 PLFLT *arg3 = (PLFLT *) 0 ;
21896 PLFLT *arg4 = (PLFLT *) 0 ;
21897 PLBOOL *arg5 = (PLBOOL *) 0 ;
21898 PLBOOL arg6 ;
21899 Matrix temp1 ;
21900 Matrix temp3 ;
21901 Matrix temp4 ;
21902 Matrix temp5 ;
21903 int val6 ;
21904 int ecode6 = 0 ;
21905 octave_value_list _out;
21906 octave_value_list *_outp=&_out;
21907 octave_value _outv;
21908
21909 try {
21910 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
21911 SWIG_fail;
21912 }
21913 {
21914 if ( _n_dims( args(0) ) > 1 )
21915 {
21916 error( "argument must be a scalar or vector" ); SWIG_fail;
21917 }
21918 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21919 temp1 = args(0).matrix_value();
21920 arg2 = &temp1( 0, 0 );
21921 }
21922 {
21923 if ( _n_dims( args(1) ) > 1 )
21924 {
21925 error( "argument must be a scalar or vector" ); SWIG_fail;
21926 }
21927 if ( _dim( args(1), 0 ) != Alen )
21928 {
21929 error( "argument vectors must be same length" ); SWIG_fail;
21930 }
21931 temp3 = args(1).matrix_value();
21932 arg3 = &temp3( 0, 0 );
21933 }
21934 {
21935 if ( _n_dims( args(2) ) > 1 )
21936 {
21937 error( "argument must be a scalar or vector" ); SWIG_fail;
21938 }
21939 if ( _dim( args(2), 0 ) != Alen )
21940 {
21941 error( "argument vectors must be same length" ); SWIG_fail;
21942 }
21943 temp4 = args(2).matrix_value();
21944 arg4 = &temp4( 0, 0 );
21945 }
21946 {
21947 if ( _n_dims( args(3) ) > 1 )
21948 {
21949 error( "argument must be a scalar or vector" ); SWIG_fail;
21950 }
21951 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
21952 {
21953 error( "argument vector must be same length or one less" ); SWIG_fail;
21954 }
21955 temp5 = args(3).matrix_value();
21956 arg5 = new PLINT[Alen];
21957 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
21958 }
21959 ecode6 = SWIG_AsVal_int(args(4), &val6);
21960 if (!SWIG_IsOK(ecode6)) {
21961 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
21962 }
21963 arg6 = static_cast< PLBOOL >(val6);
21964 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
21965 _outv = octave_value();
21966 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21967 {
21968
21969 }
21970 {
21971
21972 }
21973 {
21974
21975 }
21976 {
21977 delete [] arg5;
21978 }
21979 return _out;
21980 fail:
21981 {
21982
21983 }
21984 {
21985
21986 }
21987 {
21988
21989 }
21990 {
21991 delete [] arg5;
21992 }
21993 return octave_value_list();
21994 }
21995 catch(...) {
21996 {
21997
21998 }
21999 {
22000
22001 }
22002 {
22003
22004 }
22005 {
22006 delete [] arg5;
22007 }
22008 throw;
22009 }
22010}
22011
22012
22014 PLINT arg1 ;
22015 PLINT arg2 ;
22016 int val1 ;
22017 int ecode1 = 0 ;
22018 int val2 ;
22019 int ecode2 = 0 ;
22020 octave_value_list _out;
22021 octave_value_list *_outp=&_out;
22022 octave_value _outv;
22023
22024 try {
22025 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22026 SWIG_fail;
22027 }
22028 ecode1 = SWIG_AsVal_int(args(0), &val1);
22029 if (!SWIG_IsOK(ecode1)) {
22030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22031 }
22032 arg1 = static_cast< PLINT >(val1);
22033 ecode2 = SWIG_AsVal_int(args(1), &val2);
22034 if (!SWIG_IsOK(ecode2)) {
22035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22036 }
22037 arg2 = static_cast< PLINT >(val2);
22038 plprec(arg1,arg2);
22039 _outv = octave_value();
22040 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22041 return _out;
22042 fail:
22043 return octave_value_list();
22044 }
22045 catch(...) {
22046 throw;
22047 }
22048}
22049
22050
22052 PLINT arg1 ;
22053 int val1 ;
22054 int ecode1 = 0 ;
22055 octave_value_list _out;
22056 octave_value_list *_outp=&_out;
22057 octave_value _outv;
22058
22059 try {
22060 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22061 SWIG_fail;
22062 }
22063 ecode1 = SWIG_AsVal_int(args(0), &val1);
22064 if (!SWIG_IsOK(ecode1)) {
22065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22066 }
22067 arg1 = static_cast< PLINT >(val1);
22068 plpsty(arg1);
22069 _outv = octave_value();
22070 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22071 return _out;
22072 fail:
22073 return octave_value_list();
22074 }
22075 catch(...) {
22076 throw;
22077 }
22078}
22079
22080
22082 PLFLT arg1 ;
22083 PLFLT arg2 ;
22084 PLFLT arg3 ;
22085 PLFLT arg4 ;
22086 PLFLT arg5 ;
22087 char *arg6 = (char *) 0 ;
22088 double val1 ;
22089 int ecode1 = 0 ;
22090 double val2 ;
22091 int ecode2 = 0 ;
22092 double val3 ;
22093 int ecode3 = 0 ;
22094 double val4 ;
22095 int ecode4 = 0 ;
22096 double val5 ;
22097 int ecode5 = 0 ;
22098 int res6 ;
22099 char *buf6 = 0 ;
22100 int alloc6 = 0 ;
22101 octave_value_list _out;
22102 octave_value_list *_outp=&_out;
22103 octave_value _outv;
22104
22105 try {
22106 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22107 SWIG_fail;
22108 }
22109 ecode1 = SWIG_AsVal_double(args(0), &val1);
22110 if (!SWIG_IsOK(ecode1)) {
22111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22112 }
22113 arg1 = static_cast< PLFLT >(val1);
22114 ecode2 = SWIG_AsVal_double(args(1), &val2);
22115 if (!SWIG_IsOK(ecode2)) {
22116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22117 }
22118 arg2 = static_cast< PLFLT >(val2);
22119 ecode3 = SWIG_AsVal_double(args(2), &val3);
22120 if (!SWIG_IsOK(ecode3)) {
22121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22122 }
22123 arg3 = static_cast< PLFLT >(val3);
22124 ecode4 = SWIG_AsVal_double(args(3), &val4);
22125 if (!SWIG_IsOK(ecode4)) {
22126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22127 }
22128 arg4 = static_cast< PLFLT >(val4);
22129 ecode5 = SWIG_AsVal_double(args(4), &val5);
22130 if (!SWIG_IsOK(ecode5)) {
22131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22132 }
22133 arg5 = static_cast< PLFLT >(val5);
22134 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22135 if (!SWIG_IsOK(res6)) {
22136 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22137 }
22138 arg6 = reinterpret_cast< char * >(buf6);
22139 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22140 _outv = octave_value();
22141 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22142 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22143 return _out;
22144 fail:
22145 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22146 return octave_value_list();
22147 }
22148 catch(...) {
22149 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22150 throw;
22151 }
22152}
22153
22154
22156 PLFLT arg1 ;
22157 PLFLT arg2 ;
22158 PLFLT arg3 ;
22159 PLFLT arg4 ;
22160 PLFLT arg5 ;
22161 PLFLT arg6 ;
22162 PLFLT arg7 ;
22163 PLFLT arg8 ;
22164 PLFLT arg9 ;
22165 PLFLT arg10 ;
22166 char *arg11 = (char *) 0 ;
22167 double val1 ;
22168 int ecode1 = 0 ;
22169 double val2 ;
22170 int ecode2 = 0 ;
22171 double val3 ;
22172 int ecode3 = 0 ;
22173 double val4 ;
22174 int ecode4 = 0 ;
22175 double val5 ;
22176 int ecode5 = 0 ;
22177 double val6 ;
22178 int ecode6 = 0 ;
22179 double val7 ;
22180 int ecode7 = 0 ;
22181 double val8 ;
22182 int ecode8 = 0 ;
22183 double val9 ;
22184 int ecode9 = 0 ;
22185 double val10 ;
22186 int ecode10 = 0 ;
22187 int res11 ;
22188 char *buf11 = 0 ;
22189 int alloc11 = 0 ;
22190 octave_value_list _out;
22191 octave_value_list *_outp=&_out;
22192 octave_value _outv;
22193
22194 try {
22195 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22196 SWIG_fail;
22197 }
22198 ecode1 = SWIG_AsVal_double(args(0), &val1);
22199 if (!SWIG_IsOK(ecode1)) {
22200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22201 }
22202 arg1 = static_cast< PLFLT >(val1);
22203 ecode2 = SWIG_AsVal_double(args(1), &val2);
22204 if (!SWIG_IsOK(ecode2)) {
22205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22206 }
22207 arg2 = static_cast< PLFLT >(val2);
22208 ecode3 = SWIG_AsVal_double(args(2), &val3);
22209 if (!SWIG_IsOK(ecode3)) {
22210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22211 }
22212 arg3 = static_cast< PLFLT >(val3);
22213 ecode4 = SWIG_AsVal_double(args(3), &val4);
22214 if (!SWIG_IsOK(ecode4)) {
22215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22216 }
22217 arg4 = static_cast< PLFLT >(val4);
22218 ecode5 = SWIG_AsVal_double(args(4), &val5);
22219 if (!SWIG_IsOK(ecode5)) {
22220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22221 }
22222 arg5 = static_cast< PLFLT >(val5);
22223 ecode6 = SWIG_AsVal_double(args(5), &val6);
22224 if (!SWIG_IsOK(ecode6)) {
22225 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22226 }
22227 arg6 = static_cast< PLFLT >(val6);
22228 ecode7 = SWIG_AsVal_double(args(6), &val7);
22229 if (!SWIG_IsOK(ecode7)) {
22230 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22231 }
22232 arg7 = static_cast< PLFLT >(val7);
22233 ecode8 = SWIG_AsVal_double(args(7), &val8);
22234 if (!SWIG_IsOK(ecode8)) {
22235 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22236 }
22237 arg8 = static_cast< PLFLT >(val8);
22238 ecode9 = SWIG_AsVal_double(args(8), &val9);
22239 if (!SWIG_IsOK(ecode9)) {
22240 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22241 }
22242 arg9 = static_cast< PLFLT >(val9);
22243 ecode10 = SWIG_AsVal_double(args(9), &val10);
22244 if (!SWIG_IsOK(ecode10)) {
22245 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22246 }
22247 arg10 = static_cast< PLFLT >(val10);
22248 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22249 if (!SWIG_IsOK(res11)) {
22250 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22251 }
22252 arg11 = reinterpret_cast< char * >(buf11);
22253 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22254 _outv = octave_value();
22255 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22256 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22257 return _out;
22258 fail:
22259 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22260 return octave_value_list();
22261 }
22262 catch(...) {
22263 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22264 throw;
22265 }
22266}
22267
22268
22270 octave_value_list _out;
22271 octave_value_list *_outp=&_out;
22272 octave_value _outv;
22273 PLFLT result;
22274
22275 try {
22276 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22277 SWIG_fail;
22278 }
22279 result = (PLFLT)plrandd();
22280 _outv = SWIG_From_double(static_cast< double >(result));
22281 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22282 return _out;
22283 fail:
22284 return octave_value_list();
22285 }
22286 catch(...) {
22287 throw;
22288 }
22289}
22290
22291
22293 octave_value_list _out;
22294 octave_value_list *_outp=&_out;
22295 octave_value _outv;
22296
22297 try {
22298 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22299 SWIG_fail;
22300 }
22301 plreplot();
22302 _outv = octave_value();
22303 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22304 return _out;
22305 fail:
22306 return octave_value_list();
22307 }
22308 catch(...) {
22309 throw;
22310 }
22311}
22312
22313
22315 PLFLT arg1 ;
22316 PLFLT arg2 ;
22317 PLFLT arg3 ;
22318 PLFLT *arg4 = (PLFLT *) 0 ;
22319 PLFLT *arg5 = (PLFLT *) 0 ;
22320 PLFLT *arg6 = (PLFLT *) 0 ;
22321 double val1 ;
22322 int ecode1 = 0 ;
22323 double val2 ;
22324 int ecode2 = 0 ;
22325 double val3 ;
22326 int ecode3 = 0 ;
22327 PLFLT temp4 ;
22328 int res4 = SWIG_TMPOBJ ;
22329 PLFLT temp5 ;
22330 int res5 = SWIG_TMPOBJ ;
22331 PLFLT temp6 ;
22332 int res6 = SWIG_TMPOBJ ;
22333 octave_value_list _out;
22334 octave_value_list *_outp=&_out;
22335 octave_value _outv;
22336
22337 try {
22338 arg4 = &temp4;
22339 arg5 = &temp5;
22340 arg6 = &temp6;
22341 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22342 SWIG_fail;
22343 }
22344 ecode1 = SWIG_AsVal_double(args(0), &val1);
22345 if (!SWIG_IsOK(ecode1)) {
22346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22347 }
22348 arg1 = static_cast< PLFLT >(val1);
22349 ecode2 = SWIG_AsVal_double(args(1), &val2);
22350 if (!SWIG_IsOK(ecode2)) {
22351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22352 }
22353 arg2 = static_cast< PLFLT >(val2);
22354 ecode3 = SWIG_AsVal_double(args(2), &val3);
22355 if (!SWIG_IsOK(ecode3)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22357 }
22358 arg3 = static_cast< PLFLT >(val3);
22359 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22360 _outv = octave_value();
22361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22362 if (SWIG_IsTmpObj(res4)) {
22363 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22364 } else {
22365 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22366 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22367 }
22368 if (SWIG_IsTmpObj(res5)) {
22369 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22370 } else {
22371 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22372 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22373 }
22374 if (SWIG_IsTmpObj(res6)) {
22375 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22376 } else {
22377 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22378 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22379 }
22380 return _out;
22381 fail:
22382 return octave_value_list();
22383 }
22384 catch(...) {
22385 throw;
22386 }
22387}
22388
22389
22391 PLFLT arg1 ;
22392 PLFLT arg2 ;
22393 double val1 ;
22394 int ecode1 = 0 ;
22395 double val2 ;
22396 int ecode2 = 0 ;
22397 octave_value_list _out;
22398 octave_value_list *_outp=&_out;
22399 octave_value _outv;
22400
22401 try {
22402 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22403 SWIG_fail;
22404 }
22405 ecode1 = SWIG_AsVal_double(args(0), &val1);
22406 if (!SWIG_IsOK(ecode1)) {
22407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22408 }
22409 arg1 = static_cast< PLFLT >(val1);
22410 ecode2 = SWIG_AsVal_double(args(1), &val2);
22411 if (!SWIG_IsOK(ecode2)) {
22412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22413 }
22414 arg2 = static_cast< PLFLT >(val2);
22415 plschr(arg1,arg2);
22416 _outv = octave_value();
22417 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22418 return _out;
22419 fail:
22420 return octave_value_list();
22421 }
22422 catch(...) {
22423 throw;
22424 }
22425}
22426
22427
22429 PLINT *arg1 = (PLINT *) 0 ;
22430 PLINT *arg2 = (PLINT *) 0 ;
22431 PLINT *arg3 = (PLINT *) 0 ;
22432 PLINT arg4 ;
22433 Matrix temp1 ;
22434 Matrix temp2 ;
22435 Matrix temp3 ;
22436 octave_value_list _out;
22437 octave_value_list *_outp=&_out;
22438 octave_value _outv;
22439
22440 try {
22441 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22442 SWIG_fail;
22443 }
22444 {
22445 if ( _n_dims( args(0) ) > 1 )
22446 {
22447 error( "argument must be a scalar or vector" ); SWIG_fail;
22448 }
22449 Alen = (PLINT) ( _dim( args(0), 0 ) );
22450 temp1 = args(0).matrix_value();
22451 arg1 = new PLINT[Alen];
22452 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22453 }
22454 {
22455 if ( _n_dims( args(1) ) > 1 )
22456 {
22457 error( "argument must be a scalar or vector" ); SWIG_fail;
22458 }
22459 if ( _dim( args(1), 0 ) != Alen )
22460 {
22461 error( "argument vectors must be same length" ); SWIG_fail;
22462 }
22463 temp2 = args(1).matrix_value();
22464 arg2 = new PLINT[Alen];
22465 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22466 }
22467 {
22468 if ( _n_dims( args(2) ) > 1 )
22469 {
22470 error( "argument must be a scalar or vector" ); SWIG_fail;
22471 }
22472 if ( _dim( args(2), 0 ) != Alen )
22473 {
22474 error( "argument vectors must be same length" ); SWIG_fail;
22475 }
22476 temp3 = args(2).matrix_value();
22477 arg3 = new PLINT[Alen];
22478 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22479 arg4 = Alen;
22480 }
22481 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22482 _outv = octave_value();
22483 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22484 {
22485 delete [] arg1;
22486 }
22487 {
22488 delete [] arg2;
22489 }
22490 {
22491 delete [] arg3;
22492 }
22493 return _out;
22494 fail:
22495 {
22496 delete [] arg1;
22497 }
22498 {
22499 delete [] arg2;
22500 }
22501 {
22502 delete [] arg3;
22503 }
22504 return octave_value_list();
22505 }
22506 catch(...) {
22507 {
22508 delete [] arg1;
22509 }
22510 {
22511 delete [] arg2;
22512 }
22513 {
22514 delete [] arg3;
22515 }
22516 throw;
22517 }
22518}
22519
22520
22522 PLINT *arg1 = (PLINT *) 0 ;
22523 PLINT *arg2 = (PLINT *) 0 ;
22524 PLINT *arg3 = (PLINT *) 0 ;
22525 PLFLT *arg4 = (PLFLT *) 0 ;
22526 PLINT arg5 ;
22527 Matrix temp1 ;
22528 Matrix temp2 ;
22529 Matrix temp3 ;
22530 Matrix temp4 ;
22531 octave_value_list _out;
22532 octave_value_list *_outp=&_out;
22533 octave_value _outv;
22534
22535 try {
22536 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22537 SWIG_fail;
22538 }
22539 {
22540 if ( _n_dims( args(0) ) > 1 )
22541 {
22542 error( "argument must be a scalar or vector" ); SWIG_fail;
22543 }
22544 Alen = (PLINT) ( _dim( args(0), 0 ) );
22545 temp1 = args(0).matrix_value();
22546 arg1 = new PLINT[Alen];
22547 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22548 }
22549 {
22550 if ( _n_dims( args(1) ) > 1 )
22551 {
22552 error( "argument must be a scalar or vector" ); SWIG_fail;
22553 }
22554 if ( _dim( args(1), 0 ) != Alen )
22555 {
22556 error( "argument vectors must be same length" ); SWIG_fail;
22557 }
22558 temp2 = args(1).matrix_value();
22559 arg2 = new PLINT[Alen];
22560 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22561 }
22562 {
22563 if ( _n_dims( args(2) ) > 1 )
22564 {
22565 error( "argument must be a scalar or vector" ); SWIG_fail;
22566 }
22567 if ( _dim( args(2), 0 ) != Alen )
22568 {
22569 error( "argument vectors must be same length" ); SWIG_fail;
22570 }
22571 temp3 = args(2).matrix_value();
22572 arg3 = new PLINT[Alen];
22573 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22574 }
22575 {
22576 if ( _n_dims( args(3) ) > 1 )
22577 {
22578 error( "argument must be a scalar or vector" ); SWIG_fail;
22579 }
22580 if ( _dim( args(3), 0 ) != Alen )
22581 {
22582 error( "argument vectors must be same length" ); SWIG_fail;
22583 }
22584 temp4 = args(3).matrix_value();
22585 arg4 = &temp4( 0, 0 );
22586 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22587 }
22588 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22589 _outv = octave_value();
22590 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22591 {
22592 delete [] arg1;
22593 }
22594 {
22595 delete [] arg2;
22596 }
22597 {
22598 delete [] arg3;
22599 }
22600 {
22601
22602 }
22603 return _out;
22604 fail:
22605 {
22606 delete [] arg1;
22607 }
22608 {
22609 delete [] arg2;
22610 }
22611 {
22612 delete [] arg3;
22613 }
22614 {
22615
22616 }
22617 return octave_value_list();
22618 }
22619 catch(...) {
22620 {
22621 delete [] arg1;
22622 }
22623 {
22624 delete [] arg2;
22625 }
22626 {
22627 delete [] arg3;
22628 }
22629 {
22630
22631 }
22632 throw;
22633 }
22634}
22635
22636
22638 PLINT arg1 ;
22639 int val1 ;
22640 int ecode1 = 0 ;
22641 octave_value_list _out;
22642 octave_value_list *_outp=&_out;
22643 octave_value _outv;
22644
22645 try {
22646 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22647 SWIG_fail;
22648 }
22649 ecode1 = SWIG_AsVal_int(args(0), &val1);
22650 if (!SWIG_IsOK(ecode1)) {
22651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22652 }
22653 arg1 = static_cast< PLINT >(val1);
22654 plscmap0n(arg1);
22655 _outv = octave_value();
22656 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22657 return _out;
22658 fail:
22659 return octave_value_list();
22660 }
22661 catch(...) {
22662 throw;
22663 }
22664}
22665
22666
22668 PLINT *arg1 = (PLINT *) 0 ;
22669 PLINT *arg2 = (PLINT *) 0 ;
22670 PLINT *arg3 = (PLINT *) 0 ;
22671 PLINT arg4 ;
22672 Matrix temp1 ;
22673 Matrix temp2 ;
22674 Matrix temp3 ;
22675 octave_value_list _out;
22676 octave_value_list *_outp=&_out;
22677 octave_value _outv;
22678
22679 try {
22680 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22681 SWIG_fail;
22682 }
22683 {
22684 if ( _n_dims( args(0) ) > 1 )
22685 {
22686 error( "argument must be a scalar or vector" ); SWIG_fail;
22687 }
22688 Alen = (PLINT) ( _dim( args(0), 0 ) );
22689 temp1 = args(0).matrix_value();
22690 arg1 = new PLINT[Alen];
22691 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22692 }
22693 {
22694 if ( _n_dims( args(1) ) > 1 )
22695 {
22696 error( "argument must be a scalar or vector" ); SWIG_fail;
22697 }
22698 if ( _dim( args(1), 0 ) != Alen )
22699 {
22700 error( "argument vectors must be same length" ); SWIG_fail;
22701 }
22702 temp2 = args(1).matrix_value();
22703 arg2 = new PLINT[Alen];
22704 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22705 }
22706 {
22707 if ( _n_dims( args(2) ) > 1 )
22708 {
22709 error( "argument must be a scalar or vector" ); SWIG_fail;
22710 }
22711 if ( _dim( args(2), 0 ) != Alen )
22712 {
22713 error( "argument vectors must be same length" ); SWIG_fail;
22714 }
22715 temp3 = args(2).matrix_value();
22716 arg3 = new PLINT[Alen];
22717 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22718 arg4 = Alen;
22719 }
22720 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22721 _outv = octave_value();
22722 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22723 {
22724 delete [] arg1;
22725 }
22726 {
22727 delete [] arg2;
22728 }
22729 {
22730 delete [] arg3;
22731 }
22732 return _out;
22733 fail:
22734 {
22735 delete [] arg1;
22736 }
22737 {
22738 delete [] arg2;
22739 }
22740 {
22741 delete [] arg3;
22742 }
22743 return octave_value_list();
22744 }
22745 catch(...) {
22746 {
22747 delete [] arg1;
22748 }
22749 {
22750 delete [] arg2;
22751 }
22752 {
22753 delete [] arg3;
22754 }
22755 throw;
22756 }
22757}
22758
22759
22761 PLINT *arg1 = (PLINT *) 0 ;
22762 PLINT *arg2 = (PLINT *) 0 ;
22763 PLINT *arg3 = (PLINT *) 0 ;
22764 PLFLT *arg4 = (PLFLT *) 0 ;
22765 PLINT arg5 ;
22766 Matrix temp1 ;
22767 Matrix temp2 ;
22768 Matrix temp3 ;
22769 Matrix temp4 ;
22770 octave_value_list _out;
22771 octave_value_list *_outp=&_out;
22772 octave_value _outv;
22773
22774 try {
22775 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22776 SWIG_fail;
22777 }
22778 {
22779 if ( _n_dims( args(0) ) > 1 )
22780 {
22781 error( "argument must be a scalar or vector" ); SWIG_fail;
22782 }
22783 Alen = (PLINT) ( _dim( args(0), 0 ) );
22784 temp1 = args(0).matrix_value();
22785 arg1 = new PLINT[Alen];
22786 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22787 }
22788 {
22789 if ( _n_dims( args(1) ) > 1 )
22790 {
22791 error( "argument must be a scalar or vector" ); SWIG_fail;
22792 }
22793 if ( _dim( args(1), 0 ) != Alen )
22794 {
22795 error( "argument vectors must be same length" ); SWIG_fail;
22796 }
22797 temp2 = args(1).matrix_value();
22798 arg2 = new PLINT[Alen];
22799 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22800 }
22801 {
22802 if ( _n_dims( args(2) ) > 1 )
22803 {
22804 error( "argument must be a scalar or vector" ); SWIG_fail;
22805 }
22806 if ( _dim( args(2), 0 ) != Alen )
22807 {
22808 error( "argument vectors must be same length" ); SWIG_fail;
22809 }
22810 temp3 = args(2).matrix_value();
22811 arg3 = new PLINT[Alen];
22812 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22813 }
22814 {
22815 if ( _n_dims( args(3) ) > 1 )
22816 {
22817 error( "argument must be a scalar or vector" ); SWIG_fail;
22818 }
22819 if ( _dim( args(3), 0 ) != Alen )
22820 {
22821 error( "argument vectors must be same length" ); SWIG_fail;
22822 }
22823 temp4 = args(3).matrix_value();
22824 arg4 = &temp4( 0, 0 );
22825 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22826 }
22827 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22828 _outv = octave_value();
22829 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22830 {
22831 delete [] arg1;
22832 }
22833 {
22834 delete [] arg2;
22835 }
22836 {
22837 delete [] arg3;
22838 }
22839 {
22840
22841 }
22842 return _out;
22843 fail:
22844 {
22845 delete [] arg1;
22846 }
22847 {
22848 delete [] arg2;
22849 }
22850 {
22851 delete [] arg3;
22852 }
22853 {
22854
22855 }
22856 return octave_value_list();
22857 }
22858 catch(...) {
22859 {
22860 delete [] arg1;
22861 }
22862 {
22863 delete [] arg2;
22864 }
22865 {
22866 delete [] arg3;
22867 }
22868 {
22869
22870 }
22871 throw;
22872 }
22873}
22874
22875
22877 PLBOOL arg1 ;
22878 PLINT arg2 ;
22879 PLFLT *arg3 = (PLFLT *) 0 ;
22880 PLFLT *arg4 = (PLFLT *) 0 ;
22881 PLFLT *arg5 = (PLFLT *) 0 ;
22882 PLFLT *arg6 = (PLFLT *) 0 ;
22883 PLBOOL *arg7 = (PLBOOL *) 0 ;
22884 int val1 ;
22885 int ecode1 = 0 ;
22886 Matrix temp2 ;
22887 Matrix temp4 ;
22888 Matrix temp5 ;
22889 Matrix temp6 ;
22890 Matrix temp7 ;
22891 octave_value_list _out;
22892 octave_value_list *_outp=&_out;
22893 octave_value _outv;
22894
22895 try {
22896 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
22897 SWIG_fail;
22898 }
22899 ecode1 = SWIG_AsVal_int(args(0), &val1);
22900 if (!SWIG_IsOK(ecode1)) {
22901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
22902 }
22903 arg1 = static_cast< PLBOOL >(val1);
22904 {
22905 if ( _n_dims( args(1) ) > 1 )
22906 {
22907 error( "argument must be a scalar or vector" ); SWIG_fail;
22908 }
22909 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22910 temp2 = args(1).matrix_value();
22911 arg3 = &temp2( 0, 0 );
22912 }
22913 {
22914 if ( _n_dims( args(2) ) > 1 )
22915 {
22916 error( "argument must be a scalar or vector" ); SWIG_fail;
22917 }
22918 if ( _dim( args(2), 0 ) != Alen )
22919 {
22920 error( "argument vectors must be same length" ); SWIG_fail;
22921 }
22922 temp4 = args(2).matrix_value();
22923 arg4 = &temp4( 0, 0 );
22924 }
22925 {
22926 if ( _n_dims( args(3) ) > 1 )
22927 {
22928 error( "argument must be a scalar or vector" ); SWIG_fail;
22929 }
22930 if ( _dim( args(3), 0 ) != Alen )
22931 {
22932 error( "argument vectors must be same length" ); SWIG_fail;
22933 }
22934 temp5 = args(3).matrix_value();
22935 arg5 = &temp5( 0, 0 );
22936 }
22937 {
22938 if ( _n_dims( args(4) ) > 1 )
22939 {
22940 error( "argument must be a scalar or vector" ); SWIG_fail;
22941 }
22942 if ( _dim( args(4), 0 ) != Alen )
22943 {
22944 error( "argument vectors must be same length" ); SWIG_fail;
22945 }
22946 temp6 = args(4).matrix_value();
22947 arg6 = &temp6( 0, 0 );
22948 }
22949 {
22950 if ( _n_dims( args(5) ) > 1 )
22951 {
22952 error( "argument must be a scalar or vector" ); SWIG_fail;
22953 }
22954 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
22955 {
22956 error( "argument vector must be same length or one less" ); SWIG_fail;
22957 }
22958 temp7 = args(5).matrix_value();
22959 arg7 = new PLINT[Alen];
22960 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
22961 }
22962 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
22963 _outv = octave_value();
22964 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22965 {
22966
22967 }
22968 {
22969
22970 }
22971 {
22972
22973 }
22974 {
22975
22976 }
22977 {
22978 delete [] arg7;
22979 }
22980 return _out;
22981 fail:
22982 {
22983
22984 }
22985 {
22986
22987 }
22988 {
22989
22990 }
22991 {
22992
22993 }
22994 {
22995 delete [] arg7;
22996 }
22997 return octave_value_list();
22998 }
22999 catch(...) {
23000 {
23001
23002 }
23003 {
23004
23005 }
23006 {
23007
23008 }
23009 {
23010
23011 }
23012 {
23013 delete [] arg7;
23014 }
23015 throw;
23016 }
23017}
23018
23019
23021 PLBOOL arg1 ;
23022 PLINT arg2 ;
23023 PLFLT *arg3 = (PLFLT *) 0 ;
23024 PLFLT *arg4 = (PLFLT *) 0 ;
23025 PLFLT *arg5 = (PLFLT *) 0 ;
23026 PLFLT *arg6 = (PLFLT *) 0 ;
23027 PLFLT *arg7 = (PLFLT *) 0 ;
23028 PLBOOL *arg8 = (PLBOOL *) 0 ;
23029 int val1 ;
23030 int ecode1 = 0 ;
23031 Matrix temp2 ;
23032 Matrix temp4 ;
23033 Matrix temp5 ;
23034 Matrix temp6 ;
23035 Matrix temp7 ;
23036 Matrix temp8 ;
23037 octave_value_list _out;
23038 octave_value_list *_outp=&_out;
23039 octave_value _outv;
23040
23041 try {
23042 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23043 SWIG_fail;
23044 }
23045 ecode1 = SWIG_AsVal_int(args(0), &val1);
23046 if (!SWIG_IsOK(ecode1)) {
23047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23048 }
23049 arg1 = static_cast< PLBOOL >(val1);
23050 {
23051 if ( _n_dims( args(1) ) > 1 )
23052 {
23053 error( "argument must be a scalar or vector" ); SWIG_fail;
23054 }
23055 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23056 temp2 = args(1).matrix_value();
23057 arg3 = &temp2( 0, 0 );
23058 }
23059 {
23060 if ( _n_dims( args(2) ) > 1 )
23061 {
23062 error( "argument must be a scalar or vector" ); SWIG_fail;
23063 }
23064 if ( _dim( args(2), 0 ) != Alen )
23065 {
23066 error( "argument vectors must be same length" ); SWIG_fail;
23067 }
23068 temp4 = args(2).matrix_value();
23069 arg4 = &temp4( 0, 0 );
23070 }
23071 {
23072 if ( _n_dims( args(3) ) > 1 )
23073 {
23074 error( "argument must be a scalar or vector" ); SWIG_fail;
23075 }
23076 if ( _dim( args(3), 0 ) != Alen )
23077 {
23078 error( "argument vectors must be same length" ); SWIG_fail;
23079 }
23080 temp5 = args(3).matrix_value();
23081 arg5 = &temp5( 0, 0 );
23082 }
23083 {
23084 if ( _n_dims( args(4) ) > 1 )
23085 {
23086 error( "argument must be a scalar or vector" ); SWIG_fail;
23087 }
23088 if ( _dim( args(4), 0 ) != Alen )
23089 {
23090 error( "argument vectors must be same length" ); SWIG_fail;
23091 }
23092 temp6 = args(4).matrix_value();
23093 arg6 = &temp6( 0, 0 );
23094 }
23095 {
23096 if ( _n_dims( args(5) ) > 1 )
23097 {
23098 error( "argument must be a scalar or vector" ); SWIG_fail;
23099 }
23100 if ( _dim( args(5), 0 ) != Alen )
23101 {
23102 error( "argument vectors must be same length" ); SWIG_fail;
23103 }
23104 temp7 = args(5).matrix_value();
23105 arg7 = &temp7( 0, 0 );
23106 }
23107 {
23108 if ( _n_dims( args(6) ) > 1 )
23109 {
23110 error( "argument must be a scalar or vector" ); SWIG_fail;
23111 }
23112 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23113 {
23114 error( "argument vector must be same length or one less" ); SWIG_fail;
23115 }
23116 temp8 = args(6).matrix_value();
23117 arg8 = new PLINT[Alen];
23118 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23119 }
23120 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23121 _outv = octave_value();
23122 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23123 {
23124
23125 }
23126 {
23127
23128 }
23129 {
23130
23131 }
23132 {
23133
23134 }
23135 {
23136
23137 }
23138 {
23139 delete [] arg8;
23140 }
23141 return _out;
23142 fail:
23143 {
23144
23145 }
23146 {
23147
23148 }
23149 {
23150
23151 }
23152 {
23153
23154 }
23155 {
23156
23157 }
23158 {
23159 delete [] arg8;
23160 }
23161 return octave_value_list();
23162 }
23163 catch(...) {
23164 {
23165
23166 }
23167 {
23168
23169 }
23170 {
23171
23172 }
23173 {
23174
23175 }
23176 {
23177
23178 }
23179 {
23180 delete [] arg8;
23181 }
23182 throw;
23183 }
23184}
23185
23186
23188 PLINT arg1 ;
23189 int val1 ;
23190 int ecode1 = 0 ;
23191 octave_value_list _out;
23192 octave_value_list *_outp=&_out;
23193 octave_value _outv;
23194
23195 try {
23196 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23197 SWIG_fail;
23198 }
23199 ecode1 = SWIG_AsVal_int(args(0), &val1);
23200 if (!SWIG_IsOK(ecode1)) {
23201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23202 }
23203 arg1 = static_cast< PLINT >(val1);
23204 plscmap1n(arg1);
23205 _outv = octave_value();
23206 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23207 return _out;
23208 fail:
23209 return octave_value_list();
23210 }
23211 catch(...) {
23212 throw;
23213 }
23214}
23215
23216
23218 PLFLT arg1 ;
23219 PLFLT arg2 ;
23220 double val1 ;
23221 int ecode1 = 0 ;
23222 double val2 ;
23223 int ecode2 = 0 ;
23224 octave_value_list _out;
23225 octave_value_list *_outp=&_out;
23226 octave_value _outv;
23227
23228 try {
23229 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23230 SWIG_fail;
23231 }
23232 ecode1 = SWIG_AsVal_double(args(0), &val1);
23233 if (!SWIG_IsOK(ecode1)) {
23234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23235 }
23236 arg1 = static_cast< PLFLT >(val1);
23237 ecode2 = SWIG_AsVal_double(args(1), &val2);
23238 if (!SWIG_IsOK(ecode2)) {
23239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23240 }
23241 arg2 = static_cast< PLFLT >(val2);
23242 plscmap1_range(arg1,arg2);
23243 _outv = octave_value();
23244 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23245 return _out;
23246 fail:
23247 return octave_value_list();
23248 }
23249 catch(...) {
23250 throw;
23251 }
23252}
23253
23254
23256 PLFLT *arg1 = (PLFLT *) 0 ;
23257 PLFLT *arg2 = (PLFLT *) 0 ;
23258 PLFLT temp1 ;
23259 int res1 = SWIG_TMPOBJ ;
23260 PLFLT temp2 ;
23261 int res2 = SWIG_TMPOBJ ;
23262 octave_value_list _out;
23263 octave_value_list *_outp=&_out;
23264 octave_value _outv;
23265
23266 try {
23267 arg1 = &temp1;
23268 arg2 = &temp2;
23269 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23270 SWIG_fail;
23271 }
23272 plgcmap1_range(arg1,arg2);
23273 _outv = octave_value();
23274 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23275 if (SWIG_IsTmpObj(res1)) {
23276 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23277 } else {
23278 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23279 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23280 }
23281 if (SWIG_IsTmpObj(res2)) {
23282 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23283 } else {
23284 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23285 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23286 }
23287 return _out;
23288 fail:
23289 return octave_value_list();
23290 }
23291 catch(...) {
23292 throw;
23293 }
23294}
23295
23296
23298 PLINT arg1 ;
23299 PLINT arg2 ;
23300 PLINT arg3 ;
23301 PLINT arg4 ;
23302 int val1 ;
23303 int ecode1 = 0 ;
23304 int val2 ;
23305 int ecode2 = 0 ;
23306 int val3 ;
23307 int ecode3 = 0 ;
23308 int val4 ;
23309 int ecode4 = 0 ;
23310 octave_value_list _out;
23311 octave_value_list *_outp=&_out;
23312 octave_value _outv;
23313
23314 try {
23315 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23316 SWIG_fail;
23317 }
23318 ecode1 = SWIG_AsVal_int(args(0), &val1);
23319 if (!SWIG_IsOK(ecode1)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23321 }
23322 arg1 = static_cast< PLINT >(val1);
23323 ecode2 = SWIG_AsVal_int(args(1), &val2);
23324 if (!SWIG_IsOK(ecode2)) {
23325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23326 }
23327 arg2 = static_cast< PLINT >(val2);
23328 ecode3 = SWIG_AsVal_int(args(2), &val3);
23329 if (!SWIG_IsOK(ecode3)) {
23330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23331 }
23332 arg3 = static_cast< PLINT >(val3);
23333 ecode4 = SWIG_AsVal_int(args(3), &val4);
23334 if (!SWIG_IsOK(ecode4)) {
23335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23336 }
23337 arg4 = static_cast< PLINT >(val4);
23338 plscol0(arg1,arg2,arg3,arg4);
23339 _outv = octave_value();
23340 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23341 return _out;
23342 fail:
23343 return octave_value_list();
23344 }
23345 catch(...) {
23346 throw;
23347 }
23348}
23349
23350
23352 PLINT arg1 ;
23353 PLINT arg2 ;
23354 PLINT arg3 ;
23355 PLINT arg4 ;
23356 PLFLT arg5 ;
23357 int val1 ;
23358 int ecode1 = 0 ;
23359 int val2 ;
23360 int ecode2 = 0 ;
23361 int val3 ;
23362 int ecode3 = 0 ;
23363 int val4 ;
23364 int ecode4 = 0 ;
23365 double val5 ;
23366 int ecode5 = 0 ;
23367 octave_value_list _out;
23368 octave_value_list *_outp=&_out;
23369 octave_value _outv;
23370
23371 try {
23372 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23373 SWIG_fail;
23374 }
23375 ecode1 = SWIG_AsVal_int(args(0), &val1);
23376 if (!SWIG_IsOK(ecode1)) {
23377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23378 }
23379 arg1 = static_cast< PLINT >(val1);
23380 ecode2 = SWIG_AsVal_int(args(1), &val2);
23381 if (!SWIG_IsOK(ecode2)) {
23382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23383 }
23384 arg2 = static_cast< PLINT >(val2);
23385 ecode3 = SWIG_AsVal_int(args(2), &val3);
23386 if (!SWIG_IsOK(ecode3)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23388 }
23389 arg3 = static_cast< PLINT >(val3);
23390 ecode4 = SWIG_AsVal_int(args(3), &val4);
23391 if (!SWIG_IsOK(ecode4)) {
23392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23393 }
23394 arg4 = static_cast< PLINT >(val4);
23395 ecode5 = SWIG_AsVal_double(args(4), &val5);
23396 if (!SWIG_IsOK(ecode5)) {
23397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23398 }
23399 arg5 = static_cast< PLFLT >(val5);
23400 plscol0a(arg1,arg2,arg3,arg4,arg5);
23401 _outv = octave_value();
23402 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23403 return _out;
23404 fail:
23405 return octave_value_list();
23406 }
23407 catch(...) {
23408 throw;
23409 }
23410}
23411
23412
23414 PLINT arg1 ;
23415 PLINT arg2 ;
23416 PLINT arg3 ;
23417 int val1 ;
23418 int ecode1 = 0 ;
23419 int val2 ;
23420 int ecode2 = 0 ;
23421 int val3 ;
23422 int ecode3 = 0 ;
23423 octave_value_list _out;
23424 octave_value_list *_outp=&_out;
23425 octave_value _outv;
23426
23427 try {
23428 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23429 SWIG_fail;
23430 }
23431 ecode1 = SWIG_AsVal_int(args(0), &val1);
23432 if (!SWIG_IsOK(ecode1)) {
23433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23434 }
23435 arg1 = static_cast< PLINT >(val1);
23436 ecode2 = SWIG_AsVal_int(args(1), &val2);
23437 if (!SWIG_IsOK(ecode2)) {
23438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23439 }
23440 arg2 = static_cast< PLINT >(val2);
23441 ecode3 = SWIG_AsVal_int(args(2), &val3);
23442 if (!SWIG_IsOK(ecode3)) {
23443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23444 }
23445 arg3 = static_cast< PLINT >(val3);
23446 plscolbg(arg1,arg2,arg3);
23447 _outv = octave_value();
23448 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23449 return _out;
23450 fail:
23451 return octave_value_list();
23452 }
23453 catch(...) {
23454 throw;
23455 }
23456}
23457
23458
23460 PLINT arg1 ;
23461 PLINT arg2 ;
23462 PLINT arg3 ;
23463 PLFLT arg4 ;
23464 int val1 ;
23465 int ecode1 = 0 ;
23466 int val2 ;
23467 int ecode2 = 0 ;
23468 int val3 ;
23469 int ecode3 = 0 ;
23470 double val4 ;
23471 int ecode4 = 0 ;
23472 octave_value_list _out;
23473 octave_value_list *_outp=&_out;
23474 octave_value _outv;
23475
23476 try {
23477 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23478 SWIG_fail;
23479 }
23480 ecode1 = SWIG_AsVal_int(args(0), &val1);
23481 if (!SWIG_IsOK(ecode1)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23483 }
23484 arg1 = static_cast< PLINT >(val1);
23485 ecode2 = SWIG_AsVal_int(args(1), &val2);
23486 if (!SWIG_IsOK(ecode2)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23488 }
23489 arg2 = static_cast< PLINT >(val2);
23490 ecode3 = SWIG_AsVal_int(args(2), &val3);
23491 if (!SWIG_IsOK(ecode3)) {
23492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23493 }
23494 arg3 = static_cast< PLINT >(val3);
23495 ecode4 = SWIG_AsVal_double(args(3), &val4);
23496 if (!SWIG_IsOK(ecode4)) {
23497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23498 }
23499 arg4 = static_cast< PLFLT >(val4);
23500 plscolbga(arg1,arg2,arg3,arg4);
23501 _outv = octave_value();
23502 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23503 return _out;
23504 fail:
23505 return octave_value_list();
23506 }
23507 catch(...) {
23508 throw;
23509 }
23510}
23511
23512
23514 PLINT arg1 ;
23515 int val1 ;
23516 int ecode1 = 0 ;
23517 octave_value_list _out;
23518 octave_value_list *_outp=&_out;
23519 octave_value _outv;
23520
23521 try {
23522 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23523 SWIG_fail;
23524 }
23525 ecode1 = SWIG_AsVal_int(args(0), &val1);
23526 if (!SWIG_IsOK(ecode1)) {
23527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23528 }
23529 arg1 = static_cast< PLINT >(val1);
23530 plscolor(arg1);
23531 _outv = octave_value();
23532 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23533 return _out;
23534 fail:
23535 return octave_value_list();
23536 }
23537 catch(...) {
23538 throw;
23539 }
23540}
23541
23542
23544 PLINT arg1 ;
23545 int val1 ;
23546 int ecode1 = 0 ;
23547 octave_value_list _out;
23548 octave_value_list *_outp=&_out;
23549 octave_value _outv;
23550
23551 try {
23552 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23553 SWIG_fail;
23554 }
23555 ecode1 = SWIG_AsVal_int(args(0), &val1);
23556 if (!SWIG_IsOK(ecode1)) {
23557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23558 }
23559 arg1 = static_cast< PLINT >(val1);
23560 plscompression(arg1);
23561 _outv = octave_value();
23562 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23563 return _out;
23564 fail:
23565 return octave_value_list();
23566 }
23567 catch(...) {
23568 throw;
23569 }
23570}
23571
23572
23574 char *arg1 = (char *) 0 ;
23575 int res1 ;
23576 char *buf1 = 0 ;
23577 int alloc1 = 0 ;
23578 octave_value_list _out;
23579 octave_value_list *_outp=&_out;
23580 octave_value _outv;
23581
23582 try {
23583 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23584 SWIG_fail;
23585 }
23586 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23587 if (!SWIG_IsOK(res1)) {
23588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23589 }
23590 arg1 = reinterpret_cast< char * >(buf1);
23591 plsdev((char const *)arg1);
23592 _outv = octave_value();
23593 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23594 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23595 return _out;
23596 fail:
23597 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23598 return octave_value_list();
23599 }
23600 catch(...) {
23601 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23602 throw;
23603 }
23604}
23605
23606
23608 PLFLT arg1 ;
23609 PLFLT arg2 ;
23610 PLFLT arg3 ;
23611 PLFLT arg4 ;
23612 double val1 ;
23613 int ecode1 = 0 ;
23614 double val2 ;
23615 int ecode2 = 0 ;
23616 double val3 ;
23617 int ecode3 = 0 ;
23618 double val4 ;
23619 int ecode4 = 0 ;
23620 octave_value_list _out;
23621 octave_value_list *_outp=&_out;
23622 octave_value _outv;
23623
23624 try {
23625 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23626 SWIG_fail;
23627 }
23628 ecode1 = SWIG_AsVal_double(args(0), &val1);
23629 if (!SWIG_IsOK(ecode1)) {
23630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23631 }
23632 arg1 = static_cast< PLFLT >(val1);
23633 ecode2 = SWIG_AsVal_double(args(1), &val2);
23634 if (!SWIG_IsOK(ecode2)) {
23635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23636 }
23637 arg2 = static_cast< PLFLT >(val2);
23638 ecode3 = SWIG_AsVal_double(args(2), &val3);
23639 if (!SWIG_IsOK(ecode3)) {
23640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23641 }
23642 arg3 = static_cast< PLFLT >(val3);
23643 ecode4 = SWIG_AsVal_double(args(3), &val4);
23644 if (!SWIG_IsOK(ecode4)) {
23645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23646 }
23647 arg4 = static_cast< PLFLT >(val4);
23648 plsdidev(arg1,arg2,arg3,arg4);
23649 _outv = octave_value();
23650 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23651 return _out;
23652 fail:
23653 return octave_value_list();
23654 }
23655 catch(...) {
23656 throw;
23657 }
23658}
23659
23660
23662 PLINT arg1 ;
23663 PLINT arg2 ;
23664 PLINT arg3 ;
23665 PLINT arg4 ;
23666 PLFLT arg5 ;
23667 PLFLT arg6 ;
23668 int val1 ;
23669 int ecode1 = 0 ;
23670 int val2 ;
23671 int ecode2 = 0 ;
23672 int val3 ;
23673 int ecode3 = 0 ;
23674 int val4 ;
23675 int ecode4 = 0 ;
23676 double val5 ;
23677 int ecode5 = 0 ;
23678 double val6 ;
23679 int ecode6 = 0 ;
23680 octave_value_list _out;
23681 octave_value_list *_outp=&_out;
23682 octave_value _outv;
23683
23684 try {
23685 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23686 SWIG_fail;
23687 }
23688 ecode1 = SWIG_AsVal_int(args(0), &val1);
23689 if (!SWIG_IsOK(ecode1)) {
23690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23691 }
23692 arg1 = static_cast< PLINT >(val1);
23693 ecode2 = SWIG_AsVal_int(args(1), &val2);
23694 if (!SWIG_IsOK(ecode2)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23696 }
23697 arg2 = static_cast< PLINT >(val2);
23698 ecode3 = SWIG_AsVal_int(args(2), &val3);
23699 if (!SWIG_IsOK(ecode3)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23701 }
23702 arg3 = static_cast< PLINT >(val3);
23703 ecode4 = SWIG_AsVal_int(args(3), &val4);
23704 if (!SWIG_IsOK(ecode4)) {
23705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23706 }
23707 arg4 = static_cast< PLINT >(val4);
23708 ecode5 = SWIG_AsVal_double(args(4), &val5);
23709 if (!SWIG_IsOK(ecode5)) {
23710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23711 }
23712 arg5 = static_cast< PLFLT >(val5);
23713 ecode6 = SWIG_AsVal_double(args(5), &val6);
23714 if (!SWIG_IsOK(ecode6)) {
23715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23716 }
23717 arg6 = static_cast< PLFLT >(val6);
23718 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23719 _outv = octave_value();
23720 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23721 return _out;
23722 fail:
23723 return octave_value_list();
23724 }
23725 catch(...) {
23726 throw;
23727 }
23728}
23729
23730
23732 PLFLT arg1 ;
23733 double val1 ;
23734 int ecode1 = 0 ;
23735 octave_value_list _out;
23736 octave_value_list *_outp=&_out;
23737 octave_value _outv;
23738
23739 try {
23740 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23741 SWIG_fail;
23742 }
23743 ecode1 = SWIG_AsVal_double(args(0), &val1);
23744 if (!SWIG_IsOK(ecode1)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23746 }
23747 arg1 = static_cast< PLFLT >(val1);
23748 plsdiori(arg1);
23749 _outv = octave_value();
23750 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23751 return _out;
23752 fail:
23753 return octave_value_list();
23754 }
23755 catch(...) {
23756 throw;
23757 }
23758}
23759
23760
23762 PLFLT arg1 ;
23763 PLFLT arg2 ;
23764 PLFLT arg3 ;
23765 PLFLT arg4 ;
23766 double val1 ;
23767 int ecode1 = 0 ;
23768 double val2 ;
23769 int ecode2 = 0 ;
23770 double val3 ;
23771 int ecode3 = 0 ;
23772 double val4 ;
23773 int ecode4 = 0 ;
23774 octave_value_list _out;
23775 octave_value_list *_outp=&_out;
23776 octave_value _outv;
23777
23778 try {
23779 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23780 SWIG_fail;
23781 }
23782 ecode1 = SWIG_AsVal_double(args(0), &val1);
23783 if (!SWIG_IsOK(ecode1)) {
23784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23785 }
23786 arg1 = static_cast< PLFLT >(val1);
23787 ecode2 = SWIG_AsVal_double(args(1), &val2);
23788 if (!SWIG_IsOK(ecode2)) {
23789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23790 }
23791 arg2 = static_cast< PLFLT >(val2);
23792 ecode3 = SWIG_AsVal_double(args(2), &val3);
23793 if (!SWIG_IsOK(ecode3)) {
23794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23795 }
23796 arg3 = static_cast< PLFLT >(val3);
23797 ecode4 = SWIG_AsVal_double(args(3), &val4);
23798 if (!SWIG_IsOK(ecode4)) {
23799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23800 }
23801 arg4 = static_cast< PLFLT >(val4);
23802 plsdiplt(arg1,arg2,arg3,arg4);
23803 _outv = octave_value();
23804 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23805 return _out;
23806 fail:
23807 return octave_value_list();
23808 }
23809 catch(...) {
23810 throw;
23811 }
23812}
23813
23814
23816 PLFLT arg1 ;
23817 PLFLT arg2 ;
23818 PLFLT arg3 ;
23819 PLFLT arg4 ;
23820 double val1 ;
23821 int ecode1 = 0 ;
23822 double val2 ;
23823 int ecode2 = 0 ;
23824 double val3 ;
23825 int ecode3 = 0 ;
23826 double val4 ;
23827 int ecode4 = 0 ;
23828 octave_value_list _out;
23829 octave_value_list *_outp=&_out;
23830 octave_value _outv;
23831
23832 try {
23833 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23834 SWIG_fail;
23835 }
23836 ecode1 = SWIG_AsVal_double(args(0), &val1);
23837 if (!SWIG_IsOK(ecode1)) {
23838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23839 }
23840 arg1 = static_cast< PLFLT >(val1);
23841 ecode2 = SWIG_AsVal_double(args(1), &val2);
23842 if (!SWIG_IsOK(ecode2)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23844 }
23845 arg2 = static_cast< PLFLT >(val2);
23846 ecode3 = SWIG_AsVal_double(args(2), &val3);
23847 if (!SWIG_IsOK(ecode3)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23849 }
23850 arg3 = static_cast< PLFLT >(val3);
23851 ecode4 = SWIG_AsVal_double(args(3), &val4);
23852 if (!SWIG_IsOK(ecode4)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23854 }
23855 arg4 = static_cast< PLFLT >(val4);
23856 plsdiplz(arg1,arg2,arg3,arg4);
23857 _outv = octave_value();
23858 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23859 return _out;
23860 fail:
23861 return octave_value_list();
23862 }
23863 catch(...) {
23864 throw;
23865 }
23866}
23867
23868
23870 unsigned int arg1 ;
23871 unsigned int val1 ;
23872 int ecode1 = 0 ;
23873 octave_value_list _out;
23874 octave_value_list *_outp=&_out;
23875 octave_value _outv;
23876
23877 try {
23878 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
23879 SWIG_fail;
23880 }
23881 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23882 if (!SWIG_IsOK(ecode1)) {
23883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
23884 }
23885 arg1 = static_cast< unsigned int >(val1);
23886 plseed(arg1);
23887 _outv = octave_value();
23888 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23889 return _out;
23890 fail:
23891 return octave_value_list();
23892 }
23893 catch(...) {
23894 throw;
23895 }
23896}
23897
23898
23900 char arg1 ;
23901 char val1 ;
23902 int ecode1 = 0 ;
23903 octave_value_list _out;
23904 octave_value_list *_outp=&_out;
23905 octave_value _outv;
23906
23907 try {
23908 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
23909 SWIG_fail;
23910 }
23911 ecode1 = SWIG_AsVal_char(args(0), &val1);
23912 if (!SWIG_IsOK(ecode1)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
23914 }
23915 arg1 = static_cast< char >(val1);
23916 plsesc(arg1);
23917 _outv = octave_value();
23918 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23919 return _out;
23920 fail:
23921 return octave_value_list();
23922 }
23923 catch(...) {
23924 throw;
23925 }
23926}
23927
23928
23929SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
23930 char *arg1 = (char *) 0 ;
23931 char *arg2 = (char *) 0 ;
23932 int res1 ;
23933 char *buf1 = 0 ;
23934 int alloc1 = 0 ;
23935 int res2 ;
23936 char *buf2 = 0 ;
23937 int alloc2 = 0 ;
23938 octave_value_list _out;
23939 octave_value_list *_outp=&_out;
23940 octave_value _outv;
23941 PLINT result;
23942
23943 try {
23944 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
23945 SWIG_fail;
23946 }
23947 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
23950 }
23951 arg1 = reinterpret_cast< char * >(buf1);
23952 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23953 if (!SWIG_IsOK(res2)) {
23954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
23955 }
23956 arg2 = reinterpret_cast< char * >(buf2);
23957 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
23958 _outv = SWIG_From_int(static_cast< int >(result));
23959 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23960 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23961 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23962 return _out;
23963 fail:
23964 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23965 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23966 return octave_value_list();
23967 }
23968 catch(...) {
23969 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23970 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23971 throw;
23972 }
23973}
23974
23975
23977 PLINT arg1 ;
23978 PLINT arg2 ;
23979 PLINT arg3 ;
23980 int val1 ;
23981 int ecode1 = 0 ;
23982 int val2 ;
23983 int ecode2 = 0 ;
23984 int val3 ;
23985 int ecode3 = 0 ;
23986 octave_value_list _out;
23987 octave_value_list *_outp=&_out;
23988 octave_value _outv;
23989
23990 try {
23991 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
23992 SWIG_fail;
23993 }
23994 ecode1 = SWIG_AsVal_int(args(0), &val1);
23995 if (!SWIG_IsOK(ecode1)) {
23996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
23997 }
23998 arg1 = static_cast< PLINT >(val1);
23999 ecode2 = SWIG_AsVal_int(args(1), &val2);
24000 if (!SWIG_IsOK(ecode2)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24002 }
24003 arg2 = static_cast< PLINT >(val2);
24004 ecode3 = SWIG_AsVal_int(args(2), &val3);
24005 if (!SWIG_IsOK(ecode3)) {
24006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24007 }
24008 arg3 = static_cast< PLINT >(val3);
24009 plsfam(arg1,arg2,arg3);
24010 _outv = octave_value();
24011 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24012 return _out;
24013 fail:
24014 return octave_value_list();
24015 }
24016 catch(...) {
24017 throw;
24018 }
24019}
24020
24021
24023 PLUNICODE arg1 ;
24024 unsigned int val1 ;
24025 int ecode1 = 0 ;
24026 octave_value_list _out;
24027 octave_value_list *_outp=&_out;
24028 octave_value _outv;
24029
24030 try {
24031 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24032 SWIG_fail;
24033 }
24034 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24035 if (!SWIG_IsOK(ecode1)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24037 }
24038 arg1 = static_cast< PLUNICODE >(val1);
24039 plsfci(arg1);
24040 _outv = octave_value();
24041 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24042 return _out;
24043 fail:
24044 return octave_value_list();
24045 }
24046 catch(...) {
24047 throw;
24048 }
24049}
24050
24051
24053 char *arg1 = (char *) 0 ;
24054 int res1 ;
24055 char *buf1 = 0 ;
24056 int alloc1 = 0 ;
24057 octave_value_list _out;
24058 octave_value_list *_outp=&_out;
24059 octave_value _outv;
24060
24061 try {
24062 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24063 SWIG_fail;
24064 }
24065 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24066 if (!SWIG_IsOK(res1)) {
24067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24068 }
24069 arg1 = reinterpret_cast< char * >(buf1);
24070 plsfnam((char const *)arg1);
24071 _outv = octave_value();
24072 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24073 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24074 return _out;
24075 fail:
24076 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24077 return octave_value_list();
24078 }
24079 catch(...) {
24080 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24081 throw;
24082 }
24083}
24084
24085
24087 PLINT arg1 ;
24088 PLINT arg2 ;
24089 PLINT arg3 ;
24090 int val1 ;
24091 int ecode1 = 0 ;
24092 int val2 ;
24093 int ecode2 = 0 ;
24094 int val3 ;
24095 int ecode3 = 0 ;
24096 octave_value_list _out;
24097 octave_value_list *_outp=&_out;
24098 octave_value _outv;
24099
24100 try {
24101 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24102 SWIG_fail;
24103 }
24104 ecode1 = SWIG_AsVal_int(args(0), &val1);
24105 if (!SWIG_IsOK(ecode1)) {
24106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24107 }
24108 arg1 = static_cast< PLINT >(val1);
24109 ecode2 = SWIG_AsVal_int(args(1), &val2);
24110 if (!SWIG_IsOK(ecode2)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24112 }
24113 arg2 = static_cast< PLINT >(val2);
24114 ecode3 = SWIG_AsVal_int(args(2), &val3);
24115 if (!SWIG_IsOK(ecode3)) {
24116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24117 }
24118 arg3 = static_cast< PLINT >(val3);
24119 plsfont(arg1,arg2,arg3);
24120 _outv = octave_value();
24121 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24122 return _out;
24123 fail:
24124 return octave_value_list();
24125 }
24126 catch(...) {
24127 throw;
24128 }
24129}
24130
24131
24133 label_func arg1 = (label_func) 0 ;
24134 PLPointer arg2 = (PLPointer) 0 ;
24135 int res2 ;
24136 octave_value_list _out;
24137 octave_value_list *_outp=&_out;
24138 octave_value _outv;
24139
24140 try {
24141 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24142 SWIG_fail;
24143 }
24144 {
24145 octave_value obj = args(0);
24146#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24147 if ( !obj.isempty() )
24148#else
24149 if ( !obj.is_empty() )
24150#endif
24151 {
24152 if ( obj.is_function_handle() || obj.is_inline_function() )
24153 {
24154 fcnLabelFunc = obj.function_value();
24155 }
24156 else if ( obj.is_string() )
24157 {
24158 nameLabelFunc = obj.string_value();
24159 fcnLabelFunc = NULL;
24160 }
24161 arg1 = labelfunc_octave;
24162 }
24163 else
24164 {
24165 arg1 = NULL;
24166 }
24167 }
24168 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24169 if (!SWIG_IsOK(res2)) {
24170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24171 }
24172 plslabelfunc(arg1,arg2);
24173 _outv = octave_value();
24174 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24175 return _out;
24176 fail:
24177 return octave_value_list();
24178 }
24179 catch(...) {
24180 throw;
24181 }
24182}
24183
24184
24186 PLFLT arg1 ;
24187 PLFLT arg2 ;
24188 double val1 ;
24189 int ecode1 = 0 ;
24190 double val2 ;
24191 int ecode2 = 0 ;
24192 octave_value_list _out;
24193 octave_value_list *_outp=&_out;
24194 octave_value _outv;
24195
24196 try {
24197 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24198 SWIG_fail;
24199 }
24200 ecode1 = SWIG_AsVal_double(args(0), &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24203 }
24204 arg1 = static_cast< PLFLT >(val1);
24205 ecode2 = SWIG_AsVal_double(args(1), &val2);
24206 if (!SWIG_IsOK(ecode2)) {
24207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24208 }
24209 arg2 = static_cast< PLFLT >(val2);
24210 plsmaj(arg1,arg2);
24211 _outv = octave_value();
24212 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24213 return _out;
24214 fail:
24215 return octave_value_list();
24216 }
24217 catch(...) {
24218 throw;
24219 }
24220}
24221
24222
24224 PLFLT arg1 ;
24225 PLFLT arg2 ;
24226 double val1 ;
24227 int ecode1 = 0 ;
24228 double val2 ;
24229 int ecode2 = 0 ;
24230 octave_value_list _out;
24231 octave_value_list *_outp=&_out;
24232 octave_value _outv;
24233
24234 try {
24235 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24236 SWIG_fail;
24237 }
24238 ecode1 = SWIG_AsVal_double(args(0), &val1);
24239 if (!SWIG_IsOK(ecode1)) {
24240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24241 }
24242 arg1 = static_cast< PLFLT >(val1);
24243 ecode2 = SWIG_AsVal_double(args(1), &val2);
24244 if (!SWIG_IsOK(ecode2)) {
24245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24246 }
24247 arg2 = static_cast< PLFLT >(val2);
24248 plsmin(arg1,arg2);
24249 _outv = octave_value();
24250 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24251 return _out;
24252 fail:
24253 return octave_value_list();
24254 }
24255 catch(...) {
24256 throw;
24257 }
24258}
24259
24260
24262 PLINT arg1 ;
24263 int val1 ;
24264 int ecode1 = 0 ;
24265 octave_value_list _out;
24266 octave_value_list *_outp=&_out;
24267 octave_value _outv;
24268
24269 try {
24270 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24271 SWIG_fail;
24272 }
24273 ecode1 = SWIG_AsVal_int(args(0), &val1);
24274 if (!SWIG_IsOK(ecode1)) {
24275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24276 }
24277 arg1 = static_cast< PLINT >(val1);
24278 plsori(arg1);
24279 _outv = octave_value();
24280 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24281 return _out;
24282 fail:
24283 return octave_value_list();
24284 }
24285 catch(...) {
24286 throw;
24287 }
24288}
24289
24290
24292 PLFLT arg1 ;
24293 PLFLT arg2 ;
24294 PLINT arg3 ;
24295 PLINT arg4 ;
24296 PLINT arg5 ;
24297 PLINT arg6 ;
24298 double val1 ;
24299 int ecode1 = 0 ;
24300 double val2 ;
24301 int ecode2 = 0 ;
24302 int val3 ;
24303 int ecode3 = 0 ;
24304 int val4 ;
24305 int ecode4 = 0 ;
24306 int val5 ;
24307 int ecode5 = 0 ;
24308 int val6 ;
24309 int ecode6 = 0 ;
24310 octave_value_list _out;
24311 octave_value_list *_outp=&_out;
24312 octave_value _outv;
24313
24314 try {
24315 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24316 SWIG_fail;
24317 }
24318 ecode1 = SWIG_AsVal_double(args(0), &val1);
24319 if (!SWIG_IsOK(ecode1)) {
24320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24321 }
24322 arg1 = static_cast< PLFLT >(val1);
24323 ecode2 = SWIG_AsVal_double(args(1), &val2);
24324 if (!SWIG_IsOK(ecode2)) {
24325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24326 }
24327 arg2 = static_cast< PLFLT >(val2);
24328 ecode3 = SWIG_AsVal_int(args(2), &val3);
24329 if (!SWIG_IsOK(ecode3)) {
24330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24331 }
24332 arg3 = static_cast< PLINT >(val3);
24333 ecode4 = SWIG_AsVal_int(args(3), &val4);
24334 if (!SWIG_IsOK(ecode4)) {
24335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24336 }
24337 arg4 = static_cast< PLINT >(val4);
24338 ecode5 = SWIG_AsVal_int(args(4), &val5);
24339 if (!SWIG_IsOK(ecode5)) {
24340 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24341 }
24342 arg5 = static_cast< PLINT >(val5);
24343 ecode6 = SWIG_AsVal_int(args(5), &val6);
24344 if (!SWIG_IsOK(ecode6)) {
24345 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24346 }
24347 arg6 = static_cast< PLINT >(val6);
24348 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24349 _outv = octave_value();
24350 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24351 return _out;
24352 fail:
24353 return octave_value_list();
24354 }
24355 catch(...) {
24356 throw;
24357 }
24358}
24359
24360
24362 char *arg1 = (char *) 0 ;
24363 int res1 ;
24364 char *buf1 = 0 ;
24365 int alloc1 = 0 ;
24366 octave_value_list _out;
24367 octave_value_list *_outp=&_out;
24368 octave_value _outv;
24369
24370 try {
24371 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24372 SWIG_fail;
24373 }
24374 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24377 }
24378 arg1 = reinterpret_cast< char * >(buf1);
24379 plspal0((char const *)arg1);
24380 _outv = octave_value();
24381 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24382 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24383 return _out;
24384 fail:
24385 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24386 return octave_value_list();
24387 }
24388 catch(...) {
24389 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24390 throw;
24391 }
24392}
24393
24394
24396 char *arg1 = (char *) 0 ;
24397 PLBOOL arg2 ;
24398 int res1 ;
24399 char *buf1 = 0 ;
24400 int alloc1 = 0 ;
24401 int val2 ;
24402 int ecode2 = 0 ;
24403 octave_value_list _out;
24404 octave_value_list *_outp=&_out;
24405 octave_value _outv;
24406
24407 try {
24408 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24409 SWIG_fail;
24410 }
24411 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24412 if (!SWIG_IsOK(res1)) {
24413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24414 }
24415 arg1 = reinterpret_cast< char * >(buf1);
24416 ecode2 = SWIG_AsVal_int(args(1), &val2);
24417 if (!SWIG_IsOK(ecode2)) {
24418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24419 }
24420 arg2 = static_cast< PLBOOL >(val2);
24421 plspal1((char const *)arg1,arg2);
24422 _outv = octave_value();
24423 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24424 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24425 return _out;
24426 fail:
24427 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24428 return octave_value_list();
24429 }
24430 catch(...) {
24431 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24432 throw;
24433 }
24434}
24435
24436
24438 PLBOOL arg1 ;
24439 int val1 ;
24440 int ecode1 = 0 ;
24441 octave_value_list _out;
24442 octave_value_list *_outp=&_out;
24443 octave_value _outv;
24444
24445 try {
24446 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24447 SWIG_fail;
24448 }
24449 ecode1 = SWIG_AsVal_int(args(0), &val1);
24450 if (!SWIG_IsOK(ecode1)) {
24451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24452 }
24453 arg1 = static_cast< PLBOOL >(val1);
24454 plspause(arg1);
24455 _outv = octave_value();
24456 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24457 return _out;
24458 fail:
24459 return octave_value_list();
24460 }
24461 catch(...) {
24462 throw;
24463 }
24464}
24465
24466
24468 PLINT arg1 ;
24469 int val1 ;
24470 int ecode1 = 0 ;
24471 octave_value_list _out;
24472 octave_value_list *_outp=&_out;
24473 octave_value _outv;
24474
24475 try {
24476 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24477 SWIG_fail;
24478 }
24479 ecode1 = SWIG_AsVal_int(args(0), &val1);
24480 if (!SWIG_IsOK(ecode1)) {
24481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24482 }
24483 arg1 = static_cast< PLINT >(val1);
24484 plsstrm(arg1);
24485 _outv = octave_value();
24486 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24487 return _out;
24488 fail:
24489 return octave_value_list();
24490 }
24491 catch(...) {
24492 throw;
24493 }
24494}
24495
24496
24498 PLINT arg1 ;
24499 PLINT arg2 ;
24500 int val1 ;
24501 int ecode1 = 0 ;
24502 int val2 ;
24503 int ecode2 = 0 ;
24504 octave_value_list _out;
24505 octave_value_list *_outp=&_out;
24506 octave_value _outv;
24507
24508 try {
24509 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24510 SWIG_fail;
24511 }
24512 ecode1 = SWIG_AsVal_int(args(0), &val1);
24513 if (!SWIG_IsOK(ecode1)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24515 }
24516 arg1 = static_cast< PLINT >(val1);
24517 ecode2 = SWIG_AsVal_int(args(1), &val2);
24518 if (!SWIG_IsOK(ecode2)) {
24519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24520 }
24521 arg2 = static_cast< PLINT >(val2);
24522 plssub(arg1,arg2);
24523 _outv = octave_value();
24524 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24525 return _out;
24526 fail:
24527 return octave_value_list();
24528 }
24529 catch(...) {
24530 throw;
24531 }
24532}
24533
24534
24536 PLFLT arg1 ;
24537 PLFLT arg2 ;
24538 double val1 ;
24539 int ecode1 = 0 ;
24540 double val2 ;
24541 int ecode2 = 0 ;
24542 octave_value_list _out;
24543 octave_value_list *_outp=&_out;
24544 octave_value _outv;
24545
24546 try {
24547 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24548 SWIG_fail;
24549 }
24550 ecode1 = SWIG_AsVal_double(args(0), &val1);
24551 if (!SWIG_IsOK(ecode1)) {
24552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24553 }
24554 arg1 = static_cast< PLFLT >(val1);
24555 ecode2 = SWIG_AsVal_double(args(1), &val2);
24556 if (!SWIG_IsOK(ecode2)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24558 }
24559 arg2 = static_cast< PLFLT >(val2);
24560 plssym(arg1,arg2);
24561 _outv = octave_value();
24562 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24563 return _out;
24564 fail:
24565 return octave_value_list();
24566 }
24567 catch(...) {
24568 throw;
24569 }
24570}
24571
24572
24574 PLINT arg1 ;
24575 PLINT arg2 ;
24576 int val1 ;
24577 int ecode1 = 0 ;
24578 int val2 ;
24579 int ecode2 = 0 ;
24580 octave_value_list _out;
24581 octave_value_list *_outp=&_out;
24582 octave_value _outv;
24583
24584 try {
24585 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24586 SWIG_fail;
24587 }
24588 ecode1 = SWIG_AsVal_int(args(0), &val1);
24589 if (!SWIG_IsOK(ecode1)) {
24590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24591 }
24592 arg1 = static_cast< PLINT >(val1);
24593 ecode2 = SWIG_AsVal_int(args(1), &val2);
24594 if (!SWIG_IsOK(ecode2)) {
24595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24596 }
24597 arg2 = static_cast< PLINT >(val2);
24598 plstar(arg1,arg2);
24599 _outv = octave_value();
24600 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24601 return _out;
24602 fail:
24603 return octave_value_list();
24604 }
24605 catch(...) {
24606 throw;
24607 }
24608}
24609
24610
24612 char *arg1 = (char *) 0 ;
24613 PLINT arg2 ;
24614 PLINT arg3 ;
24615 int res1 ;
24616 char *buf1 = 0 ;
24617 int alloc1 = 0 ;
24618 int val2 ;
24619 int ecode2 = 0 ;
24620 int val3 ;
24621 int ecode3 = 0 ;
24622 octave_value_list _out;
24623 octave_value_list *_outp=&_out;
24624 octave_value _outv;
24625
24626 try {
24627 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24628 SWIG_fail;
24629 }
24630 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24633 }
24634 arg1 = reinterpret_cast< char * >(buf1);
24635 ecode2 = SWIG_AsVal_int(args(1), &val2);
24636 if (!SWIG_IsOK(ecode2)) {
24637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24638 }
24639 arg2 = static_cast< PLINT >(val2);
24640 ecode3 = SWIG_AsVal_int(args(2), &val3);
24641 if (!SWIG_IsOK(ecode3)) {
24642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24643 }
24644 arg3 = static_cast< PLINT >(val3);
24645 plstart((char const *)arg1,arg2,arg3);
24646 _outv = octave_value();
24647 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24648 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24649 return _out;
24650 fail:
24651 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24652 return octave_value_list();
24653 }
24654 catch(...) {
24655 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24656 throw;
24657 }
24658}
24659
24660
24662 ct_func arg1 = (ct_func) 0 ;
24663 PLPointer arg2 = (PLPointer) 0 ;
24664 int res2 ;
24665 octave_value_list _out;
24666 octave_value_list *_outp=&_out;
24667 octave_value _outv;
24668
24669 try {
24670 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24671 SWIG_fail;
24672 }
24673 {
24674 octave_value obj = args(0);
24675#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24676 if ( !obj.isempty() )
24677#else
24678 if ( !obj.is_empty() )
24679#endif
24680 {
24681 if ( obj.is_function_handle() || obj.is_inline_function() )
24682 {
24683 fcnCoordTrans = obj.function_value();
24684 }
24685 else if ( obj.is_string() )
24686 {
24687 nameCoordTrans = obj.string_value();
24688 fcnCoordTrans = NULL;
24689 }
24690 arg1 = ct_octave;
24691 }
24692 else
24693 {
24694 arg1 = NULL;
24695 }
24696 }
24697 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24698 if (!SWIG_IsOK(res2)) {
24699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24700 }
24701 plstransform(arg1,arg2);
24702 _outv = octave_value();
24703 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24704 return _out;
24705 fail:
24706 return octave_value_list();
24707 }
24708 catch(...) {
24709 throw;
24710 }
24711}
24712
24713
24715 PLINT arg1 ;
24716 PLFLT *arg2 = (PLFLT *) 0 ;
24717 PLFLT *arg3 = (PLFLT *) 0 ;
24718 char *arg4 = (char *) 0 ;
24719 Matrix temp1 ;
24720 Matrix temp3 ;
24721 int res4 ;
24722 char *buf4 = 0 ;
24723 int alloc4 = 0 ;
24724 octave_value_list _out;
24725 octave_value_list *_outp=&_out;
24726 octave_value _outv;
24727
24728 try {
24729 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24730 SWIG_fail;
24731 }
24732 {
24733 if ( _n_dims( args(0) ) > 1 )
24734 {
24735 error( "argument must be a scalar or vector" ); SWIG_fail;
24736 }
24737 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24738 temp1 = args(0).matrix_value();
24739 arg2 = &temp1( 0, 0 );
24740 }
24741 {
24742 if ( _n_dims( args(1) ) > 1 )
24743 {
24744 error( "argument must be a scalar or vector" ); SWIG_fail;
24745 }
24746 if ( _dim( args(1), 0 ) != Alen )
24747 {
24748 error( "argument vectors must be same length" ); SWIG_fail;
24749 }
24750 temp3 = args(1).matrix_value();
24751 arg3 = &temp3( 0, 0 );
24752 }
24753 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24754 if (!SWIG_IsOK(res4)) {
24755 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24756 }
24757 arg4 = reinterpret_cast< char * >(buf4);
24758 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24759 _outv = octave_value();
24760 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24761 {
24762
24763 }
24764 {
24765
24766 }
24767 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24768 return _out;
24769 fail:
24770 {
24771
24772 }
24773 {
24774
24775 }
24776 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24777 return octave_value_list();
24778 }
24779 catch(...) {
24780 {
24781
24782 }
24783 {
24784
24785 }
24786 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24787 throw;
24788 }
24789}
24790
24791
24793 PLINT arg1 ;
24794 PLFLT *arg2 = (PLFLT *) 0 ;
24795 PLFLT *arg3 = (PLFLT *) 0 ;
24796 PLFLT *arg4 = (PLFLT *) 0 ;
24797 char *arg5 = (char *) 0 ;
24798 Matrix temp1 ;
24799 Matrix temp3 ;
24800 Matrix temp4 ;
24801 int res5 ;
24802 char *buf5 = 0 ;
24803 int alloc5 = 0 ;
24804 octave_value_list _out;
24805 octave_value_list *_outp=&_out;
24806 octave_value _outv;
24807
24808 try {
24809 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24810 SWIG_fail;
24811 }
24812 {
24813 if ( _n_dims( args(0) ) > 1 )
24814 {
24815 error( "argument must be a scalar or vector" ); SWIG_fail;
24816 }
24817 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24818 temp1 = args(0).matrix_value();
24819 arg2 = &temp1( 0, 0 );
24820 }
24821 {
24822 if ( _n_dims( args(1) ) > 1 )
24823 {
24824 error( "argument must be a scalar or vector" ); SWIG_fail;
24825 }
24826 if ( _dim( args(1), 0 ) != Alen )
24827 {
24828 error( "argument vectors must be same length" ); SWIG_fail;
24829 }
24830 temp3 = args(1).matrix_value();
24831 arg3 = &temp3( 0, 0 );
24832 }
24833 {
24834 if ( _n_dims( args(2) ) > 1 )
24835 {
24836 error( "argument must be a scalar or vector" ); SWIG_fail;
24837 }
24838 if ( _dim( args(2), 0 ) != Alen )
24839 {
24840 error( "argument vectors must be same length" ); SWIG_fail;
24841 }
24842 temp4 = args(2).matrix_value();
24843 arg4 = &temp4( 0, 0 );
24844 }
24845 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24846 if (!SWIG_IsOK(res5)) {
24847 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24848 }
24849 arg5 = reinterpret_cast< char * >(buf5);
24850 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24851 _outv = octave_value();
24852 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24853 {
24854
24855 }
24856 {
24857
24858 }
24859 {
24860
24861 }
24862 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24863 return _out;
24864 fail:
24865 {
24866
24867 }
24868 {
24869
24870 }
24871 {
24872
24873 }
24874 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24875 return octave_value_list();
24876 }
24877 catch(...) {
24878 {
24879
24880 }
24881 {
24882
24883 }
24884 {
24885
24886 }
24887 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24888 throw;
24889 }
24890}
24891
24892
24894 PLINT arg1 ;
24895 PLINT arg2 ;
24896 PLFLT arg3 ;
24897 PLFLT arg4 ;
24898 int val1 ;
24899 int ecode1 = 0 ;
24900 int val2 ;
24901 int ecode2 = 0 ;
24902 double val3 ;
24903 int ecode3 = 0 ;
24904 double val4 ;
24905 int ecode4 = 0 ;
24906 octave_value_list _out;
24907 octave_value_list *_outp=&_out;
24908 octave_value _outv;
24909
24910 try {
24911 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
24912 SWIG_fail;
24913 }
24914 ecode1 = SWIG_AsVal_int(args(0), &val1);
24915 if (!SWIG_IsOK(ecode1)) {
24916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
24917 }
24918 arg1 = static_cast< PLINT >(val1);
24919 ecode2 = SWIG_AsVal_int(args(1), &val2);
24920 if (!SWIG_IsOK(ecode2)) {
24921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
24922 }
24923 arg2 = static_cast< PLINT >(val2);
24924 ecode3 = SWIG_AsVal_double(args(2), &val3);
24925 if (!SWIG_IsOK(ecode3)) {
24926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
24927 }
24928 arg3 = static_cast< PLFLT >(val3);
24929 ecode4 = SWIG_AsVal_double(args(3), &val4);
24930 if (!SWIG_IsOK(ecode4)) {
24931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
24932 }
24933 arg4 = static_cast< PLFLT >(val4);
24934 plstripa(arg1,arg2,arg3,arg4);
24935 _outv = octave_value();
24936 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24937 return _out;
24938 fail:
24939 return octave_value_list();
24940 }
24941 catch(...) {
24942 throw;
24943 }
24944}
24945
24946
24948 PLINT arg1 ;
24949 int val1 ;
24950 int ecode1 = 0 ;
24951 octave_value_list _out;
24952 octave_value_list *_outp=&_out;
24953 octave_value _outv;
24954
24955 try {
24956 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
24957 SWIG_fail;
24958 }
24959 ecode1 = SWIG_AsVal_int(args(0), &val1);
24960 if (!SWIG_IsOK(ecode1)) {
24961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
24962 }
24963 arg1 = static_cast< PLINT >(val1);
24964 plstripd(arg1);
24965 _outv = octave_value();
24966 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24967 return _out;
24968 fail:
24969 return octave_value_list();
24970 }
24971 catch(...) {
24972 throw;
24973 }
24974}
24975
24976
24978 PLINT arg1 ;
24979 PLINT *arg2 = (PLINT *) 0 ;
24980 PLINT *arg3 = (PLINT *) 0 ;
24981 Matrix temp1 ;
24982 Matrix temp3 ;
24983 octave_value_list _out;
24984 octave_value_list *_outp=&_out;
24985 octave_value _outv;
24986
24987 try {
24988 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
24989 SWIG_fail;
24990 }
24991 {
24992 if ( _n_dims( args(0) ) > 1 )
24993 {
24994 error( "argument must be a scalar or vector" ); SWIG_fail;
24995 }
24996 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24997 arg2 = new PLINT[Alen];
24998 temp1 = args(0).matrix_value();
24999 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25000 }
25001 {
25002 if ( _n_dims( args(1) ) > 1 )
25003 {
25004 error( "argument must be a scalar or vector" ); SWIG_fail;
25005 }
25006 if ( _dim( args(1), 0 ) != Alen )
25007 {
25008 error( "argument vectors must be same length" ); SWIG_fail;
25009 }
25010 temp3 = args(1).matrix_value();
25011 arg3 = new PLINT[Alen];
25012 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25013 }
25014 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25015 _outv = octave_value();
25016 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25017 {
25018 delete [] arg2;
25019 }
25020 {
25021 delete [] arg3;
25022 }
25023 return _out;
25024 fail:
25025 {
25026 delete [] arg2;
25027 }
25028 {
25029 delete [] arg3;
25030 }
25031 return octave_value_list();
25032 }
25033 catch(...) {
25034 {
25035 delete [] arg2;
25036 }
25037 {
25038 delete [] arg3;
25039 }
25040 throw;
25041 }
25042}
25043
25044
25046 PLFLT *arg1 = (PLFLT *) 0 ;
25047 PLFLT *arg2 = (PLFLT *) 0 ;
25048 PLINT arg3 ;
25049 PLBOOL arg4 ;
25050 Matrix temp1 ;
25051 Matrix temp2 ;
25052 int val4 ;
25053 int ecode4 = 0 ;
25054 octave_value_list _out;
25055 octave_value_list *_outp=&_out;
25056 octave_value _outv;
25057
25058 try {
25059 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25060 SWIG_fail;
25061 }
25062 {
25063 if ( _n_dims( args(0) ) > 1 )
25064 {
25065 error( "argument must be a scalar or vector" ); SWIG_fail;
25066 }
25067#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25068 if ( !args(0).isempty() )
25069#else
25070 if ( !args(0).is_empty() )
25071#endif
25072 {
25073 Alen = (PLINT) ( _dim( args(0), 0 ) );
25074 temp1 = args(0).matrix_value();
25075 arg1 = &temp1( 0, 0 );
25076 }
25077 else
25078 {
25079 arg1 = NULL;
25080 Alen = 0;
25081 }
25082 }
25083 {
25084 if ( _n_dims( args(1) ) > 1 )
25085 {
25086 error( "argument must be a scalar or vector" ); SWIG_fail;
25087 }
25088#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25089 if ( !args(1).isempty() )
25090#else
25091 if ( !args(1).is_empty() )
25092#endif
25093 {
25094 if ( _dim( args(1), 0 ) != Alen )
25095 {
25096 error( "argument vectors must be same length" ); SWIG_fail;
25097 }
25098 temp2 = args(1).matrix_value();
25099 arg2 = &temp2( 0, 0 );
25100 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25101 }
25102 else
25103 {
25104 arg2 = NULL;
25105 arg3 = 0;
25106 }
25107 }
25108 ecode4 = SWIG_AsVal_int(args(2), &val4);
25109 if (!SWIG_IsOK(ecode4)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25111 }
25112 arg4 = static_cast< PLBOOL >(val4);
25113 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25114 _outv = octave_value();
25115 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25116 {
25117
25118 }
25119 {
25120
25121 }
25122 return _out;
25123 fail:
25124 {
25125
25126 }
25127 {
25128
25129 }
25130 return octave_value_list();
25131 }
25132 catch(...) {
25133 {
25134
25135 }
25136 {
25137
25138 }
25139 throw;
25140 }
25141}
25142
25143
25145 PLFLT arg1 ;
25146 PLFLT arg2 ;
25147 PLFLT arg3 ;
25148 PLFLT arg4 ;
25149 double val1 ;
25150 int ecode1 = 0 ;
25151 double val2 ;
25152 int ecode2 = 0 ;
25153 double val3 ;
25154 int ecode3 = 0 ;
25155 double val4 ;
25156 int ecode4 = 0 ;
25157 octave_value_list _out;
25158 octave_value_list *_outp=&_out;
25159 octave_value _outv;
25160
25161 try {
25162 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25163 SWIG_fail;
25164 }
25165 ecode1 = SWIG_AsVal_double(args(0), &val1);
25166 if (!SWIG_IsOK(ecode1)) {
25167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25168 }
25169 arg1 = static_cast< PLFLT >(val1);
25170 ecode2 = SWIG_AsVal_double(args(1), &val2);
25171 if (!SWIG_IsOK(ecode2)) {
25172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25173 }
25174 arg2 = static_cast< PLFLT >(val2);
25175 ecode3 = SWIG_AsVal_double(args(2), &val3);
25176 if (!SWIG_IsOK(ecode3)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25178 }
25179 arg3 = static_cast< PLFLT >(val3);
25180 ecode4 = SWIG_AsVal_double(args(3), &val4);
25181 if (!SWIG_IsOK(ecode4)) {
25182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25183 }
25184 arg4 = static_cast< PLFLT >(val4);
25185 plsvpa(arg1,arg2,arg3,arg4);
25186 _outv = octave_value();
25187 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25188 return _out;
25189 fail:
25190 return octave_value_list();
25191 }
25192 catch(...) {
25193 throw;
25194 }
25195}
25196
25197
25199 PLINT arg1 ;
25200 PLINT arg2 ;
25201 int val1 ;
25202 int ecode1 = 0 ;
25203 int val2 ;
25204 int ecode2 = 0 ;
25205 octave_value_list _out;
25206 octave_value_list *_outp=&_out;
25207 octave_value _outv;
25208
25209 try {
25210 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25211 SWIG_fail;
25212 }
25213 ecode1 = SWIG_AsVal_int(args(0), &val1);
25214 if (!SWIG_IsOK(ecode1)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25216 }
25217 arg1 = static_cast< PLINT >(val1);
25218 ecode2 = SWIG_AsVal_int(args(1), &val2);
25219 if (!SWIG_IsOK(ecode2)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25221 }
25222 arg2 = static_cast< PLINT >(val2);
25223 plsxax(arg1,arg2);
25224 _outv = octave_value();
25225 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25226 return _out;
25227 fail:
25228 return octave_value_list();
25229 }
25230 catch(...) {
25231 throw;
25232 }
25233}
25234
25235
25237 PLINT arg1 ;
25238 PLINT arg2 ;
25239 int val1 ;
25240 int ecode1 = 0 ;
25241 int val2 ;
25242 int ecode2 = 0 ;
25243 octave_value_list _out;
25244 octave_value_list *_outp=&_out;
25245 octave_value _outv;
25246
25247 try {
25248 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25249 SWIG_fail;
25250 }
25251 ecode1 = SWIG_AsVal_int(args(0), &val1);
25252 if (!SWIG_IsOK(ecode1)) {
25253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25254 }
25255 arg1 = static_cast< PLINT >(val1);
25256 ecode2 = SWIG_AsVal_int(args(1), &val2);
25257 if (!SWIG_IsOK(ecode2)) {
25258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25259 }
25260 arg2 = static_cast< PLINT >(val2);
25261 plsyax(arg1,arg2);
25262 _outv = octave_value();
25263 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25264 return _out;
25265 fail:
25266 return octave_value_list();
25267 }
25268 catch(...) {
25269 throw;
25270 }
25271}
25272
25273
25275 PLINT arg1 ;
25276 PLFLT *arg2 = (PLFLT *) 0 ;
25277 PLFLT *arg3 = (PLFLT *) 0 ;
25278 PLINT arg4 ;
25279 Matrix temp1 ;
25280 Matrix temp3 ;
25281 int val4 ;
25282 int ecode4 = 0 ;
25283 octave_value_list _out;
25284 octave_value_list *_outp=&_out;
25285 octave_value _outv;
25286
25287 try {
25288 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25289 SWIG_fail;
25290 }
25291 {
25292 if ( _n_dims( args(0) ) > 1 )
25293 {
25294 error( "argument must be a scalar or vector" ); SWIG_fail;
25295 }
25296 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25297 temp1 = args(0).matrix_value();
25298 arg2 = &temp1( 0, 0 );
25299 }
25300 {
25301 if ( _n_dims( args(1) ) > 1 )
25302 {
25303 error( "argument must be a scalar or vector" ); SWIG_fail;
25304 }
25305 if ( _dim( args(1), 0 ) != Alen )
25306 {
25307 error( "argument vectors must be same length" ); SWIG_fail;
25308 }
25309 temp3 = args(1).matrix_value();
25310 arg3 = &temp3( 0, 0 );
25311 }
25312 ecode4 = SWIG_AsVal_int(args(2), &val4);
25313 if (!SWIG_IsOK(ecode4)) {
25314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25315 }
25316 arg4 = static_cast< PLINT >(val4);
25317 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25318 _outv = octave_value();
25319 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25320 {
25321
25322 }
25323 {
25324
25325 }
25326 return _out;
25327 fail:
25328 {
25329
25330 }
25331 {
25332
25333 }
25334 return octave_value_list();
25335 }
25336 catch(...) {
25337 {
25338
25339 }
25340 {
25341
25342 }
25343 throw;
25344 }
25345}
25346
25347
25349 PLINT arg1 ;
25350 PLINT arg2 ;
25351 int val1 ;
25352 int ecode1 = 0 ;
25353 int val2 ;
25354 int ecode2 = 0 ;
25355 octave_value_list _out;
25356 octave_value_list *_outp=&_out;
25357 octave_value _outv;
25358
25359 try {
25360 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25361 SWIG_fail;
25362 }
25363 ecode1 = SWIG_AsVal_int(args(0), &val1);
25364 if (!SWIG_IsOK(ecode1)) {
25365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25366 }
25367 arg1 = static_cast< PLINT >(val1);
25368 ecode2 = SWIG_AsVal_int(args(1), &val2);
25369 if (!SWIG_IsOK(ecode2)) {
25370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25371 }
25372 arg2 = static_cast< PLINT >(val2);
25373 plszax(arg1,arg2);
25374 _outv = octave_value();
25375 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25376 return _out;
25377 fail:
25378 return octave_value_list();
25379 }
25380 catch(...) {
25381 throw;
25382 }
25383}
25384
25385
25387 octave_value_list _out;
25388 octave_value_list *_outp=&_out;
25389 octave_value _outv;
25390
25391 try {
25392 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25393 SWIG_fail;
25394 }
25395 pltext();
25396 _outv = octave_value();
25397 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25398 return _out;
25399 fail:
25400 return octave_value_list();
25401 }
25402 catch(...) {
25403 throw;
25404 }
25405}
25406
25407
25409 char *arg1 = (char *) 0 ;
25410 int res1 ;
25411 char *buf1 = 0 ;
25412 int alloc1 = 0 ;
25413 octave_value_list _out;
25414 octave_value_list *_outp=&_out;
25415 octave_value _outv;
25416
25417 try {
25418 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25419 SWIG_fail;
25420 }
25421 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25422 if (!SWIG_IsOK(res1)) {
25423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25424 }
25425 arg1 = reinterpret_cast< char * >(buf1);
25426 pltimefmt((char const *)arg1);
25427 _outv = octave_value();
25428 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25429 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25430 return _out;
25431 fail:
25432 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25433 return octave_value_list();
25434 }
25435 catch(...) {
25436 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25437 throw;
25438 }
25439}
25440
25441
25443 PLFLT arg1 ;
25444 double val1 ;
25445 int ecode1 = 0 ;
25446 octave_value_list _out;
25447 octave_value_list *_outp=&_out;
25448 octave_value _outv;
25449
25450 try {
25451 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25452 SWIG_fail;
25453 }
25454 ecode1 = SWIG_AsVal_double(args(0), &val1);
25455 if (!SWIG_IsOK(ecode1)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25457 }
25458 arg1 = static_cast< PLFLT >(val1);
25459 plvasp(arg1);
25460 _outv = octave_value();
25461 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25462 return _out;
25463 fail:
25464 return octave_value_list();
25465 }
25466 catch(...) {
25467 throw;
25468 }
25469}
25470
25471
25473 PLFLT arg1 ;
25474 PLFLT arg2 ;
25475 PLFLT arg3 ;
25476 PLFLT arg4 ;
25477 PLFLT arg5 ;
25478 double val1 ;
25479 int ecode1 = 0 ;
25480 double val2 ;
25481 int ecode2 = 0 ;
25482 double val3 ;
25483 int ecode3 = 0 ;
25484 double val4 ;
25485 int ecode4 = 0 ;
25486 double val5 ;
25487 int ecode5 = 0 ;
25488 octave_value_list _out;
25489 octave_value_list *_outp=&_out;
25490 octave_value _outv;
25491
25492 try {
25493 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25494 SWIG_fail;
25495 }
25496 ecode1 = SWIG_AsVal_double(args(0), &val1);
25497 if (!SWIG_IsOK(ecode1)) {
25498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25499 }
25500 arg1 = static_cast< PLFLT >(val1);
25501 ecode2 = SWIG_AsVal_double(args(1), &val2);
25502 if (!SWIG_IsOK(ecode2)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25504 }
25505 arg2 = static_cast< PLFLT >(val2);
25506 ecode3 = SWIG_AsVal_double(args(2), &val3);
25507 if (!SWIG_IsOK(ecode3)) {
25508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25509 }
25510 arg3 = static_cast< PLFLT >(val3);
25511 ecode4 = SWIG_AsVal_double(args(3), &val4);
25512 if (!SWIG_IsOK(ecode4)) {
25513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25514 }
25515 arg4 = static_cast< PLFLT >(val4);
25516 ecode5 = SWIG_AsVal_double(args(4), &val5);
25517 if (!SWIG_IsOK(ecode5)) {
25518 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25519 }
25520 arg5 = static_cast< PLFLT >(val5);
25521 plvpas(arg1,arg2,arg3,arg4,arg5);
25522 _outv = octave_value();
25523 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25524 return _out;
25525 fail:
25526 return octave_value_list();
25527 }
25528 catch(...) {
25529 throw;
25530 }
25531}
25532
25533
25535 PLFLT arg1 ;
25536 PLFLT arg2 ;
25537 PLFLT arg3 ;
25538 PLFLT arg4 ;
25539 double val1 ;
25540 int ecode1 = 0 ;
25541 double val2 ;
25542 int ecode2 = 0 ;
25543 double val3 ;
25544 int ecode3 = 0 ;
25545 double val4 ;
25546 int ecode4 = 0 ;
25547 octave_value_list _out;
25548 octave_value_list *_outp=&_out;
25549 octave_value _outv;
25550
25551 try {
25552 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25553 SWIG_fail;
25554 }
25555 ecode1 = SWIG_AsVal_double(args(0), &val1);
25556 if (!SWIG_IsOK(ecode1)) {
25557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25558 }
25559 arg1 = static_cast< PLFLT >(val1);
25560 ecode2 = SWIG_AsVal_double(args(1), &val2);
25561 if (!SWIG_IsOK(ecode2)) {
25562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25563 }
25564 arg2 = static_cast< PLFLT >(val2);
25565 ecode3 = SWIG_AsVal_double(args(2), &val3);
25566 if (!SWIG_IsOK(ecode3)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25568 }
25569 arg3 = static_cast< PLFLT >(val3);
25570 ecode4 = SWIG_AsVal_double(args(3), &val4);
25571 if (!SWIG_IsOK(ecode4)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25573 }
25574 arg4 = static_cast< PLFLT >(val4);
25575 plvpor(arg1,arg2,arg3,arg4);
25576 _outv = octave_value();
25577 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25578 return _out;
25579 fail:
25580 return octave_value_list();
25581 }
25582 catch(...) {
25583 throw;
25584 }
25585}
25586
25587
25589 octave_value_list _out;
25590 octave_value_list *_outp=&_out;
25591 octave_value _outv;
25592
25593 try {
25594 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25595 SWIG_fail;
25596 }
25597 plvsta();
25598 _outv = octave_value();
25599 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25600 return _out;
25601 fail:
25602 return octave_value_list();
25603 }
25604 catch(...) {
25605 throw;
25606 }
25607}
25608
25609
25611 PLFLT arg1 ;
25612 PLFLT arg2 ;
25613 PLFLT arg3 ;
25614 PLFLT arg4 ;
25615 PLFLT arg5 ;
25616 PLFLT arg6 ;
25617 PLFLT arg7 ;
25618 PLFLT arg8 ;
25619 PLFLT arg9 ;
25620 PLFLT arg10 ;
25621 PLFLT arg11 ;
25622 double val1 ;
25623 int ecode1 = 0 ;
25624 double val2 ;
25625 int ecode2 = 0 ;
25626 double val3 ;
25627 int ecode3 = 0 ;
25628 double val4 ;
25629 int ecode4 = 0 ;
25630 double val5 ;
25631 int ecode5 = 0 ;
25632 double val6 ;
25633 int ecode6 = 0 ;
25634 double val7 ;
25635 int ecode7 = 0 ;
25636 double val8 ;
25637 int ecode8 = 0 ;
25638 double val9 ;
25639 int ecode9 = 0 ;
25640 double val10 ;
25641 int ecode10 = 0 ;
25642 double val11 ;
25643 int ecode11 = 0 ;
25644 octave_value_list _out;
25645 octave_value_list *_outp=&_out;
25646 octave_value _outv;
25647
25648 try {
25649 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25650 SWIG_fail;
25651 }
25652 ecode1 = SWIG_AsVal_double(args(0), &val1);
25653 if (!SWIG_IsOK(ecode1)) {
25654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25655 }
25656 arg1 = static_cast< PLFLT >(val1);
25657 ecode2 = SWIG_AsVal_double(args(1), &val2);
25658 if (!SWIG_IsOK(ecode2)) {
25659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25660 }
25661 arg2 = static_cast< PLFLT >(val2);
25662 ecode3 = SWIG_AsVal_double(args(2), &val3);
25663 if (!SWIG_IsOK(ecode3)) {
25664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25665 }
25666 arg3 = static_cast< PLFLT >(val3);
25667 ecode4 = SWIG_AsVal_double(args(3), &val4);
25668 if (!SWIG_IsOK(ecode4)) {
25669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25670 }
25671 arg4 = static_cast< PLFLT >(val4);
25672 ecode5 = SWIG_AsVal_double(args(4), &val5);
25673 if (!SWIG_IsOK(ecode5)) {
25674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25675 }
25676 arg5 = static_cast< PLFLT >(val5);
25677 ecode6 = SWIG_AsVal_double(args(5), &val6);
25678 if (!SWIG_IsOK(ecode6)) {
25679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25680 }
25681 arg6 = static_cast< PLFLT >(val6);
25682 ecode7 = SWIG_AsVal_double(args(6), &val7);
25683 if (!SWIG_IsOK(ecode7)) {
25684 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25685 }
25686 arg7 = static_cast< PLFLT >(val7);
25687 ecode8 = SWIG_AsVal_double(args(7), &val8);
25688 if (!SWIG_IsOK(ecode8)) {
25689 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25690 }
25691 arg8 = static_cast< PLFLT >(val8);
25692 ecode9 = SWIG_AsVal_double(args(8), &val9);
25693 if (!SWIG_IsOK(ecode9)) {
25694 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25695 }
25696 arg9 = static_cast< PLFLT >(val9);
25697 ecode10 = SWIG_AsVal_double(args(9), &val10);
25698 if (!SWIG_IsOK(ecode10)) {
25699 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25700 }
25701 arg10 = static_cast< PLFLT >(val10);
25702 ecode11 = SWIG_AsVal_double(args(10), &val11);
25703 if (!SWIG_IsOK(ecode11)) {
25704 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25705 }
25706 arg11 = static_cast< PLFLT >(val11);
25707 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25708 _outv = octave_value();
25709 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25710 return _out;
25711 fail:
25712 return octave_value_list();
25713 }
25714 catch(...) {
25715 throw;
25716 }
25717}
25718
25719
25721 PLFLT arg1 ;
25722 double val1 ;
25723 int ecode1 = 0 ;
25724 octave_value_list _out;
25725 octave_value_list *_outp=&_out;
25726 octave_value _outv;
25727
25728 try {
25729 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25730 SWIG_fail;
25731 }
25732 ecode1 = SWIG_AsVal_double(args(0), &val1);
25733 if (!SWIG_IsOK(ecode1)) {
25734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25735 }
25736 arg1 = static_cast< PLFLT >(val1);
25737 plwidth(arg1);
25738 _outv = octave_value();
25739 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25740 return _out;
25741 fail:
25742 return octave_value_list();
25743 }
25744 catch(...) {
25745 throw;
25746 }
25747}
25748
25749
25751 PLFLT arg1 ;
25752 PLFLT arg2 ;
25753 PLFLT arg3 ;
25754 PLFLT arg4 ;
25755 double val1 ;
25756 int ecode1 = 0 ;
25757 double val2 ;
25758 int ecode2 = 0 ;
25759 double val3 ;
25760 int ecode3 = 0 ;
25761 double val4 ;
25762 int ecode4 = 0 ;
25763 octave_value_list _out;
25764 octave_value_list *_outp=&_out;
25765 octave_value _outv;
25766
25767 try {
25768 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25769 SWIG_fail;
25770 }
25771 ecode1 = SWIG_AsVal_double(args(0), &val1);
25772 if (!SWIG_IsOK(ecode1)) {
25773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25774 }
25775 arg1 = static_cast< PLFLT >(val1);
25776 ecode2 = SWIG_AsVal_double(args(1), &val2);
25777 if (!SWIG_IsOK(ecode2)) {
25778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25779 }
25780 arg2 = static_cast< PLFLT >(val2);
25781 ecode3 = SWIG_AsVal_double(args(2), &val3);
25782 if (!SWIG_IsOK(ecode3)) {
25783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25784 }
25785 arg3 = static_cast< PLFLT >(val3);
25786 ecode4 = SWIG_AsVal_double(args(3), &val4);
25787 if (!SWIG_IsOK(ecode4)) {
25788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25789 }
25790 arg4 = static_cast< PLFLT >(val4);
25791 plwind(arg1,arg2,arg3,arg4);
25792 _outv = octave_value();
25793 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25794 return _out;
25795 fail:
25796 return octave_value_list();
25797 }
25798 catch(...) {
25799 throw;
25800 }
25801}
25802
25803
25805 PLBOOL arg1 ;
25806 PLBOOL *arg2 = (PLBOOL *) 0 ;
25807 int val1 ;
25808 int ecode1 = 0 ;
25809 PLBOOL temp2 ;
25810 int res2 = SWIG_TMPOBJ ;
25811 octave_value_list _out;
25812 octave_value_list *_outp=&_out;
25813 octave_value _outv;
25814
25815 try {
25816 arg2 = &temp2;
25817 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25818 SWIG_fail;
25819 }
25820 ecode1 = SWIG_AsVal_int(args(0), &val1);
25821 if (!SWIG_IsOK(ecode1)) {
25822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25823 }
25824 arg1 = static_cast< PLBOOL >(val1);
25825 plxormod(arg1,arg2);
25826 _outv = octave_value();
25827 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25828 if (SWIG_IsTmpObj(res2)) {
25829 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25830 } else {
25831 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25832 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25833 }
25834 return _out;
25835 fail:
25836 return octave_value_list();
25837 }
25838 catch(...) {
25839 throw;
25840 }
25841}
25842
25843
25845 mapform_func arg1 = (mapform_func) 0 ;
25846 char *arg2 = (char *) 0 ;
25847 PLFLT arg3 ;
25848 PLFLT arg4 ;
25849 PLFLT arg5 ;
25850 PLFLT arg6 ;
25851 int res2 ;
25852 char *buf2 = 0 ;
25853 int alloc2 = 0 ;
25854 double val3 ;
25855 int ecode3 = 0 ;
25856 double val4 ;
25857 int ecode4 = 0 ;
25858 double val5 ;
25859 int ecode5 = 0 ;
25860 double val6 ;
25861 int ecode6 = 0 ;
25862 octave_value_list _out;
25863 octave_value_list *_outp=&_out;
25864 octave_value _outv;
25865
25866 try {
25867 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25868 SWIG_fail;
25869 }
25870 {
25871 octave_value obj = args(0);
25872#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25873 if ( !obj.isempty() )
25874#else
25875 if ( !obj.is_empty() )
25876#endif
25877 {
25878 if ( obj.is_function_handle() || obj.is_inline_function() )
25879 {
25880 fcnMapForm = obj.function_value();
25881 }
25882 else if ( obj.is_string() )
25883 {
25884 nameMapForm = obj.string_value();
25885 fcnMapForm = NULL;
25886 }
25887 arg1 = mapform_octave;
25888 }
25889 else
25890 {
25891 arg1 = NULL;
25892 }
25893 }
25894 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25895 if (!SWIG_IsOK(res2)) {
25896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
25897 }
25898 arg2 = reinterpret_cast< char * >(buf2);
25899 ecode3 = SWIG_AsVal_double(args(2), &val3);
25900 if (!SWIG_IsOK(ecode3)) {
25901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
25902 }
25903 arg3 = static_cast< PLFLT >(val3);
25904 ecode4 = SWIG_AsVal_double(args(3), &val4);
25905 if (!SWIG_IsOK(ecode4)) {
25906 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
25907 }
25908 arg4 = static_cast< PLFLT >(val4);
25909 ecode5 = SWIG_AsVal_double(args(4), &val5);
25910 if (!SWIG_IsOK(ecode5)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
25912 }
25913 arg5 = static_cast< PLFLT >(val5);
25914 ecode6 = SWIG_AsVal_double(args(5), &val6);
25915 if (!SWIG_IsOK(ecode6)) {
25916 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
25917 }
25918 arg6 = static_cast< PLFLT >(val6);
25919 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
25920 _outv = octave_value();
25921 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25922 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25923 return _out;
25924 fail:
25925 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25926 return octave_value_list();
25927 }
25928 catch(...) {
25929 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25930 throw;
25931 }
25932}
25933
25934
25936 mapform_func arg1 = (mapform_func) 0 ;
25937 char *arg2 = (char *) 0 ;
25938 PLFLT arg3 ;
25939 PLFLT arg4 ;
25940 PLFLT arg5 ;
25941 PLFLT arg6 ;
25942 PLINT *arg7 = (PLINT *) 0 ;
25943 PLINT arg8 ;
25944 int res2 ;
25945 char *buf2 = 0 ;
25946 int alloc2 = 0 ;
25947 double val3 ;
25948 int ecode3 = 0 ;
25949 double val4 ;
25950 int ecode4 = 0 ;
25951 double val5 ;
25952 int ecode5 = 0 ;
25953 double val6 ;
25954 int ecode6 = 0 ;
25955 Matrix temp7 ;
25956 octave_value_list _out;
25957 octave_value_list *_outp=&_out;
25958 octave_value _outv;
25959
25960 try {
25961 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
25962 SWIG_fail;
25963 }
25964 {
25965 octave_value obj = args(0);
25966#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25967 if ( !obj.isempty() )
25968#else
25969 if ( !obj.is_empty() )
25970#endif
25971 {
25972 if ( obj.is_function_handle() || obj.is_inline_function() )
25973 {
25974 fcnMapForm = obj.function_value();
25975 }
25976 else if ( obj.is_string() )
25977 {
25978 nameMapForm = obj.string_value();
25979 fcnMapForm = NULL;
25980 }
25981 arg1 = mapform_octave;
25982 }
25983 else
25984 {
25985 arg1 = NULL;
25986 }
25987 }
25988 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25989 if (!SWIG_IsOK(res2)) {
25990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
25991 }
25992 arg2 = reinterpret_cast< char * >(buf2);
25993 ecode3 = SWIG_AsVal_double(args(2), &val3);
25994 if (!SWIG_IsOK(ecode3)) {
25995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
25996 }
25997 arg3 = static_cast< PLFLT >(val3);
25998 ecode4 = SWIG_AsVal_double(args(3), &val4);
25999 if (!SWIG_IsOK(ecode4)) {
26000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26001 }
26002 arg4 = static_cast< PLFLT >(val4);
26003 ecode5 = SWIG_AsVal_double(args(4), &val5);
26004 if (!SWIG_IsOK(ecode5)) {
26005 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26006 }
26007 arg5 = static_cast< PLFLT >(val5);
26008 ecode6 = SWIG_AsVal_double(args(5), &val6);
26009 if (!SWIG_IsOK(ecode6)) {
26010 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26011 }
26012 arg6 = static_cast< PLFLT >(val6);
26013 {
26014 if ( _n_dims( args(6) ) > 1 )
26015 {
26016 error( "argument must be a scalar or vector" ); SWIG_fail;
26017 }
26018#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26019 if ( !args(6).isempty() )
26020#else
26021 if ( !args(6).is_empty() )
26022#endif
26023 {
26024 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26025 temp7 = args(6).matrix_value();
26026 arg7 = new PLINT[arg8];
26027 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26028 }
26029 else
26030 {
26031 arg7 = NULL;
26032 arg8 = 0;
26033 }
26034 }
26035 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26036 _outv = octave_value();
26037 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26038 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26039 {
26040 delete [] arg7;
26041 }
26042 return _out;
26043 fail:
26044 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26045 {
26046 delete [] arg7;
26047 }
26048 return octave_value_list();
26049 }
26050 catch(...) {
26051 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26052 {
26053 delete [] arg7;
26054 }
26055 throw;
26056 }
26057}
26058
26059
26061 mapform_func arg1 = (mapform_func) 0 ;
26062 char *arg2 = (char *) 0 ;
26063 char *arg3 = (char *) 0 ;
26064 PLFLT arg4 ;
26065 PLFLT arg5 ;
26066 PLFLT arg6 ;
26067 PLFLT arg7 ;
26068 PLINT *arg8 = (PLINT *) 0 ;
26069 PLINT arg9 ;
26070 int res2 ;
26071 char *buf2 = 0 ;
26072 int alloc2 = 0 ;
26073 int res3 ;
26074 char *buf3 = 0 ;
26075 int alloc3 = 0 ;
26076 double val4 ;
26077 int ecode4 = 0 ;
26078 double val5 ;
26079 int ecode5 = 0 ;
26080 double val6 ;
26081 int ecode6 = 0 ;
26082 double val7 ;
26083 int ecode7 = 0 ;
26084 Matrix temp8 ;
26085 octave_value_list _out;
26086 octave_value_list *_outp=&_out;
26087 octave_value _outv;
26088
26089 try {
26090 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26091 SWIG_fail;
26092 }
26093 {
26094 octave_value obj = args(0);
26095#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26096 if ( !obj.isempty() )
26097#else
26098 if ( !obj.is_empty() )
26099#endif
26100 {
26101 if ( obj.is_function_handle() || obj.is_inline_function() )
26102 {
26103 fcnMapForm = obj.function_value();
26104 }
26105 else if ( obj.is_string() )
26106 {
26107 nameMapForm = obj.string_value();
26108 fcnMapForm = NULL;
26109 }
26110 arg1 = mapform_octave;
26111 }
26112 else
26113 {
26114 arg1 = NULL;
26115 }
26116 }
26117 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26118 if (!SWIG_IsOK(res2)) {
26119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26120 }
26121 arg2 = reinterpret_cast< char * >(buf2);
26122 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26123 if (!SWIG_IsOK(res3)) {
26124 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26125 }
26126 arg3 = reinterpret_cast< char * >(buf3);
26127 ecode4 = SWIG_AsVal_double(args(3), &val4);
26128 if (!SWIG_IsOK(ecode4)) {
26129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26130 }
26131 arg4 = static_cast< PLFLT >(val4);
26132 ecode5 = SWIG_AsVal_double(args(4), &val5);
26133 if (!SWIG_IsOK(ecode5)) {
26134 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26135 }
26136 arg5 = static_cast< PLFLT >(val5);
26137 ecode6 = SWIG_AsVal_double(args(5), &val6);
26138 if (!SWIG_IsOK(ecode6)) {
26139 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26140 }
26141 arg6 = static_cast< PLFLT >(val6);
26142 ecode7 = SWIG_AsVal_double(args(6), &val7);
26143 if (!SWIG_IsOK(ecode7)) {
26144 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26145 }
26146 arg7 = static_cast< PLFLT >(val7);
26147 {
26148 if ( _n_dims( args(7) ) > 1 )
26149 {
26150 error( "argument must be a scalar or vector" ); SWIG_fail;
26151 }
26152#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26153 if ( !args(7).isempty() )
26154#else
26155 if ( !args(7).is_empty() )
26156#endif
26157 {
26158 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26159 temp8 = args(7).matrix_value();
26160 arg8 = new PLINT[arg9];
26161 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26162 }
26163 else
26164 {
26165 arg8 = NULL;
26166 arg9 = 0;
26167 }
26168 }
26169 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26170 _outv = octave_value();
26171 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26172 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26173 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26174 {
26175 delete [] arg8;
26176 }
26177 return _out;
26178 fail:
26179 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26180 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26181 {
26182 delete [] arg8;
26183 }
26184 return octave_value_list();
26185 }
26186 catch(...) {
26187 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26188 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26189 {
26190 delete [] arg8;
26191 }
26192 throw;
26193 }
26194}
26195
26196
26198 mapform_func arg1 = (mapform_func) 0 ;
26199 char *arg2 = (char *) 0 ;
26200 PLFLT arg3 ;
26201 PLFLT arg4 ;
26202 PLFLT arg5 ;
26203 char *arg6 = (char *) 0 ;
26204 PLFLT arg7 ;
26205 PLFLT arg8 ;
26206 PLFLT arg9 ;
26207 PLFLT arg10 ;
26208 PLINT arg11 ;
26209 int res2 ;
26210 char *buf2 = 0 ;
26211 int alloc2 = 0 ;
26212 double val3 ;
26213 int ecode3 = 0 ;
26214 double val4 ;
26215 int ecode4 = 0 ;
26216 double val5 ;
26217 int ecode5 = 0 ;
26218 int res6 ;
26219 char *buf6 = 0 ;
26220 int alloc6 = 0 ;
26221 double val7 ;
26222 int ecode7 = 0 ;
26223 double val8 ;
26224 int ecode8 = 0 ;
26225 double val9 ;
26226 int ecode9 = 0 ;
26227 double val10 ;
26228 int ecode10 = 0 ;
26229 int val11 ;
26230 int ecode11 = 0 ;
26231 octave_value_list _out;
26232 octave_value_list *_outp=&_out;
26233 octave_value _outv;
26234
26235 try {
26236 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26237 SWIG_fail;
26238 }
26239 {
26240 octave_value obj = args(0);
26241#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26242 if ( !obj.isempty() )
26243#else
26244 if ( !obj.is_empty() )
26245#endif
26246 {
26247 if ( obj.is_function_handle() || obj.is_inline_function() )
26248 {
26249 fcnMapForm = obj.function_value();
26250 }
26251 else if ( obj.is_string() )
26252 {
26253 nameMapForm = obj.string_value();
26254 fcnMapForm = NULL;
26255 }
26256 arg1 = mapform_octave;
26257 }
26258 else
26259 {
26260 arg1 = NULL;
26261 }
26262 }
26263 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26264 if (!SWIG_IsOK(res2)) {
26265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26266 }
26267 arg2 = reinterpret_cast< char * >(buf2);
26268 ecode3 = SWIG_AsVal_double(args(2), &val3);
26269 if (!SWIG_IsOK(ecode3)) {
26270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26271 }
26272 arg3 = static_cast< PLFLT >(val3);
26273 ecode4 = SWIG_AsVal_double(args(3), &val4);
26274 if (!SWIG_IsOK(ecode4)) {
26275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26276 }
26277 arg4 = static_cast< PLFLT >(val4);
26278 ecode5 = SWIG_AsVal_double(args(4), &val5);
26279 if (!SWIG_IsOK(ecode5)) {
26280 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26281 }
26282 arg5 = static_cast< PLFLT >(val5);
26283 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26284 if (!SWIG_IsOK(res6)) {
26285 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26286 }
26287 arg6 = reinterpret_cast< char * >(buf6);
26288 ecode7 = SWIG_AsVal_double(args(6), &val7);
26289 if (!SWIG_IsOK(ecode7)) {
26290 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26291 }
26292 arg7 = static_cast< PLFLT >(val7);
26293 ecode8 = SWIG_AsVal_double(args(7), &val8);
26294 if (!SWIG_IsOK(ecode8)) {
26295 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26296 }
26297 arg8 = static_cast< PLFLT >(val8);
26298 ecode9 = SWIG_AsVal_double(args(8), &val9);
26299 if (!SWIG_IsOK(ecode9)) {
26300 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26301 }
26302 arg9 = static_cast< PLFLT >(val9);
26303 ecode10 = SWIG_AsVal_double(args(9), &val10);
26304 if (!SWIG_IsOK(ecode10)) {
26305 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26306 }
26307 arg10 = static_cast< PLFLT >(val10);
26308 ecode11 = SWIG_AsVal_int(args(10), &val11);
26309 if (!SWIG_IsOK(ecode11)) {
26310 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26311 }
26312 arg11 = static_cast< PLINT >(val11);
26313 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26314 _outv = octave_value();
26315 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26316 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26317 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26318 return _out;
26319 fail:
26320 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26321 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26322 return octave_value_list();
26323 }
26324 catch(...) {
26325 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26326 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26327 throw;
26328 }
26329}
26330
26331
26333 mapform_func arg1 = (mapform_func) 0 ;
26334 char *arg2 = (char *) 0 ;
26335 PLFLT arg3 ;
26336 PLFLT arg4 ;
26337 PLFLT arg5 ;
26338 PLFLT arg6 ;
26339 PLINT *arg7 = (PLINT *) 0 ;
26340 PLINT arg8 ;
26341 int res2 ;
26342 char *buf2 = 0 ;
26343 int alloc2 = 0 ;
26344 double val3 ;
26345 int ecode3 = 0 ;
26346 double val4 ;
26347 int ecode4 = 0 ;
26348 double val5 ;
26349 int ecode5 = 0 ;
26350 double val6 ;
26351 int ecode6 = 0 ;
26352 Matrix temp7 ;
26353 octave_value_list _out;
26354 octave_value_list *_outp=&_out;
26355 octave_value _outv;
26356
26357 try {
26358 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26359 SWIG_fail;
26360 }
26361 {
26362 octave_value obj = args(0);
26363#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26364 if ( !obj.isempty() )
26365#else
26366 if ( !obj.is_empty() )
26367#endif
26368 {
26369 if ( obj.is_function_handle() || obj.is_inline_function() )
26370 {
26371 fcnMapForm = obj.function_value();
26372 }
26373 else if ( obj.is_string() )
26374 {
26375 nameMapForm = obj.string_value();
26376 fcnMapForm = NULL;
26377 }
26378 arg1 = mapform_octave;
26379 }
26380 else
26381 {
26382 arg1 = NULL;
26383 }
26384 }
26385 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26386 if (!SWIG_IsOK(res2)) {
26387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26388 }
26389 arg2 = reinterpret_cast< char * >(buf2);
26390 ecode3 = SWIG_AsVal_double(args(2), &val3);
26391 if (!SWIG_IsOK(ecode3)) {
26392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26393 }
26394 arg3 = static_cast< PLFLT >(val3);
26395 ecode4 = SWIG_AsVal_double(args(3), &val4);
26396 if (!SWIG_IsOK(ecode4)) {
26397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26398 }
26399 arg4 = static_cast< PLFLT >(val4);
26400 ecode5 = SWIG_AsVal_double(args(4), &val5);
26401 if (!SWIG_IsOK(ecode5)) {
26402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26403 }
26404 arg5 = static_cast< PLFLT >(val5);
26405 ecode6 = SWIG_AsVal_double(args(5), &val6);
26406 if (!SWIG_IsOK(ecode6)) {
26407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26408 }
26409 arg6 = static_cast< PLFLT >(val6);
26410 {
26411 if ( _n_dims( args(6) ) > 1 )
26412 {
26413 error( "argument must be a scalar or vector" ); SWIG_fail;
26414 }
26415#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26416 if ( !args(6).isempty() )
26417#else
26418 if ( !args(6).is_empty() )
26419#endif
26420 {
26421 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26422 temp7 = args(6).matrix_value();
26423 arg7 = new PLINT[arg8];
26424 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26425 }
26426 else
26427 {
26428 arg7 = NULL;
26429 arg8 = 0;
26430 }
26431 }
26432 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26433 _outv = octave_value();
26434 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26435 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26436 {
26437 delete [] arg7;
26438 }
26439 return _out;
26440 fail:
26441 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26442 {
26443 delete [] arg7;
26444 }
26445 return octave_value_list();
26446 }
26447 catch(...) {
26448 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26449 {
26450 delete [] arg7;
26451 }
26452 throw;
26453 }
26454}
26455
26456
26458 mapform_func arg1 = (mapform_func) 0 ;
26459 PLFLT arg2 ;
26460 PLFLT arg3 ;
26461 PLFLT arg4 ;
26462 PLFLT arg5 ;
26463 PLFLT arg6 ;
26464 PLFLT arg7 ;
26465 double val2 ;
26466 int ecode2 = 0 ;
26467 double val3 ;
26468 int ecode3 = 0 ;
26469 double val4 ;
26470 int ecode4 = 0 ;
26471 double val5 ;
26472 int ecode5 = 0 ;
26473 double val6 ;
26474 int ecode6 = 0 ;
26475 double val7 ;
26476 int ecode7 = 0 ;
26477 octave_value_list _out;
26478 octave_value_list *_outp=&_out;
26479 octave_value _outv;
26480
26481 try {
26482 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26483 SWIG_fail;
26484 }
26485 {
26486 octave_value obj = args(0);
26487#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26488 if ( !obj.isempty() )
26489#else
26490 if ( !obj.is_empty() )
26491#endif
26492 {
26493 if ( obj.is_function_handle() || obj.is_inline_function() )
26494 {
26495 fcnMapForm = obj.function_value();
26496 }
26497 else if ( obj.is_string() )
26498 {
26499 nameMapForm = obj.string_value();
26500 fcnMapForm = NULL;
26501 }
26502 arg1 = mapform_octave;
26503 }
26504 else
26505 {
26506 arg1 = NULL;
26507 }
26508 }
26509 ecode2 = SWIG_AsVal_double(args(1), &val2);
26510 if (!SWIG_IsOK(ecode2)) {
26511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26512 }
26513 arg2 = static_cast< PLFLT >(val2);
26514 ecode3 = SWIG_AsVal_double(args(2), &val3);
26515 if (!SWIG_IsOK(ecode3)) {
26516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26517 }
26518 arg3 = static_cast< PLFLT >(val3);
26519 ecode4 = SWIG_AsVal_double(args(3), &val4);
26520 if (!SWIG_IsOK(ecode4)) {
26521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26522 }
26523 arg4 = static_cast< PLFLT >(val4);
26524 ecode5 = SWIG_AsVal_double(args(4), &val5);
26525 if (!SWIG_IsOK(ecode5)) {
26526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26527 }
26528 arg5 = static_cast< PLFLT >(val5);
26529 ecode6 = SWIG_AsVal_double(args(5), &val6);
26530 if (!SWIG_IsOK(ecode6)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26532 }
26533 arg6 = static_cast< PLFLT >(val6);
26534 ecode7 = SWIG_AsVal_double(args(6), &val7);
26535 if (!SWIG_IsOK(ecode7)) {
26536 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26537 }
26538 arg7 = static_cast< PLFLT >(val7);
26539 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26540 _outv = octave_value();
26541 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26542 return _out;
26543 fail:
26544 return octave_value_list();
26545 }
26546 catch(...) {
26547 throw;
26548 }
26549}
26550
26551
26553 octave_value_list _out;
26554 octave_value_list *_outp=&_out;
26555 octave_value _outv;
26556
26557 try {
26558 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26559 SWIG_fail;
26560 }
26561 plClearOpts();
26562 _outv = octave_value();
26563 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26564 return _out;
26565 fail:
26566 return octave_value_list();
26567 }
26568 catch(...) {
26569 throw;
26570 }
26571}
26572
26573
26575 octave_value_list _out;
26576 octave_value_list *_outp=&_out;
26577 octave_value _outv;
26578
26579 try {
26580 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26581 SWIG_fail;
26582 }
26583 plResetOpts();
26584 _outv = octave_value();
26585 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26586 return _out;
26587 fail:
26588 return octave_value_list();
26589 }
26590 catch(...) {
26591 throw;
26592 }
26593}
26594
26595
26597 char *arg1 = (char *) 0 ;
26598 char *arg2 = (char *) 0 ;
26599 int res1 ;
26600 char *buf1 = 0 ;
26601 int alloc1 = 0 ;
26602 int res2 ;
26603 char *buf2 = 0 ;
26604 int alloc2 = 0 ;
26605 octave_value_list _out;
26606 octave_value_list *_outp=&_out;
26607 octave_value _outv;
26608
26609 try {
26610 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26611 SWIG_fail;
26612 }
26613 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26616 }
26617 arg1 = reinterpret_cast< char * >(buf1);
26618 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26619 if (!SWIG_IsOK(res2)) {
26620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26621 }
26622 arg2 = reinterpret_cast< char * >(buf2);
26623 plSetUsage((char const *)arg1,(char const *)arg2);
26624 _outv = octave_value();
26625 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26626 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26627 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26628 return _out;
26629 fail:
26630 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26631 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26632 return octave_value_list();
26633 }
26634 catch(...) {
26635 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26636 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26637 throw;
26638 }
26639}
26640
26641
26643 octave_value_list _out;
26644 octave_value_list *_outp=&_out;
26645 octave_value _outv;
26646
26647 try {
26648 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26649 SWIG_fail;
26650 }
26651 plOptUsage();
26652 _outv = octave_value();
26653 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26654 return _out;
26655 fail:
26656 return octave_value_list();
26657 }
26658 catch(...) {
26659 throw;
26660 }
26661}
26662
26663
26664
26665static const struct swig_octave_member swig_globals[] = {
26666{"testppchar",_wrap_testppchar,0,0,2,0},
26667{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26668{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26669{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26670{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26671{"plcont0",_wrap_plcont0,0,0,2,0},
26672{"plcont1",_wrap_plcont1,0,0,2,0},
26673{"plcont2",_wrap_plcont2,0,0,2,0},
26674{"plcont2p",_wrap_plcont2p,0,0,2,0},
26675{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26676{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26677{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26678{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26679{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26680{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26681{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26682{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26683{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26684{"plshade1",_wrap_plshade1,0,0,2,0},
26685{"plshade2",_wrap_plshade2,0,0,2,0},
26686{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26687{"plshadesx",_wrap_plshadesx,0,0,2,0},
26688{"plshades1",_wrap_plshades1,0,0,2,0},
26689{"plshades2",_wrap_plshades2,0,0,2,0},
26690{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26691{"plvect1",_wrap_plvect1,0,0,2,0},
26692{"plvect2",_wrap_plvect2,0,0,2,0},
26693{"pplimage",_wrap_pplimage,0,0,2,0},
26694{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26695{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26696{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26697{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26698{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26699{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26700{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26701{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26702{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26703{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26704{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26705{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26706{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26707{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26708{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26709{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26710{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26711{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26712{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26713{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26714{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26715{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26716{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26717{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26718{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26719{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26720{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26721{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26722{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26723{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26724{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26727{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26728{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26729{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26730{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26731{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26732{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26733{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26734{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26735{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26736{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26737{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26738{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26739{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26740{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26741{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26742{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26743{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26744{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26745{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26746{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26747{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26748{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26749{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26750{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26751{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26752{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26753{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26754{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26755{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26756{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26757{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26758{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26759{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26760{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26761{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26762{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26763{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26764{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26765{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26766{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26767{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26768{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26769{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26770{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26771{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26772{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26773{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26774{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26775{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26776{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26777{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26778{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26779{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26780{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26781{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26782{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26783{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26784{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26785{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26786{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26787{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26788{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26789{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26790{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26791{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26792{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26793{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26794{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26795{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26796{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26797{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26798{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26799{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26800{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26801{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26802{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26803{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26804{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26805{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26806{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26807{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26808{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26809{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26810{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26811{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26812{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26813{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26814{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26815{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26816{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26817{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26818{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26819{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26820{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26821{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26822{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26823{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26824{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26825{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26826{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26827{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26828{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26829{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26830{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26831{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26832{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26833{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26834{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26835{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26836{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26837{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26838{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26839{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26840{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26841{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26842{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26843{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26844{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26845{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26846{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26847{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26848{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26849{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26850{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26851{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26852{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26853{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26854{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26855{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26856{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26857{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26858{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26859{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26860{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26861{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26862{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26863{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26864{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26865{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26866{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26867{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26868{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26869{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26870{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26871{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26872{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
26873{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
26874{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
26875{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
26876{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
26877{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
26878{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
26879{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
26880{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
26881{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
26882{0,0,0,0,0,0}
26883};
26884
26885/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26886
26887static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
26888static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26889static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
26890static 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};
26891static 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};
26892static 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};
26893static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
26894static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26895static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
26896
26907};
26908
26909static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
26910static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26911static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26915static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26916static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26917static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26918
26929};
26930
26931
26932/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26933
26934/* -----------------------------------------------------------------------------
26935 * Type initialization:
26936 * This problem is tough by the requirement that no dynamic
26937 * memory is used. Also, since swig_type_info structures store pointers to
26938 * swig_cast_info structures and swig_cast_info structures store pointers back
26939 * to swig_type_info structures, we need some lookup code at initialization.
26940 * The idea is that swig generates all the structures that are needed.
26941 * The runtime then collects these partially filled structures.
26942 * The SWIG_InitializeModule function takes these initial arrays out of
26943 * swig_module, and does all the lookup, filling in the swig_module.types
26944 * array with the correct data and linking the correct swig_cast_info
26945 * structures together.
26946 *
26947 * The generated swig_type_info structures are assigned statically to an initial
26948 * array. We just loop through that array, and handle each type individually.
26949 * First we lookup if this type has been already loaded, and if so, use the
26950 * loaded structure instead of the generated one. Then we have to fill in the
26951 * cast linked list. The cast data is initially stored in something like a
26952 * two-dimensional array. Each row corresponds to a type (there are the same
26953 * number of rows as there are in the swig_type_initial array). Each entry in
26954 * a column is one of the swig_cast_info structures for that type.
26955 * The cast_initial array is actually an array of arrays, because each row has
26956 * a variable number of columns. So to actually build the cast linked list,
26957 * we find the array of casts associated with the type, and loop through it
26958 * adding the casts to the list. The one last trick we need to do is making
26959 * sure the type pointer in the swig_cast_info struct is correct.
26960 *
26961 * First off, we lookup the cast->type name to see if it is already loaded.
26962 * There are three cases to handle:
26963 * 1) If the cast->type has already been loaded AND the type we are adding
26964 * casting info to has not been loaded (it is in this module), THEN we
26965 * replace the cast->type pointer with the type pointer that has already
26966 * been loaded.
26967 * 2) If BOTH types (the one we are adding casting info to, and the
26968 * cast->type) are loaded, THEN the cast info has already been loaded by
26969 * the previous module so we just ignore it.
26970 * 3) Finally, if cast->type has not already been loaded, then we add that
26971 * swig_cast_info to the linked list (because the cast->type) pointer will
26972 * be correct.
26973 * ----------------------------------------------------------------------------- */
26974
26975#ifdef __cplusplus
26976extern "C" {
26977#if 0
26978} /* c-mode */
26979#endif
26980#endif
26981
26982#if 0
26983#define SWIGRUNTIME_DEBUG
26984#endif
26985
26986
26987SWIGRUNTIME void
26988SWIG_InitializeModule(void *clientdata) {
26989 size_t i;
26990 swig_module_info *module_head, *iter;
26991 int init;
26992
26993 /* check to see if the circular list has been setup, if not, set it up */
26994 if (swig_module.next==0) {
26995 /* Initialize the swig_module */
26999 init = 1;
27000 } else {
27001 init = 0;
27002 }
27003
27004 /* Try and load any already created modules */
27005 module_head = SWIG_GetModule(clientdata);
27006 if (!module_head) {
27007 /* This is the first module loaded for this interpreter */
27008 /* so set the swig module into the interpreter */
27009 SWIG_SetModule(clientdata, &swig_module);
27010 } else {
27011 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27012 iter=module_head;
27013 do {
27014 if (iter==&swig_module) {
27015 /* Our module is already in the list, so there's nothing more to do. */
27016 return;
27017 }
27018 iter=iter->next;
27019 } while (iter!= module_head);
27020
27021 /* otherwise we must add our module into the list */
27022 swig_module.next = module_head->next;
27023 module_head->next = &swig_module;
27024 }
27025
27026 /* When multiple interpreters are used, a module could have already been initialized in
27027 a different interpreter, but not yet have a pointer in this interpreter.
27028 In this case, we do not want to continue adding types... everything should be
27029 set up already */
27030 if (init == 0) return;
27031
27032 /* Now work on filling in swig_module.types */
27033#ifdef SWIGRUNTIME_DEBUG
27034 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27035#endif
27036 for (i = 0; i < swig_module.size; ++i) {
27037 swig_type_info *type = 0;
27038 swig_type_info *ret;
27039 swig_cast_info *cast;
27040
27041#ifdef SWIGRUNTIME_DEBUG
27042 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27043#endif
27044
27045 /* if there is another module already loaded */
27046 if (swig_module.next != &swig_module) {
27048 }
27049 if (type) {
27050 /* Overwrite clientdata field */
27051#ifdef SWIGRUNTIME_DEBUG
27052 printf("SWIG_InitializeModule: found type %s\n", type->name);
27053#endif
27056#ifdef SWIGRUNTIME_DEBUG
27057 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27058#endif
27059 }
27060 } else {
27061 type = swig_module.type_initial[i];
27062 }
27063
27064 /* Insert casting types */
27065 cast = swig_module.cast_initial[i];
27066 while (cast->type) {
27067
27068 /* Don't need to add information already in the list */
27069 ret = 0;
27070#ifdef SWIGRUNTIME_DEBUG
27071 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27072#endif
27073 if (swig_module.next != &swig_module) {
27075#ifdef SWIGRUNTIME_DEBUG
27076 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27077#endif
27078 }
27079 if (ret) {
27080 if (type == swig_module.type_initial[i]) {
27081#ifdef SWIGRUNTIME_DEBUG
27082 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27083#endif
27084 cast->type = ret;
27085 ret = 0;
27086 } else {
27087 /* Check for casting already in the list */
27088 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27089#ifdef SWIGRUNTIME_DEBUG
27090 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27091#endif
27092 if (!ocast) ret = 0;
27093 }
27094 }
27095
27096 if (!ret) {
27097#ifdef SWIGRUNTIME_DEBUG
27098 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27099#endif
27100 if (type->cast) {
27101 type->cast->prev = cast;
27102 cast->next = type->cast;
27103 }
27104 type->cast = cast;
27105 }
27106 cast++;
27107 }
27108 /* Set entry in modules->types array equal to the type */
27109 swig_module.types[i] = type;
27110 }
27111 swig_module.types[i] = 0;
27112
27113#ifdef SWIGRUNTIME_DEBUG
27114 printf("**** SWIG_InitializeModule: Cast List ******\n");
27115 for (i = 0; i < swig_module.size; ++i) {
27116 int j = 0;
27118 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27119 while (cast->type) {
27120 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27121 cast++;
27122 ++j;
27123 }
27124 printf("---- Total casts: %d\n",j);
27125 }
27126 printf("**** SWIG_InitializeModule: Cast List ******\n");
27127#endif
27128}
27129
27130/* This function will propagate the clientdata field of type to
27131* any new swig_type_info structures that have been added into the list
27132* of equivalent types. It is like calling
27133* SWIG_TypeClientData(type, clientdata) a second time.
27134*/
27135SWIGRUNTIME void
27137 size_t i;
27138 swig_cast_info *equiv;
27139 static int init_run = 0;
27140
27141 if (init_run) return;
27142 init_run = 1;
27143
27144 for (i = 0; i < swig_module.size; i++) {
27145 if (swig_module.types[i]->clientdata) {
27146 equiv = swig_module.types[i]->cast;
27147 while (equiv) {
27148 if (!equiv->converter) {
27149 if (equiv->type && !equiv->type->clientdata)
27151 }
27152 equiv = equiv->next;
27153 }
27154 }
27155 }
27156}
27157
27158#ifdef __cplusplus
27159#if 0
27160{ /* c-mode */
27161#endif
27162}
27163#endif
27164
27165
27166
27167static bool SWIG_init_user(octave_swig_type* module_ns);
27168
27170 bool retn = false;
27171 {
27172#if SWIG_OCTAVE_PREREQ(6,0,0)
27173#elif SWIG_OCTAVE_PREREQ(4,2,0)
27174 octave::unwind_protect frame;
27175 frame.protect_var(discard_error_messages); discard_error_messages = true;
27176 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27177#elif SWIG_OCTAVE_PREREQ(3,3,50)
27178 unwind_protect frame;
27179 frame.protect_var(error_state); error_state = 0;
27180 frame.protect_var(warning_state); warning_state = 0;
27181 frame.protect_var(discard_error_messages); discard_error_messages = true;
27182 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27183#else
27184 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27185 unwind_protect_int(error_state); error_state = 0;
27186 unwind_protect_int(warning_state); warning_state = 0;
27187 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27188 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27189#endif
27190#if SWIG_OCTAVE_PREREQ(4,2,0)
27191 try {
27192#if SWIG_OCTAVE_PREREQ(4,4,0)
27193 octave::feval(name, octave_value_list(), 0);
27194#else
27195 feval(name, octave_value_list(), 0);
27196#endif
27197 retn = true;
27198 } catch (octave::execution_exception&) { }
27199#else
27200 feval(name, octave_value_list(), 0);
27201 retn = (error_state == 0);
27202#endif
27203#if !SWIG_OCTAVE_PREREQ(3,3,50)
27204 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27205#endif
27206 }
27207 if (!retn) {
27208 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27209 }
27210 return retn;
27211}
27212
27213SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27214 bool retn = false;
27215 {
27216#if SWIG_OCTAVE_PREREQ(6,0,0)
27217#elif SWIG_OCTAVE_PREREQ(4,2,0)
27218 octave::unwind_protect frame;
27219 frame.protect_var(discard_error_messages); discard_error_messages = true;
27220 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27221#elif SWIG_OCTAVE_PREREQ(3,3,50)
27222 unwind_protect frame;
27223 frame.protect_var(error_state); error_state = 0;
27224 frame.protect_var(warning_state); warning_state = 0;
27225 frame.protect_var(discard_error_messages); discard_error_messages = true;
27226 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27227#else
27228 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27229 unwind_protect_int(error_state); error_state = 0;
27230 unwind_protect_int(warning_state); warning_state = 0;
27231 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27232 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27233#endif
27234 octave_value_list args;
27235 args.append(name);
27236 args.append(octloadfcn->fcn_file_name());
27237#if SWIG_OCTAVE_PREREQ(4,2,0)
27238 try {
27239#if SWIG_OCTAVE_PREREQ(4,4,0)
27240 octave::feval("autoload", args, 0);
27241#else
27242 feval("autoload", args, 0);
27243#endif
27244 retn = true;
27245 } catch (octave::execution_exception&) { }
27246#else
27247 feval("autoload", args, 0);
27248 retn = (error_state == 0);
27249#endif
27250#if !SWIG_OCTAVE_PREREQ(3,3,50)
27251 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27252#endif
27253 }
27254 if (!retn) {
27255 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27256 }
27257 return retn;
27258}
27259
27260static const char *const subclass_usage = "-*- texinfo -*- \n\
27261@deftypefn {Loadable Function} {} subclass()\n\
27262@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27263Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27264\n\
27265See the SWIG manual for usage examples.\n\
27266@end deftypefn";
27267
27268DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27270 for (int j = 0; j < args.length(); ++j) {
27271 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27272 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27273 octave_swig_type *ost = osr->get_ptr();
27274 if (!ost->is_owned()) {
27275 error("subclass: cannot subclass object not constructed on octave side");
27276 return octave_value_list();
27277 }
27278 top->merge(*ost);
27279 } else if (args(j).is_function_handle()) {
27280 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27281 } else if (args(j).is_string()) {
27282 if (j + 1 >= args.length()) {
27283 error("subclass: member assignments must be of string,value form");
27284 return octave_value_list();
27285 }
27286 top->assign(args(j).string_value(), args(j + 1));
27287 ++j;
27288 } else {
27289 error("subclass: invalid arguments to subclass()");
27290 return octave_value_list();
27291 }
27292 }
27293 return octave_value(Swig::swig_value_ref(top));
27294}
27295
27296static const char *const swig_type_usage = "-*- texinfo -*- \n\
27297@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27298Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27299@end deftypefn";
27300
27301DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27302 if (args.length() != 1) {
27303 error("swig_type: must be called with only a single object");
27304 return octave_value_list();
27305 }
27307 if (!ost) {
27308 error("swig_type: object is not a swig_ref");
27309 return octave_value_list();
27310 }
27311 return octave_value(ost->swig_type_name());
27312}
27313
27314static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27315@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27316Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27317otherwise return `<unknown>'.\n\
27318@end deftypefn";
27319
27320DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27321 if (args.length() != 1 || !args(0).is_string()) {
27322 error("swig_typequery: must be called with single string argument");
27323 return octave_value_list();
27324 }
27325 swig_module_info *module = SWIG_GetModule(0);
27326 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27327 if (!type)
27328 return octave_value("<unknown>");
27329 return octave_value(type->name);
27330}
27331
27332static const char *const swig_this_usage = "-*- texinfo -*- \n\
27333@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27334Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27335@end deftypefn";
27336
27337DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27338 if (args.length() != 1) {
27339 error("swig_this: must be called with only a single object");
27340 return octave_value_list();
27341 }
27342 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27343 return octave_value(octave_uint64(0));
27345 if (!ost) {
27346 error("swig_this: object is not a swig_ref");
27347 return octave_value_list();
27348 }
27349 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27350}
27351
27352static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27353@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27354Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27355@end deftypefn";
27356
27357DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27358 if (args.length() != 3) {
27359 error("swig_octave_prereq: must be called with 3 arguments");
27360 return octave_value_list();
27361 }
27362 const int major = args(0).int_value();
27363 const int minor = args(1).int_value();
27364 const int patch = args(2).int_value();
27365 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27366 return octave_value(prereq);
27367}
27368
27369static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27370@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27371Exit Octave without performing any memory cleanup.\n\
27372@end deftypefn";
27373
27374DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27375 if (args.length() > 1) {
27376 error("swig_exit: must be called with at most one arguments");
27377 return octave_value_list();
27378 }
27379 int exit_status = 0;
27380 if (args.length() == 1) {
27381 exit_status = args(0).int_value();
27382 }
27383 ::_Exit(exit_status);
27384 return octave_value();
27385}
27386
27387static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27388@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27389Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27390@end deftypefn";
27391
27393
27394 static octave_swig_type* module_ns = 0;
27395
27396 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27397 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27398 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27399 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27400 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27401 // can be turned off with macro definition.
27402#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27403#if !SWIG_OCTAVE_PREREQ(4,4,0)
27404#if SWIG_OCTAVE_PREREQ(3,2,0)
27405 octave_exit = ::_Exit;
27406#endif
27407#endif
27408#endif
27409
27410 // check for no input and output args
27411 if (args.length() != 0 || nargout != 0) {
27412 print_usage();
27413 return octave_value_list();
27414 }
27415
27416 // create module on first function call
27417 if (!module_ns) {
27418
27419 // workaround bug in octave where installing global variable of custom type and then
27420 // exiting without explicitly clearing the variable causes octave to segfault.
27421#if SWIG_OCTAVE_PREREQ(3,2,0)
27422 octave_value_list eval_args;
27423 eval_args.append("base");
27424 eval_args.append("function __swig_atexit__; "
27425 " if mislocked() "
27426 " clear -all; "
27427 " else "
27428 " mlock(); "
27429 " endif; "
27430 "endfunction; "
27431 "__swig_atexit__; "
27432 "atexit(\"__swig_atexit__\", false); "
27433 "atexit(\"__swig_atexit__\")");
27434#if SWIG_OCTAVE_PREREQ(4,4,0)
27435 octave::feval("evalin", eval_args, 0);
27436#else
27437 feval("evalin", eval_args, 0);
27438#endif
27439#endif
27440
27441#if SWIG_OCTAVE_PREREQ(4,4,0)
27442 {
27443 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27444 string_vector types = typeinfo.installed_type_names();
27445 bool register_octave_swig_ref = true;
27446 bool register_octave_swig_packed = true;
27447 for (int i = 0; i < types.numel(); ++i) {
27448 if (types(i) == octave_swig_ref::static_type_name()) {
27449 register_octave_swig_ref = false;
27450 octave_swig_ref::set_type_id(i);
27451 }
27452 if (types(i) == octave_swig_packed::static_type_name()) {
27453 register_octave_swig_packed = false;
27454 octave_swig_packed::set_type_id(i);
27455 }
27456 }
27457 if (register_octave_swig_ref) {
27458 octave_swig_ref::register_type();
27459 }
27460 if (register_octave_swig_packed) {
27461 octave_swig_packed::register_type();
27462 }
27463 }
27464#else
27465 octave_swig_ref::register_type();
27466 octave_swig_packed::register_type();
27467#endif
27470
27471#if SWIG_OCTAVE_PREREQ(6,0,0)
27472 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27473 octave::call_stack& stack = tree_eval.get_call_stack();
27474 octave_function *me = stack.current_function();
27475#elif SWIG_OCTAVE_PREREQ(4,4,0)
27476 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27477 octave_function *me = stack.current();
27478#else
27479 octave_function *me = octave_call_stack::current();
27480#endif
27481
27482 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27483 return octave_value_list();
27484 }
27485 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27486 return octave_value_list();
27487 }
27488 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27489 return octave_value_list();
27490 }
27491 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27492 return octave_value_list();
27493 }
27494 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27495 return octave_value_list();
27496 }
27497 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27498 return octave_value_list();
27499 }
27500
27501 octave_swig_type* cvar_ns=0;
27502 if (std::string(SWIG_global_name) != ".") {
27503 cvar_ns=new octave_swig_type;
27504 for (int j=0;swig_globals[j].name;++j)
27505 if (swig_globals[j].get_method)
27506 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27507 }
27508
27509 module_ns=new octave_swig_type(0, 0, 0, true);
27510 if (std::string(SWIG_global_name) != ".") {
27511 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27512 }
27513 else {
27514 for (int j=0;swig_globals[j].name;++j)
27515 if (swig_globals[j].get_method)
27516 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27517 }
27518 for (int j=0;swig_globals[j].name;++j)
27519 if (swig_globals[j].method)
27520 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27521
27522 // * need better solution here; swig_type -> octave_class mapping is
27523 // * really n-to-1, in some cases such as template partial spec, etc.
27524 // * see failing tests.
27525 for (int j=0;swig_types[j];++j)
27526 if (swig_types[j]->clientdata) {
27528 module_ns->assign(c->name,
27530 (new octave_swig_type(0,swig_types[j])));
27531 }
27532
27533 if (!SWIG_init_user(module_ns)) {
27534 delete module_ns;
27535 module_ns=0;
27536 return octave_value_list();
27537 }
27538
27539 SWIG_InstallOps(octave_swig_ref::static_type_id());
27540
27542 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27543 if (mb->second.first && mb->second.first->method) {
27544 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27545 return octave_value_list();
27546 }
27547 }
27548 }
27549
27550#if SWIG_OCTAVE_PREREQ(4,4,0)
27551 octave::interpreter::the_interpreter()->mlock();
27552#elif SWIG_OCTAVE_PREREQ(3,2,0)
27553 mlock();
27554#else
27555 mlock(me->name());
27556#endif
27557
27558 }
27559
27561 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27562 if (mb->second.second.is_defined()) {
27563 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27564 SWIG_Octave_LinkGlobalValue(mb->first);
27565 }
27566 }
27567
27570
27571 return octave_value_list();
27572
27573}
27574
27575
27576static bool SWIG_init_user(octave_swig_type* module_ns)
27577{
27578 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27579 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27580 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27581 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27582 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27583 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27584 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27585 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27586 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27587 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27588 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27589 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27590 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27591 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27592 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27593 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27594 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27595 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27596 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27597 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27598 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27599 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27600 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27601 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27602 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27603 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27604 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27605 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27606 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27607 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27608 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27609 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27610 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27611 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27612 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27613 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27614 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27615 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27616 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27617 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27618 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27619 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27620 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27621 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27622 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27623 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27624 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27625 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27626 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27627 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27628 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27629 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27630 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27631 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27632 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27633 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27634 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27635 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27636 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27637 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27638 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27639 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27640 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27641 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27642 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27643 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27644 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27645 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27646 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27647 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27648 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27649 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27650 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27651 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27652 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27653 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27654 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27655 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27656 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27657 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27658 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27659 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27660 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27661 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27662 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27663 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27664 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27665 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27666 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27667 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27668 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27669 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27670 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27671 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27672 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27673 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27674 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27675 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27676 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27677 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27678 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27679 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27680 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27681 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27682 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27683 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27684 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27685 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27686 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27687 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27688 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27689 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27690 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27691 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27692 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27693 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27694 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27695 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27696 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27697 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27698 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27699 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27700 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27701 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27702 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27703 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27704 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27705 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27706 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27707 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27708 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27709 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27710 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27711 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27712 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27713 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27714 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27715 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27716 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27717 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27718 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27719 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27720 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27721 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27722 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27723 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27724 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27725 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27726 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27727 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27728 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27729 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27730 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27731 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27732 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27733 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27734 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27735 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27736 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27737 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27738 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27739 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27740 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27741 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27742 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27743 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27744 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27745 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27746 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27747 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27748 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27749 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27750 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27751 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27752 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27753 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27754 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27755 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27756 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27757 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27758 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27759 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27760 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27761 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27762 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27763 return true;
27764}
27765
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_base_value * empty_clone() const
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
octave_base_value * clone() const
virtual bool save_ascii(std::ostream &os)
virtual string_vector map_keys() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual double scalar_value(bool frc_str_conv=false) const
virtual bool is_object() const
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual bool save_ascii(std::ostream &os)
octave_swig_type * get_ptr() const
dim_vector dims(void) const
octave_base_value * clone() const
virtual Octave_map map_value() const
virtual bool is_map() const
virtual bool is_string() const
virtual std::string string_value(bool force=false) const
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
octave_base_value * empty_clone() const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
octave_swig_ref(octave_swig_type *_ptr=0)
virtual bool load_ascii(std::istream &is)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void load_members(member_map &out) const
virtual Octave_map map_value() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
octave_base_value * empty_clone() const
dim_vector dims(void) const
octave_base_value * clone() const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
virtual bool is_object() const
const char * help_text() const
void assign(const std::string &name, const swig_octave_member *m)
octave_swig_type & operator=(const octave_swig_type &rhs)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
void assign(const std::string &name, const octave_value &ov)
virtual bool is_string() const
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
std::vector< type_ptr_pair > types
virtual double scalar_value(bool frc_str_conv=false) const
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
void merge(octave_swig_type &rhs)
member_map::const_iterator swig_member_const_iterator
void print(std::ostream &os, bool pr_as_read_syntax=false) const
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
const swig_type_info * construct_type
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
void plOptUsage(void)
Definition: plargs.c:1304
void plClearOpts(void)
Definition: plargs.c:830
void plResetOpts(void)
Definition: plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
static int error
Definition: plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plcont.c:508
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plimage.c:238
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
Definition: pllegend.c:1525
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:326
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:150
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:921
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:389
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:860
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:883
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
#define plgfci
Definition: plplot.h:735
#define plgstrm
Definition: plplot.h:744
#define plpat
Definition: plplot.h:779
#define plschr
Definition: plplot.h:790
#define plfontld
Definition: plplot.h:721
#define plpath
Definition: plplot.h:761
#define plerry
Definition: plplot.h:715
#define plsfam
Definition: plplot.h:816
#define plsmaj
Definition: plplot.h:826
#define plsmin
Definition: plplot.h:829
#define pleop
Definition: plplot.h:713
#define plimage
Definition: plplot.h:753
#define plstransform
Definition: plplot.h:840
#define plfill
Definition: plplot.h:717
#define plvpas
Definition: plplot.h:859
#define plgdiplt
Definition: plplot.h:732
#define plerrx
Definition: plplot.h:714
#define plinit
Definition: plplot.h:755
#define plscmap1l
Definition: plplot.h:796
#define plsori
Definition: plplot.h:830
#define plbox3
Definition: plplot.h:698
#define plcol1
Definition: plplot.h:703
#define pltimefmt
Definition: plplot.h:856
PLUINT PLUNICODE
Definition: plplot.h:201
#define plvect
Definition: plplot.h:858
#define plgchr
Definition: plplot.h:722
float PLFLT
Definition: plplot.h:163
#define pllegend
Definition: plplot.h:758
#define plsyax
Definition: plplot.h:852
#define plgver
Definition: plplot.h:745
#define plscolbg
Definition: plplot.h:802
#define plpsty
Definition: plplot.h:784
#define plgfont
Definition: plplot.h:737
#define plenv
Definition: plplot.h:711
#define pllightsource
Definition: plplot.h:759
#define plpoin3
Definition: plplot.h:781
#define plgspa
Definition: plplot.h:743
#define plscol0
Definition: plplot.h:800
#define plptex
Definition: plplot.h:785
#define plrgbhls
Definition: plplot.h:789
#define plbop
Definition: plplot.h:696
#define plgdidev
Definition: plplot.h:730
#define plpoin
Definition: plplot.h:780
#define plptex3
Definition: plplot.h:786
#define plstripd
Definition: plplot.h:845
#define plhist
Definition: plplot.h:751
#define plgfnam
Definition: plplot.h:736
#define plgdiori
Definition: plplot.h:731
#define PL_MAXKEY
Definition: plplot.h:408
#define plszax
Definition: plplot.h:854
#define plstripa
Definition: plplot.h:843
#define plgxax
Definition: plplot.h:748
#define plgra
Definition: plplot.h:740
#define plenv0
Definition: plplot.h:712
#define plspal1
Definition: plplot.h:833
#define plstring3
Definition: plplot.h:842
#define plxormod
Definition: plplot.h:865
#define plspause
Definition: plplot.h:834
#define plgdev
Definition: plplot.h:729
#define plgradient
Definition: plplot.h:741
#define plspal0
Definition: plplot.h:832
#define plcalc_world
Definition: plplot.h:700
#define plwidth
Definition: plplot.h:863
#define pllab
Definition: plplot.h:757
#define plsurf3d
Definition: plplot.h:847
#define plsurf3dl
Definition: plplot.h:848
#define plvasp
Definition: plplot.h:857
#define plscmap0n
Definition: plplot.h:793
#define plmtex3
Definition: plplot.h:774
#define plctime
Definition: plplot.h:708
#define plclear
Definition: plplot.h:701
#define plsvpa
Definition: plplot.h:850
#define plw3d
Definition: plplot.h:862
#define plot3dcl
Definition: plplot.h:777
#define plscmap1n
Definition: plplot.h:798
#define plgvpd
Definition: plplot.h:746
#define plhlsrgb
Definition: plplot.h:752
#define pl_setcontlabelformat
Definition: plplot.h:690
#define plsdev
Definition: plplot.h:806
#define plconfigtime
Definition: plplot.h:705
#define plscolbga
Definition: plplot.h:803
#define plscmap1
Definition: plplot.h:794
#define plsdiplz
Definition: plplot.h:811
#define plparseopts
Definition: plplot.h:778
#define plot3d
Definition: plplot.h:775
#define plsesc
Definition: plplot.h:814
#define plarc
Definition: plplot.h:693
#define plsetopt
Definition: plplot.h:815
#define plgvpw
Definition: plplot.h:747
#define pltext
Definition: plplot.h:855
#define plstring
Definition: plplot.h:841
#define plsdiori
Definition: plplot.h:809
#define plcont
Definition: plplot.h:706
#define plspage
Definition: plplot.h:831
#define plaxes
Definition: plplot.h:694
#define pllsty
Definition: plplot.h:763
#define plslabelfunc
Definition: plplot.h:825
#define plshades
Definition: plplot.h:824
#define plglevel
Definition: plplot.h:738
#define plscompression
Definition: plplot.h:805
#define plfamadv
Definition: plplot.h:716
#define plfont
Definition: plplot.h:720
#define plscmap0a
Definition: plplot.h:792
#define plgcol0a
Definition: plplot.h:725
#define plscmap1_range
Definition: plplot.h:799
#define plmeshc
Definition: plplot.h:771
#define plshade
Definition: plplot.h:820
#define plsym
Definition: plplot.h:853
#define plscmap1a
Definition: plplot.h:795
#define plscmap0
Definition: plplot.h:791
#define plgriddata
Definition: plplot.h:742
#define plstripc
Definition: plplot.h:844
#define pl_setcontlabelparam
Definition: plplot.h:691
#define plsvect
Definition: plplot.h:849
#define plstyl
Definition: plplot.h:846
#define plline
Definition: plplot.h:760
#define pljoin
Definition: plplot.h:756
#define plgzax
Definition: plplot.h:750
#define plsstrm
Definition: plplot.h:835
#define plscmap1la
Definition: plplot.h:797
#define plssym
Definition: plplot.h:837
#define plscolor
Definition: plplot.h:804
#define plcol0
Definition: plplot.h:702
#define plsdiplt
Definition: plplot.h:810
#define plcolorbar
Definition: plplot.h:704
#define plvsta
Definition: plplot.h:861
#define plot3dc
Definition: plplot.h:776
#define plcpstrm
Definition: plplot.h:707
#define plmkstrm
Definition: plplot.h:772
#define plgcol0
Definition: plplot.h:724
#define pladv
Definition: plplot.h:692
#define plgcolbga
Definition: plplot.h:727
#define plline3
Definition: plplot.h:762
#define plprec
Definition: plplot.h:783
#define plfill3
Definition: plplot.h:718
#define plseed
Definition: plplot.h:813
#define plgcompression
Definition: plplot.h:728
#define plimagefr
Definition: plplot.h:754
#define plsfont
Definition: plplot.h:819
int PLINT
Definition: plplot.h:181
#define plgfam
Definition: plplot.h:734
#define plscol0a
Definition: plplot.h:801
#define plend1
Definition: plplot.h:710
#define plrandd
Definition: plplot.h:787
#define plbin
Definition: plplot.h:695
#define plsdidev
Definition: plplot.h:807
#define plsfnam
Definition: plplot.h:818
void * PLPointer
Definition: plplot.h:209
#define plflush
Definition: plplot.h:719
#define plwind
Definition: plplot.h:864
#define plstar
Definition: plplot.h:838
#define plmtex
Definition: plplot.h:773
PLINT PLBOOL
Definition: plplot.h:204
#define plsdimap
Definition: plplot.h:808
#define plsfci
Definition: plplot.h:817
#define plend
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:770
#define plreplot
Definition: plplot.h:788
#define plgcolbg
Definition: plplot.h:726
#define plgcmap1_range
Definition: plplot.h:723
#define plstart
Definition: plplot.h:839
#define plsxax
Definition: plplot.h:851
#define plbox
Definition: plplot.h:697
#define plbtime
Definition: plplot.h:699
#define plgyax
Definition: plplot.h:749
#define plvpor
Definition: plplot.h:860
#define plpoly3
Definition: plplot.h:782
#define plgpage
Definition: plplot.h:739
#define plssub
Definition: plplot.h:836
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
static const char * _wrap_plszax_texinfo
static const char * _wrap_plstring3_texinfo
static const char * _wrap_plvsta_texinfo
static const char * _wrap_plscmap1_texinfo
static const char * _wrap_plbox3_texinfo
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
static swig_cast_info * swig_cast_initial[]
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plvpas_texinfo
static const char accounting for coordinate transforms n n n y1 to(\n\ x2,\n\ y2) . If a global coordinate transform is defined then the line is\n\ broken in to n segments to approximate the path. If no transform is\n\ defined then this simply acts like a call to pljoin.\n\ \n\ Redacted form reads the desired grid location from the input vectors n xg[nptsx] and yg[nptsy]
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plmkstrm_texinfo
#define SWIG_global_name
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static swig_type_info * swig_types[10]
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plend_texinfo
static const swig_type_info * swig_PLGraphicsIn_base[]
static const char * _wrap_plsvpa_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
octave_function * fcnCoordTrans
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
#define SWIG_TypeQuery(name)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
#define SWIG_POINTER_OWN
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
#define SWIG_SyntaxError
static const char * _wrap_plflush_texinfo
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
static const char * _wrap_plsfnam_texinfo
#define SWIG_CheckState(r)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plot3dc_texinfo
static const char * _wrap_plptex_texinfo
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
static const char * _wrap_plbin_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
static const char * _wrap_plsmaj_texinfo
#define SWIG_TypeError
static const char * _wrap_plsstrm_texinfo
static PLINT Alen
static swig_cast_info _swigc__p_double[]
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define SWIGTYPE_p_PLGraphicsIn
static const char * _wrap_plgcompression_texinfo
static const char * _wrap_plscolor_texinfo
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
struct swig_cast_info swig_cast_info
static const char * _wrap_plfill_texinfo
static const struct swig_octave_member swig_globals[]
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_pllightsource_texinfo
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plscmap0_texinfo
static const char *const swig_typequery_usage
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
std::string nameCoordTrans
static const char * _wrap_plgcol0a_texinfo
static const char * _wrap_plSetOpt_texinfo
#define SWIG_RuntimeError
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
static const char * _wrap_plend1_texinfo
static const char * _wrap_plgcolbga_texinfo
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plprec_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
static const char *const SWIG_name_usage
static const char * _wrap_plgpage_texinfo
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plschr_texinfo
static int _arraylen(const octave_value &o_obj)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
#define SWIGRUNTIME
static const char * _wrap_plsurf3d_texinfo
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_plgfnam_texinfo
static const char * _wrap_plenv0_texinfo
#define swigreg_binary_op(name)
#define SWIG_as_voidptrptr(a)
static const char * _wrap_plsym_texinfo
static const char * _wrap_plmapstring_texinfo
#define SWIG_RUNTIME_VERSION
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static const char * _wrap_plslabelfunc_texinfo
#define SWIG_ValueError
static const char * _wrap_plsfci_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
static const char * _wrap_plgchr_texinfo
#define SWIG_AddCast(r)
static const char * _wrap_plstripd_texinfo
static const char * _wrap_plsori_texinfo
static const char * _wrap_plsdiplt_texinfo
#define SWIG_name_d
#define SWIG_IsNewObj(r)
static const char * _wrap_plsfam_texinfo
static const char * _wrap_plgver_texinfo
static const char * _wrap_plstransform_texinfo
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
std::string nameMapForm
#define SWIG_exception_fail(code, msg)
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
static const char * _wrap_plgdiori_texinfo
static const char * _wrap_plbtime_texinfo
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
static swig_module_info swig_module
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static int _n_dims(const octave_value &o_obj)
static const char * _wrap_plot3d_texinfo
static const char * _wrap_plmtex_texinfo
static const char * _wrap_plmap_texinfo
#define swigreg_unary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static const char * swig_PLGraphicsIn_base_names[]
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
static PLINT Ylen
static swig_type_info _swigt__p_double
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plaxes_texinfo
static const char * _wrap_plscmap0n_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
static const char * _wrap_plsesc_texinfo
#define SWIG_SetModule(clientdata, pointer)
plgriddata(x, y, z, xg, yg, type, data)\n\ \n\ \n\ This function is used in example 21.\n\ \n\ \n\ \n\ SYNOPSIS:\n\ \n\ plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ \n\ ARGUMENTS:\n\ \n\ x(PLFLT_VECTOR, input) :The input x vector.\n\ \n\ y(PLFLT_VECTOR, input) :The input y vector.\n\ \n\ z(PLFLT_VECTOR, input) :The input z vector. Each triple x[i],\n\ y[i], z[i] represents one data sample coordinate.\n\ \n\ npts(PLINT, input) :The number of data samples in the x, y and z\n\ vectors.\n\ \n\ xg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the x direction. Usually xg has nptsx equally spaced values\n\ from the minimum to the maximum values of the x input vector.\n\ \n\ nptsx(PLINT, input) :The number of points in the xg vector.\n\ \n\ yg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the y direction. Similar to the xg parameter.\n\ \n\ nptsy(PLINT, input) :The number of points in the yg vector.\n\ \n\ zg(PLFLT_NC_MATRIX, output) :The matrix of interpolated results\n\ where data lies in the grid specified by xg and yg. Therefore the\n\ zg matrix must be dimensioned\n\ nptsx by\n\ nptsy.\n\ \n\ type(PLINT, input) :The type of grid interpolation algorithm to\n\ use, which can be:GRID_CSA:Bivariate Cubic Spline approximation\n\ GRID_DTLI:Delaunay Triangulation Linear Interpolation\n\ GRID_NNI:Natural Neighbors Interpolation\n\ GRID_NNIDW:Nearest Neighbors Inverse Distance Weighted\n\ GRID_NNLI:Nearest Neighbors Linear Interpolation\n\ GRID_NNAIDW:Nearest Neighbors Around Inverse Distance\n\ Weighted\n\ For details of the algorithms read the source file plgridd.c.\n\ \n\ data(PLFLT, input) :Some gridding algorithms require extra data,\n\ which can be specified through this argument. Currently, for\n\ algorithm:GRID_NNIDW, data specifies the number of neighbors to\n\ use, the lower the value, the noisier(more local) the\n\ approximation is.\n\ GRID_NNLI, data specifies what a thin triangle is, in the\n\ range[1. .. 2.]. High values enable the usage of very thin\n\ triangles for interpolation, possibly resulting in error in\n\ the approximation.\n\ GRID_NNI, only weights greater than data will be accepted. If\n\ 0, all weights will be accepted.\n\ " zg
static const char * _wrap_plgvpw_texinfo
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plsdiplz_texinfo
static swig_type_info _swigt__p_p_char
static const char * _wrap_pllsty_texinfo
static const char *const subclass_usage
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static const char * _wrap_plgstrm_texinfo
static const char * _wrap_plconfigtime_texinfo
static const char * _wrap_plssub_texinfo
#define SWIG_ConvertPtr(obj, pptr, type, flags)
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
static const char * _wrap_plline_texinfo
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static const char *const swig_type_usage
static const char * _wrap_plshade_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
static const char *const swig_exit_usage
static const char * _wrap_plsdev_texinfo
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
void *(* swig_converter_func)(void *, int *)
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plcpstrm_texinfo
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plvect_texinfo
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
static swig_cast_info _swigc__p_char[]
static const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
PLINT(* defined_func)(PLFLT, PLFLT)
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plscmap1a_texinfo
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
#define SWIGINTERN
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
static int _dim(const octave_value &o_obj, int dim_idx)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
#define SWIG_op_prefix
static const char * _wrap_plgcol0_texinfo
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static const char * _wrap_plstar_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
#define SWIG_ArgError(r)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
static const char * _wrap_plsmin_texinfo
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plglevel_texinfo
static const char * _wrap_plvpor_texinfo
#define SWIG_POINTER_NO_NULL
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
octave_function * fcnLabelFunc
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
static const char * _wrap_plgfci_texinfo
#define SWIG_IOError
static const char * _wrap_plsfont_texinfo
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_pllegend_texinfo
#define SWIG_NullReferenceError
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
#define SWIG_IsTmpObj(r)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)
static const char *const swig_octave_prereq_usage
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscmap1l_texinfo
#define SWIG_NEWOBJ
static swig_octave_class _wrap_class_PLGraphicsIn
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
#define SWIG_TMPOBJ
octave_function * fcnMapForm
#define SWIG_DelNewMask(r)
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
#define SWIG_GetModule(clientdata)
static const char * _wrap_pllab_texinfo
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
static const char * _wrap_plspage_texinfo
static int my_plGetCursor(int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin)
SWIGRUNTIME void SWIG_PropagateClientData(void)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plpoin_texinfo
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
int min(int a, int b)
static const char * _wrap_plspause_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
static const char * _wrap_plclear_texinfo
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
struct swig_module_info swig_module_info
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plimagefr_texinfo
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define SWIG_ERROR
#define SWIG_name
static const char * _wrap_pljoin_texinfo
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plfont_texinfo
static const char * _wrap_plstripa_texinfo
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plot3dcl_texinfo
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plgcolbg_texinfo
static swig_type_info * swig_type_initial[]
static const char * _wrap_plgspa_texinfo
static const char * _wrap_plpat_texinfo
static const char * _wrap_plline3_texinfo
#define swig_binary_op(name)
static const char * _wrap_plmaptex_texinfo
static swig_cast_info _swigc__p_PLGraphicsIn[]
void my_plshade1(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plstring_texinfo
static const char * _wrap_plgdidev_texinfo
static const char *const swig_this_usage
static swig_cast_info _swigc__p_p_char[]
static const char * _wrap_plpoly3_texinfo
void my_plcont2(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
#define SWIG_MemoryError
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plvasp_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
SWIGRUNTIME void SWIG_InstallOps(int tid)
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
static const char * _wrap_plw3d_texinfo
#define SWIG_SystemError
#define SWIG_DivisionByZero
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static swig_type_info _swigt__p_char
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
static const char * _wrap_plssym_texinfo
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
#define SWIG_OverflowError
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
#define SWIG_IsOK(r)
static const char * _wrap_plspal1_texinfo
static const char * _wrap_plscmap0a_texinfo
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
static const char * _wrap_plcont_texinfo
static const char * _wrap_plctime_texinfo
static const char * _wrap_plscolbg_texinfo
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plcol1_texinfo
void my_plshadesx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, PLFLT *tr)
int max(int a, int b)
#define SWIG_IndexError
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
static bool SWIG_init_user(octave_swig_type *module_ns)
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_texinfo
#define SWIG_OK
static const char * _wrap_plcolorbar_texinfo
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
#define SWIGINTERNINLINE
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
#define SWIGRUNTIMEINLINE
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plshades(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:216
void c_plshade(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:352
void c_plstripc(PLINT *id, PLCHAR_VECTOR xspec, PLCHAR_VECTOR yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, PLINT_VECTOR colline, PLINT_VECTOR styline, PLCHAR_MATRIX legline, PLCHAR_VECTOR labx, PLCHAR_VECTOR laby, PLCHAR_VECTOR labtop)
Definition: plstripc.c:66
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plvect.c:261
static int text
Definition: ps.c:77
char string[PL_MAXKEY]
Definition: plplot.h:440
PLFLT wX
Definition: plplot.h:443
PLFLT wY
Definition: plplot.h:443
PLINT subwindow
Definition: plplot.h:439
PLFLT dY
Definition: plplot.h:442
unsigned int state
Definition: plplot.h:436
unsigned int keysym
Definition: plplot.h:437
PLFLT dX
Definition: plplot.h:442
unsigned int button
Definition: plplot.h:438
PLINT nx
Definition: plplot.h:521
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
PLINT ny
Definition: plplot.h:521
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
PLINT nx
Definition: plplot.h:509
PLINT ny
Definition: plplot.h:509
octave_value operator*() const
const octave_value_list & ovl
octave_value_ref(const octave_value_list &_ovl, int _j)
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
const swig_octave_member * members
const swig_type_info ** base
swig_dycast_func dcast
struct swig_cast_info * cast
static char buf[200]
Definition: tclAPI.c:873
static Tcl_Interp * interp
Definition: tkMain.c:120
static const char * name
Definition: tkMain.c:135