PLplot 5.15.0
Loading...
Searching...
No Matches
plplot_octaveOCTAVE_wrap.cxx
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.3.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040301
11#define SWIGOCTAVE
12#define SWIG_name_d "plplot_octave"
13#define SWIG_name plplot_octave
14
15#define SWIG_global_name "cvar"
16#define SWIG_op_prefix "op_"
17
18/* -----------------------------------------------------------------------------
19 * This section contains generic SWIG labels for method/variable
20 * declarations/attributes, and other compiler dependent labels.
21 * ----------------------------------------------------------------------------- */
22
23/* template workaround for compilers that cannot correctly implement the C++ standard */
24#ifndef SWIGTEMPLATEDISAMBIGUATOR
25# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# elif defined(__HP_aCC)
28/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30# define SWIGTEMPLATEDISAMBIGUATOR template
31# else
32# define SWIGTEMPLATEDISAMBIGUATOR
33# endif
34#endif
35
36/* inline attribute */
37#ifndef SWIGINLINE
38# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39# define SWIGINLINE inline
40# else
41# define SWIGINLINE
42# endif
43#endif
44
45/* attribute recognised by some compilers to avoid 'unused' warnings */
46#ifndef SWIGUNUSED
47# if defined(__GNUC__)
48# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49# define SWIGUNUSED __attribute__ ((__unused__))
50# else
51# define SWIGUNUSED
52# endif
53# elif defined(__ICC)
54# define SWIGUNUSED __attribute__ ((__unused__))
55# else
56# define SWIGUNUSED
57# endif
58#endif
59
60#ifndef SWIG_MSC_UNSUPPRESS_4505
61# if defined(_MSC_VER)
62# pragma warning(disable : 4505) /* unreferenced local function has been removed */
63# endif
64#endif
65
66#ifndef SWIGUNUSEDPARM
67# ifdef __cplusplus
68# define SWIGUNUSEDPARM(p)
69# else
70# define SWIGUNUSEDPARM(p) p SWIGUNUSED
71# endif
72#endif
73
74/* internal SWIG method */
75#ifndef SWIGINTERN
76# define SWIGINTERN static SWIGUNUSED
77#endif
78
79/* internal inline SWIG method */
80#ifndef SWIGINTERNINLINE
81# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82#endif
83
84/* exporting methods */
85#if defined(__GNUC__)
86# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87# ifndef GCC_HASCLASSVISIBILITY
88# define GCC_HASCLASSVISIBILITY
89# endif
90# endif
91#endif
92
93#ifndef SWIGEXPORT
94# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95# if defined(STATIC_LINKED)
96# define SWIGEXPORT
97# else
98# define SWIGEXPORT __declspec(dllexport)
99# endif
100# else
101# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102# define SWIGEXPORT __attribute__ ((visibility("default")))
103# else
104# define SWIGEXPORT
105# endif
106# endif
107#endif
108
109/* calling conventions for Windows */
110#ifndef SWIGSTDCALL
111# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112# define SWIGSTDCALL __stdcall
113# else
114# define SWIGSTDCALL
115# endif
116#endif
117
118/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120# define _CRT_SECURE_NO_DEPRECATE
121#endif
122
123/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125# define _SCL_SECURE_NO_DEPRECATE
126#endif
127
128/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131#endif
132
133/* Intel's compiler complains if a variable which was never initialised is
134 * cast to void, which is a common idiom which we use to indicate that we
135 * are aware a variable isn't used. So we just silence that warning.
136 * See: https://github.com/swig/swig/issues/192 for more discussion.
137 */
138#ifdef __INTEL_COMPILER
139# pragma warning disable 592
140#endif
141
142#if defined(__cplusplus) && __cplusplus >=201103L
143# define SWIG_NULLPTR nullptr
144#else
145# define SWIG_NULLPTR NULL
146#endif
147
148/* -----------------------------------------------------------------------------
149 * swigcompat.swg
150 *
151 * Macros to provide support compatibility with older C and C++ standards.
152 *
153 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
154 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
155 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
156 * ----------------------------------------------------------------------------- */
157
158/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
159 * if you're missing it.
160 */
161#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
162 (defined __cplusplus && __cplusplus >= 201103L) || \
163 defined SWIG_HAVE_SNPRINTF) && \
164 !defined SWIG_NO_SNPRINTF
165# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
166# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
167#else
168/* Fallback versions ignore the buffer size, but most of our uses either have a
169 * fixed maximum possible size or dynamically allocate a buffer that's large
170 * enough.
171 */
172# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
173# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
174#endif
175
176//
177// This header includes all C++ headers required for generated Octave wrapper code.
178// Using a single header file allows pre-compilation of Octave headers, as follows:
179// * Check out this header file:
180// swig -octave -co octheaders.hpp
181// * Pre-compile header file into octheaders.hpp.gch:
182// g++ -c ... octheaders.hpp
183// * Use pre-compiled header file:
184// g++ -c -include octheaders.hpp ...
185//
186
187#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
188#define SWIG_OCTAVE_OCTHEADERS_HPP
189
190// Required C headers
191#include <assert.h>
192
193// Required C++ headers
194#include <cstdlib>
195#include <climits>
196#include <iostream>
197#include <exception>
198#include <functional>
199#include <complex>
200#include <string>
201#include <vector>
202#include <map>
203
204// Minimal headers to define Octave version
205#include <octave/oct.h>
206#include <octave/version.h>
207
208// Macro for enabling features which require Octave version >= major.minor.patch
209// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
210#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
211 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
212
213// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
214#if !defined(OCTAVE_MAJOR_VERSION)
215
216# if !defined(OCTAVE_API_VERSION_NUMBER)
217
218// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
219// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
220# include <octave/ov.h>
221# if defined(octave_ov_h)
222# define OCTAVE_MAJOR_VERSION 3
223# define OCTAVE_MINOR_VERSION 8
224# define OCTAVE_PATCH_VERSION 0
225# else
226
227// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
228# define ComplexLU __ignore
229# include <octave/CmplxLU.h>
230# undef ComplexLU
231# if defined(octave_Complex_LU_h)
232
233// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
234# define OCTAVE_MAJOR_VERSION 3
235# define OCTAVE_MINOR_VERSION 1
236# define OCTAVE_PATCH_VERSION 99
237
238# else
239
240// OCTAVE_API_VERSION_NUMBER == 37
241# define OCTAVE_MAJOR_VERSION 3
242# define OCTAVE_MINOR_VERSION 2
243# define OCTAVE_PATCH_VERSION 0
244
245# endif // defined(octave_Complex_LU_h)
246
247# endif // defined(octave_ov_h)
248
249// Correlation between Octave API and version numbers extracted from Octave's
250// ChangeLogs; version is the *earliest* released Octave with that API number
251# elif OCTAVE_API_VERSION_NUMBER >= 48
252# define OCTAVE_MAJOR_VERSION 3
253# define OCTAVE_MINOR_VERSION 6
254# define OCTAVE_PATCH_VERSION 0
255
256# elif OCTAVE_API_VERSION_NUMBER >= 45
257# define OCTAVE_MAJOR_VERSION 3
258# define OCTAVE_MINOR_VERSION 4
259# define OCTAVE_PATCH_VERSION 1
260
261# elif OCTAVE_API_VERSION_NUMBER >= 42
262# define OCTAVE_MAJOR_VERSION 3
263# define OCTAVE_MINOR_VERSION 3
264# define OCTAVE_PATCH_VERSION 54
265
266# elif OCTAVE_API_VERSION_NUMBER >= 41
267# define OCTAVE_MAJOR_VERSION 3
268# define OCTAVE_MINOR_VERSION 3
269# define OCTAVE_PATCH_VERSION 53
270
271# elif OCTAVE_API_VERSION_NUMBER >= 40
272# define OCTAVE_MAJOR_VERSION 3
273# define OCTAVE_MINOR_VERSION 3
274# define OCTAVE_PATCH_VERSION 52
275
276# elif OCTAVE_API_VERSION_NUMBER >= 39
277# define OCTAVE_MAJOR_VERSION 3
278# define OCTAVE_MINOR_VERSION 3
279# define OCTAVE_PATCH_VERSION 51
280
281# else // OCTAVE_API_VERSION_NUMBER == 38
282# define OCTAVE_MAJOR_VERSION 3
283# define OCTAVE_MINOR_VERSION 3
284# define OCTAVE_PATCH_VERSION 50
285
286# endif // !defined(OCTAVE_API_VERSION_NUMBER)
287
288#endif // !defined(OCTAVE_MAJOR_VERSION)
289
290// Required Octave headers
291#include <octave/Cell.h>
292#include <octave/dynamic-ld.h>
293#include <octave/oct-env.h>
294#include <octave/oct-map.h>
295#include <octave/ov-scalar.h>
296#include <octave/ov-fcn-handle.h>
297#include <octave/parse.h>
298#if SWIG_OCTAVE_PREREQ(4,2,0)
299#include <octave/interpreter.h>
300#else
301#include <octave/toplev.h>
302#endif
303#include <octave/unwind-prot.h>
304#if SWIG_OCTAVE_PREREQ(4,2,0)
305#include <octave/call-stack.h>
306#endif
307
308#endif // !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
309
310/* -----------------------------------------------------------------------------
311 * swigrun.swg
312 *
313 * This file contains generic C API SWIG runtime support for pointer
314 * type checking.
315 * ----------------------------------------------------------------------------- */
316
317/* This should only be incremented when either the layout of swig_type_info changes,
318 or for whatever reason, the runtime changes incompatibly */
319#define SWIG_RUNTIME_VERSION "4"
320
321/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
322#ifdef SWIG_TYPE_TABLE
323# define SWIG_QUOTE_STRING(x) #x
324# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
325# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
326#else
327# define SWIG_TYPE_TABLE_NAME
328#endif
329
330/*
331 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
332 creating a static or dynamic library from the SWIG runtime code.
333 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
334
335 But only do this if strictly necessary, ie, if you have problems
336 with your compiler or suchlike.
337*/
338
339#ifndef SWIGRUNTIME
340# define SWIGRUNTIME SWIGINTERN
341#endif
342
343#ifndef SWIGRUNTIMEINLINE
344# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
345#endif
346
347/* Generic buffer size */
348#ifndef SWIG_BUFFER_SIZE
349# define SWIG_BUFFER_SIZE 1024
350#endif
351
352/* Flags for pointer conversions */
353#define SWIG_POINTER_DISOWN 0x1
354#define SWIG_CAST_NEW_MEMORY 0x2
355#define SWIG_POINTER_NO_NULL 0x4
356#define SWIG_POINTER_CLEAR 0x8
357#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
358
359/* Flags for new pointer objects */
360#define SWIG_POINTER_OWN 0x1
361
362
363/*
364 Flags/methods for returning states.
365
366 The SWIG conversion methods, as ConvertPtr, return an integer
367 that tells if the conversion was successful or not. And if not,
368 an error code can be returned (see swigerrors.swg for the codes).
369
370 Use the following macros/flags to set or process the returning
371 states.
372
373 In old versions of SWIG, code such as the following was usually written:
374
375 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
376 // success code
377 } else {
378 //fail code
379 }
380
381 Now you can be more explicit:
382
383 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
384 if (SWIG_IsOK(res)) {
385 // success code
386 } else {
387 // fail code
388 }
389
390 which is the same really, but now you can also do
391
392 Type *ptr;
393 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
394 if (SWIG_IsOK(res)) {
395 // success code
396 if (SWIG_IsNewObj(res) {
397 ...
398 delete *ptr;
399 } else {
400 ...
401 }
402 } else {
403 // fail code
404 }
405
406 I.e., now SWIG_ConvertPtr can return new objects and you can
407 identify the case and take care of the deallocation. Of course that
408 also requires SWIG_ConvertPtr to return new result values, such as
409
410 int SWIG_ConvertPtr(obj, ptr,...) {
411 if (<obj is ok>) {
412 if (<need new object>) {
413 *ptr = <ptr to new allocated object>;
414 return SWIG_NEWOBJ;
415 } else {
416 *ptr = <ptr to old object>;
417 return SWIG_OLDOBJ;
418 }
419 } else {
420 return SWIG_BADOBJ;
421 }
422 }
423
424 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
425 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
426 SWIG errors code.
427
428 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
429 allows returning the 'cast rank', for example, if you have this
430
431 int food(double)
432 int fooi(int);
433
434 and you call
435
436 food(1) // cast rank '1' (1 -> 1.0)
437 fooi(1) // cast rank '0'
438
439 just use the SWIG_AddCast()/SWIG_CheckState()
440*/
441
442#define SWIG_OK (0)
443/* Runtime errors are < 0 */
444#define SWIG_ERROR (-1)
445/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
446/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
447/* Errors < -200 are generic runtime specific errors */
448#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
449
450#define SWIG_IsOK(r) (r >= 0)
451#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
452
453/* The CastRankLimit says how many bits are used for the cast rank */
454#define SWIG_CASTRANKLIMIT (1 << 8)
455/* The NewMask denotes the object was created (using new/malloc) */
456#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
457/* The TmpMask is for in/out typemaps that use temporary objects */
458#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
459/* Simple returning values */
460#define SWIG_BADOBJ (SWIG_ERROR)
461#define SWIG_OLDOBJ (SWIG_OK)
462#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
463#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
464/* Check, add and del object mask methods */
465#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
466#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
467#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
468#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
469#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
470#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
471
472/* Cast-Rank Mode */
473#if defined(SWIG_CASTRANK_MODE)
474# ifndef SWIG_TypeRank
475# define SWIG_TypeRank unsigned long
476# endif
477# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
478# define SWIG_MAXCASTRANK (2)
479# endif
480# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
481# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
483 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
484}
486 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
487}
488#else /* no cast-rank mode */
489# define SWIG_AddCast(r) (r)
490# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
491#endif
492
493
494#include <string.h>
495
496#ifdef __cplusplus
497extern "C" {
498#endif
499
500typedef void *(*swig_converter_func)(void *, int *);
501typedef struct swig_type_info *(*swig_dycast_func)(void **);
502
503/* Structure to store information on one type */
504typedef struct swig_type_info {
505 const char *name; /* mangled name of this type */
506 const char *str; /* human readable name of this type */
507 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
508 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
509 void *clientdata; /* language specific type data */
510 int owndata; /* flag if the structure owns the clientdata */
512
513/* Structure to store a type and conversion function used for casting */
514typedef struct swig_cast_info {
515 swig_type_info *type; /* pointer to type that is equivalent to this type */
516 swig_converter_func converter; /* function to cast the void pointers */
517 struct swig_cast_info *next; /* pointer to next cast in linked list */
518 struct swig_cast_info *prev; /* pointer to the previous cast */
520
521/* Structure used to store module information
522 * Each module generates one structure like this, and the runtime collects
523 * all of these structures and stores them in a circularly linked list.*/
524typedef struct swig_module_info {
525 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
526 size_t size; /* Number of types in this module */
527 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
528 swig_type_info **type_initial; /* Array of initially generated type structures */
529 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
530 void *clientdata; /* Language specific module data */
532
533/*
534 Compare two type names skipping the space characters, therefore
535 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
536
537 Return 0 when the two name types are equivalent, as in
538 strncmp, but skipping ' '.
539*/
540SWIGRUNTIME int
541SWIG_TypeNameComp(const char *f1, const char *l1,
542 const char *f2, const char *l2) {
543 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
544 while ((*f1 == ' ') && (f1 != l1)) ++f1;
545 while ((*f2 == ' ') && (f2 != l2)) ++f2;
546 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
547 }
548 return (int)((l1 - f1) - (l2 - f2));
549}
550
551/*
552 Check type equivalence in a name list like <name1>|<name2>|...
553 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
554*/
555SWIGRUNTIME int
556SWIG_TypeCmp(const char *nb, const char *tb) {
557 int equiv = 1;
558 const char* te = tb + strlen(tb);
559 const char* ne = nb;
560 while (equiv != 0 && *ne) {
561 for (nb = ne; *ne; ++ne) {
562 if (*ne == '|') break;
563 }
564 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
565 if (*ne) ++ne;
566 }
567 return equiv;
568}
569
570/*
571 Check type equivalence in a name list like <name1>|<name2>|...
572 Return 0 if not equal, 1 if equal
573*/
574SWIGRUNTIME int
575SWIG_TypeEquiv(const char *nb, const char *tb) {
576 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
577}
578
579/*
580 Check the typename
581*/
583SWIG_TypeCheck(const char *c, swig_type_info *ty) {
584 if (ty) {
585 swig_cast_info *iter = ty->cast;
586 while (iter) {
587 if (strcmp(iter->type->name, c) == 0) {
588 if (iter == ty->cast)
589 return iter;
590 /* Move iter to the top of the linked list */
591 iter->prev->next = iter->next;
592 if (iter->next)
593 iter->next->prev = iter->prev;
594 iter->next = ty->cast;
595 iter->prev = 0;
596 if (ty->cast) ty->cast->prev = iter;
597 ty->cast = iter;
598 return iter;
599 }
600 iter = iter->next;
601 }
602 }
603 return 0;
604}
605
606/*
607 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
608*/
611 if (ty) {
612 swig_cast_info *iter = ty->cast;
613 while (iter) {
614 if (iter->type == from) {
615 if (iter == ty->cast)
616 return iter;
617 /* Move iter to the top of the linked list */
618 iter->prev->next = iter->next;
619 if (iter->next)
620 iter->next->prev = iter->prev;
621 iter->next = ty->cast;
622 iter->prev = 0;
623 if (ty->cast) ty->cast->prev = iter;
624 ty->cast = iter;
625 return iter;
626 }
627 iter = iter->next;
628 }
629 }
630 return 0;
631}
632
633/*
634 Cast a pointer up an inheritance hierarchy
635*/
637SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
638 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
639}
640
641/*
642 Dynamic pointer casting. Down an inheritance hierarchy
643*/
646 swig_type_info *lastty = ty;
647 if (!ty || !ty->dcast) return ty;
648 while (ty && (ty->dcast)) {
649 ty = (*ty->dcast)(ptr);
650 if (ty) lastty = ty;
651 }
652 return lastty;
653}
654
655/*
656 Return the name associated with this type
657*/
658SWIGRUNTIMEINLINE const char *
660 return ty->name;
661}
662
663/*
664 Return the pretty name associated with this type,
665 that is an unmangled type name in a form presentable to the user.
666*/
667SWIGRUNTIME const char *
669 /* The "str" field contains the equivalent pretty names of the
670 type, separated by vertical-bar characters. Choose the last
671 name. It should be the most specific; a fully resolved name
672 but not necessarily with default template parameters expanded. */
673 if (!type) return NULL;
674 if (type->str != NULL) {
675 const char *last_name = type->str;
676 const char *s;
677 for (s = type->str; *s; s++)
678 if (*s == '|') last_name = s+1;
679 return last_name;
680 }
681 else
682 return type->name;
683}
684
685/*
686 Set the clientdata field for a type
687*/
688SWIGRUNTIME void
690 swig_cast_info *cast = ti->cast;
691 /* if (ti->clientdata == clientdata) return; */
693
694 while (cast) {
695 if (!cast->converter) {
696 swig_type_info *tc = cast->type;
697 if (!tc->clientdata) {
699 }
700 }
701 cast = cast->next;
702 }
703}
704SWIGRUNTIME void
709
710/*
711 Search for a swig_type_info structure only by mangled name
712 Search is a O(log #types)
713
714 We start searching at module start, and finish searching when start == end.
715 Note: if start == end at the beginning of the function, we go all the way around
716 the circular list.
717*/
720 swig_module_info *end,
721 const char *name) {
722 swig_module_info *iter = start;
723 do {
724 if (iter->size) {
725 size_t l = 0;
726 size_t r = iter->size - 1;
727 do {
728 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
729 size_t i = (l + r) >> 1;
730 const char *iname = iter->types[i]->name;
731 if (iname) {
732 int compare = strcmp(name, iname);
733 if (compare == 0) {
734 return iter->types[i];
735 } else if (compare < 0) {
736 if (i) {
737 r = i - 1;
738 } else {
739 break;
740 }
741 } else if (compare > 0) {
742 l = i + 1;
743 }
744 } else {
745 break; /* should never happen */
746 }
747 } while (l <= r);
748 }
749 iter = iter->next;
750 } while (iter != end);
751 return 0;
752}
753
754/*
755 Search for a swig_type_info structure for either a mangled name or a human readable name.
756 It first searches the mangled names of the types, which is a O(log #types)
757 If a type is not found it then searches the human readable names, which is O(#types).
758
759 We start searching at module start, and finish searching when start == end.
760 Note: if start == end at the beginning of the function, we go all the way around
761 the circular list.
762*/
765 swig_module_info *end,
766 const char *name) {
767 /* STEP 1: Search the name field using binary search */
769 if (ret) {
770 return ret;
771 } else {
772 /* STEP 2: If the type hasn't been found, do a complete search
773 of the str field (the human readable name) */
774 swig_module_info *iter = start;
775 do {
776 size_t i = 0;
777 for (; i < iter->size; ++i) {
778 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
779 return iter->types[i];
780 }
781 iter = iter->next;
782 } while (iter != end);
783 }
784
785 /* neither found a match */
786 return 0;
787}
788
789/*
790 Pack binary data into a string
791*/
792SWIGRUNTIME char *
793SWIG_PackData(char *c, void *ptr, size_t sz) {
794 static const char hex[17] = "0123456789abcdef";
795 const unsigned char *u = (unsigned char *) ptr;
796 const unsigned char *eu = u + sz;
797 for (; u != eu; ++u) {
798 unsigned char uu = *u;
799 *(c++) = hex[(uu & 0xf0) >> 4];
800 *(c++) = hex[uu & 0xf];
801 }
802 return c;
803}
804
805/*
806 Unpack binary data from a string
807*/
808SWIGRUNTIME const char *
809SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
810 unsigned char *u = (unsigned char *) ptr;
811 const unsigned char *eu = u + sz;
812 for (; u != eu; ++u) {
813 char d = *(c++);
814 unsigned char uu;
815 if ((d >= '0') && (d <= '9'))
816 uu = (unsigned char)((d - '0') << 4);
817 else if ((d >= 'a') && (d <= 'f'))
818 uu = (unsigned char)((d - ('a'-10)) << 4);
819 else
820 return (char *) 0;
821 d = *(c++);
822 if ((d >= '0') && (d <= '9'))
823 uu |= (unsigned char)(d - '0');
824 else if ((d >= 'a') && (d <= 'f'))
825 uu |= (unsigned char)(d - ('a'-10));
826 else
827 return (char *) 0;
828 *u = uu;
829 }
830 return c;
831}
832
833/*
834 Pack 'void *' into a string buffer.
835*/
836SWIGRUNTIME char *
837SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
838 char *r = buff;
839 if ((2*sizeof(void *) + 2) > bsz) return 0;
840 *(r++) = '_';
841 r = SWIG_PackData(r,&ptr,sizeof(void *));
842 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
843 strcpy(r,name);
844 return buff;
845}
846
847SWIGRUNTIME const char *
848SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
849 if (*c != '_') {
850 if (strcmp(c,"NULL") == 0) {
851 *ptr = (void *) 0;
852 return name;
853 } else {
854 return 0;
855 }
856 }
857 return SWIG_UnpackData(++c,ptr,sizeof(void *));
858}
859
860SWIGRUNTIME char *
861SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
862 char *r = buff;
863 size_t lname = (name ? strlen(name) : 0);
864 if ((2*sz + 2 + lname) > bsz) return 0;
865 *(r++) = '_';
866 r = SWIG_PackData(r,ptr,sz);
867 if (lname) {
868 strncpy(r,name,lname+1);
869 } else {
870 *r = 0;
871 }
872 return buff;
873}
874
875SWIGRUNTIME const char *
876SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
877 if (*c != '_') {
878 if (strcmp(c,"NULL") == 0) {
879 memset(ptr,0,sz);
880 return name;
881 } else {
882 return 0;
883 }
884 }
885 return SWIG_UnpackData(++c,ptr,sz);
886}
887
888#ifdef __cplusplus
889}
890#endif
891
892/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
893#define SWIG_UnknownError -1
894#define SWIG_IOError -2
895#define SWIG_RuntimeError -3
896#define SWIG_IndexError -4
897#define SWIG_TypeError -5
898#define SWIG_DivisionByZero -6
899#define SWIG_OverflowError -7
900#define SWIG_SyntaxError -8
901#define SWIG_ValueError -9
902#define SWIG_SystemError -10
903#define SWIG_AttributeError -11
904#define SWIG_MemoryError -12
905#define SWIG_NullReferenceError -13
906
907
908#if !SWIG_OCTAVE_PREREQ(3,2,0)
909#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
910#else
911#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
912#endif
913
914SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
915 if (num_args > max_args && !varargs)
916 error("function %s takes at most %i arguments", func_name, max_args);
917 else if (num_args < min_args)
918 error("function %s requires at least %i arguments", func_name, min_args);
919 else
920 return true;
921 return false;
922}
923
924SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
925 ovl->append(ov);
926 return ovl;
927}
928
929SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
930 switch (code) {
931 case SWIG_MemoryError:
932 return "SWIG_MemoryError";
933 case SWIG_IOError:
934 return "SWIG_IOError";
936 return "SWIG_RuntimeError";
937 case SWIG_IndexError:
938 return "SWIG_IndexError";
939 case SWIG_TypeError:
940 return "SWIG_TypeError";
942 return "SWIG_DivisionByZero";
944 return "SWIG_OverflowError";
945 case SWIG_SyntaxError:
946 return "SWIG_SyntaxError";
947 case SWIG_ValueError:
948 return "SWIG_ValueError";
949 case SWIG_SystemError:
950 return "SWIG_SystemError";
952 return "SWIG_AttributeError";
954 return "SWIG_NullReferenceError";
955 }
956 return "SWIG unknown error";
957}
958
959SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
960 octave_value type(SWIG_ErrorType(code));
961 std::string r = msg;
962 r += " (" + type.string_value() + ")";
963 error("%s", r.c_str());
964 return octave_value(r);
965}
966
967#define SWIG_fail goto fail
968
969#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
970#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
971#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
972#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
973#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
974#define swig_owntype int
975
976#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
977#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
978
979#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
980#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
981
982#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
983#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
984
985#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
986#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
987#define SWIG_MODULE_CLIENTDATA_TYPE void*
988
989#define Octave_Error_Occurred() 0
990#define SWIG_Octave_AddErrorMsg(msg) {;}
991
994
995// For backward compatibility only
996#define SWIG_POINTER_EXCEPTION 0
997#define SWIG_arg_fail(arg) 0
998
999// Runtime API implementation
1000
1001typedef octave_value_list(*octave_func) (const octave_value_list &, int);
1002class octave_swig_type;
1003
1004namespace Swig {
1005
1006#ifdef SWIG_DIRECTORS
1007
1008 class Director;
1009
1010 typedef std::map < void *, Director * > rtdir_map;
1011 SWIGINTERN rtdir_map* get_rtdir_map();
1012 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
1013 SWIGINTERNINLINE void erase_rtdir(void *vptr);
1014 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
1015
1016 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
1017 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
1018 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
1019
1020#endif
1021
1022 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
1024 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
1025}
1026
1027#ifdef SWIG_DIRECTORS
1028SWIGRUNTIME void swig_acquire_ownership(void *vptr);
1029SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
1030SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
1031#endif
1032
1034 const char *name;
1038 int flags; // 1 static, 2 global
1039 const char *doc;
1040 bool is_static() const {
1041 return flags &1;
1042 } bool is_global() const {
1043 return flags &2;
1044 }
1045 };
1046
1058
1059#if SWIG_OCTAVE_PREREQ(4,4,0)
1060 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1061 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1062#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1063 class octave_swig_bound_func : public octave_function {
1064 public:
1065
1066 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1067 { }
1068
1069 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1070 : octave_function("", ""), method(_method), first_args(_first_args)
1071 { }
1072
1073 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1074
1075 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1076
1077 ~octave_swig_bound_func(void) = default;
1078
1079 bool is_function(void) const { return true; }
1080
1081 octave_function* function_value(bool = false) { return this; }
1082
1083#if SWIG_OCTAVE_PREREQ(6,0,0)
1084 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1085 return execute(tw,nargout,args);
1086 }
1087#endif
1088#if SWIG_OCTAVE_PREREQ(6,0,0)
1089 octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1090#else
1091 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1092#endif
1093 octave_value_list all_args;
1094 all_args.append(first_args);
1095 all_args.append(args);
1096 return method->call(tw, nargout, all_args);
1097 }
1098
1099 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1100 octave_value_list ovl = subsref(ops, idx, 1);
1101 return ovl.length() ? ovl(0) : octave_value();
1102 }
1103
1104 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1105 assert(ops.size() > 0);
1106 assert(ops.size() == idx.size());
1107 if (ops != "(")
1108 error("invalid function call");
1109 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1110 return call(tw, nargout, *idx.begin());
1111 }
1112
1113 protected:
1114
1115 octave_function* method;
1116 octave_value_list first_args;
1117
1118 std::set<std::string> dispatch_classes;
1119
1120 };
1121#else
1122#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1123#endif
1124
1125 // octave_swig_type plays the role of both the shadow class and the class
1126 // representation within Octave, since there is no support for classes.
1127 //
1128 // These should really be decoupled, with the class support added to Octave
1129 // and the shadow class given by an m-file script. That would dramatically
1130 // reduce the runtime complexity, and be more in line with other modules.
1131
1132 class octave_swig_type:public octave_base_value {
1133 struct cpp_ptr {
1134 void *ptr;
1136 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1137 }};
1138 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1139
1141
1142 const swig_type_info *construct_type; // type of special type object
1143 std::vector < type_ptr_pair > types; // our c++ base classes
1144 int thisown; // whether we call c++ destructors when we die
1145
1146 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1147 typedef std::map < std::string, member_value_pair > member_map;
1150
1151 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1152 if (!type->clientdata)
1153 return 0;
1154 swig_octave_class *c = (swig_octave_class *) type->clientdata;
1155 const swig_octave_member *m;
1156 for (m = c->members; m->name; ++m)
1157 if (m->name == name)
1158 return m;
1159 for (int j = 0; c->base_names[j]; ++j) {
1160 if (!c->base[j]) {
1161 if (!module)
1162 module = SWIG_GetModule(0);
1163 assert(module);
1165 }
1166 if (!c->base[j])
1167 return 0;
1168 if ((m = find_member(c->base[j], name)))
1169 return m;
1170 }
1171 return 0;
1172 }
1173
1174 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1175 member_map::iterator it = members.find(name);
1176 if (it != members.end())
1177 return &it->second;
1178 const swig_octave_member *m;
1179 for (unsigned int j = 0; j < types.size(); ++j)
1180 if ((m = find_member(types[j].first, name)))
1181 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1182 if (!insert_if_not_found)
1183 return 0;
1184 return &members[name];
1185 }
1186
1187 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1188 if (!base) {
1189 for (unsigned int j = 0; j < types.size(); ++j) {
1190 assert(types[j].first->clientdata);
1191 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1192 if (cj->name == name)
1193 return types[j].first;
1194 }
1195 return 0;
1196 }
1197 assert(base->clientdata);
1199 for (int j = 0; c->base_names[j]; ++j) {
1200 if (!c->base[j]) {
1201 if (!module)
1202 module = SWIG_GetModule(0);
1203 assert(module);
1205 }
1206 if (!c->base[j])
1207 return 0;
1208 assert(c->base[j]->clientdata);
1210 if (cj->name == name)
1211 return c->base[j];
1212 }
1213 return 0;
1214 }
1215
1216 void load_members(const swig_octave_class* c,member_map& out) const {
1217 for (const swig_octave_member *m = c->members; m->name; ++m) {
1218 if (out.find(m->name) == out.end())
1219 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1220 }
1221 for (int j = 0; c->base_names[j]; ++j) {
1222 if (!c->base[j]) {
1223 if (!module)
1224 module = SWIG_GetModule(0);
1225 assert(module);
1227 }
1228 if (!c->base[j])
1229 continue;
1230 assert(c->base[j]->clientdata);
1231 const swig_octave_class *cj =
1232 (const swig_octave_class *) c->base[j]->clientdata;
1233 load_members(cj,out);
1234 }
1235 }
1236
1237 void load_members(member_map& out) const {
1238 out=members;
1239 for (unsigned int j = 0; j < types.size(); ++j)
1240 if (types[j].first->clientdata)
1241 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1242 }
1243
1244 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1245 if (m->second.is_defined())
1246 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1247 else if (m->first && m->first->method)
1248 return m->first->method(args, nargout);
1249 error("member not defined or not invocable");
1250 return octave_value_list();
1251 }
1252
1253 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1254 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1255 member_value_pair *m = nc_this->find_member(symbol, false);
1256 if (!m || m->first->is_static() || m->first->is_global())
1257 return false;
1258 octave_value_list args;
1259 args.append(nc_this->as_value());
1260 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1261 if (argout.length() < 1)
1262 return false;
1263 ret = argout(0);
1264 return true;
1265 }
1266
1267 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1268 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1269 member_value_pair *m = nc_this->find_member(symbol, false);
1270 if (!m || m->first->is_static() || m->first->is_global())
1271 return false;
1272 octave_value_list args;
1273 args.append(nc_this->as_value());
1274 args.append(make_value_hack(rhs));
1275 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1276 if (argout.length() < 1)
1277 return false;
1278 ret = argout(0);
1279 return true;
1280 }
1281
1282 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1283 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1284 member_value_pair *m = nc_this->find_member(symbol, false);
1285 if (!m || m->first->is_static() || m->first->is_global())
1286 return false;
1287 octave_value_list args;
1288 args.append(nc_this->as_value());
1289 args.append(rhs);
1290 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1291 if (argout.length() >= 1)
1292 ret = argout(0);
1293 return true;
1294 }
1295
1296 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1297 if (m->second.is_defined()) {
1298 if (m->second.is_function() || m->second.is_function_handle()) {
1299 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1300 } else {
1301 return m->second;
1302 }
1303 } else if (m->first) {
1304 if (m->first->get_method)
1305 return m->first->get_method(args, 1);
1306 else if (m->first->method)
1307 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1308 }
1309 error("undefined member");
1310 return octave_value_list();
1311 }
1312
1313 static octave_value make_value_hack(const octave_base_value &x) {
1314#if SWIG_OCTAVE_PREREQ(9,0,0)
1315 ((octave_swig_type &) x).m_count++;
1316#else
1317 ((octave_swig_type &) x).count++;
1318#endif
1319 return octave_value((octave_base_value *) &x);
1320 }
1321
1324 public:
1325
1326 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1327 bool _always_static = false)
1328 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1329 always_static(_always_static) {
1330 if (_type || _ptr)
1331 types.push_back(std::make_pair(_type, _ptr));
1332#ifdef SWIG_DIRECTORS
1333 if (_ptr) {
1334 Swig::Director *d = Swig::get_rtdir(_ptr);
1335 if (d)
1336 Swig::swig_director_set_self(d, this);
1337 }
1338#endif
1339 }
1340
1342 if (thisown) {
1343#if SWIG_OCTAVE_PREREQ(9,0,0)
1344 ++m_count;
1345#else
1346 ++count;
1347#endif
1348 for (unsigned int j = 0; j < types.size(); ++j) {
1349 if (!types[j].first || !types[j].first->clientdata)
1350 continue;
1351 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1352 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1353 c->destructor(as_value(), 0);
1354 }
1355 }
1356 }
1357#ifdef SWIG_DIRECTORS
1358 for (unsigned int j = 0; j < types.size(); ++j)
1359 Swig::erase_rtdir(types[j].second.ptr);
1360#endif
1361 }
1362
1363 dim_vector dims(void) const {
1364 octave_value out;
1365 if (!dispatch_unary_op("__dims__", out))
1366 return dim_vector(1,1);
1367
1368 // Return value should be cell or matrix of integers
1369#if SWIG_OCTAVE_PREREQ(4,4,0)
1370 if (out.iscell()) {
1371#else
1372 if (out.is_cell()) {
1373#endif
1374 const Cell & c=out.cell_value();
1375 int ndim = c.rows();
1376 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1377
1378 dim_vector d;
1379 d.resize(ndim < 2 ? 2 : ndim);
1380 d(0) = d(1) = 1;
1381
1382 // Fill in dim_vector
1383 for (int k=0;k<ndim;k++) {
1384 const octave_value& obj = c(k);
1385#if SWIG_OCTAVE_PREREQ(6,0,0)
1386 try {
1387 d.elem(k) = obj.int_value();
1388 }
1389 catch (octave::execution_exception& oee) {
1390 // __dims__ should return a cell filled with integers
1391 return dim_vector(1,1);
1392 }
1393#else
1394 d.elem(k) = obj.int_value();
1395
1396 // __dims__ should return a cell filled with integers
1397 if (error_state) return dim_vector(1,1);
1398#endif
1399 }
1400 return d;
1401#if SWIG_OCTAVE_PREREQ(4,4,0)
1402 } else if (out.is_matrix_type() || out.isnumeric() ) {
1403#else
1404 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1405#endif
1406 if (out.rows()==1 || out.columns()==1) {
1407#if SWIG_OCTAVE_PREREQ(6,0,0)
1408 Array<int> a;
1409 try {
1410 a = out.int_vector_value();
1411 }
1412 catch (octave::execution_exception& oee) {
1413 return dim_vector(1,1);
1414 }
1415#else
1416 Array<int> a = out.int_vector_value();
1417 if (error_state) return dim_vector(1,1);
1418#endif
1419 dim_vector d;
1420 d.resize(a.numel() < 2 ? 2 : a.numel());
1421 d(0) = d(1) = 1;
1422 for (int k=0;k<a.numel();k++) {
1423 d.elem(k) = a(k);
1424 }
1425 return d;
1426 } else {
1427 return dim_vector(1,1);
1428 }
1429 } else {
1430 return dim_vector(1,1);
1431 }
1432 }
1433
1434 octave_value as_value() {
1435#if SWIG_OCTAVE_PREREQ(9,0,0)
1436 ++m_count;
1437#else
1438 ++count;
1439#endif
1440 return Swig::swig_value_ref(this);
1441 }
1442
1443 void incref() {
1444#if SWIG_OCTAVE_PREREQ(9,0,0)
1445 ++m_count;
1446#else
1447 ++count;
1448#endif
1449 }
1450
1451 void decref() {
1452#if SWIG_OCTAVE_PREREQ(9,0,0)
1453 if (!--m_count)
1454#else
1455 if (!--count)
1456#endif
1457 delete this;
1458 }
1459
1460 size_t swig_this() const {
1461 if (!types.size())
1462 return (size_t) this;
1463 return (size_t) types[0].second.ptr;
1464 }
1465 const char* help_text() const {
1466 if (!types.size())
1467 return 0;
1468 if (!types[0].first->clientdata)
1469 return 0;
1470 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1471 return c->constructor_doc;
1472 }
1473
1474 std::string swig_type_name() const {
1475 // * need some way to manually name subclasses.
1476 // * eg optional first arg to subclass(), or named_subclass()
1477 std::string ret;
1478 for (unsigned int j = 0; j < types.size(); ++j) {
1479 if (j)
1480 ret += "_";
1481 if (types[j].first->clientdata) {
1482 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1483 ret += c->name;
1484 } else
1485 ret += types[j].first->name;
1486 }
1487 return ret;
1488 }
1489
1491 rhs.thisown = 0;
1492 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1493 assert(!rhs.types[j].second.destroyed);
1494#ifdef SWIG_DIRECTORS
1495 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1496 if (d)
1497 Swig::swig_director_set_self(d, this);
1498#endif
1499 }
1500 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1501 members.insert(rhs.members.begin(), rhs.members.end());
1502#if SWIG_OCTAVE_PREREQ(4,4,0)
1503 assign(rhs.swig_type_name(), rhs.as_value());
1504#else
1505 rhs.types.clear();
1506 rhs.members.clear();
1507#endif
1508 }
1509
1510 typedef member_map::const_iterator swig_member_const_iterator;
1513
1514 int cast(void **vptr, swig_type_info *type, int *own, int flags) {
1515 int res = SWIG_ERROR;
1516 int clear_pointer = 0;
1517
1518 if (own)
1519 *own = 0;
1520 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !thisown) {
1522 } else {
1523 if (own)
1524 *own = *own | thisown;
1525 if (flags & SWIG_POINTER_DISOWN) {
1526 thisown = 0;
1527 }
1528 if (flags & SWIG_POINTER_CLEAR) {
1529 clear_pointer = 1;
1530 }
1531 }
1532
1533 if (!type && types.size()) {
1534 if (vptr) {
1535 *vptr = types[0].second.ptr;
1536 if (clear_pointer)
1537 types[0].second.ptr = 0;
1538 }
1539 return SWIG_OK;
1540 }
1541 for (unsigned int j = 0; j < types.size(); ++j)
1542 if (type == types[j].first) {
1543 if (vptr) {
1544 *vptr = types[j].second.ptr;
1545 if (clear_pointer)
1546 types[j].second.ptr = 0;
1547 }
1548 return SWIG_OK;
1549 }
1550 for (unsigned int j = 0; j < types.size(); ++j) {
1551 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1552 if (!tc)
1553 continue;
1554 if (vptr) {
1555 int newmemory = 0;
1556 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1557 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1558 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1559 if (own)
1560 *own = *own | SWIG_CAST_NEW_MEMORY;
1561 }
1562 if (clear_pointer)
1563 types[j].second.ptr = 0;
1564 }
1565 res = SWIG_OK;
1566 break;
1567 }
1568 return res;
1569 }
1570
1571 bool is_owned() const {
1572 return thisown;
1573 }
1574
1575#ifdef SWIG_DIRECTORS
1576 void director_destroyed(Swig::Director *d) {
1577 bool found = false;
1578 for (unsigned int j = 0; j < types.size(); ++j) {
1579 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1580 if (dj == d) {
1581 types[j].second.destroyed = true;
1582 found = true;
1583 }
1584 }
1585 assert(found);
1586 }
1587#endif
1588
1589 void assign(const std::string &name, const octave_value &ov) {
1590 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1591 }
1592
1593 void assign(const std::string &name, const swig_octave_member *m) {
1594 members[name] = std::make_pair(m, octave_value());
1595 }
1596
1597 octave_base_value *clone() const {
1598 // pass-by-value is probably not desired, and is harder;
1599 // requires calling copy constructors of contained types etc.
1600 assert(0);
1601 *(int *) 0 = 0;
1602 return 0;
1603 }
1604
1605 octave_base_value *empty_clone() const {
1606 return new octave_swig_type();
1607 }
1608
1609 bool is_defined() const {
1610 return true;
1611 }
1612
1613#if SWIG_OCTAVE_PREREQ(6,0,0)
1614 virtual bool isstruct() const {
1615#else
1616 virtual bool is_map() const {
1617#endif
1618 return true;
1619 }
1620
1621 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1622 octave_value_list ovl = subsref(ops, idx, 1);
1623 return ovl.length()? ovl(0) : octave_value();
1624 }
1625
1626 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1627 assert(ops.size() > 0);
1628 assert(ops.size() == idx.size());
1629
1630 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1631 int skip = 0;
1632 octave_value_list sub_ovl;
1633
1634 // constructor invocation
1635 if (ops[skip] == '(' && construct_type) {
1636 assert(construct_type->clientdata);
1638 if (!c->constructor) {
1639 error("cannot create instance");
1640 return octave_value_list();
1641 }
1642 octave_value_list args;
1643 if (c->director)
1644 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1645 args.append(*idx_it++);
1646 ++skip;
1647 sub_ovl = c->constructor(args, nargout);
1648 }
1649 // member dereference or invocation
1650 else if (ops[skip] == '.') {
1651 std::string subname;
1652 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1653 for (;;) {
1654 octave_value_list subname_ovl(*idx_it++);
1655 ++skip;
1656 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1657 subname = subname_ovl(0).string_value();
1658
1659 const swig_type_info *next_base = find_base(subname, base);
1660 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1661 break;
1662 base = next_base;
1663 }
1664
1665 member_value_pair tmp, *m = &tmp;
1666 if (!base || !(m->first = find_member(base, subname)))
1667 m = find_member(subname, false);
1668 if (!m) {
1669 error("member not found");
1670 return octave_value_list();
1671 }
1672
1673 octave_value_list args;
1674 if (!always_static &&
1675 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1676 args.append(as_value());
1677 if (skip < (int) ops.size() && ops[skip] == '(' &&
1678 ((m->first && m->first->method) || m->second.is_function() ||
1679 m->second.is_function_handle())) {
1680 args.append(*idx_it++);
1681 ++skip;
1682 sub_ovl = member_invoke(m, args, nargout);
1683 } else {
1684 sub_ovl = member_deref(m, args);
1685 }
1686 }
1687 // index operator
1688 else {
1689 if (ops[skip] == '(' || ops[skip] == '{') {
1690 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1691 octave_value_list args;
1692 args.append(*idx_it++);
1693 ++skip;
1694 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1695 error("error evaluating index operator");
1696 return octave_value_list();
1697 }
1698 } else {
1699 error("unsupported subsref");
1700 return octave_value_list();
1701 }
1702 }
1703
1704 if (skip >= (int) ops.size())
1705 return sub_ovl;
1706 if (sub_ovl.length() < 1) {
1707 error("bad subs ref");
1708 return octave_value_list();
1709 }
1710 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1711 }
1712
1713 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1714 assert(ops.size() > 0);
1715 assert(ops.size() == idx.size());
1716
1717 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1718 int skip = 0;
1719
1720 if (ops.size() > 1) {
1721 std::list < octave_value_list >::const_iterator last = idx.end();
1722 --last;
1723 std::list < octave_value_list > next_idx(idx.begin(), last);
1724 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1725 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1726 }
1727
1728 else if (ops[skip] == '(' || ops[skip] == '{') {
1729 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1730 member_value_pair *m = find_member(op_name, false);
1731 if (m) {
1732 octave_value_list args;
1733 args.append(as_value());
1734 args.append(*idx_it);
1735 args.append(rhs);
1736 member_invoke(m, args, 1);
1737 } else
1738 error("%s member not found", op_name);
1739 }
1740
1741 else if (ops[skip] == '.') {
1742 octave_value_list subname_ovl(*idx_it++);
1743 ++skip;
1744 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1745 std::string subname = subname_ovl(0).string_value();
1746
1747 member_value_pair *m = find_member(subname, true);
1748 if (!m->first || !m->first->set_method) {
1749 m->first = 0;
1750 m->second = rhs;
1751 } else if (m->first->set_method) {
1752 octave_value_list args;
1753 if (!m->first->is_static() && !m->first->is_global())
1754 args.append(as_value());
1755 args.append(rhs);
1756 m->first->set_method(args, 1);
1757 } else
1758 error("member not assignable");
1759 } else
1760 error("unsupported subsasgn");
1761
1762 return as_value();
1763 }
1764
1765#if SWIG_OCTAVE_PREREQ(4,4,0)
1766 virtual bool isobject() const {
1767#else
1768 virtual bool is_object() const {
1769#endif
1770 return true;
1771 }
1772
1773 virtual bool is_string() const {
1774 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1775 return !!nc_this->find_member("__str__", false);
1776 }
1777
1778 virtual std::string string_value(bool force = false) const {
1779 octave_value ret;
1780 if (!dispatch_unary_op("__str__", ret)) {
1781 error("__str__ method not defined");
1782 return std::string();
1783 }
1784 if (!ret.is_string()) {
1785 error("__str__ method did not return a string");
1786 return std::string();
1787 }
1788 return ret.string_value();
1789 }
1790
1791 virtual double scalar_value(bool frc_str_conv = false) const {
1792 octave_value ret;
1793 if (!dispatch_unary_op("__float__", ret)) {
1794 error("__float__ method not defined");
1795 }
1796 return ret.scalar_value();
1797 }
1798
1799#if SWIG_OCTAVE_PREREQ(4,2,0)
1800 virtual octave_value as_double(void) const {
1801 octave_value ret;
1802 if (!dispatch_unary_op("__float__", ret)) {
1803 error("__float__ method not defined");
1804 }
1805 return ret.as_double();
1806 }
1807
1808 virtual octave_value as_single(void) const {
1809 octave_value ret;
1810 if (!dispatch_unary_op("__float__", ret)) {
1811 error("__float__ method not defined");
1812 }
1813 return ret.as_single();
1814 }
1815#endif
1816
1817#if SWIG_OCTAVE_PREREQ(3,8,0)
1818 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1819 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1820 octave_value ret;
1821 if (!dispatch_unary_op(opname, ret)) {
1822 error("%s", (opname + std::string(" method not found")).c_str());
1823 return octave_value();
1824 }
1825 return ret;
1826 }
1827#endif
1828
1829#if SWIG_OCTAVE_PREREQ(3,3,52)
1830 virtual octave_map map_value() const {
1831 return octave_map();
1832 }
1833#else
1834 virtual Octave_map map_value() const {
1835 return Octave_map();
1836 }
1837#endif
1838
1839 virtual string_vector map_keys() const {
1840 member_map tmp;
1841 load_members(tmp);
1842
1843 string_vector keys(tmp.size());
1844 int k = 0;
1845 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1846 keys(k++) = it->first;
1847
1848 return keys;
1849 }
1850
1851 virtual bool save_ascii (std::ostream& os) {
1852 return true;
1853 }
1854
1855 virtual bool load_ascii (std::istream& is) {
1856 return true;
1857 }
1858
1859 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1860 return true;
1861 }
1862
1863 virtual bool load_binary (std::istream& is, bool swap,
1864#if SWIG_OCTAVE_PREREQ(6,0,0)
1865 octave::mach_info::float_format fmt) {
1866#else
1867 oct_mach_info::float_format fmt) {
1868#endif
1869 return true;
1870 }
1871
1872#if defined (HAVE_HDF5)
1873# if SWIG_OCTAVE_PREREQ(4,0,0)
1874 virtual bool
1875 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1876 return true;
1877 }
1878
1879 virtual bool
1880 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1881 return true;
1882 }
1883# else
1884 virtual bool
1885 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1886 return true;
1887 }
1888
1889 virtual bool
1890 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1891 return true;
1892 }
1893# endif
1894#endif
1895
1896 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1897 return string_value();
1898 }
1899
1900 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1901 return string_value();
1902 }
1903
1904 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1905 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1906 // (rather than any module namespace).
1907
1908 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1909 if (!fcn)
1910 return false;
1911#if SWIG_OCTAVE_PREREQ(4,4,0)
1912 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1913 octave_value_list retval = fcn->call(tw, 1, args);
1914 if (retval.length() == 1)
1915 ret = retval(0);
1916#else
1917 ret = fcn->do_multi_index_op(1, args)(0);
1918#endif
1919 return true;
1920 }
1921
1922 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1924 assert(ost);
1925
1926 octave_value ret;
1927 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1928 return ret;
1929 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1930 octave_value_list args;
1931 args.append(make_value_hack(x));
1932 if (dispatch_global_op(symbol, args, ret))
1933 return ret;
1934
1935 error("could not dispatch unary operator");
1936 return octave_value();
1937 }
1938
1939 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1942
1943 octave_value ret;
1944 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1945 return ret;
1946 if (rhs_ost) {
1947 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1948 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1949 return ret;
1950 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1951 return ret;
1952 }
1953 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1954 return ret;
1955 }
1956
1957 std::string symbol;
1958 octave_value_list args;
1959 args.append(make_value_hack(lhs));
1960 args.append(make_value_hack(rhs));
1961
1962 symbol = SWIG_op_prefix;
1963 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1964 symbol += "_";
1965 symbol += op_name;
1966 symbol += "_";
1967 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1968 if (dispatch_global_op(symbol, args, ret))
1969 return ret;
1970
1971 symbol = SWIG_op_prefix;
1972 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1973 symbol += "_";
1974 symbol += op_name;
1975 symbol += "_";
1976 symbol += "any";
1977 if (dispatch_global_op(symbol, args, ret))
1978 return ret;
1979
1980 symbol = SWIG_op_prefix;
1981 symbol += "any";
1982 symbol += "_";
1983 symbol += op_name;
1984 symbol += "_";
1985 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1986 if (dispatch_global_op(symbol, args, ret))
1987 return ret;
1988
1989 error("could not dispatch binary operator");
1990 return octave_value();
1991 }
1992
1993#if SWIG_OCTAVE_PREREQ(4,0,0)
1994 void print(std::ostream &os, bool pr_as_read_syntax = false)
1995#else
1996 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1997#endif
1998 {
1999 if (is_string()) {
2000 os << string_value();
2001 return;
2002 }
2003
2004 member_map tmp;
2005 load_members(tmp);
2006
2007 indent(os);
2008 os << "{"; newline(os);
2009 increment_indent_level();
2010 for (unsigned int j = 0; j < types.size(); ++j) {
2011 indent(os);
2012 if (types[j].first->clientdata) {
2013 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
2014 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
2015 } else {
2016 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
2017 }
2018 }
2019 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2020 indent(os);
2021 if (it->second.first) {
2022 const char *objtype = it->second.first->method ? "method" : "variable";
2023 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
2024 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
2025 assert(it->second.first->name == it->first);
2026 } else {
2027 os << it->first; newline(os);
2028 }
2029 }
2030 decrement_indent_level();
2031 indent(os);
2032 os << "}"; newline(os);
2033 }
2034 };
2035
2036 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
2037 // will call clone() via make_unique() if there is more than one outstanding
2038 // reference to the lhs, and forces the clone's reference count to 1
2039 // (so you can't just increment your own count and return this).
2040 //
2041 // One way to fix this (without modifying Octave) is to add a level of
2042 // indirection such that clone copies ref-counted pointer and we keep
2043 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
2044 //
2045 // Supporting both pass-by-{ref,value} and toggling via %feature/option
2046 // might be nice.
2047
2048 class octave_swig_ref:public octave_base_value {
2050 public:
2052 :ptr(_ptr)
2053 {
2054 // Ensure type_id() is set correctly
2055#if SWIG_OCTAVE_PREREQ(9,0,0)
2056 if (s_t_id == -1) {
2057 s_t_id = octave_swig_ref::static_type_id();
2058#else
2059 if (t_id == -1) {
2060 t_id = octave_swig_ref::static_type_id();
2061#endif
2062 }
2063 }
2064
2066 { if (ptr) ptr->decref(); }
2067
2069 { return ptr; }
2070
2071 octave_base_value *clone() const
2072 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2073
2074 octave_base_value *empty_clone() const
2075 { return new octave_swig_ref(0); }
2076
2077 dim_vector dims(void) const
2078 { return ptr->dims(); }
2079
2080 bool is_defined() const
2081 { return ptr->is_defined(); }
2082
2083#if SWIG_OCTAVE_PREREQ(6,0,0)
2084 virtual bool isstruct() const
2085 { return ptr->isstruct(); }
2086#else
2087 virtual bool is_map() const
2088 { return ptr->is_map(); }
2089#endif
2090
2091 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2092 { return ptr->subsref(ops, idx); }
2093
2094 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2095 { return ptr->subsref(ops, idx, nargout); }
2096
2097 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2098 { return ptr->subsasgn(ops, idx, rhs); }
2099
2100#if SWIG_OCTAVE_PREREQ(4,4,0)
2101 virtual bool isobject() const
2102 { return ptr->isobject(); }
2103#else
2104 virtual bool is_object() const
2105 { return ptr->is_object(); }
2106#endif
2107
2108 virtual bool is_string() const
2109 { return ptr->is_string(); }
2110
2111 virtual std::string string_value(bool force = false) const
2112 { return ptr->string_value(force); }
2113
2114 virtual double scalar_value(bool frc_str_conv = false) const
2115 { return ptr->scalar_value(frc_str_conv); }
2116
2117#if SWIG_OCTAVE_PREREQ(4,2,0)
2118 virtual octave_value as_double(void) const
2119 { return ptr->as_double(); }
2120
2121 virtual octave_value as_single(void) const
2122 { return ptr->as_single(); }
2123#endif
2124
2125#if SWIG_OCTAVE_PREREQ(3,8,0)
2126 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2127 { return ptr->map(umap); }
2128#endif
2129
2130#if SWIG_OCTAVE_PREREQ(3,3,52)
2131 virtual octave_map map_value() const
2132 { return ptr->map_value(); }
2133#else
2134 virtual Octave_map map_value() const
2135 { return ptr->map_value(); }
2136#endif
2137
2138 virtual string_vector map_keys() const
2139 { return ptr->map_keys(); }
2140
2141 virtual bool save_ascii (std::ostream& os)
2142 { return ptr->save_ascii(os); }
2143
2144 virtual bool load_ascii (std::istream& is)
2145 { return ptr->load_ascii(is); }
2146
2147 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2148 { return ptr->save_binary(os, save_as_floats); }
2149
2150 virtual bool load_binary (std::istream& is, bool swap,
2151#if SWIG_OCTAVE_PREREQ(6,0,0)
2152 octave::mach_info::float_format fmt)
2153#else
2154 oct_mach_info::float_format fmt)
2155#endif
2156 { return ptr->load_binary(is, swap, fmt); }
2157
2158#if defined (HAVE_HDF5)
2159# if SWIG_OCTAVE_PREREQ(4,0,0)
2160 virtual bool
2161 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2162 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2163
2164 virtual bool
2165 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2166 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2167# else
2168 virtual bool
2169 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2170 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2171
2172 virtual bool
2173 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2174 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2175# endif
2176#endif
2177
2178 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2179 { return ptr->convert_to_str(pad, force, type); }
2180
2181 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2182 { return ptr->convert_to_str_internal(pad, force, type); }
2183
2184#if SWIG_OCTAVE_PREREQ(4,0,0)
2185 void print(std::ostream &os, bool pr_as_read_syntax = false)
2186#else
2187 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2188#endif
2189 { return ptr->print(os, pr_as_read_syntax); }
2190
2191#if SWIG_OCTAVE_PREREQ(9,0,0)
2192 static void set_type_id(int type_id) { s_t_id=type_id; }
2193#else
2194# if SWIG_OCTAVE_PREREQ(4,4,0)
2195 static void set_type_id(int type_id) { t_id=type_id; }
2196# endif
2197#endif
2198
2199 virtual type_conv_info numeric_conversion_function(void) const {
2200 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2201 octave_scalar::static_type_id ());
2202 }
2203
2204 private:
2205 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2206 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2207 return new octave_scalar(v.scalar_value());
2208 }
2209
2210#if !SWIG_OCTAVE_PREREQ(4,0,0)
2212#endif
2214 };
2215#if !SWIG_OCTAVE_PREREQ(4,0,0)
2217#endif
2219
2220 class octave_swig_packed:public octave_base_value {
2222 std::vector < char > buf;
2223 public:
2224
2225 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2226 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2227 {
2228 // Ensure type_id() is set correctly
2229#if SWIG_OCTAVE_PREREQ(9,0,0)
2230 if (s_t_id == -1) {
2231 s_t_id = octave_swig_packed::static_type_id();
2232#else
2233 if (t_id == -1) {
2234 t_id = octave_swig_packed::static_type_id();
2235#endif
2236 }
2237 }
2238
2239 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2240 if (outtype && outtype != type)
2241 return false;
2242 assert(sz <= buf.size());
2243 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2244 return true;
2245 }
2246
2247 octave_base_value *clone() const {
2248 return new octave_swig_packed(*this);
2249 }
2250
2251 octave_base_value *empty_clone() const {
2252 return new octave_swig_packed();
2253 }
2254
2255 bool is_defined() const {
2256 return true;
2257 }
2258
2259#if SWIG_OCTAVE_PREREQ(4,0,0)
2260 void print(std::ostream &os, bool pr_as_read_syntax = false)
2261#else
2262 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2263#endif
2264 {
2265 indent(os);
2266 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2267 }
2268
2269
2270 virtual bool save_ascii (std::ostream& os) {
2271 return true;
2272 }
2273
2274 virtual bool load_ascii (std::istream& is) {
2275 return true;
2276 }
2277
2278 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2279 return true;
2280 }
2281
2282 virtual bool load_binary (std::istream& is, bool swap,
2283#if SWIG_OCTAVE_PREREQ(6,0,0)
2284 octave::mach_info::float_format fmt) {
2285#else
2286 oct_mach_info::float_format fmt) {
2287#endif
2288 return true;
2289 }
2290
2291#if defined (HAVE_HDF5)
2292# if SWIG_OCTAVE_PREREQ(4,0,0)
2293 virtual bool
2294 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2295 return true;
2296 }
2297
2298 virtual bool
2299 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2300 return true;
2301 }
2302# else
2303 virtual bool
2304 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2305 return true;
2306 }
2307
2308 virtual bool
2309 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2310 return true;
2311 }
2312# endif
2313#endif
2314
2315#if SWIG_OCTAVE_PREREQ(9,0,0)
2316 static void set_type_id(int type_id) { s_t_id=type_id; }
2317#else
2318# if SWIG_OCTAVE_PREREQ(4,4,0)
2319 static void set_type_id(int type_id) { t_id=type_id; }
2320# endif
2321#endif
2322
2323 private:
2324#if !SWIG_OCTAVE_PREREQ(4,0,0)
2326#endif
2328 };
2329#if !SWIG_OCTAVE_PREREQ(4,0,0)
2331#endif
2333
2334 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2335 error("attempt to set immutable member variable");
2336 return octave_value_list();
2337 }
2338
2340 const octave_value_list &ovl;
2341 int j;
2342
2343 octave_value_ref(const octave_value_list &_ovl, int _j)
2344 :ovl(_ovl), j(_j) { }
2345
2346 operator octave_value() const {
2347 return ovl(j);
2348 }
2349
2350 octave_value operator*() const {
2351 return ovl(j);
2352 }
2353 };
2354
2355
2356namespace Swig {
2357
2359 return new octave_swig_ref(ost);
2360 }
2361
2363 if (
2364#if SWIG_OCTAVE_PREREQ(4,4,0)
2365 ov.iscell()
2366#else
2367 ov.is_cell()
2368#endif
2369 && ov.rows() == 1 && ov.columns() == 1)
2370 ov = ov.cell_value()(0);
2371 return swig_value_deref(*ov.internal_rep());
2372 }
2373
2374 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2375 if (ov.type_id() != octave_swig_ref::static_type_id())
2376 return 0;
2377 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2378 return osr->get_ptr();
2379 }
2380
2381}
2382
2383
2384#define swig_unary_op(name) \
2385SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2386 return octave_swig_type::dispatch_unary_op(x,#name); \
2387}
2388#define swig_binary_op(name) \
2389SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2390 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2391}
2392#if SWIG_OCTAVE_PREREQ(4,4,0)
2393#define swigreg_unary_op(name) \
2394if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2395typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2396#else
2397#define swigreg_unary_op(name) \
2398if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2399octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2400#endif
2401#if SWIG_OCTAVE_PREREQ(4,4,0)
2402#define swigreg_binary_op(name) \
2403if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2404typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2405#else
2406#define swigreg_binary_op(name) \
2407if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2408octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2409#endif
2410
2414 swig_unary_op(transpose);
2415 swig_unary_op(hermitian);
2418
2425#if !SWIG_OCTAVE_PREREQ(4,2,0)
2428#endif
2441
2443#if SWIG_OCTAVE_PREREQ(4,4,0)
2444 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2445#endif
2446 swigreg_unary_op(not);
2447 swigreg_unary_op(uplus);
2448 swigreg_unary_op(uminus);
2449 swigreg_unary_op(transpose);
2450 swigreg_unary_op(hermitian);
2451 swigreg_unary_op(incr);
2452 swigreg_unary_op(decr);
2453 }
2454 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2455#if SWIG_OCTAVE_PREREQ(4,4,0)
2456 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2457#endif
2458 swigreg_binary_op(add);
2459 swigreg_binary_op(sub);
2460 swigreg_binary_op(mul);
2461 swigreg_binary_op(div);
2462 swigreg_binary_op(pow);
2463 swigreg_binary_op(ldiv);
2464#if !SWIG_OCTAVE_PREREQ(4,2,0)
2465 swigreg_binary_op(lshift);
2466 swigreg_binary_op(rshift);
2467#endif
2474 swigreg_binary_op(el_mul);
2475 swigreg_binary_op(el_div);
2476 swigreg_binary_op(el_pow);
2477 swigreg_binary_op(el_ldiv);
2478 swigreg_binary_op(el_and);
2479 swigreg_binary_op(el_or);
2480 }
2482 // here we assume that tid are conseq integers increasing from zero, and
2483 // that our tid is the last one. might be better to have explicit string
2484 // list of types we should bind to, and use lookup_type to resolve their tid.
2485
2487 SWIG_InstallBinaryOps(tid, tid);
2488 for (int j = 0; j < tid; ++j) {
2489 SWIG_InstallBinaryOps(j, tid);
2490 SWIG_InstallBinaryOps(tid, j);
2491 }
2492 }
2493
2494SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2495 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2496
2497 if (ptr) {
2498#ifdef SWIG_DIRECTORS
2499 Swig::Director *d = Swig::get_rtdir(ptr);
2500 if (d && Swig::swig_director_get_self(d))
2501 return Swig::swig_director_get_self(d)->as_value();
2502#endif
2503 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2504 }
2505 return octave_value(Matrix()); // null matrix
2506}
2507
2508SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2509 if (
2510#if SWIG_OCTAVE_PREREQ(4,4,0)
2511 ov.iscell()
2512#else
2513 ov.is_cell()
2514#endif
2515 && ov.rows() == 1 && ov.columns() == 1)
2516 ov = ov.cell_value()(0);
2517 if (!ov.is_defined() ||
2518 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2519 if (ptr)
2520 *ptr = 0;
2522 }
2523 if (ov.type_id() != octave_swig_ref::static_type_id())
2524 return SWIG_ERROR;
2525 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2526 octave_swig_type *ost = osr->get_ptr();
2527 return ost->cast(ptr, type, own, flags);
2528}
2529
2530SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2531 return new octave_swig_packed(type, (char *) ptr, sz);
2532}
2533
2534SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2535 if (!ov.is_defined())
2536 return SWIG_ERROR;
2537 if (ov.type_id() != octave_swig_packed::static_type_id())
2538 return SWIG_ERROR;
2539 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2540 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2541}
2542
2543SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2544 module_ns->assign(name, ov);
2545}
2546
2548#if SWIG_OCTAVE_PREREQ(6,0,0)
2549 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2550 return interp->global_varval(name);
2551#else
2552#if SWIG_OCTAVE_PREREQ(4,4,0)
2553 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2554 return symtab.global_varval(name);
2555#else
2556 return get_global_value(name, true);
2557#endif
2558#endif
2559}
2560
2561SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2562#if SWIG_OCTAVE_PREREQ(6,0,0)
2563 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2564 interp->global_assign(name, value);
2565#elif SWIG_OCTAVE_PREREQ(4,4,0)
2566 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2567 symtab.global_assign(name, value);
2568#else
2569 set_global_value(name, value);
2570#endif
2571}
2572
2574#if SWIG_OCTAVE_PREREQ(4,4,0)
2575 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2576#if SWIG_OCTAVE_PREREQ(6,0,0)
2577 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2578 interp->assign(name, interp->global_varval(name));
2579 octave::tree_evaluator& tree_eval = interp->get_evaluator();
2580#if SWIG_OCTAVE_PREREQ(8,0,0)
2581 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2582#else
2583 octave::call_stack& callStack = tree_eval.get_call_stack();
2584 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2585#endif
2586 octave::symbol_record sym=symscope.lookup_symbol(name);
2587 stackFrame->mark_global(sym);
2588#else
2589 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2590 symscope.assign(name, symtab.global_varval(name));
2591 symscope.mark_global(name);
2592#endif
2593#else
2594#if !SWIG_OCTAVE_PREREQ(3,2,0)
2595 link_to_global_variable(curr_sym_tab->lookup(name, true));
2596#else
2597#if !SWIG_OCTAVE_PREREQ(3,8,0)
2598 symbol_table::varref(name);
2599#endif
2600 symbol_table::mark_global(name);
2601#endif
2602#endif
2603}
2604
2606 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2607 if (!ov.is_defined() ||
2608 ov.type_id() != octave_swig_packed::static_type_id())
2609 return 0;
2610 const octave_swig_packed* osp =
2611 static_cast < const octave_swig_packed *> (ov.internal_rep());
2612 swig_module_info *pointer = 0;
2613 osp->copy(0, &pointer, sizeof(swig_module_info *));
2614 return pointer;
2615}
2616
2617SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2618 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2620}
2621
2622
2623SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
2624 if (obj.is_string())
2625 error("%s", obj.string_value().c_str());
2626 else
2627 error("C++ side threw an exception of type %s", type);
2628}
2629
2630
2631
2632#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2633
2634#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2635
2636
2637
2638/* -------- TYPES TABLE (BEGIN) -------- */
2639
2640#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2641#define SWIGTYPE_p_char swig_types[1]
2642#define SWIGTYPE_p_double swig_types[2]
2643#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2644#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2645#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2646#define SWIGTYPE_p_int swig_types[6]
2647#define SWIGTYPE_p_p_char swig_types[7]
2648#define SWIGTYPE_p_unsigned_int swig_types[8]
2650static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2651#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2652#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2653
2654/* -------- TYPES TABLE (END) -------- */
2655
2656
2657#ifdef __cplusplus
2658#include <utility>
2659/* SwigValueWrapper is described in swig.swg */
2660template<typename T> class SwigValueWrapper {
2661 struct SwigSmartPointer {
2662 T *ptr;
2663 SwigSmartPointer(T *p) : ptr(p) { }
2664 ~SwigSmartPointer() { delete ptr; }
2665 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
2666 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
2667 } pointer;
2668 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
2669 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
2670public:
2671 SwigValueWrapper() : pointer(0) { }
2672 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
2673#if __cplusplus >=201103L
2674 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
2675 operator T&&() const { return std::move(*pointer.ptr); }
2676#else
2677 operator T&() const { return *pointer.ptr; }
2678#endif
2679 T *operator&() const { return pointer.ptr; }
2680 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2681};
2682
2683/*
2684 * SwigValueInit() is a generic initialisation solution as the following approach:
2685 *
2686 * T c_result = T();
2687 *
2688 * doesn't compile for all types for example:
2689 *
2690 * unsigned int c_result = unsigned int();
2691 */
2692template <typename T> T SwigValueInit() {
2693 return T();
2694}
2695
2696#if __cplusplus >=201103L
2697# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2698#else
2699# define SWIG_STD_MOVE(OBJ) OBJ
2700#endif
2701
2702#endif
2703
2704
2705#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2706#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2707
2708
2709#include <stdexcept>
2710
2711
2712// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2713#undef PACKAGE
2714#undef VERSION
2715
2716#include "plplotP.h"
2717
2718// Temporary fix for problems with -fvisibility=hidden and octave headers.
2719#ifdef OCTAVE_EXPORT
2720 #if defined ( __GNUC__ ) && __GNUC__ > 3
2721 #undef OCTAVE_EXPORT
2722 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2723 #endif
2724#endif
2725
2726
2727
2728// I hate global variables but this is the best way I can think of
2729// to manage consistency checking among function arguments.
2730 static PLINT Alen = 0;
2731 static PLINT Xlen = 0, Ylen = 0;
2732
2733
2734// Convenience functions copied from matwrap-based approach (currently
2735// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2736// tricky scalar case and also adopted so that the resulting
2737// swig-generated source code will look similar to the matwrap-generated
2738// source code.
2739
2740 inline int max( int a, int b )
2741 {
2742 return a >= b ? a : b;
2743 }
2744 inline int min( int a, int b )
2745 {
2746 return a >= b ? a : b;
2747 }
2748
2749//
2750// Function to get the total length (rows*columns) of an octave object of
2751// arbitrary type.
2752// Arguments:
2753// 1) The octave object.
2754//
2755// If the object is a scalar, the array length is 1.
2756//
2757 static int
2758 _arraylen( const octave_value &o_obj )
2759 {
2760 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2761 // max is necessary because sometimes
2762 // rows() or columns() return -1 or 0 for
2763 // scalars.
2764 }
2765
2766//
2767// Function to get the number of dimensions of an object.
2768//
2769 static int
2770 _n_dims( const octave_value &o_obj )
2771 {
2772 if ( max( o_obj.columns(), 1 ) > 1 )
2773 return 2;
2774 // max is necessary because sometimes
2775 // rows() or columns() return -1 or 0 for
2776 // scalars.
2777 else if ( max( o_obj.rows(), 1 ) > 1 )
2778 return 1;
2779 else
2780 return 0;
2781 }
2782
2783//
2784// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2785//
2786 static inline int
2787 _dim( const octave_value &o_obj, int dim_idx )
2788 {
2789 if ( dim_idx == 0 )
2790 return max( o_obj.rows(), 0 );
2791 // max is necessary because sometimes
2792 // rows() or columns() return -1 or 0 for
2793 // scalars.
2794 else if ( dim_idx == 1 )
2795 return max( o_obj.columns(), 0 );
2796 else
2797 return 1;
2798 }
2799
2800//
2801// The following function converts an array of doubles into some other
2802// numeric type. Arguments:
2803// 1) Where to store the result. The type is determined from the type of
2804// this pointer.
2805// 2) A vector of doubles to convert.
2806// 3) The number of doubles.
2807//
2808 template <class FLOAT>
2809 static inline void
2810 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2811 {
2812 while ( n_el-- > 0 )
2813 *out_arr++ = (FLOAT) ( *in_arr++ );
2814 }
2815
2816 template void _cvt_double_to( int *, double *, unsigned );
2817 template void _cvt_double_to( unsigned *, double *, unsigned );
2818 template void _cvt_double_to( long *, double *, unsigned );
2819 template void _cvt_double_to( unsigned long *, double *, unsigned );
2820 template void _cvt_double_to( short *, double *, unsigned );
2821 template void _cvt_double_to( unsigned short *, double *, unsigned );
2822 template void _cvt_double_to( float *, double *, unsigned );
2823 // Instantiate our templates. Octave uses
2824 // manual template instantiation.
2825
2826//
2827// Convert an array of some other type into an array of doubles. Arguments:
2828// 1) The array of objects of other type.
2829// 2) The output array of doubles.
2830// 3) The number of elements to convert.
2831//
2832 template <class FLOAT>
2833 static inline void
2834 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2835 {
2836 while ( n_el-- > 0 )
2837 *d_arr++ = double(*arr++);
2838 }
2839
2840 template void _cvt_to_double( int *, double *, unsigned );
2841 template void _cvt_to_double( unsigned *, double *, unsigned );
2842 template void _cvt_to_double( long *, double *, unsigned );
2843 template void _cvt_to_double( unsigned long *, double *, unsigned );
2844 template void _cvt_to_double( short *, double *, unsigned );
2845 template void _cvt_to_double( unsigned short *, double *, unsigned );
2846 template void _cvt_to_double( float *, double *, unsigned );
2847 // Instantiate our templates. Octave uses
2848 // manual template instantiation.
2849
2850
2851 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2852 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2853 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2854 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2855 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2857 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2858
2859
2860#include <iostream>
2861
2862 octave_function *fcnMapForm;
2863 std::string nameMapForm;
2864
2866 {
2867 octave_idx_type i;
2868 octave_value_list functionArguments;
2869 octave_value_list retval;
2870
2871 Matrix xin( n, 1 );
2872 Matrix yin( n, 1 );
2873 Matrix xout;
2874 Matrix yout;
2875
2876 for ( i = 0; i < n; i++ )
2877 {
2878 xin( i, 0 ) = x[i];
2879 yin( i, 0 ) = y[i];
2880 }
2881
2882 functionArguments( 0 ) = xin;
2883 functionArguments( 1 ) = yin;
2884
2885 if ( fcnMapForm != NULL )
2886#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2887 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2888#else
2889 retval = feval( fcnMapForm, functionArguments, 1 );
2890#endif
2891 else
2892#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2893 retval = octave::feval( nameMapForm, functionArguments, 1 );
2894#else
2895 retval = feval( nameMapForm, functionArguments, 1 );
2896#endif
2897
2898 if ( retval.length() >= 2 )
2899 {
2900 xout = retval( 0 ).matrix_value();
2901 yout = retval( 1 ).matrix_value();
2902
2903 for ( i = 0; i < n; i++ )
2904 {
2905 x[i] = xout( i, 0 );
2906 y[i] = yout( i, 0 );
2907 }
2908 }
2909 }
2910
2911
2912 octave_function *fcnLabelFunc;
2913 std::string nameLabelFunc;
2914
2915 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2916 {
2917 int i;
2918 octave_value_list functionArguments;
2919 octave_value_list retval;
2920
2921 Matrix inAxis( 1, 1 );
2922 Matrix inValue( 1, 1 );
2923 inAxis( 0, 0 ) = axis;
2924 inValue( 0, 0 ) = value;
2925
2926 functionArguments( 0 ) = inAxis;
2927 functionArguments( 1 ) = inValue;
2928
2929 if ( fcnLabelFunc != NULL )
2930#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2931 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2932#else
2933 retval = feval( fcnLabelFunc, functionArguments, 1 );
2934#endif
2935 else
2936#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2937 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2938#else
2939 retval = feval( nameLabelFunc, functionArguments, 1 );
2940#endif
2941
2942 strncpy( label, retval( 0 ).string_value().c_str(), length );
2943 }
2944
2945
2946 octave_function *fcnCoordTrans;
2947 std::string nameCoordTrans;
2948
2949 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2950 {
2951 octave_idx_type i;
2952 octave_value_list functionArguments;
2953 octave_value_list retval;
2954
2955 Matrix xin( 1, 1 );
2956 Matrix yin( 1, 1 );
2957 Matrix xout;
2958 Matrix yout;
2959
2960 xin( 0, 0 ) = x;
2961 yin( 0, 0 ) = y;
2962
2963 functionArguments( 0 ) = xin;
2964 functionArguments( 1 ) = yin;
2965
2966 if ( fcnCoordTrans != NULL )
2967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2968 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2969#else
2970 retval = feval( fcnCoordTrans, functionArguments, 1 );
2971#endif
2972 else
2973#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2974 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2975#else
2976 retval = feval( nameCoordTrans, functionArguments, 1 );
2977#endif
2978
2979 if ( retval.length() >= 2 )
2980 {
2981 xout = retval( 0 ).matrix_value();
2982 yout = retval( 1 ).matrix_value();
2983
2984 *xt = xout( 0, 0 );
2985 *yt = yout( 0, 0 );
2986 }
2987 }
2988
2989
2990 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2991 {
2992 PLINT i;
2993 printf( "nlegend =%d\n", nlegend );
2994 for ( i = 0; i < nlegend; i++ )
2995 {
2996 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2997 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2998 printf( "text[%d] =%s\n", i, text[i] );
2999 }
3000 }
3001
3002
3003#include <limits.h>
3004#if !defined(SWIG_NO_LLONG_MAX)
3005# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3006# define LLONG_MAX __LONG_LONG_MAX__
3007# define LLONG_MIN (-LLONG_MAX - 1LL)
3008# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3009# endif
3010#endif
3011
3012
3013 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
3014 {
3015 if (!ov.is_scalar_type())
3016 return SWIG_TypeError;
3017 if (ov.is_complex_scalar())
3018 return SWIG_TypeError;
3019 if (ov.is_double_type()||ov.is_single_type()) {
3020 double v=ov.double_value();
3021 if (v!=floor(v))
3022 return SWIG_TypeError;
3023 }
3024 if (val)
3025 *val = ov.long_value();
3026 return SWIG_OK;
3027 }
3028
3029
3030SWIGINTERN int
3031SWIG_AsVal_int (octave_value obj, int *val)
3032{
3033 long v;
3034 int res = SWIG_AsVal_long (obj, &v);
3035 if (SWIG_IsOK(res)) {
3036 if ((v < INT_MIN || v > INT_MAX)) {
3037 return SWIG_OverflowError;
3038 } else {
3039 if (val) *val = static_cast< int >(v);
3040 }
3041 }
3042 return res;
3043}
3044
3045
3046 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 )
3047 {
3048 PLGraphicsIn gin;
3049 int status; status = plGetCursor( &gin );
3050 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
3051 strncpy( string, gin.string, PL_MAXKEY - 1 );
3052 string[PL_MAXKEY - 1] = '\0';
3053
3054 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
3055 return status;
3056 }
3057
3058
3059SWIGINTERN int
3060SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
3061{
3062 if (
3063#if SWIG_OCTAVE_PREREQ(4,4,0)
3064 ov.iscell()
3065#else
3066 ov.is_cell()
3067#endif
3068 && ov.rows() == 1 && ov.columns() == 1)
3069 ov = ov.cell_value()(0);
3070
3071 if (ov.is_string()) {
3072 std::string str=ov.string_value();
3073 size_t len=str.size();
3074 char* cstr=(char*)str.c_str();
3075 if (alloc) {
3076 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3077 *alloc = SWIG_NEWOBJ;
3078 } else if (cptr)
3079 *cptr = cstr;
3080 if (psize)
3081 *psize = len + 1;
3082 } else if (!ov.is_defined() || (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
3083 if (cptr)
3084 *cptr = 0;
3085 } else {
3086 return SWIG_TypeError;
3087 }
3088 return SWIG_OK;
3089}
3090
3091
3092
3093
3094
3096 {
3097 return octave_value(value);
3098 }
3099
3100
3101SWIGINTERNINLINE octave_value
3103{
3104 return SWIG_From_long (value);
3105}
3106
3107
3109 {
3110 return octave_value(value);
3111 }
3112
3113
3114// Translates relative device coordinates to world coordinates.
3115 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
3116 {
3117 PLGraphicsIn gin;
3118 int st;
3119 gin.dX = x_in; gin.dY = y_in;
3120 st = plTranslateCursor( &gin );
3121 *x = gin.wX; *y = gin.wY;
3122 return st;
3123 }
3124
3125
3126 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
3127 {
3128 if (!ov.is_scalar_type())
3129 return SWIG_TypeError;
3130 if (ov.is_complex_scalar())
3131 return SWIG_TypeError;
3132 if (val)
3133 *val = ov.double_value();
3134 return SWIG_OK;
3135 }
3136
3137
3138// Create 1d stripchart
3139
3140 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3141 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3142 PLFLT xlpos, PLFLT ylpos,
3143 PLBOOL y_ascl, PLBOOL acc,
3144 PLINT colbox, PLINT collab,
3145 const PLINT *colline, const PLINT *styline,
3146 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3147 const char *labx, const char *laby, const char *labtop )
3148 {
3149 const char *legline[4];
3150 legline[0] = legline1; legline[1] = legline2;
3151 legline[2] = legline3; legline[3] = legline4;
3152 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3153 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3154 labx, laby, labtop );
3155 }
3156
3157
3158// One more hack. As it is not possible (and would not be desirable) to pass
3159// an Octave function to plcont(), I have defined three plcont():
3160// plcont uses a defined here xform()
3161// plcont0 uses pltr0()
3162// plcont1 uses pltr1()
3163// plcont2 uses pltr2()
3164// plcont2p uses pltr2p()
3165//
3166// Also, as plplot expect vectorized bidimensional arrays, I provided a
3167// f2c, which is a #define that does the necessary conversion.
3168//
3169
3170 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3171 {
3172 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3173 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3174 }
3175
3176// convert from Fortran like arrays (one vector), to C like 2D arrays
3177
3178#define f2c( f, ff, nx, ny ) \
3179 PLFLT * *ff; \
3180 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3181 for ( int i = 0; i < nx; i++ ) { \
3182 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3183 for ( int j = 0; j < ny; j++ ) \
3184 *( ff[i] + j ) = *( f + nx * j + i );}
3185
3186// simpler plcont() for use with xform()
3187
3188 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3189 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3190 {
3191 f2c( f, ff, nx, ny );
3192 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3193 }
3194
3195// plcont() for use with pltr0() NOT TESTED
3196
3197 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3198 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3199 {
3200 f2c( f, ff, nx, ny );
3201 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3202 }
3203
3204// plcont() for use with pltr1()
3205
3206 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3207 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3208 {
3209 PLcGrid grid1;
3210 grid1.nx = nx; grid1.ny = ny;
3211 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3212 f2c( f, ff, nx, ny );
3213 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3214 }
3215
3216// plcont() for use with pltr2()
3217 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3218 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3219 {
3220 PLcGrid2 grid2;
3221 f2c( xg, xgg, nx, ny );
3222 f2c( yg, ygg, nx, ny );
3223 grid2.nx = nx; grid2.ny = ny;
3224 grid2.xg = xgg; grid2.yg = ygg;
3225 f2c( f, ff, nx, ny );
3226 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3227 }
3228
3229// plcont() for use with pltr2p()
3230
3231 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3232 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3233 {
3234 PLcGrid2 grid2;
3235 f2c( xg, xgg, nx, ny );
3236 f2c( yg, ygg, nx, ny );
3237 grid2.nx = nx; grid2.ny = ny;
3238 grid2.xg = xgg; grid2.yg = ygg;
3239 f2c( f, ff, nx, ny );
3240 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3241 }
3242
3243
3244 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3245 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3246 PLFLT *zg, int type, PLFLT data )
3247 {
3248 f2c( zg, zgg, nptsx, nptsy );
3249 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3250 for ( int i = 0; i < nptsx; i++ )
3251 for ( int j = 0; j < nptsy; j++ )
3252 *( zg + nptsx * j + i ) = zgg[i][j];
3253 }
3254
3255
3256// Plots a mesh representation of the function z[x][y].
3257
3258 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3259 {
3260 f2c( z, zz, nx, ny );
3261 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3262 }
3263
3264// Plots a mesh representation of the function z[x][y] with contour
3265
3266 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3267 {
3268 f2c( z, zz, nx, ny );
3269 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3270 }
3271
3272
3273// Plots a 3-d representation of the function z[x][y].
3274 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3275 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3276 {
3277 f2c( z, zz, nx, ny );
3278 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3279 }
3280
3281// Plots a 3-d representation of the function z[x][y] with contour
3282 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3283 PLINT nx, PLINT ny, PLINT opt,
3284 const PLFLT *clevel, PLINT nlevel )
3285 {
3286 f2c( z, zz, nx, ny );
3287 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3288 }
3289// Plots a 3-d representation of the function z[x][y] with contour with y
3290// index limits
3291 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3292 PLINT nx, PLINT ny, PLINT opt,
3293 const PLFLT * clevel, PLINT nlevel,
3294 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3295 {
3296 f2c( z, zz, nx, ny );
3297 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3298 indexxmin, indexxmax, indexymin, indexymax );
3299 }
3300
3301
3302 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3303 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3304 {
3305 f2c( z, zz, nx, ny );
3306 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3307 }
3308
3309 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3310 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3311 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3312 {
3313 f2c( z, zz, nx, ny );
3314 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3315 indexxmin, indexxmax, indexymin, indexymax );
3316 }
3317
3318
3319// The same as in plcont. I have hardcoded the first function pointer
3320// to plfill(). The second function pointer will use the same convention
3321// as in plcont().
3322//
3323
3324// the simpler plshade()
3325 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3326 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3327 PLFLT shade_min, PLFLT shade_max,
3328 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3329 PLINT min_color, PLINT min_width,
3330 PLINT max_color, PLINT max_width,
3331 PLINT rectangular, PLFLT *tr )
3332 {
3333 f2c( a, aa, nx, ny );
3334 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3335 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3336 min_color, min_width, max_color, max_width,
3337 plfill, rectangular, xform, tr );
3338 }
3339
3340// plshade() for use with pltr1
3341 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3342 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3343 PLFLT shade_min, PLFLT shade_max,
3344 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3345 PLINT min_color, PLINT min_width,
3346 PLINT max_color, PLINT max_width,
3347 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3348 {
3349 PLcGrid grid1;
3350 grid1.nx = nx; grid1.ny = ny;
3351 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3352 f2c( a, aa, nx, ny );
3353 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3354 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3355 min_color, min_width, max_color, max_width,
3356 plfill, rectangular, pltr1, &grid1 );
3357 }
3358
3359// plshade() for use with pltr2
3360 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3361 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3362 PLFLT shade_min, PLFLT shade_max,
3363 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3364 PLINT min_color, PLINT min_width,
3365 PLINT max_color, PLINT max_width,
3366 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3367 {
3368 PLcGrid2 grid2;
3369 f2c( xg, xgg, nx, ny );
3370 f2c( yg, ygg, nx, ny );
3371 grid2.nx = nx; grid2.ny = ny;
3372 grid2.xg = xgg; grid2.yg = ygg;
3373 f2c( a, aa, nx, ny );
3374 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3375 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3376 min_color, min_width, max_color, max_width,
3377 plfill, rectangular, pltr2, &grid2 );
3378 }
3379
3380
3381
3382 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3383 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3384 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3385 PLINT cont_color, PLINT cont_width,
3386 PLINT rectangular )
3387 {
3388 f2c( a, aa, nx, ny );
3389 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3390 clevel, nlevel, fill_width, cont_color, cont_width,
3391 plfill, rectangular, NULL, NULL );
3392 }
3393
3394 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3395 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3396 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3397 PLINT cont_color, PLINT cont_width,
3398 PLINT rectangular, PLFLT *tr )
3399 {
3400 f2c( a, aa, nx, ny );
3401 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3402 clevel, nlevel, fill_width, cont_color, cont_width,
3403 plfill, rectangular, xform, tr );
3404 }
3405
3406 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3407 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3408 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3409 PLINT cont_color, PLINT cont_width,
3410 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3411 {
3412 PLcGrid grid1;
3413 grid1.nx = nx; grid1.ny = ny;
3414 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3415
3416 f2c( a, aa, nx, ny );
3417 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3418 clevel, nlevel, fill_width, cont_color, cont_width,
3419 plfill, rectangular, pltr1, &grid1 );
3420 }
3421
3422 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3423 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3424 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3425 PLINT cont_color, PLINT cont_width,
3426 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3427 {
3428 PLcGrid2 grid2;
3429 f2c( xg, xgg, nx, ny );
3430 f2c( yg, ygg, nx, ny );
3431 grid2.nx = nx; grid2.ny = ny;
3432 grid2.xg = xgg; grid2.yg = ygg;
3433 f2c( a, aa, nx, ny );
3434 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3435 clevel, nlevel, fill_width, cont_color, cont_width,
3436 plfill, rectangular, pltr2, &grid2 );
3437 }
3438
3439
3440// Plot an array of vector arrows - uses the same function pointer
3441// convention as plcont
3442
3443 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3444 {
3445 f2c( u, uu, nx, ny );
3446 f2c( v, vv, nx, ny );
3447 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3448 }
3449
3450// plvect() for use with pltr1
3451 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3452 {
3453 PLcGrid grid1;
3454 grid1.nx = nx; grid1.ny = ny;
3455 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3456 f2c( u, uu, nx, ny );
3457 f2c( v, vv, nx, ny );
3458 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3459 }
3460
3461// plvect() for use with pltr2
3462 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3463 {
3464 PLcGrid2 grid2;
3465 f2c( xg, xgg, nx, ny );
3466 f2c( yg, ygg, nx, ny );
3467 grid2.nx = nx; grid2.ny = ny;
3468 grid2.xg = xgg; grid2.yg = ygg;
3469 f2c( u, uu, nx, ny );
3470 f2c( v, vv, nx, ny );
3471 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3472 }
3473
3474
3475// Plot an image with distortion - uses the same function pointer
3476 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3477 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3478 PLFLT zmin, PLFLT zmax,
3479 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3480 {
3481 f2c( a, aa, nx, ny );
3482 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3483 }
3484
3485// Plot an image with distortion - uses the same function pointer
3486// convention as plcont
3487 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3488 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3489 PLFLT zmin, PLFLT zmax,
3490 PLFLT valuemin, PLFLT valuemax )
3491 {
3492 f2c( a, aa, nx, ny );
3493 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3494 }
3495
3496 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3497 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3498 PLFLT zmin, PLFLT zmax,
3499 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3500 {
3501 f2c( a, aa, nx, ny );
3502 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3503 }
3504
3505// plimagefr() for use with pltr1
3506 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3507 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3508 PLFLT zmin, PLFLT zmax,
3509 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3510 {
3511 PLcGrid grid1;
3512 grid1.nx = nx + 1; grid1.ny = ny + 1;
3513 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3514 f2c( a, aa, nx, ny );
3515 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3516 }
3517
3518// plimagefr() for use with pltr2
3519 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3520 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3521 PLFLT zmin, PLFLT zmax,
3522 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3523 {
3524 PLcGrid2 grid2;
3525 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3526 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3527 grid2.nx = nx + 1; grid2.ny = ny + 1;
3528 grid2.xg = xgg; grid2.yg = ygg;
3529 f2c( a, aa, nx, ny );
3530 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3531 }
3532
3533
3534
3535 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3536 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3537 PLFLT x_length, PLFLT y_length,
3538 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3539 PLFLT low_cap_color, PLFLT high_cap_color,
3540 PLINT cont_color, PLFLT cont_width,
3541 PLINT n_labels, const PLINT *label_opts, const char **label,
3542 PLINT n_axes, const char ** axis_opts,
3543 const PLFLT *ticks, const PLINT *sub_ticks,
3544 const PLINT *n_values, const PLFLT *a )
3545 {
3546 PLINT nx, ny, i;
3547 nx = n_axes;
3548 ny = -1;
3549 for ( i = 0; i < nx; i++ )
3550 if ( n_values[i] > ny )
3551 ny = n_values[i];
3552 f2c( a, aa, nx, ny );
3553 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3554 opt, position, x, y,
3555 x_length, y_length,
3556 bg_color, bb_color, bb_style,
3557 low_cap_color, high_cap_color,
3558 cont_color, cont_width,
3559 n_labels, label_opts, label,
3560 n_axes, axis_opts,
3561 ticks, sub_ticks,
3562 n_values, aa );
3563 }
3564
3565
3566
3567 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3568 {
3569 if (!ov.is_scalar_type())
3570 return SWIG_TypeError;
3571 if (ov.is_complex_scalar())
3572 return SWIG_TypeError;
3573 if (ov.is_double_type()||ov.is_single_type()) {
3574 double v=ov.double_value();
3575 if (v<0)
3576 return SWIG_OverflowError;
3577 if (v!=floor(v))
3578 return SWIG_TypeError;
3579 }
3580 if (ov.is_int8_type()||ov.is_int16_type()||
3581 ov.is_int32_type()) {
3582 long v=ov.long_value();
3583 if (v<0)
3584 return SWIG_OverflowError;
3585 }
3586 if (ov.is_int64_type()) {
3587 long long v=ov.int64_scalar_value().value();
3588 if (v<0)
3589 return SWIG_OverflowError;
3590 }
3591 if (val)
3592 *val = ov.ulong_value();
3593 return SWIG_OK;
3594 }
3595
3596
3597SWIGINTERN int
3598SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3599{
3600 unsigned long v;
3601 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3602 if (SWIG_IsOK(res)) {
3603 if ((v > UINT_MAX)) {
3604 return SWIG_OverflowError;
3605 } else {
3606 if (val) *val = static_cast< unsigned int >(v);
3607 }
3608 }
3609 return res;
3610}
3611
3612
3614 {
3615 return octave_value(value);
3616 }
3617
3618
3619SWIGINTERNINLINE octave_value
3621{
3623}
3624
3625
3626SWIGINTERN int
3627SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3628{
3629 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3630 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3631 if (SWIG_IsOK(res)) {
3632 /* special case of single char conversion when we don't need space for NUL */
3633 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3634 if (csize <= size) {
3635 if (val) {
3636 if (csize) memcpy(val, cptr, csize*sizeof(char));
3637 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3638 }
3639 if (alloc == SWIG_NEWOBJ) {
3640 delete[] cptr;
3641 res = SWIG_DelNewMask(res);
3642 }
3643 return res;
3644 }
3645 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3646 }
3647 return SWIG_TypeError;
3648}
3649
3650
3653{
3654 static swig_type_info* info = 0;
3655 if (!info) {
3656 info = SWIG_TypeQuery("_p_char");
3657 }
3658 return info;
3659}
3660
3661
3662SWIGINTERNINLINE octave_value
3663SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3664{
3665 return std::string(carray,carray+size);
3666}
3667
3668
3669SWIGINTERN size_t
3670SWIG_strnlen(const char* s, size_t maxlen)
3671{
3672 const char *p;
3673 for (p = s; maxlen-- && *p; p++)
3674 ;
3675 return p - s;
3676}
3677
3678
3679SWIGINTERN int
3680SWIG_AsVal_char (octave_value obj, char *val)
3681{
3682 int res = SWIG_AsCharArray(obj, val, 1);
3683 if (!SWIG_IsOK(res)) {
3684 long v;
3685 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3686 if (SWIG_IsOK(res)) {
3687 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3688 if (val) *val = static_cast< char >(v);
3689 } else {
3690 res = SWIG_OverflowError;
3691 }
3692 }
3693 }
3694 return res;
3695}
3696
3697static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3698Set up transformation from metafile coordinates\n\
3699\n\
3700DESCRIPTION:\n\
3701\n\
3702 Set up transformation from metafile coordinates. The size of the plot\n\
3703 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3704 general-purpose facility just yet (not sure why the user would need\n\
3705 it, for one).\n\
3706\n\
3707 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3708 dimypmm)\n\
3709\n\
3710 This function is not used in any examples.\n\
3711\n\
3712\n\
3713\n\
3714SYNOPSIS:\n\
3715\n\
3716plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3717\n\
3718ARGUMENTS:\n\
3719\n\
3720 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3721\n\
3722 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3723\n\
3724 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3725\n\
3726 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3727\n\
3728 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3729\n\
3730 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3731";
3732static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3733Set the cmap0 palette using the specified cmap0*.pal format file\n\
3734\n\
3735DESCRIPTION:\n\
3736\n\
3737 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3738\n\
3739 Redacted form: plspal0(filename)\n\
3740\n\
3741 This function is in example 16.\n\
3742\n\
3743\n\
3744\n\
3745SYNOPSIS:\n\
3746\n\
3747plspal0(filename)\n\
3748\n\
3749ARGUMENTS:\n\
3750\n\
3751 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3752 containing the name of the cmap0*.pal file. If this string is\n\
3753 empty, use the default cmap0*.pal file.\n\
3754";
3755static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3756Set the cmap1 palette using the specified cmap1*.pal format file\n\
3757\n\
3758DESCRIPTION:\n\
3759\n\
3760 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3761\n\
3762 Redacted form: plspal1(filename, interpolate)\n\
3763\n\
3764 This function is used in example 16.\n\
3765\n\
3766\n\
3767\n\
3768SYNOPSIS:\n\
3769\n\
3770plspal1(filename, interpolate)\n\
3771\n\
3772ARGUMENTS:\n\
3773\n\
3774 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3775 containing the name of the cmap1*.pal file. If this string is\n\
3776 empty, use the default cmap1*.pal file.\n\
3777\n\
3778 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3779 columns containing the intensity index, r, g, b, alpha and\n\
3780 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3781 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3782 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3783 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3784 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3785 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3786 are used instead to set the cmap1 palette directly with a call to\n\
3787 plscmap1a.\n\
3788";
3789static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3790Draw a line in 3 space\n\
3791\n\
3792DESCRIPTION:\n\
3793\n\
3794 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3795 first set up the viewport, the 2d viewing window (in world\n\
3796 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3797 more info.\n\
3798\n\
3799 Redacted form: plline3(x, y, z)\n\
3800\n\
3801 This function is used in example 18.\n\
3802\n\
3803\n\
3804\n\
3805SYNOPSIS:\n\
3806\n\
3807plline3(n, x, y, z)\n\
3808\n\
3809ARGUMENTS:\n\
3810\n\
3811 n (PLINT, input) : Number of points defining line.\n\
3812\n\
3813 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3814 points.\n\
3815\n\
3816 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3817 points.\n\
3818\n\
3819 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3820 points.\n\
3821";
3822static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3823Magnitude colored plot surface mesh with contour\n\
3824\n\
3825DESCRIPTION:\n\
3826\n\
3827 A more powerful form of plmesh: the surface mesh can be colored\n\
3828 accordingly to the current z value being plotted, a contour plot can\n\
3829 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3830 plotted function border and the base XY plane.\n\
3831\n\
3832 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3833\n\
3834 This function is used in example 11.\n\
3835\n\
3836\n\
3837\n\
3838SYNOPSIS:\n\
3839\n\
3840plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3841\n\
3842ARGUMENTS:\n\
3843\n\
3844 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3845 which the function is evaluated.\n\
3846\n\
3847 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3848 which the function is evaluated.\n\
3849\n\
3850 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3851 plot. Should have dimensions of\n\
3852 nx by\n\
3853 ny.\n\
3854\n\
3855 nx (PLINT, input) : Number of x values at which function is\n\
3856 evaluated.\n\
3857\n\
3858 ny (PLINT, input) : Number of y values at which function is\n\
3859 evaluated.\n\
3860\n\
3861 opt (PLINT, input) : Determines the way in which the surface is\n\
3862 represented. To specify more than one option just add the options,\n\
3863 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3864 showing z as a function of x for each value of y[j] .\n\
3865 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3866 for each value of x[i] .\n\
3867 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3868 at which function is defined.\n\
3869 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3870 the z value being plotted. The color is used from the current\n\
3871 cmap1.\n\
3872 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3873 using parameters\n\
3874 nlevel and\n\
3875 clevel.\n\
3876 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3877 the borders of the plotted function.\n\
3878\n\
3879\n\
3880 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3881 levels.\n\
3882\n\
3883 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3884";
3885static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3886Draw a line between two points, accounting for coordinate transforms\n\
3887\n\
3888DESCRIPTION:\n\
3889\n\
3890 Joins the point (\n\
3891 x1,\n\
3892 y1) to (\n\
3893 x2,\n\
3894 y2) . If a global coordinate transform is defined then the line is\n\
3895 broken in to n segments to approximate the path. If no transform is\n\
3896 defined then this simply acts like a call to pljoin.\n\
3897\n\
3898 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3899\n\
3900 This function is used in example 22.\n\
3901\n\
3902\n\
3903\n\
3904SYNOPSIS:\n\
3905\n\
3906plpath(n, x1, y1, x2, y2)\n\
3907\n\
3908ARGUMENTS:\n\
3909\n\
3910 n (PLINT, input) : number of points to use to approximate the path.\n\
3911\n\
3912 x1 (PLFLT, input) : x coordinate of first point.\n\
3913\n\
3914 y1 (PLFLT, input) : y coordinate of first point.\n\
3915\n\
3916 x2 (PLFLT, input) : x coordinate of second point.\n\
3917\n\
3918 y2 (PLFLT, input) : y coordinate of second point.\n\
3919";
3920static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3921Write text inside the viewport\n\
3922\n\
3923DESCRIPTION:\n\
3924\n\
3925 Writes text at a specified position and inclination within the\n\
3926 viewport. Text is clipped at the viewport boundaries. The reference\n\
3927 point of a string lies along a line passing through the string at half\n\
3928 the height of a capital letter. The position of the reference point\n\
3929 along this line is determined by just, the reference point is placed\n\
3930 at world coordinates (\n\
3931 x,\n\
3932 y) within the viewport. The inclination of the string is specified\n\
3933 in terms of differences of world coordinates making it easy to write\n\
3934 text parallel to a line in a graph.\n\
3935\n\
3936 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3937\n\
3938 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3939\n\
3940\n\
3941\n\
3942SYNOPSIS:\n\
3943\n\
3944plptex(x, y, dx, dy, just, text)\n\
3945\n\
3946ARGUMENTS:\n\
3947\n\
3948 x (PLFLT, input) : x coordinate of reference point of string.\n\
3949\n\
3950 y (PLFLT, input) : y coordinate of reference point of string.\n\
3951\n\
3952 dx (PLFLT, input) : Together with dy, this specifies the\n\
3953 inclination of the string. The baseline of the string is parallel\n\
3954 to a line joining (\n\
3955 x,\n\
3956 y) to (\n\
3957 x+\n\
3958 dx,\n\
3959 y+\n\
3960 dy) .\n\
3961\n\
3962 dy (PLFLT, input) : Together with dx, this specifies the\n\
3963 inclination of the string.\n\
3964\n\
3965 just (PLFLT, input) : Specifies the position of the string relative\n\
3966 to its reference point. If just=0. , the reference point is at\n\
3967 the left and if just=1. , it is at the right of the string. Other\n\
3968 values of just give intermediate justifications.\n\
3969\n\
3970 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3971 written out.\n\
3972";
3973static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3974Set family file parameters\n\
3975\n\
3976DESCRIPTION:\n\
3977\n\
3978 Sets variables dealing with output file familying. Does nothing if\n\
3979 familying not supported by the driver. This routine, if used, must be\n\
3980 called before initializing PLplot. See the PLplot documentation for\n\
3981 more information.\n\
3982\n\
3983 Redacted form: plsfam(fam, num, bmax)\n\
3984\n\
3985 This function is used in examples 14 and 31.\n\
3986\n\
3987\n\
3988\n\
3989SYNOPSIS:\n\
3990\n\
3991plsfam(fam, num, bmax)\n\
3992\n\
3993ARGUMENTS:\n\
3994\n\
3995 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3996 is enabled.\n\
3997\n\
3998 num (PLINT, input) : Current family file number.\n\
3999\n\
4000 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
4001 file.\n\
4002";
4003static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
4004Set y axis parameters\n\
4005\n\
4006DESCRIPTION:\n\
4007\n\
4008 Identical to plsxax, except that arguments are flags for y axis. See\n\
4009 the description of plsxax for more detail.\n\
4010\n\
4011 Redacted form: plsyax(digmax, digits)\n\
4012\n\
4013 This function is used in examples 1, 14, and 31.\n\
4014\n\
4015\n\
4016\n\
4017SYNOPSIS:\n\
4018\n\
4019plsyax(digmax, digits)\n\
4020\n\
4021ARGUMENTS:\n\
4022\n\
4023 digmax (PLINT, input) : Variable to set the maximum number of\n\
4024 digits for the y axis. If nonzero, the printed label will be\n\
4025 switched to a floating-point representation when the number of\n\
4026 digits exceeds digmax.\n\
4027\n\
4028 digits (PLINT, input) : Field digits value. Currently, changing\n\
4029 its value here has no effect since it is set only by plbox or\n\
4030 plbox3. However, the user may obtain its value after a call to\n\
4031 either of these functions by calling plgyax.\n\
4032";
4033static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
4034Get z axis parameters\n\
4035\n\
4036DESCRIPTION:\n\
4037\n\
4038 Identical to plgxax, except that arguments are flags for z axis. See\n\
4039 the description of plgxax for more detail.\n\
4040\n\
4041 Redacted form: plgzax(p_digmax, p_digits)\n\
4042\n\
4043 This function is used in example 31.\n\
4044\n\
4045\n\
4046\n\
4047SYNOPSIS:\n\
4048\n\
4049plgzax(p_digmax, p_digits)\n\
4050\n\
4051ARGUMENTS:\n\
4052\n\
4053 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4054 number of digits for the z axis. If nonzero, the printed label\n\
4055 has been switched to a floating-point representation when the\n\
4056 number of digits exceeds this value.\n\
4057\n\
4058 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4059 number of digits for the numeric labels (z axis) from the last\n\
4060 plot.\n\
4061";
4062static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
4063Set format of numerical label for contours\n\
4064\n\
4065DESCRIPTION:\n\
4066\n\
4067 Set format of numerical label for contours.\n\
4068\n\
4069 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4070\n\
4071 This function is used example 9.\n\
4072\n\
4073\n\
4074\n\
4075SYNOPSIS:\n\
4076\n\
4077pl_setcontlabelformat(lexp, sigdig)\n\
4078\n\
4079ARGUMENTS:\n\
4080\n\
4081 lexp (PLINT, input) : If the contour numerical label is greater\n\
4082 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4083 format is used. Default value of lexp is 4.\n\
4084\n\
4085 sigdig (PLINT, input) : Number of significant digits. Default\n\
4086 value is 2.\n\
4087";
4088static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4089Set pen width\n\
4090\n\
4091DESCRIPTION:\n\
4092\n\
4093 Sets the pen width.\n\
4094\n\
4095 Redacted form: plwidth(width)\n\
4096\n\
4097 This function is used in examples 1 and 2.\n\
4098\n\
4099\n\
4100\n\
4101SYNOPSIS:\n\
4102\n\
4103plwidth(width)\n\
4104\n\
4105ARGUMENTS:\n\
4106\n\
4107 width (PLFLT, input) : The desired pen width. If width is negative\n\
4108 or the same as the previous value no action is taken. width = 0.\n\
4109 should be interpreted as as the minimum valid pen width for the\n\
4110 device. The interpretation of positive width values is also\n\
4111 device dependent.\n\
4112";
4113static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4114Get parameters that define current plot-space window\n\
4115\n\
4116DESCRIPTION:\n\
4117\n\
4118 Get relative minima and maxima that define current plot-space window.\n\
4119 If plsdiplt has not been called the default values pointed to by\n\
4120 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4121\n\
4122 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4123\n\
4124 This function is used in example 31.\n\
4125\n\
4126\n\
4127\n\
4128SYNOPSIS:\n\
4129\n\
4130plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4131\n\
4132ARGUMENTS:\n\
4133\n\
4134 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4135 minimum in x.\n\
4136\n\
4137 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4138 minimum in y.\n\
4139\n\
4140 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4141 maximum in x.\n\
4142\n\
4143 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4144 maximum in y.\n\
4145";
4146static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4147Set the cmap1 argument range for continuous color plots\n\
4148\n\
4149DESCRIPTION:\n\
4150\n\
4151 Set the cmap1 argument range for continuous color plots that\n\
4152 corresponds to the range of data values. The maximum range\n\
4153 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4154 the cmap1 argument range that is specified with this routine, the\n\
4155 smaller the subset of the cmap1 color palette that is used to\n\
4156 represent the continuous data being plotted. If\n\
4157 min_color is greater than\n\
4158 max_color or\n\
4159 max_color is greater than 1.0 or\n\
4160 min_color is less than 0.0 then no change is made to the cmap1\n\
4161 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4162\n\
4163 Redacted form: plscmap1_range(min_color, max_color)\n\
4164\n\
4165 This function is currently used in example 33.\n\
4166\n\
4167\n\
4168\n\
4169SYNOPSIS:\n\
4170\n\
4171plscmap1_range(min_color, max_color)\n\
4172\n\
4173ARGUMENTS:\n\
4174\n\
4175 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4176 than 0.0, then 0.0 is used instead.\n\
4177\n\
4178 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4179 than 1.0, then 1.0 is used instead.\n\
4180";
4181static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4182Select standard viewport\n\
4183\n\
4184DESCRIPTION:\n\
4185\n\
4186 Selects the largest viewport within the subpage that leaves a standard\n\
4187 margin (left-hand margin of eight character heights, and a margin\n\
4188 around the other three sides of five character heights).\n\
4189\n\
4190 Redacted form: plvsta()\n\
4191\n\
4192 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4193\n\
4194\n\
4195\n\
4196SYNOPSIS:\n\
4197\n\
4198plvsta()\n\
4199";
4200static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4201Load Hershey fonts\n\
4202\n\
4203DESCRIPTION:\n\
4204\n\
4205 Loads the Hershey fonts used for text and symbols. This routine may\n\
4206 be called before or after initializing PLplot. If not explicitly\n\
4207 called before PLplot initialization, then by default that\n\
4208 initialization loads Hershey fonts with the extended character set.\n\
4209 This routine only has a practical effect for devices that still use\n\
4210 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4211 system fonts instead of Hershey fonts).\n\
4212\n\
4213 Redacted form: plfontld(fnt)\n\
4214\n\
4215 This function is used in examples 1 and 7.\n\
4216\n\
4217\n\
4218\n\
4219SYNOPSIS:\n\
4220\n\
4221plfontld(fnt)\n\
4222\n\
4223ARGUMENTS:\n\
4224\n\
4225 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4226 A zero value specifies Hershey fonts with the standard character\n\
4227 set and a non-zero value (the default assumed if plfontld is never\n\
4228 called) specifies Hershey fonts with the extended character set.\n\
4229";
4230static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4231Draw error bars in x direction\n\
4232\n\
4233DESCRIPTION:\n\
4234\n\
4235 Draws a set of n error bars in x direction, the i\'th error bar\n\
4236 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4237 of the error bars are of length equal to the minor tick length\n\
4238 (settable using plsmin).\n\
4239\n\
4240 Redacted form: General: plerrx(xmin, ymax, y)\n\
4241\n\
4242\n\
4243 This function is used in example 29.\n\
4244\n\
4245\n\
4246\n\
4247SYNOPSIS:\n\
4248\n\
4249plerrx(n, xmin, xmax, y)\n\
4250\n\
4251ARGUMENTS:\n\
4252\n\
4253 n (PLINT, input) : Number of error bars to draw.\n\
4254\n\
4255 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4256 of the left-hand endpoints of the error bars.\n\
4257\n\
4258 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4259 of the right-hand endpoints of the error bars.\n\
4260\n\
4261 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4262 the error bars.\n\
4263";
4264static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4265Plot shaded 3-d surface plot\n\
4266\n\
4267DESCRIPTION:\n\
4268\n\
4269 Plots a three-dimensional shaded surface plot within the environment\n\
4270 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4271 z[\n\
4272 nx][\n\
4273 ny], the point z[i][j] being the value of the function at (\n\
4274 x[i],\n\
4275 y[j]). Note that the points in vectors x and y do not need to be\n\
4276 equally spaced, but must be stored in ascending order. For further\n\
4277 details see the PLplot documentation.\n\
4278\n\
4279 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4280\n\
4281 This function is not used in any examples.\n\
4282\n\
4283\n\
4284\n\
4285SYNOPSIS:\n\
4286\n\
4287plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4288\n\
4289ARGUMENTS:\n\
4290\n\
4291 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4292 which the function is evaluated.\n\
4293\n\
4294 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4295 which the function is evaluated.\n\
4296\n\
4297 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4298 plot. Should have dimensions of\n\
4299 nx by\n\
4300 ny.\n\
4301\n\
4302 nx (PLINT, input) : Number of x values at which function is\n\
4303 evaluated.\n\
4304\n\
4305 ny (PLINT, input) : Number of y values at which function is\n\
4306 evaluated.\n\
4307\n\
4308 opt (PLINT, input) : Determines the way in which the surface is\n\
4309 represented. To specify more than one option just add the options,\n\
4310 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4311 connecting points at which function is defined.\n\
4312 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4313 using parameters\n\
4314 nlevel and\n\
4315 clevel.\n\
4316 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4317 using parameters\n\
4318 nlevel and\n\
4319 clevel.\n\
4320 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4321 the borders of the plotted function.\n\
4322 opt=MAG_COLOR : the surface is colored according to the value\n\
4323 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4324 according to the intensity of the reflected light in the\n\
4325 surface from a light source whose position is set using\n\
4326 pllightsource.\n\
4327\n\
4328\n\
4329 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4330 levels.\n\
4331\n\
4332 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4333";
4334static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4335Get the current library version number\n\
4336\n\
4337DESCRIPTION:\n\
4338\n\
4339 Get the current library version number. Note: you must have allocated\n\
4340 space for this (80 characters is safe).\n\
4341\n\
4342 Redacted form: plgver(p_ver)\n\
4343\n\
4344 This function is used in example 1.\n\
4345\n\
4346\n\
4347\n\
4348SYNOPSIS:\n\
4349\n\
4350plgver(p_ver)\n\
4351\n\
4352ARGUMENTS:\n\
4353\n\
4354 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4355 (with preallocated length of 80 characters or more) containing the\n\
4356 PLplot version number.\n\
4357";
4358static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4359End plotting session for current stream\n\
4360\n\
4361DESCRIPTION:\n\
4362\n\
4363 Ends a plotting session for the current output stream only. See\n\
4364 plsstrm for more info.\n\
4365\n\
4366 Redacted form: plend1()\n\
4367\n\
4368 This function is used in examples 1 and 20.\n\
4369\n\
4370\n\
4371\n\
4372SYNOPSIS:\n\
4373\n\
4374plend1()\n\
4375";
4376static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4377Draw error bars in the y direction\n\
4378\n\
4379DESCRIPTION:\n\
4380\n\
4381 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4382 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4383 of the error bars are of length equal to the minor tick length\n\
4384 (settable using plsmin).\n\
4385\n\
4386 Redacted form: General: plerry(x, ymin, ymax)\n\
4387\n\
4388\n\
4389 This function is used in example 29.\n\
4390\n\
4391\n\
4392\n\
4393SYNOPSIS:\n\
4394\n\
4395plerry(n, x, ymin, ymax)\n\
4396\n\
4397ARGUMENTS:\n\
4398\n\
4399 n (PLINT, input) : Number of error bars to draw.\n\
4400\n\
4401 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4402 the error bars.\n\
4403\n\
4404 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4405 of the lower endpoints of the error bars.\n\
4406\n\
4407 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4408 of the upper endpoints of the error bars.\n\
4409";
4410static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4411Set seed for internal random number generator.\n\
4412\n\
4413DESCRIPTION:\n\
4414\n\
4415 Set the seed for the internal random number generator. See plrandd for\n\
4416 further details.\n\
4417\n\
4418 Redacted form: plseed(seed)\n\
4419\n\
4420 This function is used in example 21.\n\
4421\n\
4422\n\
4423\n\
4424SYNOPSIS:\n\
4425\n\
4426plseed(seed)\n\
4427\n\
4428ARGUMENTS:\n\
4429\n\
4430 seed (unsigned int, input) : Seed for random number generator.\n\
4431";
4432static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4433Specify viewport using normalized subpage coordinates\n\
4434\n\
4435DESCRIPTION:\n\
4436\n\
4437 Device-independent routine for setting up the viewport. This defines\n\
4438 the viewport in terms of normalized subpage coordinates which run from\n\
4439 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4440 current subpage. Use the alternate routine plsvpa in order to create\n\
4441 a viewport of a definite size.\n\
4442\n\
4443 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4444\n\
4445 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4446 24, 26, 27, and 31.\n\
4447\n\
4448\n\
4449\n\
4450SYNOPSIS:\n\
4451\n\
4452plvpor(xmin, xmax, ymin, ymax)\n\
4453\n\
4454ARGUMENTS:\n\
4455\n\
4456 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4457 left-hand edge of the viewport.\n\
4458\n\
4459 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4460 right-hand edge of the viewport.\n\
4461\n\
4462 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4463 bottom edge of the viewport.\n\
4464\n\
4465 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4466 edge of the viewport.\n\
4467";
4468static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4469Plot surface mesh\n\
4470\n\
4471DESCRIPTION:\n\
4472\n\
4473 Plots a surface mesh within the environment set up by plw3d. The\n\
4474 surface is defined by the matrix z[\n\
4475 nx][\n\
4476 ny] , the point z[i][j] being the value of the function at (\n\
4477 x[i],\n\
4478 y[j]). Note that the points in vectors x and y do not need to be\n\
4479 equally spaced, but must be stored in ascending order. The parameter\n\
4480 opt controls the way in which the surface is displayed. For further\n\
4481 details see the PLplot documentation.\n\
4482\n\
4483 Redacted form: plmesh(x, y, z, opt)\n\
4484\n\
4485 This function is used in example 11.\n\
4486\n\
4487\n\
4488\n\
4489SYNOPSIS:\n\
4490\n\
4491plmesh(x, y, z, nx, ny, opt)\n\
4492\n\
4493ARGUMENTS:\n\
4494\n\
4495 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4496 which the function is evaluated.\n\
4497\n\
4498 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4499 which the function is evaluated.\n\
4500\n\
4501 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4502 plot. Should have dimensions of\n\
4503 nx by\n\
4504 ny.\n\
4505\n\
4506 nx (PLINT, input) : Number of x values at which function has been\n\
4507 evaluated.\n\
4508\n\
4509 ny (PLINT, input) : Number of y values at which function has been\n\
4510 evaluated.\n\
4511\n\
4512 opt (PLINT, input) : Determines the way in which the surface is\n\
4513 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4514 function of x for each value of y[j] .\n\
4515 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4516 for each value of x[i] .\n\
4517 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4518 at which function is defined.\n\
4519";
4520static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4521Get the cmap1 argument range for continuous color plots\n\
4522\n\
4523DESCRIPTION:\n\
4524\n\
4525 Get the cmap1 argument range for continuous color plots. (Use\n\
4526 plscmap1_range to set the cmap1 argument range.)\n\
4527\n\
4528 Redacted form: plgcmap1_range(min_color, max_color)\n\
4529\n\
4530 This function is currently not used in any example.\n\
4531\n\
4532\n\
4533\n\
4534SYNOPSIS:\n\
4535\n\
4536plgcmap1_range(min_color, max_color)\n\
4537\n\
4538ARGUMENTS:\n\
4539\n\
4540 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4541 minimum cmap1 argument.\n\
4542\n\
4543 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4544 maximum cmap1 argument.\n\
4545";
4546static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4547Set arrow style for vector plots\n\
4548\n\
4549DESCRIPTION:\n\
4550\n\
4551 Set the style for the arrow used by plvect to plot vectors.\n\
4552\n\
4553 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4554\n\
4555 This function is used in example 22.\n\
4556\n\
4557\n\
4558\n\
4559SYNOPSIS:\n\
4560\n\
4561plsvect(arrowx, arrowy, npts, fill)\n\
4562\n\
4563ARGUMENTS:\n\
4564\n\
4565 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4566 the x and y points which make up the arrow. The arrow is plotted\n\
4567 by joining these points to form a polygon. The scaling assumes\n\
4568 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4569 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4570 will be reset to its default.\n\
4571\n\
4572 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4573 arrowy.\n\
4574\n\
4575 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4576 fill is false then the arrow is open.\n\
4577";
4578static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4579Draw filled polygon\n\
4580\n\
4581DESCRIPTION:\n\
4582\n\
4583 Fills the polygon defined by the n points (\n\
4584 x[i],\n\
4585 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4586 style is a solid fill. The routine will automatically close the\n\
4587 polygon between the last and first vertices. If multiple closed\n\
4588 polygons are passed in x and y then plfill will fill in between them.\n\
4589\n\
4590 Redacted form: plfill(x,y)\n\
4591\n\
4592 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4593\n\
4594\n\
4595\n\
4596SYNOPSIS:\n\
4597\n\
4598plfill(n, x, y)\n\
4599\n\
4600ARGUMENTS:\n\
4601\n\
4602 n (PLINT, input) : Number of vertices in polygon.\n\
4603\n\
4604 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4605 vertices.\n\
4606\n\
4607 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4608 vertices.\n\
4609";
4610static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4611Convert HLS color to RGB\n\
4612\n\
4613DESCRIPTION:\n\
4614\n\
4615 Convert HLS color coordinates to RGB.\n\
4616\n\
4617 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4618\n\
4619\n\
4620 This function is used in example 2.\n\
4621\n\
4622\n\
4623\n\
4624SYNOPSIS:\n\
4625\n\
4626plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4627\n\
4628ARGUMENTS:\n\
4629\n\
4630 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4631 cylinder.\n\
4632\n\
4633 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4634 the axis of the color cylinder.\n\
4635\n\
4636 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4637 the radius of the color cylinder.\n\
4638\n\
4639 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4640 (0.0-1.0) of the color.\n\
4641\n\
4642 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4643 intensity (0.0-1.0) of the color.\n\
4644\n\
4645 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4646 intensity (0.0-1.0) of the color.\n\
4647";
4648static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4649Set format for date / time labels\n\
4650\n\
4651DESCRIPTION:\n\
4652\n\
4653 Sets the format for date / time labels. To enable date / time format\n\
4654 labels see the options to plbox, plbox3, and plenv.\n\
4655\n\
4656 Redacted form: pltimefmt(fmt)\n\
4657\n\
4658 This function is used in example 29.\n\
4659\n\
4660\n\
4661\n\
4662SYNOPSIS:\n\
4663\n\
4664pltimefmt(fmt)\n\
4665\n\
4666ARGUMENTS:\n\
4667\n\
4668 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4669 interpreted similarly to the format specifier of typical system\n\
4670 strftime routines except that PLplot ignores locale and also\n\
4671 supplies some useful extensions in the context of plotting. All\n\
4672 text in the string is printed as-is other than conversion\n\
4673 specifications which take the form of a \'%\' character followed by\n\
4674 further conversion specification character. The conversion\n\
4675 specifications which are similar to those provided by system\n\
4676 strftime routines are the following: %a: The abbreviated (English)\n\
4677 weekday name.\n\
4678 %A: The full (English) weekday name.\n\
4679 %b: The abbreviated (English) month name.\n\
4680 %B: The full (English) month name.\n\
4681 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4682 %C: The century number (year/100) as a 2-digit integer.\n\
4683 %d: The day of the month as a decimal number (range 01 to 31).\n\
4684 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4685 %e: Like %d, but a leading zero is replaced by a space.\n\
4686 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4687 %h: Equivalent to %b.\n\
4688 %H: The hour as a decimal number using a 24-hour clock (range\n\
4689 00 to 23).\n\
4690 %I: The hour as a decimal number using a 12-hour clock (range\n\
4691 01 to 12).\n\
4692 %j: The day of the year as a decimal number (range 001 to\n\
4693 366).\n\
4694 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4695 23); single digits are preceded by a blank. (See also %H.)\n\
4696 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4697 12); single digits are preceded by a blank. (See also %I.)\n\
4698 %m: The month as a decimal number (range 01 to 12).\n\
4699 %M: The minute as a decimal number (range 00 to 59).\n\
4700 %n: A newline character.\n\
4701 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4702 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4703 %r: Equivalent to %I:%M:%S %p.\n\
4704 %R: The time in 24-hour notation (%H:%M). For a version\n\
4705 including the seconds, see %T below.\n\
4706 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4707 +0000 (UTC).\n\
4708 %S: The second as a decimal number (range 00 to 60). (The\n\
4709 range is up to 60 to allow for occasional leap seconds.)\n\
4710 %t: A tab character.\n\
4711 %T: The time in 24-hour notation (%H:%M:%S).\n\
4712 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4713 being 1. See also %w.\n\
4714 %U: The week number of the current year as a decimal number,\n\
4715 range 00 to 53, starting with the first Sunday as the first\n\
4716 day of week 01. See also %V and %W.\n\
4717 %v: Equivalent to %e-%b-%Y.\n\
4718 %V: The ISO 8601 week number of the current year as a decimal\n\
4719 number, range 01 to 53, where week 1 is the first week that\n\
4720 has at least 4 days in the new year. See also %U and %W.\n\
4721 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4722 being 0. See also %u.\n\
4723 %W: The week number of the current year as a decimal number,\n\
4724 range 00 to 53, starting with the first Monday as the first\n\
4725 day of week 01.\n\
4726 %x: Equivalent to %a %b %d %Y.\n\
4727 %X: Equivalent to %T.\n\
4728 %y: The year as a decimal number without a century (range 00\n\
4729 to 99).\n\
4730 %Y: The year as a decimal number including a century.\n\
4731 %z: The UTC time-zone string = \"+0000\".\n\
4732 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4733 %+: The UTC date and time in default format of the Unix date\n\
4734 command which is equivalent to %a %b %d %T %Z %Y.\n\
4735 %%: A literal \"%\" character.\n\
4736 The conversion specifications which are extensions to those normally\n\
4737 provided by system strftime routines are the following: %(0-9):\n\
4738 The fractional part of the seconds field (including leading\n\
4739 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4740 seconds to millisecond accuracy (00.000).\n\
4741 %.: The fractional part of the seconds field (including\n\
4742 leading decimal point) to the maximum available accuracy. Thus\n\
4743 %S%. would give seconds with fractional part up to 9 decimal\n\
4744 places if available.\n\
4745";
4746static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4747Get current subpage parameters\n\
4748\n\
4749DESCRIPTION:\n\
4750\n\
4751 Gets the size of the current subpage in millimeters measured from the\n\
4752 bottom left hand corner of the output device page or screen. Can be\n\
4753 used in conjunction with plsvpa for setting the size of a viewport in\n\
4754 absolute coordinates (millimeters).\n\
4755\n\
4756 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4757\n\
4758 This function is used in example 23.\n\
4759\n\
4760\n\
4761\n\
4762SYNOPSIS:\n\
4763\n\
4764plgspa(xmin, xmax, ymin, ymax)\n\
4765\n\
4766ARGUMENTS:\n\
4767\n\
4768 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4769 the left hand edge of the subpage in millimeters.\n\
4770\n\
4771 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4772 the right hand edge of the subpage in millimeters.\n\
4773\n\
4774 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4775 the bottom edge of the subpage in millimeters.\n\
4776\n\
4777 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4778 the top edge of the subpage in millimeters.\n\
4779";
4780static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4781Calculate world coordinates and corresponding window index from relative device coordinates\n\
4782\n\
4783DESCRIPTION:\n\
4784\n\
4785 Calculate world coordinates, wx and wy, and corresponding window index\n\
4786 from relative device coordinates, rx and ry.\n\
4787\n\
4788 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4789\n\
4790\n\
4791 This function is used in example 31.\n\
4792\n\
4793\n\
4794\n\
4795SYNOPSIS:\n\
4796\n\
4797plcalc_world(rx, ry, wx, wy, window)\n\
4798\n\
4799ARGUMENTS:\n\
4800\n\
4801 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4802 the x coordinate.\n\
4803\n\
4804 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4805 the y coordinate.\n\
4806\n\
4807 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4808 coordinate corresponding to the relative device coordinates rx and\n\
4809 ry.\n\
4810\n\
4811 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4812 coordinate corresponding to the relative device coordinates rx and\n\
4813 ry.\n\
4814\n\
4815 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4816 defined window index that corresponds to the input relative device\n\
4817 coordinates (and the returned world coordinates). To give some\n\
4818 background on the window index, for each page the initial window\n\
4819 index is set to zero, and each time plwind is called within the\n\
4820 page, world and device coordinates are stored for the window and\n\
4821 the window index is incremented. Thus, for a simple page layout\n\
4822 with non-overlapping viewports and one window per viewport, window\n\
4823 corresponds to the viewport index (in the order which the\n\
4824 viewport/windows were created) of the only viewport/window\n\
4825 corresponding to rx and ry. However, for more complicated layouts\n\
4826 with potentially overlapping viewports and possibly more than one\n\
4827 window (set of world coordinates) per viewport, window and the\n\
4828 corresponding output world coordinates corresponds to the last\n\
4829 window created that fulfills the criterion that the relative\n\
4830 device coordinates are inside it. Finally, in all cases where the\n\
4831 input relative device coordinates are not inside any\n\
4832 viewport/window, then the returned value of the last defined\n\
4833 window index is set to -1.\n\
4834";
4835static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4836Get output file name\n\
4837\n\
4838DESCRIPTION:\n\
4839\n\
4840 Gets the current output file name, if applicable.\n\
4841\n\
4842 Redacted form: plgfnam(fnam)\n\
4843\n\
4844 This function is used in example 31.\n\
4845\n\
4846\n\
4847\n\
4848SYNOPSIS:\n\
4849\n\
4850plgfnam(fnam)\n\
4851\n\
4852ARGUMENTS:\n\
4853\n\
4854 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4855 (with preallocated length of 80 characters or more) containing the\n\
4856 file name.\n\
4857";
4858static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4859Vector plot\n\
4860\n\
4861DESCRIPTION:\n\
4862\n\
4863 Draws a plot of vector data contained in the matrices (\n\
4864 u[\n\
4865 nx][\n\
4866 ny],\n\
4867 v[\n\
4868 nx][\n\
4869 ny]) . The scaling factor for the vectors is given by scale. A\n\
4870 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4871 additional data required by the transformation routine to map indices\n\
4872 within the matrices to the world coordinates. The style of the vector\n\
4873 arrow may be set using plsvect.\n\
4874\n\
4875 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4876 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4877 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4878 with either one or two dimensions.\n\
4879\n\
4880 This function is used in example 22.\n\
4881\n\
4882\n\
4883\n\
4884SYNOPSIS:\n\
4885\n\
4886plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4887\n\
4888ARGUMENTS:\n\
4889\n\
4890 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4891 and y components of the vector data to be plotted.\n\
4892\n\
4893 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4894\n\
4895 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4896 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4897 automatically calculated for the data. If scale < 0 then the\n\
4898 scaling factor is automatically calculated for the data and then\n\
4899 multiplied by -\n\
4900 scale. If scale > 0 then the scaling factor is set to scale.\n\
4901\n\
4902 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4903 defines the transformation between the zero-based indices of the\n\
4904 matrices u and v and world coordinates.For the C case,\n\
4905 transformation functions are provided in the PLplot library: pltr0\n\
4906 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4907 mappings respectively defined by vectors and matrices. In\n\
4908 addition, C callback routines for the transformation can be\n\
4909 supplied by the user such as the mypltr function in\n\
4910 examples/c/x09c.c which provides a general linear transformation\n\
4911 between index coordinates and world coordinates.For languages\n\
4912 other than C you should consult the PLplot documentation for the\n\
4913 details concerning how PLTRANSFORM_callback arguments are\n\
4914 interfaced. However, in general, a particular pattern of\n\
4915 callback-associated arguments such as a tr vector with 6 elements;\n\
4916 xg and yg vectors; or xg and yg matrices are respectively\n\
4917 interfaced to a linear-transformation routine similar to the above\n\
4918 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4919 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4920 support native language callbacks for handling index to\n\
4921 world-coordinate transformations. Examples of these various\n\
4922 approaches are given in examples/<language>x09*,\n\
4923 examples/<language>x16*, examples/<language>x20*,\n\
4924 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4925 supported languages.\n\
4926\n\
4927 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4928 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4929 that is externally supplied.\n\
4930";
4931static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4932Plot a glyph at the specified points\n\
4933\n\
4934DESCRIPTION:\n\
4935\n\
4936 Plot a glyph at the specified points. (This function is largely\n\
4937 superseded by plstring which gives access to many[!] more glyphs.)\n\
4938\n\
4939 Redacted form: plsym(x, y, code)\n\
4940\n\
4941 This function is used in example 7.\n\
4942\n\
4943\n\
4944\n\
4945SYNOPSIS:\n\
4946\n\
4947plsym(n, x, y, code)\n\
4948\n\
4949ARGUMENTS:\n\
4950\n\
4951 n (PLINT, input) : Number of points in the x and y vectors.\n\
4952\n\
4953 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4954 the points.\n\
4955\n\
4956 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4957 the points.\n\
4958\n\
4959 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4960 to be plotted at each of the n points.\n\
4961";
4962static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4963Get viewport limits in normalized device coordinates\n\
4964\n\
4965DESCRIPTION:\n\
4966\n\
4967 Get viewport limits in normalized device coordinates.\n\
4968\n\
4969 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4970\n\
4971\n\
4972 This function is used in example 31.\n\
4973\n\
4974\n\
4975\n\
4976SYNOPSIS:\n\
4977\n\
4978plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4979\n\
4980ARGUMENTS:\n\
4981\n\
4982 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4983 viewport limit of the normalized device coordinate in x.\n\
4984\n\
4985 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4986 viewport limit of the normalized device coordinate in x.\n\
4987\n\
4988 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4989 viewport limit of the normalized device coordinate in y.\n\
4990\n\
4991 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4992 viewport limit of the normalized device coordinate in y.\n\
4993";
4994static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4995Get page parameters\n\
4996\n\
4997DESCRIPTION:\n\
4998\n\
4999 Gets the current page configuration. The length and offset values are\n\
5000 expressed in units that are specific to the current driver. For\n\
5001 instance: screen drivers will usually interpret them as number of\n\
5002 pixels, whereas printer drivers will usually use mm.\n\
5003\n\
5004 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5005\n\
5006 This function is used in examples 14 and 31.\n\
5007\n\
5008\n\
5009\n\
5010SYNOPSIS:\n\
5011\n\
5012plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5013\n\
5014ARGUMENTS:\n\
5015\n\
5016 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5017 pixels/inch (DPI) in x.\n\
5018\n\
5019 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5020 pixels/inch (DPI) in y.\n\
5021\n\
5022 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5023 length.\n\
5024\n\
5025 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5026 length.\n\
5027\n\
5028 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5029 offset.\n\
5030\n\
5031 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5032 offset.\n\
5033";
5034static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
5035Plot a glyph at the specified 3D points\n\
5036\n\
5037DESCRIPTION:\n\
5038\n\
5039 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5040 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5041 this function similar to what is done for plline3. The glyph is\n\
5042 specified with a PLplot user string. Note that the user string is not\n\
5043 actually limited to one glyph so it is possible (but not normally\n\
5044 useful) to plot more than one glyph at the specified points with this\n\
5045 function. As with plmtex and plptex, the user string can contain FCI\n\
5046 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5047 else PLplot escapes for Hershey or unicode text to determine the\n\
5048 glyph.\n\
5049\n\
5050 Redacted form: plstring3(x, y, z, string)\n\
5051\n\
5052 This function is used in example 18.\n\
5053\n\
5054\n\
5055\n\
5056SYNOPSIS:\n\
5057\n\
5058plstring3(n, x, y, z, string)\n\
5059\n\
5060ARGUMENTS:\n\
5061\n\
5062 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5063\n\
5064 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5065 the points.\n\
5066\n\
5067 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5068 the points.\n\
5069\n\
5070 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5071 the points.\n\
5072\n\
5073 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5074 the glyph(s) to be plotted at each of the n points. points.\n\
5075";
5076static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
5077Shade regions on the basis of value\n\
5078\n\
5079DESCRIPTION:\n\
5080\n\
5081 Shade regions on the basis of value. This is the high-level routine\n\
5082 for making continuous color shaded plots with cmap1 while plshade\n\
5083 should be used to plot individual shaded regions using either cmap0 or\n\
5084 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5085 our supported languages.\n\
5086\n\
5087 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5088 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5089 pltr_data)\n\
5090\n\
5091\n\
5092 This function is used in examples 16, 21, and 22.\n\
5093\n\
5094\n\
5095\n\
5096SYNOPSIS:\n\
5097\n\
5098plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5099\n\
5100ARGUMENTS:\n\
5101\n\
5102 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5103 plot. Should have dimensions of\n\
5104 nx by\n\
5105 ny.\n\
5106\n\
5107 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5108\n\
5109 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5110\n\
5111 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5112 the region that should be plotted in the shade plot. This\n\
5113 function accepts x and y coordinates as input arguments and must\n\
5114 return 1 if the point is to be included in the shade plot and 0\n\
5115 otherwise. If you want to plot the entire shade plot (the usual\n\
5116 case), this argument should be set to NULL.\n\
5117\n\
5118 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5119 pltr below for how these arguments are used (only for the special case\n\
5120 when the callback function\n\
5121 pltr is not supplied).\n\
5122\n\
5123 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5124 corresponding to the edges of each shaded region that will be\n\
5125 plotted by this function. To work properly the levels should be\n\
5126 monotonic.\n\
5127\n\
5128 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5129 of shade edge values in clevel).\n\
5130\n\
5131 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5132 pattern.\n\
5133\n\
5134 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5135 contours defining edges of shaded regions. The pen color is only\n\
5136 temporary set for the contour drawing. Set this value to zero or\n\
5137 less if no shade edge contours are wanted.\n\
5138\n\
5139 cont_width (PLFLT, input) : Defines line width used for contours\n\
5140 defining edges of shaded regions. This value may not be honored\n\
5141 by all drivers. The pen width is only temporary set for the\n\
5142 contour drawing. Set this value to zero or less if no shade edge\n\
5143 contours are wanted.\n\
5144\n\
5145 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5146 region. Use plfill for this purpose.\n\
5147\n\
5148 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5149 map to rectangles after coordinate transformation with pltrl.\n\
5150 Otherwise, set rectangular to false. If rectangular is set to\n\
5151 true, plshade tries to save time by filling large rectangles.\n\
5152 This optimization fails if the coordinate transformation distorts\n\
5153 the shape of rectangles. For example a plot in polar coordinates\n\
5154 has to have rectangular set to false.\n\
5155\n\
5156 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5157 defines the transformation between the zero-based indices of the\n\
5158 matrix a and world coordinates. If\n\
5159 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5160 indices of a are mapped to the range\n\
5161 xmin through\n\
5162 xmax and the y indices of a are mapped to the range\n\
5163 ymin through\n\
5164 ymax.For the C case, transformation functions are provided in the\n\
5165 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5166 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5167 matrices. In addition, C callback routines for the transformation\n\
5168 can be supplied by the user such as the mypltr function in\n\
5169 examples/c/x09c.c which provides a general linear transformation\n\
5170 between index coordinates and world coordinates.For languages\n\
5171 other than C you should consult the PLplot documentation for the\n\
5172 details concerning how PLTRANSFORM_callback arguments are\n\
5173 interfaced. However, in general, a particular pattern of\n\
5174 callback-associated arguments such as a tr vector with 6 elements;\n\
5175 xg and yg vectors; or xg and yg matrices are respectively\n\
5176 interfaced to a linear-transformation routine similar to the above\n\
5177 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5178 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5179 support native language callbacks for handling index to\n\
5180 world-coordinate transformations. Examples of these various\n\
5181 approaches are given in examples/<language>x09*,\n\
5182 examples/<language>x16*, examples/<language>x20*,\n\
5183 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5184 supported languages.\n\
5185\n\
5186 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5187 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5188 externally supplied.\n\
5189";
5190static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5191Set output file name\n\
5192\n\
5193DESCRIPTION:\n\
5194\n\
5195 Sets the current output file name, if applicable. If the file name\n\
5196 has not been specified and is required by the driver, the user will be\n\
5197 prompted for it. If using the X-windows output driver, this sets the\n\
5198 display name. This routine, if used, must be called before\n\
5199 initializing PLplot.\n\
5200\n\
5201 Redacted form: plsfnam(fnam)\n\
5202\n\
5203 This function is used in examples 1 and 20.\n\
5204\n\
5205\n\
5206\n\
5207SYNOPSIS:\n\
5208\n\
5209plsfnam(fnam)\n\
5210\n\
5211ARGUMENTS:\n\
5212\n\
5213 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5214 the file name.\n\
5215";
5216static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5217Contour plot\n\
5218\n\
5219DESCRIPTION:\n\
5220\n\
5221 Draws a contour plot of the data in f[\n\
5222 nx][\n\
5223 ny], using the nlevel contour levels specified by clevel. Only the\n\
5224 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5225 where all these index ranges are interpreted as one-based for\n\
5226 historical reasons. A transformation routine pointed to by pltr with\n\
5227 a generic pointer pltr_data for additional data required by the\n\
5228 transformation routine is used to map indices within the matrix to the\n\
5229 world coordinates.\n\
5230\n\
5231 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5232 where (see above discussion) the pltr, pltr_data callback arguments\n\
5233 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5234 vectors; or xg and yg matrices.\n\
5235\n\
5236 This function is used in examples 9, 14, 16, and 22.\n\
5237\n\
5238\n\
5239\n\
5240SYNOPSIS:\n\
5241\n\
5242plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5243\n\
5244ARGUMENTS:\n\
5245\n\
5246 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5247\n\
5248 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5249\n\
5250 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5251 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5252 zero-based for historical backwards-compatibility reasons.\n\
5253\n\
5254 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5255 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5256 zero-based for historical backwards-compatibility reasons.\n\
5257\n\
5258 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5259 which to draw contours.\n\
5260\n\
5261 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5262\n\
5263 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5264 defines the transformation between the zero-based indices of the\n\
5265 matrix f and the world coordinates.For the C case, transformation\n\
5266 functions are provided in the PLplot library: pltr0 for the\n\
5267 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5268 respectively defined by vectors and matrices. In addition, C\n\
5269 callback routines for the transformation can be supplied by the\n\
5270 user such as the mypltr function in examples/c/x09c.c which\n\
5271 provides a general linear transformation between index coordinates\n\
5272 and world coordinates.For languages other than C you should\n\
5273 consult the PLplot documentation for the details concerning how\n\
5274 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5275 general, a particular pattern of callback-associated arguments\n\
5276 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5277 yg matrices are respectively interfaced to a linear-transformation\n\
5278 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5279 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5280 the PLplot documentation) support native language callbacks for\n\
5281 handling index to world-coordinate transformations. Examples of\n\
5282 these various approaches are given in examples/<language>x09*,\n\
5283 examples/<language>x16*, examples/<language>x20*,\n\
5284 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5285 supported languages.\n\
5286\n\
5287 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5288 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5289 that is externally supplied.\n\
5290";
5291static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5292Set parameters that define current plot-space window\n\
5293\n\
5294DESCRIPTION:\n\
5295\n\
5296 Set relative minima and maxima that define the current plot-space\n\
5297 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5298 xmax, and ymax are 0., 0., 1., and 1.\n\
5299\n\
5300 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5301\n\
5302 This function is used in example 31.\n\
5303\n\
5304\n\
5305\n\
5306SYNOPSIS:\n\
5307\n\
5308plsdiplt(xmin, ymin, xmax, ymax)\n\
5309\n\
5310ARGUMENTS:\n\
5311\n\
5312 xmin (PLFLT, input) : Relative minimum in x.\n\
5313\n\
5314 ymin (PLFLT, input) : Relative minimum in y.\n\
5315\n\
5316 xmax (PLFLT, input) : Relative maximum in x.\n\
5317\n\
5318 ymax (PLFLT, input) : Relative maximum in y.\n\
5319";
5320static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5321Write text inside the viewport of a 3D plot\n\
5322\n\
5323DESCRIPTION:\n\
5324\n\
5325 Writes text at a specified position and inclination and with a\n\
5326 specified shear within the viewport. Text is clipped at the viewport\n\
5327 boundaries. The reference point of a string lies along a line passing\n\
5328 through the string at half the height of a capital letter. The\n\
5329 position of the reference point along this line is determined by just,\n\
5330 and the reference point is placed at world coordinates (\n\
5331 wx,\n\
5332 wy,\n\
5333 wz) within the viewport. The inclination and shear of the string is\n\
5334 specified in terms of differences of world coordinates making it easy\n\
5335 to write text parallel to a line in a graph.\n\
5336\n\
5337 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5338\n\
5339 This function is used in example 28.\n\
5340\n\
5341\n\
5342\n\
5343SYNOPSIS:\n\
5344\n\
5345plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5346\n\
5347ARGUMENTS:\n\
5348\n\
5349 wx (PLFLT, input) : x world coordinate of reference point of\n\
5350 string.\n\
5351\n\
5352 wy (PLFLT, input) : y world coordinate of reference point of\n\
5353 string.\n\
5354\n\
5355 wz (PLFLT, input) : z world coordinate of reference point of\n\
5356 string.\n\
5357\n\
5358 dx (PLFLT, input) : Together with dy and\n\
5359 dz , this specifies the inclination of the string. The baseline of\n\
5360 the string is parallel to a line joining (\n\
5361 x,\n\
5362 y,\n\
5363 z) to (\n\
5364 x+\n\
5365 dx,\n\
5366 y+\n\
5367 dy,\n\
5368 z+\n\
5369 dz) .\n\
5370\n\
5371 dy (PLFLT, input) : Together with dx and\n\
5372 dz, this specifies the inclination of the string.\n\
5373\n\
5374 dz (PLFLT, input) : Together with dx and\n\
5375 dy, this specifies the inclination of the string.\n\
5376\n\
5377 sx (PLFLT, input) : Together with sy and\n\
5378 sz , this specifies the shear of the string. The string is sheared so\n\
5379 that the characters are vertically parallel to a line joining (\n\
5380 x,\n\
5381 y,\n\
5382 z) to (\n\
5383 x+\n\
5384 sx,\n\
5385 y+\n\
5386 sy,\n\
5387 z+\n\
5388 sz) . If sx =\n\
5389 sy =\n\
5390 sz = 0.) then the text is not sheared.\n\
5391\n\
5392 sy (PLFLT, input) : Together with sx and\n\
5393 sz, this specifies shear of the string.\n\
5394\n\
5395 sz (PLFLT, input) : Together with sx and\n\
5396 sy, this specifies shear of the string.\n\
5397\n\
5398 just (PLFLT, input) : Specifies the position of the string relative\n\
5399 to its reference point. If just=0. , the reference point is at\n\
5400 the left and if just=1. , it is at the right of the string. Other\n\
5401 values of just give intermediate justifications.\n\
5402\n\
5403 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5404 written out.\n\
5405";
5406static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5407Plot continental outline or shapefile data in world coordinates\n\
5408\n\
5409DESCRIPTION:\n\
5410\n\
5411 Plots continental outlines or shapefile data in world coordinates. A\n\
5412 demonstration of how to use this function to create different\n\
5413 projections can be found in examples/c/x19c. PLplot is provided with\n\
5414 basic coastal outlines and USA state borders. To use the map\n\
5415 functionality PLplot must be compiled with the shapelib library.\n\
5416 Shapefiles have become a popular standard for geographical data and\n\
5417 data in this format can be easily found from a number of online\n\
5418 sources. Shapefile data is actually provided as three or more files\n\
5419 with the same filename, but different extensions. The .shp and .shx\n\
5420 files are required for plotting Shapefile data with PLplot.\n\
5421\n\
5422 PLplot currently supports the point, multipoint, polyline and polygon\n\
5423 objects within shapefiles. However holes in polygons are not\n\
5424 supported. When plmap is used the type of object is derived from the\n\
5425 shapefile, if you wish to override the type then use one of the other\n\
5426 plmap variants. The built in maps have line data only.\n\
5427\n\
5428 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5429\n\
5430 This function is used in example 19.\n\
5431\n\
5432\n\
5433\n\
5434SYNOPSIS:\n\
5435\n\
5436plmap(mapform, name, minx, maxx, miny, maxy)\n\
5437\n\
5438ARGUMENTS:\n\
5439\n\
5440 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5441 transform the original map data coordinates to a new coordinate\n\
5442 system. The PLplot-supplied map data is provided as latitudes and\n\
5443 longitudes; other Shapefile data may be provided in other\n\
5444 coordinate systems as can be found in their .prj plain text files.\n\
5445 For example, by using this transform we can change from a\n\
5446 longitude, latitude coordinate to a polar stereographic\n\
5447 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5448 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5449 corresponding y coordinates (latitudes for the PLplot supplied\n\
5450 data). After the call to mapform(), x[] and y[] should be\n\
5451 replaced by the corresponding plot coordinates. If no transform is\n\
5452 desired, mapform can be replaced by NULL.\n\
5453\n\
5454 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5455 the type of map plotted. This is either one of the PLplot built-in\n\
5456 maps or the file name of a set of Shapefile files without the file\n\
5457 extensions. For the PLplot built-in maps the possible values are:\n\
5458 \"globe\" -- continental outlines\n\
5459 \"usa\" -- USA and state boundaries\n\
5460 \"cglobe\" -- continental outlines and countries\n\
5461 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5462\n\
5463\n\
5464 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5465 drawn. The units must match the shapefile (built in maps are\n\
5466 degrees lat/lon). Objects in the file which do not encroach on the\n\
5467 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5468 note this is simply an optimisation, not a clipping so for objects\n\
5469 with some points inside the box and some points outside the box\n\
5470 all the points will be rendered. These parameters also define\n\
5471 latitude and longitude wrapping for shapefiles using these units.\n\
5472 Longitude points will be wrapped by integer multiples of 360\n\
5473 degrees to place them in the box. This allows the same data to be\n\
5474 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5475 you plot from -180-540 you will get two cycles of data drawn. The\n\
5476 value of minx must be less than the value of maxx. Passing in a\n\
5477 nan, max/-max floating point number or +/-infinity will case the\n\
5478 bounding box from the shapefile to be used.\n\
5479\n\
5480 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5481 drawn - see minx.\n\
5482\n\
5483 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5484 drawn - see minx.\n\
5485\n\
5486 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5487 drawn - see minx.\n\
5488";
5489static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5490Specify viewport using coordinates and aspect ratio\n\
5491\n\
5492DESCRIPTION:\n\
5493\n\
5494 Device-independent routine for setting up the viewport. The viewport\n\
5495 is chosen to be the largest with the given aspect ratio that fits\n\
5496 within the specified region (in terms of normalized subpage\n\
5497 coordinates). This routine is functionally equivalent to plvpor when\n\
5498 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5499 routine reserves no extra space at the edges for labels.\n\
5500\n\
5501 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5502\n\
5503 This function is used in example 9.\n\
5504\n\
5505\n\
5506\n\
5507SYNOPSIS:\n\
5508\n\
5509plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5510\n\
5511ARGUMENTS:\n\
5512\n\
5513 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5514 left-hand edge of the viewport.\n\
5515\n\
5516 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5517 right-hand edge of the viewport.\n\
5518\n\
5519 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5520 bottom edge of the viewport.\n\
5521\n\
5522 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5523 edge of the viewport.\n\
5524\n\
5525 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5526 axis.\n\
5527";
5528static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5529Set the pause (on end-of-page) status\n\
5530\n\
5531DESCRIPTION:\n\
5532\n\
5533 Set the pause (on end-of-page) status.\n\
5534\n\
5535 Redacted form: plspause(pause)\n\
5536\n\
5537 This function is in examples 14,20.\n\
5538\n\
5539\n\
5540\n\
5541SYNOPSIS:\n\
5542\n\
5543plspause(pause)\n\
5544\n\
5545ARGUMENTS:\n\
5546\n\
5547 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5548 end-of-page for those drivers which support this. Otherwise there\n\
5549 is no pause.\n\
5550";
5551static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5552Plot 3-d surface plot\n\
5553\n\
5554DESCRIPTION:\n\
5555\n\
5556 Plots a three-dimensional surface plot within the environment set up\n\
5557 by plw3d. The surface is defined by the matrix z[\n\
5558 nx][\n\
5559 ny] , the point z[i][j] being the value of the function at (\n\
5560 x[i],\n\
5561 y[j]). Note that the points in vectors x and y do not need to be\n\
5562 equally spaced, but must be stored in ascending order. The parameter\n\
5563 opt controls the way in which the surface is displayed. For further\n\
5564 details see the PLplot documentation. The only difference between\n\
5565 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5566 while plot3d only draws the surface as viewed from the top.\n\
5567\n\
5568 Redacted form: plot3d(x, y, z, opt, side)\n\
5569\n\
5570 This function is used in examples 11 and 21.\n\
5571\n\
5572\n\
5573\n\
5574SYNOPSIS:\n\
5575\n\
5576plot3d(x, y, z, nx, ny, opt, side)\n\
5577\n\
5578ARGUMENTS:\n\
5579\n\
5580 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5581 which the function is evaluated.\n\
5582\n\
5583 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5584 which the function is evaluated.\n\
5585\n\
5586 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5587 plot. Should have dimensions of\n\
5588 nx by\n\
5589 ny.\n\
5590\n\
5591 nx (PLINT, input) : Number of x values at which function is\n\
5592 evaluated.\n\
5593\n\
5594 ny (PLINT, input) : Number of y values at which function is\n\
5595 evaluated.\n\
5596\n\
5597 opt (PLINT, input) : Determines the way in which the surface is\n\
5598 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5599 function of x for each value of y[j] .\n\
5600 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5601 for each value of x[i] .\n\
5602 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5603 at which function is defined.\n\
5604\n\
5605\n\
5606 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5607 should be draw on the figure. If side is true sides are drawn,\n\
5608 otherwise no sides are drawn.\n\
5609";
5610static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5611Copy state parameters from the reference stream to the current stream\n\
5612\n\
5613DESCRIPTION:\n\
5614\n\
5615 Copies state parameters from the reference stream to the current\n\
5616 stream. Tell driver interface to map device coordinates unless flags\n\
5617 == 1.\n\
5618\n\
5619 This function is used for making save files of selected plots (e.g.\n\
5620 from the TK driver). After initializing, you can get a copy of the\n\
5621 current plot to the specified device by switching to this stream and\n\
5622 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5623 appropriate. The plot buffer must have previously been enabled (done\n\
5624 automatically by some display drivers, such as X).\n\
5625\n\
5626 Redacted form: plcpstrm(iplsr, flags)\n\
5627\n\
5628 This function is used in example 1,20.\n\
5629\n\
5630\n\
5631\n\
5632SYNOPSIS:\n\
5633\n\
5634plcpstrm(iplsr, flags)\n\
5635\n\
5636ARGUMENTS:\n\
5637\n\
5638 iplsr (PLINT, input) : Number of reference stream.\n\
5639\n\
5640 flags (PLBOOL, input) : If flags is set to true the device\n\
5641 coordinates are not copied from the reference to current stream.\n\
5642";
5643static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5644Set page parameters\n\
5645\n\
5646DESCRIPTION:\n\
5647\n\
5648 Sets the page configuration (optional). If an individual parameter is\n\
5649 zero then that parameter value is not updated. Not all parameters are\n\
5650 recognized by all drivers and the interpretation is device-dependent.\n\
5651 The X-window driver uses the length and offset parameters to determine\n\
5652 the window size and location. The length and offset values are\n\
5653 expressed in units that are specific to the current driver. For\n\
5654 instance: screen drivers will usually interpret them as number of\n\
5655 pixels, whereas printer drivers will usually use mm.\n\
5656\n\
5657 This routine, if used, must be called before initializing PLplot. It\n\
5658 may be called at later times for interactive drivers to change only\n\
5659 the dpi for subsequent redraws which you can force via a call to\n\
5660 plreplot. If this function is not called then the page size defaults\n\
5661 to landscape A4 for drivers which use real world page sizes and 744\n\
5662 pixels wide by 538 pixels high for raster drivers. The default value\n\
5663 for dx and dy is 90 pixels per inch for raster drivers.\n\
5664\n\
5665\n\
5666\n\
5667 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5668\n\
5669 This function is used in examples 14 and 31.\n\
5670\n\
5671\n\
5672\n\
5673SYNOPSIS:\n\
5674\n\
5675plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5676\n\
5677ARGUMENTS:\n\
5678\n\
5679 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5680 by raster drivers, ignored by drivers which use \"real world\" units\n\
5681 (e.g. mm).\n\
5682\n\
5683 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5684 by raster drivers, ignored by drivers which use \"real world\" units\n\
5685 (e.g. mm).\n\
5686\n\
5687 xleng (PLINT, input) : Page length, x.\n\
5688\n\
5689 yleng (PLINT, input) : Page length, y.\n\
5690\n\
5691 xoff (PLINT, input) : Page offset, x.\n\
5692\n\
5693 yoff (PLINT, input) : Page offset, y.\n\
5694";
5695static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5696Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5697\n\
5698DESCRIPTION:\n\
5699\n\
5700 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5701 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5702 Values are negative if an invalid color id is given.\n\
5703\n\
5704 Redacted form: plgcola(r, g, b)\n\
5705\n\
5706 This function is used in example 30.\n\
5707\n\
5708\n\
5709\n\
5710SYNOPSIS:\n\
5711\n\
5712plgcol0a(icol0, r, g, b, alpha)\n\
5713\n\
5714ARGUMENTS:\n\
5715\n\
5716 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5717\n\
5718 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5719 in the range from 0 to 255.\n\
5720\n\
5721 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5722 in the range from 0 to 255.\n\
5723\n\
5724 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5725 in the range from 0 to 255.\n\
5726\n\
5727 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5728 transparency in the range from (0.0-1.0).\n\
5729";
5730static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5731Returns 8-bit RGB values for given color index from cmap0\n\
5732\n\
5733DESCRIPTION:\n\
5734\n\
5735 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5736 PLplot documentation). Values are negative if an invalid color id is\n\
5737 given.\n\
5738\n\
5739 Redacted form: plgcol0(icol0, r, g, b)\n\
5740\n\
5741 This function is used in example 2.\n\
5742\n\
5743\n\
5744\n\
5745SYNOPSIS:\n\
5746\n\
5747plgcol0(icol0, r, g, b)\n\
5748\n\
5749ARGUMENTS:\n\
5750\n\
5751 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5752\n\
5753 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5754 value.\n\
5755\n\
5756 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5757 value.\n\
5758\n\
5759 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5760 value.\n\
5761";
5762static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5763Set parameters incrementally (zoom mode) that define current plot-space window\n\
5764\n\
5765DESCRIPTION:\n\
5766\n\
5767 Set relative minima and maxima incrementally (zoom mode) that define\n\
5768 the current plot-space window. This function has the same effect as\n\
5769 plsdiplt if that function has not been previously called. Otherwise,\n\
5770 this function implements zoom mode using the transformation min_used =\n\
5771 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5772 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5773 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5774\n\
5775 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5776\n\
5777 This function is used in example 31.\n\
5778\n\
5779\n\
5780\n\
5781SYNOPSIS:\n\
5782\n\
5783plsdiplz(xmin, ymin, xmax, ymax)\n\
5784\n\
5785ARGUMENTS:\n\
5786\n\
5787 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5788\n\
5789 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5790\n\
5791 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5792\n\
5793 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5794";
5795static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5796Plot all or a subset of Shapefile data, filling the polygons\n\
5797\n\
5798DESCRIPTION:\n\
5799\n\
5800 As per plmapline, however the items are filled in the same way as\n\
5801 plfill.\n\
5802\n\
5803 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5804 plotentries)\n\
5805\n\
5806 This function is used in example 19.\n\
5807\n\
5808\n\
5809\n\
5810SYNOPSIS:\n\
5811\n\
5812plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5813\n\
5814ARGUMENTS:\n\
5815\n\
5816 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5817 transform the coordinates given in the shapefile into a plot\n\
5818 coordinate system. By using this transform, we can change from a\n\
5819 longitude, latitude coordinate to a polar stereographic project,\n\
5820 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5821 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5822 mapform(), x[] and y[] should be replaced by the corresponding\n\
5823 plot coordinates. If no transform is desired, mapform can be\n\
5824 replaced by NULL.\n\
5825\n\
5826 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5827 the file name of a set of Shapefile files without the file\n\
5828 extension.\n\
5829\n\
5830 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5831 be in the same units as used by the Shapefile. You could use a\n\
5832 very large negative number to plot everything, but you can improve\n\
5833 performance by limiting the area drawn. The units must match those\n\
5834 of the Shapefile projection, which may be for example longitude or\n\
5835 distance. The value of minx must be less than the value of maxx.\n\
5836\n\
5837 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5838 use a very large number to plot everything, but you can improve\n\
5839 performance by limiting the area drawn.\n\
5840\n\
5841 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5842 be in the same units as used by the Shapefile. You could use a\n\
5843 very large negative number to plot everything, but you can improve\n\
5844 performance by limiting the area drawn. The units must match those\n\
5845 of the Shapefile projection, which may be for example latitude or\n\
5846 distance. The value of miny must be less than the value of maxy.\n\
5847\n\
5848 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5849 use a very large number to plot everything, but you can improve\n\
5850 performance by limiting the area drawn.\n\
5851\n\
5852 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5853 zero-based indices of the Shapefile elements which will be drawn.\n\
5854 Setting\n\
5855 plotentries to NULL will plot all elements of the Shapefile.\n\
5856\n\
5857 nplotentries (PLINT, input) : The number of items in\n\
5858 plotentries. Ignored if\n\
5859 plotentries is NULL.\n\
5860";
5861static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5862Draw a line\n\
5863\n\
5864DESCRIPTION:\n\
5865\n\
5866 Draws line defined by n points in x and y.\n\
5867\n\
5868 Redacted form: plline(x, y)\n\
5869\n\
5870 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5871 25-27, and 29.\n\
5872\n\
5873\n\
5874\n\
5875SYNOPSIS:\n\
5876\n\
5877plline(n, x, y)\n\
5878\n\
5879ARGUMENTS:\n\
5880\n\
5881 n (PLINT, input) : Number of points defining line.\n\
5882\n\
5883 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5884 points.\n\
5885\n\
5886 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5887 points.\n\
5888";
5889static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5890Get viewport limits in world coordinates\n\
5891\n\
5892DESCRIPTION:\n\
5893\n\
5894 Get viewport limits in world coordinates.\n\
5895\n\
5896 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5897\n\
5898\n\
5899 This function is used in example 31.\n\
5900\n\
5901\n\
5902\n\
5903SYNOPSIS:\n\
5904\n\
5905plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5906\n\
5907ARGUMENTS:\n\
5908\n\
5909 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5910 viewport limit of the world coordinate in x.\n\
5911\n\
5912 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5913 viewport limit of the world coordinate in x.\n\
5914\n\
5915 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5916 viewport limit of the world coordinate in y.\n\
5917\n\
5918 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5919 viewport limit of the world coordinate in y.\n\
5920";
5921static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5922Set area line fill pattern\n\
5923\n\
5924DESCRIPTION:\n\
5925\n\
5926 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5927 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5928 inclinations and spacings. The arguments to this routine are the\n\
5929 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5930 elements) specifying the inclinations in tenths of a degree and the\n\
5931 spacing in micrometers. (See also plpsty)\n\
5932\n\
5933 Redacted form: General: plpat(inc, del)\n\
5934\n\
5935\n\
5936 This function is used in example 15.\n\
5937\n\
5938\n\
5939\n\
5940SYNOPSIS:\n\
5941\n\
5942plpat(nlin, inc, del)\n\
5943\n\
5944ARGUMENTS:\n\
5945\n\
5946 nlin (PLINT, input) : Number of sets of lines making up the\n\
5947 pattern, either 1 or 2.\n\
5948\n\
5949 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5950 inclination in tenths of a degree. (Should be between -900 and\n\
5951 900).\n\
5952\n\
5953 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5954 spacing in micrometers between the lines making up the pattern.\n\
5955";
5956static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5957Set x axis parameters\n\
5958\n\
5959DESCRIPTION:\n\
5960\n\
5961 Sets values of the digmax and digits flags for the x axis. See the\n\
5962 PLplot documentation for more information.\n\
5963\n\
5964 Redacted form: plsxax(digmax, digits)\n\
5965\n\
5966 This function is used in example 31.\n\
5967\n\
5968\n\
5969\n\
5970SYNOPSIS:\n\
5971\n\
5972plsxax(digmax, digits)\n\
5973\n\
5974ARGUMENTS:\n\
5975\n\
5976 digmax (PLINT, input) : Variable to set the maximum number of\n\
5977 digits for the x axis. If nonzero, the printed label will be\n\
5978 switched to a floating-point representation when the number of\n\
5979 digits exceeds digmax.\n\
5980\n\
5981 digits (PLINT, input) : Field digits value. Currently, changing\n\
5982 its value here has no effect since it is set only by plbox or\n\
5983 plbox3. However, the user may obtain its value after a call to\n\
5984 either of these functions by calling plgxax.\n\
5985";
5986static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5987Get family file parameters\n\
5988\n\
5989DESCRIPTION:\n\
5990\n\
5991 Gets information about current family file, if familying is enabled.\n\
5992 See the PLplot documentation for more information.\n\
5993\n\
5994 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5995\n\
5996 This function is used in examples 14 and 31.\n\
5997\n\
5998\n\
5999\n\
6000SYNOPSIS:\n\
6001\n\
6002plgfam(p_fam, p_num, p_bmax)\n\
6003\n\
6004ARGUMENTS:\n\
6005\n\
6006 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6007 family flag value. If nonzero, familying is enabled for the\n\
6008 current device.\n\
6009\n\
6010 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6011 family file number.\n\
6012\n\
6013 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6014 file size (in bytes) for a family file.\n\
6015";
6016static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
6017Get y axis parameters\n\
6018\n\
6019DESCRIPTION:\n\
6020\n\
6021 Identical to plgxax, except that arguments are flags for y axis. See\n\
6022 the description of plgxax for more detail.\n\
6023\n\
6024 Redacted form: plgyax(p_digmax, p_digits)\n\
6025\n\
6026 This function is used in example 31.\n\
6027\n\
6028\n\
6029\n\
6030SYNOPSIS:\n\
6031\n\
6032plgyax(p_digmax, p_digits)\n\
6033\n\
6034ARGUMENTS:\n\
6035\n\
6036 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6037 number of digits for the y axis. If nonzero, the printed label\n\
6038 has been switched to a floating-point representation when the\n\
6039 number of digits exceeds this value.\n\
6040\n\
6041 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6042 number of digits for the numeric labels (y axis) from the last\n\
6043 plot.\n\
6044";
6045static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6046Plot a glyph at the specified points\n\
6047\n\
6048DESCRIPTION:\n\
6049\n\
6050 Plot a glyph at the specified points. (This function is largely\n\
6051 superseded by plstring which gives access to many[!] more glyphs.)\n\
6052 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6053 and a draw at the same place. Not ideal, since a sufficiently\n\
6054 intelligent output device may optimize it away, or there may be faster\n\
6055 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6056 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6057 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6058 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6059 code <= 127 the corresponding printable ASCII character is plotted.\n\
6060\n\
6061 Redacted form: plpoin(x, y, code)\n\
6062\n\
6063 This function is used in examples 1, 6, 14, and 29.\n\
6064\n\
6065\n\
6066\n\
6067SYNOPSIS:\n\
6068\n\
6069plpoin(n, x, y, code)\n\
6070\n\
6071ARGUMENTS:\n\
6072\n\
6073 n (PLINT, input) : Number of points in the x and y vectors.\n\
6074\n\
6075 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6076 points.\n\
6077\n\
6078 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6079 points.\n\
6080\n\
6081 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6082 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6083 each of the n points.\n\
6084";
6085static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6086Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6087\n\
6088DESCRIPTION:\n\
6089\n\
6090 As per plmapline, however the items are plotted as strings or points\n\
6091 in the same way as plstring.\n\
6092\n\
6093 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6094 maxy, plotentries)\n\
6095\n\
6096 This function is not used in any examples.\n\
6097\n\
6098\n\
6099\n\
6100SYNOPSIS:\n\
6101\n\
6102plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6103\n\
6104ARGUMENTS:\n\
6105\n\
6106 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6107 transform the coordinates given in the shapefile into a plot\n\
6108 coordinate system. By using this transform, we can change from a\n\
6109 longitude, latitude coordinate to a polar stereographic project,\n\
6110 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6111 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6112 mapform(), x[] and y[] should be replaced by the corresponding\n\
6113 plot coordinates. If no transform is desired, mapform can be\n\
6114 replaced by NULL.\n\
6115\n\
6116 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6117 the file name of a set of Shapefile files without the file\n\
6118 extension.\n\
6119\n\
6120 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6121 drawn.\n\
6122\n\
6123 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6124 be in the same units as used by the Shapefile. You could use a\n\
6125 very large negative number to plot everything, but you can improve\n\
6126 performance by limiting the area drawn. The units must match those\n\
6127 of the Shapefile projection, which may be for example longitude or\n\
6128 distance. The value of minx must be less than the value of maxx.\n\
6129\n\
6130 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6131 use a very large number to plot everything, but you can improve\n\
6132 performance by limiting the area drawn.\n\
6133\n\
6134 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6135 be in the same units as used by the Shapefile. You could use a\n\
6136 very large negative number to plot everything, but you can improve\n\
6137 performance by limiting the area drawn. The units must match those\n\
6138 of the Shapefile projection, which may be for example latitude or\n\
6139 distance. The value of miny must be less than the value of maxy.\n\
6140\n\
6141 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6142 use a very large number to plot everything, but you can improve\n\
6143 performance by limiting the area drawn.\n\
6144\n\
6145 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6146 zero-based indices of the Shapefile elements which will be drawn.\n\
6147 Setting\n\
6148 plotentries to NULL will plot all elements of the Shapefile.\n\
6149\n\
6150 nplotentries (PLINT, input) : The number of items in\n\
6151 plotentries. Ignored if\n\
6152 plotentries is NULL.\n\
6153";
6154static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6155Select area fill pattern\n\
6156\n\
6157DESCRIPTION:\n\
6158\n\
6159 If\n\
6160 patt is zero or less use either a hardware solid fill if the drivers\n\
6161 have that capability (virtually all do) or fall back to a software\n\
6162 emulation of a solid fill using the eighth area line fill pattern. If\n\
6163 0 <\n\
6164 patt <= 8, then select one of eight predefined area line fill patterns\n\
6165 to use (see plpat if you desire other patterns).\n\
6166\n\
6167 Redacted form: plpsty(patt)\n\
6168\n\
6169 This function is used in examples 12, 13, 15, 16, and 25.\n\
6170\n\
6171\n\
6172\n\
6173SYNOPSIS:\n\
6174\n\
6175plpsty(patt)\n\
6176\n\
6177ARGUMENTS:\n\
6178\n\
6179 patt (PLINT, input) : The desired pattern index. If\n\
6180 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6181 above) used. For\n\
6182 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6183 line fill capability itself (most deliberately do not so that line\n\
6184 fill patterns look identical for those drivers), the patterns\n\
6185 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6186 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6187 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6188 (8) lines at both 45 degrees and -45 degrees.\n\
6189";
6190static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6191Set 8-bit RGB values for given cmap0 color index\n\
6192\n\
6193DESCRIPTION:\n\
6194\n\
6195 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6196 index. Overwrites the previous color value for the given index and,\n\
6197 thus, does not result in any additional allocation of space for\n\
6198 colors.\n\
6199\n\
6200 Redacted form: plscol0(icol0, r, g, b)\n\
6201\n\
6202 This function is used in any example 31.\n\
6203\n\
6204\n\
6205\n\
6206SYNOPSIS:\n\
6207\n\
6208plscol0(icol0, r, g, b)\n\
6209\n\
6210ARGUMENTS:\n\
6211\n\
6212 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6213 number of colors (which is set by default, by plscmap0n, or even\n\
6214 by plscmap0).\n\
6215\n\
6216 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6217 degree of red in the color.\n\
6218\n\
6219 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6220 degree of green in the color.\n\
6221\n\
6222 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6223 degree of blue in the color.\n\
6224";
6225static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6226Used to globally turn color output on/off\n\
6227\n\
6228DESCRIPTION:\n\
6229\n\
6230 Used to globally turn color output on/off for those drivers/devices\n\
6231 that support it.\n\
6232\n\
6233 Redacted form: plscolor(color)\n\
6234\n\
6235 This function is used in example 31.\n\
6236\n\
6237\n\
6238\n\
6239SYNOPSIS:\n\
6240\n\
6241plscolor(color)\n\
6242\n\
6243ARGUMENTS:\n\
6244\n\
6245 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6246 turned off. If non-zero, color is turned on.\n\
6247";
6248static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6249End plotting session\n\
6250\n\
6251DESCRIPTION:\n\
6252\n\
6253 Ends a plotting session, tidies up all the output files, switches\n\
6254 interactive devices back into text mode and frees up any memory that\n\
6255 was allocated. Must be called before end of program.\n\
6256\n\
6257 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6258 wait state after a call to plend or other functions which trigger the\n\
6259 end of a plot page. To avoid this, use the plspause function.\n\
6260\n\
6261 Redacted form: plend()\n\
6262\n\
6263 This function is used in all of the examples.\n\
6264\n\
6265\n\
6266\n\
6267SYNOPSIS:\n\
6268\n\
6269plend()\n\
6270";
6271static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6272Plot a histogram from binned data\n\
6273\n\
6274DESCRIPTION:\n\
6275\n\
6276 Plots a histogram consisting of nbin bins. The value associated with\n\
6277 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6278 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6279 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6280 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6281 placed midway between the values in the x vector. Also see plhist for\n\
6282 drawing histograms from unbinned data.\n\
6283\n\
6284 Redacted form: General: plbin(x, y, opt)\n\
6285 Python: plbin(nbin, x, y, opt)\n\
6286\n\
6287\n\
6288 This function is not used in any examples.\n\
6289\n\
6290\n\
6291\n\
6292SYNOPSIS:\n\
6293\n\
6294plbin(nbin, x, y, opt)\n\
6295\n\
6296ARGUMENTS:\n\
6297\n\
6298 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6299 and y vectors.)\n\
6300\n\
6301 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6302 with bins. These must form a strictly increasing sequence.\n\
6303\n\
6304 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6305 proportional to the number of points in each bin. This is a PLFLT\n\
6306 (instead of PLINT) vector so as to allow histograms of\n\
6307 probabilities, etc.\n\
6308\n\
6309 opt (PLINT, input) : Is a combination of several flags:\n\
6310 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6311 outer bins are expanded to fill up the entire x-axis and bins of\n\
6312 zero height are simply drawn.\n\
6313 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6314 between the x values. If the values in x are equally spaced,\n\
6315 the values are the center values of the bins.\n\
6316 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6317 size as the ones inside.\n\
6318 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6319 (there is a gap for such bins).\n\
6320";
6321static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6322Plot a 2D matrix using cmap1\n\
6323\n\
6324DESCRIPTION:\n\
6325\n\
6326 Plot a 2D matrix using cmap1.\n\
6327\n\
6328 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6329 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6330\n\
6331\n\
6332 This function is used in example 20.\n\
6333\n\
6334\n\
6335\n\
6336SYNOPSIS:\n\
6337\n\
6338plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6339\n\
6340ARGUMENTS:\n\
6341\n\
6342 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6343 plot. Should have dimensions of\n\
6344 nx by\n\
6345 ny.\n\
6346\n\
6347 nx, ny (PLINT, input) : Dimensions of idata\n\
6348\n\
6349 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6350 pltr below for how these arguments are used (only for the special case\n\
6351 when the callback function\n\
6352 pltr is not supplied).\n\
6353\n\
6354 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6355 (inclusive) will be plotted.\n\
6356\n\
6357 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6358 values to use for value to color mappings. A datum equal to or\n\
6359 less than valuemin will be plotted with color 0.0, while a datum\n\
6360 equal to or greater than valuemax will be plotted with color 1.0.\n\
6361 Data between valuemin and valuemax map linearly to colors in the\n\
6362 range (0.0-1.0).\n\
6363\n\
6364 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6365 defines the transformation between the zero-based indices of the\n\
6366 matrix idata and world coordinates. If\n\
6367 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6368 indices of idata are mapped to the range\n\
6369 xmin through\n\
6370 xmax and the y indices of idata are mapped to the range\n\
6371 ymin through\n\
6372 ymax.For the C case, transformation functions are provided in the\n\
6373 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6374 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6375 matrices. In addition, C callback routines for the transformation\n\
6376 can be supplied by the user such as the mypltr function in\n\
6377 examples/c/x09c.c which provides a general linear transformation\n\
6378 between index coordinates and world coordinates.For languages\n\
6379 other than C you should consult the PLplot documentation for the\n\
6380 details concerning how PLTRANSFORM_callback arguments are\n\
6381 interfaced. However, in general, a particular pattern of\n\
6382 callback-associated arguments such as a tr vector with 6 elements;\n\
6383 xg and yg vectors; or xg and yg matrices are respectively\n\
6384 interfaced to a linear-transformation routine similar to the above\n\
6385 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6386 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6387 support native language callbacks for handling index to\n\
6388 world-coordinate transformations. Examples of these various\n\
6389 approaches are given in examples/<language>x09*,\n\
6390 examples/<language>x16*, examples/<language>x20*,\n\
6391 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6392 supported languages.\n\
6393\n\
6394 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6395 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6396 externally supplied.\n\
6397";
6398static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6399Sets the 3D position of the light source\n\
6400\n\
6401DESCRIPTION:\n\
6402\n\
6403 Sets the 3D position of the light source for use with plsurf3d and\n\
6404 plsurf3dl\n\
6405\n\
6406 Redacted form: pllightsource(x, y, z)\n\
6407\n\
6408 This function is used in example 8.\n\
6409\n\
6410\n\
6411\n\
6412SYNOPSIS:\n\
6413\n\
6414pllightsource(x, y, z)\n\
6415\n\
6416ARGUMENTS:\n\
6417\n\
6418 x (PLFLT, input) : X-coordinate of the light source.\n\
6419\n\
6420 y (PLFLT, input) : Y-coordinate of the light source.\n\
6421\n\
6422 z (PLFLT, input) : Z-coordinate of the light source.\n\
6423";
6424static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6425Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6426\n\
6427DESCRIPTION:\n\
6428\n\
6429 When the implementation is completed this variant of plot3dc (see that\n\
6430 function\'s documentation for more details) should be suitable for the\n\
6431 case where the area of the x, y coordinate grid where z is defined can\n\
6432 be non-rectangular. The implementation is incomplete so the last 4\n\
6433 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6434 indexymax; are currently ignored and the functionality is otherwise\n\
6435 identical to that of plot3dc.\n\
6436\n\
6437 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6438 indexymin, indexymax)\n\
6439\n\
6440\n\
6441 This function is not used in any example.\n\
6442\n\
6443\n\
6444\n\
6445SYNOPSIS:\n\
6446\n\
6447plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6448\n\
6449ARGUMENTS:\n\
6450\n\
6451 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6452 which the function is evaluated.\n\
6453\n\
6454 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6455 which the function is evaluated.\n\
6456\n\
6457 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6458 plot. Should have dimensions of\n\
6459 nx by\n\
6460 ny.\n\
6461\n\
6462 nx (PLINT, input) : Number of x values at which the function is\n\
6463 evaluated.\n\
6464\n\
6465 ny (PLINT, input) : Number of y values at which the function is\n\
6466 evaluated.\n\
6467\n\
6468 opt (PLINT, input) : Determines the way in which the surface is\n\
6469 represented. To specify more than one option just add the options,\n\
6470 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6471 showing z as a function of x for each value of y[j] .\n\
6472 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6473 for each value of x[i] .\n\
6474 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6475 at which function is defined.\n\
6476 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6477 the z value being plotted. The color is used from the current\n\
6478 cmap1.\n\
6479 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6480 using parameters\n\
6481 nlevel and\n\
6482 clevel.\n\
6483 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6484 the borders of the plotted function.\n\
6485\n\
6486\n\
6487 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6488 levels.\n\
6489\n\
6490 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6491\n\
6492 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6493 corresponds to the first x index where z is defined.\n\
6494\n\
6495 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6496 which corresponds (by convention) to one more than the last x\n\
6497 index value where z is defined.\n\
6498\n\
6499 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6500 values which all must be ≥ 0. These values are the first y index\n\
6501 where z is defined for a particular x index in the range from\n\
6502 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6503 indexxmax.\n\
6504\n\
6505 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6506 values which all must be ≤ ny. These values correspond (by\n\
6507 convention) to one more than the last y index where z is defined\n\
6508 for a particular x index in the range from indexxmin to indexxmax\n\
6509 - 1. The dimension of indexymax is indexxmax.\n\
6510";
6511static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6512Creates a new stream and makes it the default\n\
6513\n\
6514DESCRIPTION:\n\
6515\n\
6516 Creates a new stream and makes it the default. Differs from using\n\
6517 plsstrm, in that a free stream number is found, and returned.\n\
6518 Unfortunately, I have to start at stream 1 and work upward, since\n\
6519 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6520 that no initial, library-opening call is required. So stream 0 must\n\
6521 be preallocated, and there is no simple way of determining whether it\n\
6522 is already in use or not.\n\
6523\n\
6524 Redacted form: plmkstrm(p_strm)\n\
6525\n\
6526 This function is used in examples 1 and 20.\n\
6527\n\
6528\n\
6529\n\
6530SYNOPSIS:\n\
6531\n\
6532plmkstrm(p_strm)\n\
6533\n\
6534ARGUMENTS:\n\
6535\n\
6536 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6537 number of the created stream.\n\
6538";
6539static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6540Set FCI (font characterization integer)\n\
6541\n\
6542DESCRIPTION:\n\
6543\n\
6544 Sets font characteristics to be used at the start of the next string\n\
6545 using the FCI approach. See the PLplot documentation for more\n\
6546 information. Note, plsfont (which calls plsfci internally) provides a\n\
6547 more user-friendly API for setting the font characterisitics.\n\
6548\n\
6549 Redacted form: General: plsfci(fci)\n\
6550\n\
6551\n\
6552 This function is used in example 23.\n\
6553\n\
6554\n\
6555\n\
6556SYNOPSIS:\n\
6557\n\
6558plsfci(fci)\n\
6559\n\
6560ARGUMENTS:\n\
6561\n\
6562 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6563 of FCI.\n\
6564";
6565static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6566Initialize PLplot\n\
6567\n\
6568DESCRIPTION:\n\
6569\n\
6570 Initializing the plotting package. The program prompts for the device\n\
6571 keyword or number of the desired output device. Hitting a RETURN in\n\
6572 response to the prompt is the same as selecting the first device.\n\
6573 plinit will issue no prompt if either the device was specified\n\
6574 previously (via command line flag, the plsetopt function, or the\n\
6575 plsdev function), or if only one device is enabled when PLplot is\n\
6576 installed. If subpages have been specified, the output device is\n\
6577 divided into nx by ny subpages, each of which may be used\n\
6578 independently. If plinit is called again during a program, the\n\
6579 previously opened file will be closed. The subroutine pladv is used\n\
6580 to advance from one subpage to the next.\n\
6581\n\
6582 Redacted form: plinit()\n\
6583\n\
6584 This function is used in all of the examples.\n\
6585\n\
6586\n\
6587\n\
6588SYNOPSIS:\n\
6589\n\
6590plinit()\n\
6591";
6592static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6593Set line style\n\
6594\n\
6595DESCRIPTION:\n\
6596\n\
6597 This sets up the line style for all lines subsequently drawn. A line\n\
6598 consists of segments in which the pen is alternately down and up. The\n\
6599 lengths of these segments are passed in the vectors mark and space\n\
6600 respectively. The number of mark-space pairs is specified by nms. In\n\
6601 order to return the line style to the default continuous line, plstyl\n\
6602 should be called with nms =0 .(see also pllsty)\n\
6603\n\
6604 Redacted form: plstyl(mark, space)\n\
6605\n\
6606 This function is used in examples 1, 9, and 14.\n\
6607\n\
6608\n\
6609\n\
6610SYNOPSIS:\n\
6611\n\
6612plstyl(nms, mark, space)\n\
6613\n\
6614ARGUMENTS:\n\
6615\n\
6616 nms (PLINT, input) : The number of mark and space elements in a\n\
6617 line. Thus a simple broken line can be obtained by setting nms=1\n\
6618 . A continuous line is specified by setting nms=0 .\n\
6619\n\
6620 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6621 segments during which the pen is down, measured in micrometers.\n\
6622\n\
6623 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6624 the segments during which the pen is up, measured in micrometers.\n\
6625";
6626static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6627Set length of minor ticks\n\
6628\n\
6629DESCRIPTION:\n\
6630\n\
6631 This sets up the length of the minor ticks and the length of the\n\
6632 terminals on error bars. The actual length is the product of the\n\
6633 default length and a scaling factor as for character height.\n\
6634\n\
6635 Redacted form: plsmin(def, scale)\n\
6636\n\
6637 This function is used in example 29.\n\
6638\n\
6639\n\
6640\n\
6641SYNOPSIS:\n\
6642\n\
6643plsmin(def, scale)\n\
6644\n\
6645ARGUMENTS:\n\
6646\n\
6647 def (PLFLT, input) : The default length of a minor tick in\n\
6648 millimeters, should be set to zero if the default length is to\n\
6649 remain unchanged.\n\
6650\n\
6651 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6652 actual tick length.\n\
6653";
6654static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6655Draw a box with axes, etc, in 3-d\n\
6656\n\
6657DESCRIPTION:\n\
6658\n\
6659 Draws axes, numeric and text labels for a three-dimensional surface\n\
6660 plot. For a more complete description of three-dimensional plotting\n\
6661 see the PLplot documentation.\n\
6662\n\
6663 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6664 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6665\n\
6666\n\
6667 This function is used in examples 8, 11, 18, and 21.\n\
6668\n\
6669\n\
6670\n\
6671SYNOPSIS:\n\
6672\n\
6673plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6674\n\
6675ARGUMENTS:\n\
6676\n\
6677 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6678 options for the x axis. The string can include any combination of\n\
6679 the following letters (upper or lower case) in any order: b: Draws\n\
6680 axis at base, at height z=\n\
6681 zmin where zmin is defined by call to plw3d. This character must be\n\
6682 specified in order to use any of the other options.\n\
6683 d: Plot labels as date / time. Values are assumed to be\n\
6684 seconds since the epoch (as used by gmtime).\n\
6685 f: Always use fixed point numeric labels.\n\
6686 i: Inverts tick marks, so they are drawn downwards, rather\n\
6687 than upwards.\n\
6688 l: Labels axis logarithmically. This only affects the labels,\n\
6689 not the data, and so it is necessary to compute the logarithms\n\
6690 of data points before passing them to any of the drawing\n\
6691 routines.\n\
6692 n: Writes numeric labels at major tick intervals.\n\
6693 o: Use custom labelling function to generate axis label text.\n\
6694 The custom labelling function can be defined with the\n\
6695 plslabelfunc command.\n\
6696 s: Enables subticks between major ticks, only valid if t is\n\
6697 also specified.\n\
6698 t: Draws major ticks.\n\
6699 u: If this is specified, the text label for the axis is\n\
6700 written under the axis.\n\
6701\n\
6702\n\
6703 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6704 the text label for the x axis. It is only drawn if u is in the\n\
6705 xopt string.\n\
6706\n\
6707 xtick (PLFLT, input) : World coordinate interval between major\n\
6708 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6709 generates a suitable tick interval.\n\
6710\n\
6711 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6712 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6713 generates a suitable minor tick interval.\n\
6714\n\
6715 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6716 options for the y axis. The string is interpreted in the same way\n\
6717 as xopt.\n\
6718\n\
6719 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6720 the text label for the y axis. It is only drawn if u is in the\n\
6721 yopt string.\n\
6722\n\
6723 ytick (PLFLT, input) : World coordinate interval between major\n\
6724 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6725 generates a suitable tick interval.\n\
6726\n\
6727 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6728 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6729 generates a suitable minor tick interval.\n\
6730\n\
6731 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6732 options for the z axis. The string can include any combination of\n\
6733 the following letters (upper or lower case) in any order: b: Draws\n\
6734 z axis to the left of the surface plot.\n\
6735 c: Draws z axis to the right of the surface plot.\n\
6736 d: Draws grid lines parallel to the x-y plane behind the\n\
6737 figure. These lines are not drawn until after plot3d or\n\
6738 plmesh are called because of the need for hidden line removal.\n\
6739 e: Plot labels as date / time. Values are assumed to be\n\
6740 seconds since the epoch (as used by gmtime). Note this\n\
6741 suboption is interpreted the same as the d suboption for xopt\n\
6742 and yopt, but it has to be identified as e for zopt since d\n\
6743 has already been used for the different purpose above.\n\
6744 f: Always use fixed point numeric labels.\n\
6745 i: Inverts tick marks, so they are drawn away from the center.\n\
6746 l: Labels axis logarithmically. This only affects the labels,\n\
6747 not the data, and so it is necessary to compute the logarithms\n\
6748 of data points before passing them to any of the drawing\n\
6749 routines.\n\
6750 m: Writes numeric labels at major tick intervals on the\n\
6751 right-hand z axis.\n\
6752 n: Writes numeric labels at major tick intervals on the\n\
6753 left-hand z axis.\n\
6754 o: Use custom labelling function to generate axis label text.\n\
6755 The custom labelling function can be defined with the\n\
6756 plslabelfunc command.\n\
6757 s: Enables subticks between major ticks, only valid if t is\n\
6758 also specified.\n\
6759 t: Draws major ticks.\n\
6760 u: If this is specified, the text label is written beside the\n\
6761 left-hand axis.\n\
6762 v: If this is specified, the text label is written beside the\n\
6763 right-hand axis.\n\
6764\n\
6765\n\
6766 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6767 the text label for the z axis. It is only drawn if u or v are in\n\
6768 the zopt string.\n\
6769\n\
6770 ztick (PLFLT, input) : World coordinate interval between major\n\
6771 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6772 generates a suitable tick interval.\n\
6773\n\
6774 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6775 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6776 generates a suitable minor tick interval.\n\
6777";
6778static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6779Set character size\n\
6780\n\
6781DESCRIPTION:\n\
6782\n\
6783 This sets up the size of all subsequent characters drawn. The actual\n\
6784 height of a character is the product of the default character size and\n\
6785 a scaling factor.\n\
6786\n\
6787 Redacted form: plschr(def, scale)\n\
6788\n\
6789 This function is used in examples 2, 13, 23, and 24.\n\
6790\n\
6791\n\
6792\n\
6793SYNOPSIS:\n\
6794\n\
6795plschr(def, scale)\n\
6796\n\
6797ARGUMENTS:\n\
6798\n\
6799 def (PLFLT, input) : The default height of a character in\n\
6800 millimeters, should be set to zero if the default height is to\n\
6801 remain unchanged. For rasterized drivers the dx and dy values\n\
6802 specified in plspage are used to convert from mm to pixels (note\n\
6803 the different unit systems used). This dpi aware scaling is not\n\
6804 implemented for all drivers yet.\n\
6805\n\
6806 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6807 actual character height.\n\
6808";
6809static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6810Calculate continuous time from broken-down time for the current stream\n\
6811\n\
6812DESCRIPTION:\n\
6813\n\
6814 Calculate continuous time, ctime, from broken-down time for the\n\
6815 current stream. The broken-down\n\
6816 time is specified by the following parameters: year, month, day, hour,\n\
6817 min, and sec. This function is the inverse of plbtime.\n\
6818\n\
6819 The PLplot definition of broken-down time is a calendar time that\n\
6820 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6821 responsibility to apply those offsets (if so desired) before using the\n\
6822 PLplot time API. By default broken-down time is defined using the\n\
6823 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6824 continuous time is defined as the number of seconds since the Unix\n\
6825 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6826 broken-down and continuous time are possible, see plconfigtime which\n\
6827 specifies that transformation for the current stream.\n\
6828\n\
6829 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6830 ctime)\n\
6831\n\
6832\n\
6833 This function is used in example 29.\n\
6834\n\
6835\n\
6836\n\
6837SYNOPSIS:\n\
6838\n\
6839plctime(year, month, day, hour, min, sec, ctime)\n\
6840\n\
6841ARGUMENTS:\n\
6842\n\
6843 year (PLINT, input) : Input year.\n\
6844\n\
6845 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6846 (December).\n\
6847\n\
6848 day (PLINT, input) : Input day in range from 1 to 31.\n\
6849\n\
6850 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6851\n\
6852 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6853\n\
6854 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6855\n\
6856 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6857 time calculated from the broken-down time specified by the\n\
6858 previous parameters.\n\
6859";
6860static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6861Set color, cmap0\n\
6862\n\
6863DESCRIPTION:\n\
6864\n\
6865 Sets the color index for cmap0 (see the PLplot documentation).\n\
6866\n\
6867 Redacted form: plcol0(icol0)\n\
6868\n\
6869 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6870\n\
6871\n\
6872\n\
6873SYNOPSIS:\n\
6874\n\
6875plcol0(icol0)\n\
6876\n\
6877ARGUMENTS:\n\
6878\n\
6879 icol0 (PLINT, input) : Integer representing the color. The\n\
6880 defaults at present are (these may change):\n\
6881 0 black (default background)\n\
6882 1 red (default foreground)\n\
6883 2 yellow\n\
6884 3 green\n\
6885 4 aquamarine\n\
6886 5 pink\n\
6887 6 wheat\n\
6888 7 grey\n\
6889 8 brown\n\
6890 9 blue\n\
6891 10 BlueViolet\n\
6892 11 cyan\n\
6893 12 turquoise\n\
6894 13 magenta\n\
6895 14 salmon\n\
6896 15 white\n\
6897\n\
6898 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6899 change an individual color in the cmap0 color palette.\n\
6900";
6901static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6902Set color, cmap1\n\
6903\n\
6904DESCRIPTION:\n\
6905\n\
6906 Sets the color for cmap1 (see the PLplot documentation).\n\
6907\n\
6908 Redacted form: plcol1(col1)\n\
6909\n\
6910 This function is used in examples 12 and 21.\n\
6911\n\
6912\n\
6913\n\
6914SYNOPSIS:\n\
6915\n\
6916plcol1(col1)\n\
6917\n\
6918ARGUMENTS:\n\
6919\n\
6920 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6921 is mapped to color using the continuous cmap1 palette which by\n\
6922 default ranges from blue to the background color to red. The\n\
6923 cmap1 palette can also be straightforwardly changed by the user\n\
6924 with plscmap1 or plscmap1l.\n\
6925";
6926static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6927Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6928\n\
6929DESCRIPTION:\n\
6930\n\
6931 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6932\n\
6933 Redacted form: plgcolbg(r, g, b)\n\
6934\n\
6935 This function is used in example 31.\n\
6936\n\
6937\n\
6938\n\
6939SYNOPSIS:\n\
6940\n\
6941plgcolbg(r, g, b)\n\
6942\n\
6943ARGUMENTS:\n\
6944\n\
6945 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6946 in the range from 0 to 255.\n\
6947\n\
6948 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6949 in the range from 0 to 255.\n\
6950\n\
6951 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6952 in the range from 0 to 255.\n\
6953";
6954static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6955Draw a circular or elliptical arc\n\
6956\n\
6957DESCRIPTION:\n\
6958\n\
6959 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6960 semiminor axis b, starting at angle1 and ending at angle2.\n\
6961\n\
6962 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6963 fill)\n\
6964\n\
6965\n\
6966 This function is used in examples 3 and 27.\n\
6967\n\
6968\n\
6969\n\
6970SYNOPSIS:\n\
6971\n\
6972plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6973\n\
6974ARGUMENTS:\n\
6975\n\
6976 x (PLFLT, input) : X coordinate of arc center.\n\
6977\n\
6978 y (PLFLT, input) : Y coordinate of arc center.\n\
6979\n\
6980 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6981\n\
6982 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6983\n\
6984 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6985 semimajor axis.\n\
6986\n\
6987 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6988 semimajor axis.\n\
6989\n\
6990 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6991 X-axis.\n\
6992\n\
6993 fill (PLBOOL, input) : Draw a filled arc.\n\
6994";
6995static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6996Parse command-line arguments\n\
6997\n\
6998DESCRIPTION:\n\
6999\n\
7000 Parse command-line arguments.\n\
7001\n\
7002 plparseopts removes all recognized flags (decreasing argc\n\
7003 accordingly), so that invalid input may be readily detected. It can\n\
7004 also be used to process user command line flags. The user can merge\n\
7005 an option table of type PLOptionTable into the internal option table\n\
7006 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7007 the external table(s) be parsed by calling plClearOpts before\n\
7008 plMergeOpts.\n\
7009\n\
7010 The default action taken by plparseopts is as follows:\n\
7011 Returns with an error if an unrecognized option or badly formed\n\
7012 option-value pair are encountered.\n\
7013 Returns immediately (return code 0) when the first non-option command\n\
7014 line argument is found.\n\
7015 Returns with the return code of the option handler, if one was called.\n\
7016\n\
7017 Deletes command line arguments from argv list as they are found, and\n\
7018 decrements argc accordingly.\n\
7019 Does not show \"invisible\" options in usage or help messages.\n\
7020 Assumes the program name is contained in argv[0].\n\
7021\n\
7022 These behaviors may be controlled through the\n\
7023 mode argument.\n\
7024\n\
7025 Redacted form: General: plparseopts(argv, mode)\n\
7026\n\
7027\n\
7028 This function is used in all of the examples.\n\
7029\n\
7030\n\
7031\n\
7032SYNOPSIS:\n\
7033\n\
7034PLINT plparseopts(p_argc, argv, mode)\n\
7035\n\
7036ARGUMENTS:\n\
7037\n\
7038 p_argc (int *, input/output) : Number of arguments.\n\
7039\n\
7040 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7041 strings containing *p_argc command-line arguments.\n\
7042\n\
7043 mode (PLINT, input) : Parsing mode with the following\n\
7044 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7045 and all error messages enabled, including program exit when an\n\
7046 error occurs. Anything on the command line that isn\'t recognized\n\
7047 as a valid option or option argument is flagged as an error.\n\
7048 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7049 of errors.\n\
7050 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7051 arguments.\n\
7052 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7053 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7054 pointer to the program name.\n\
7055 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7056 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7057 unrecognized arguments.\n\
7058";
7059static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
7060Get parameters that define current device-space window\n\
7061\n\
7062DESCRIPTION:\n\
7063\n\
7064 Get relative margin width, aspect ratio, and relative justification\n\
7065 that define current device-space window. If plsdidev has not been\n\
7066 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7067 p_jy will all be 0.\n\
7068\n\
7069 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7070\n\
7071 This function is used in example 31.\n\
7072\n\
7073\n\
7074\n\
7075SYNOPSIS:\n\
7076\n\
7077plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7078\n\
7079ARGUMENTS:\n\
7080\n\
7081 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7082 margin width.\n\
7083\n\
7084 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7085 ratio.\n\
7086\n\
7087 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7088 justification in x.\n\
7089\n\
7090 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7091 justification in y.\n\
7092";
7093static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7094Assign a function to use for generating custom axis labels\n\
7095\n\
7096DESCRIPTION:\n\
7097\n\
7098 This function allows a user to provide their own function to provide\n\
7099 axis label text. The user function is given the numeric value for a\n\
7100 point on an axis and returns a string label to correspond with that\n\
7101 value. Custom axis labels can be enabled by passing appropriate\n\
7102 arguments to plenv, plbox, plbox3 and similar functions.\n\
7103\n\
7104 This function is used in example 19.\n\
7105\n\
7106\n\
7107\n\
7108SYNOPSIS:\n\
7109\n\
7110plslabelfunc(label_func, label_data)\n\
7111\n\
7112ARGUMENTS:\n\
7113\n\
7114 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7115 label function. In order to reset to the default labelling, set\n\
7116 this to NULL. The labelling function parameters are, in order:\n\
7117 axis: This indicates which axis a label is being requested for.\n\
7118 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7119\n\
7120 value: This is the value along the axis which is being labelled.\n\
7121\n\
7122 label_text: The string representation of the label value.\n\
7123\n\
7124 length: The maximum length in characters allowed for label_text.\n\
7125\n\
7126\n\
7127 label_data (PLPointer, input) : This parameter may be used to pass\n\
7128 data to the label_func function.\n\
7129";
7130static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7131Get the (current) run level\n\
7132\n\
7133DESCRIPTION:\n\
7134\n\
7135 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7136 1, initialized\n\
7137 2, viewport defined\n\
7138 3, world coordinates defined\n\
7139\n\
7140\n\
7141 Redacted form: plglevel(p_level)\n\
7142\n\
7143 This function is used in example 31.\n\
7144\n\
7145\n\
7146\n\
7147SYNOPSIS:\n\
7148\n\
7149plglevel(p_level)\n\
7150\n\
7151ARGUMENTS:\n\
7152\n\
7153 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7154 level.\n\
7155";
7156static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7157Select line style\n\
7158\n\
7159DESCRIPTION:\n\
7160\n\
7161 This sets the line style according to one of eight predefined patterns\n\
7162 (also see plstyl).\n\
7163\n\
7164 Redacted form: pllsty(lin)\n\
7165\n\
7166 This function is used in examples 9, 12, 22, and 25.\n\
7167\n\
7168\n\
7169\n\
7170SYNOPSIS:\n\
7171\n\
7172pllsty(lin)\n\
7173\n\
7174ARGUMENTS:\n\
7175\n\
7176 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7177 a continuous line, line style 2 is a line with short dashes and\n\
7178 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7179 4 has long dashes and short gaps and so on.\n\
7180";
7181static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7182Set up standard window and draw box\n\
7183\n\
7184DESCRIPTION:\n\
7185\n\
7186 Sets up plotter environment for simple graphs by calling pladv and\n\
7187 setting up viewport and window to sensible default values. plenv\n\
7188 leaves a standard margin (left-hand margin of eight character heights,\n\
7189 and a margin around the other three sides of five character heights)\n\
7190 around most graphs for axis labels and a title. When these defaults\n\
7191 are not suitable, use the individual routines plvpas, plvpor, or\n\
7192 plvasp for setting up the viewport, plwind for defining the window,\n\
7193 and plbox for drawing the box.\n\
7194\n\
7195 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7196\n\
7197 This function is used in example 1,3,9,13,14,19-22,29.\n\
7198\n\
7199\n\
7200\n\
7201SYNOPSIS:\n\
7202\n\
7203plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7204\n\
7205ARGUMENTS:\n\
7206\n\
7207 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7208 world coordinates).\n\
7209\n\
7210 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7211 world coordinates).\n\
7212\n\
7213 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7214 coordinates).\n\
7215\n\
7216 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7217 coordinates).\n\
7218\n\
7219 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7220 scales will not be set, the user must set up the scale before\n\
7221 calling plenv using plsvpa, plvasp or other.\n\
7222 0: the x and y axes are scaled independently to use as much of\n\
7223 the screen as possible.\n\
7224 1: the scales of the x and y axes are made equal.\n\
7225 2: the axis of the x and y axes are made equal, and the plot\n\
7226 box will be square.\n\
7227\n\
7228\n\
7229 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7230 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7231 -1: draw box only.\n\
7232 0: draw box, ticks, and numeric tick labels.\n\
7233 1: also draw coordinate axes at x=0 and y=0.\n\
7234 2: also draw a grid at major tick positions in both\n\
7235 coordinates.\n\
7236 3: also draw a grid at minor tick positions in both\n\
7237 coordinates.\n\
7238 10: same as 0 except logarithmic x tick marks. (The x data\n\
7239 have to be converted to logarithms separately.)\n\
7240 11: same as 1 except logarithmic x tick marks. (The x data\n\
7241 have to be converted to logarithms separately.)\n\
7242 12: same as 2 except logarithmic x tick marks. (The x data\n\
7243 have to be converted to logarithms separately.)\n\
7244 13: same as 3 except logarithmic x tick marks. (The x data\n\
7245 have to be converted to logarithms separately.)\n\
7246 20: same as 0 except logarithmic y tick marks. (The y data\n\
7247 have to be converted to logarithms separately.)\n\
7248 21: same as 1 except logarithmic y tick marks. (The y data\n\
7249 have to be converted to logarithms separately.)\n\
7250 22: same as 2 except logarithmic y tick marks. (The y data\n\
7251 have to be converted to logarithms separately.)\n\
7252 23: same as 3 except logarithmic y tick marks. (The y data\n\
7253 have to be converted to logarithms separately.)\n\
7254 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7255 and y data have to be converted to logarithms separately.)\n\
7256 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7257 and y data have to be converted to logarithms separately.)\n\
7258 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7259 and y data have to be converted to logarithms separately.)\n\
7260 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7261 and y data have to be converted to logarithms separately.)\n\
7262 40: same as 0 except date / time x labels.\n\
7263 41: same as 1 except date / time x labels.\n\
7264 42: same as 2 except date / time x labels.\n\
7265 43: same as 3 except date / time x labels.\n\
7266 50: same as 0 except date / time y labels.\n\
7267 51: same as 1 except date / time y labels.\n\
7268 52: same as 2 except date / time y labels.\n\
7269 53: same as 3 except date / time y labels.\n\
7270 60: same as 0 except date / time x and y labels.\n\
7271 61: same as 1 except date / time x and y labels.\n\
7272 62: same as 2 except date / time x and y labels.\n\
7273 63: same as 3 except date / time x and y labels.\n\
7274 70: same as 0 except custom x and y labels.\n\
7275 71: same as 1 except custom x and y labels.\n\
7276 72: same as 2 except custom x and y labels.\n\
7277 73: same as 3 except custom x and y labels.\n\
7278";
7279static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7280Initialization\n\
7281\n\
7282DESCRIPTION:\n\
7283\n\
7284 Alternative to plstar for initializing the plotting package. The\n\
7285 device name keyword for the desired output device must be supplied as\n\
7286 an argument. These keywords are the same as those printed out by\n\
7287 plstar. If the requested device is not available, or if the input\n\
7288 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7289 is used. This routine also divides the output device page into nx by\n\
7290 ny subpages, each of which may be used independently. The subroutine\n\
7291 pladv is used to advance from one subpage to the next.\n\
7292\n\
7293 Redacted form: General: plstart(devname, nx, ny)\n\
7294\n\
7295\n\
7296 This function is not used in any examples.\n\
7297\n\
7298\n\
7299\n\
7300SYNOPSIS:\n\
7301\n\
7302plstart(devname, nx, ny)\n\
7303\n\
7304ARGUMENTS:\n\
7305\n\
7306 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7307 containing the device name keyword of the required output device.\n\
7308 If\n\
7309 devname is NULL or if the first character of the string is a ``?\'\',\n\
7310 the normal (prompted) start up is used.\n\
7311\n\
7312 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7313 x direction.\n\
7314\n\
7315 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7316 y direction.\n\
7317";
7318static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7319Plot a glyph at the specified points\n\
7320\n\
7321DESCRIPTION:\n\
7322\n\
7323 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7324 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7325 is specified with a PLplot user string. Note that the user string is\n\
7326 not actually limited to one glyph so it is possible (but not normally\n\
7327 useful) to plot more than one glyph at the specified points with this\n\
7328 function. As with plmtex and plptex, the user string can contain FCI\n\
7329 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7330 else PLplot escapes for Hershey or unicode text to determine the\n\
7331 glyph.\n\
7332\n\
7333 Redacted form: plstring(x, y, string)\n\
7334\n\
7335 This function is used in examples 4, 21 and 26.\n\
7336\n\
7337\n\
7338\n\
7339SYNOPSIS:\n\
7340\n\
7341plstring(n, x, y, string)\n\
7342\n\
7343ARGUMENTS:\n\
7344\n\
7345 n (PLINT, input) : Number of points in the x and y vectors.\n\
7346\n\
7347 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7348 the points.\n\
7349\n\
7350 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7351 the points.\n\
7352\n\
7353 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7354 the glyph(s) to be plotted at each of the n points.\n\
7355";
7356static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7357Write text relative to viewport boundaries in 3D plots\n\
7358\n\
7359DESCRIPTION:\n\
7360\n\
7361 Writes text at a specified position relative to the viewport\n\
7362 boundaries. Text may be written inside or outside the viewport, but\n\
7363 is clipped at the subpage boundaries. The reference point of a string\n\
7364 lies along a line passing through the string at half the height of a\n\
7365 capital letter. The position of the reference point along this line\n\
7366 is determined by just, and the position of the reference point\n\
7367 relative to the viewport is set by disp and pos.\n\
7368\n\
7369 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7370\n\
7371 This function is used in example 28.\n\
7372\n\
7373\n\
7374\n\
7375SYNOPSIS:\n\
7376\n\
7377plmtex3(side, disp, pos, just, text)\n\
7378\n\
7379ARGUMENTS:\n\
7380\n\
7381 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7382 the side of the viewport along which the text is to be written.\n\
7383 The string should contain one or more of the following characters:\n\
7384 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7385 only label the X axis, not both the X and Y axes. x: Label the X\n\
7386 axis.\n\
7387 y: Label the Y axis.\n\
7388 z: Label the Z axis.\n\
7389 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7390 For X it is the axis that starts at y-min. For Y it is the\n\
7391 axis that starts at x-min.\n\
7392 s: Label the secondary axis.\n\
7393 v: Draw the text perpendicular to the axis.\n\
7394\n\
7395\n\
7396 disp (PLFLT, input) : Position of the reference point of string,\n\
7397 measured outwards from the specified viewport edge in units of the\n\
7398 current character height. Use negative disp to write within the\n\
7399 viewport.\n\
7400\n\
7401 pos (PLFLT, input) : Position of the reference point of string\n\
7402 along the specified edge, expressed as a fraction of the length of\n\
7403 the edge.\n\
7404\n\
7405 just (PLFLT, input) : Specifies the position of the string relative\n\
7406 to its reference point. If just=0. , the reference point is at\n\
7407 the left and if just=1. , it is at the right of the string. Other\n\
7408 values of just give intermediate justifications.\n\
7409\n\
7410 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7411 written out.\n\
7412";
7413static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7414Get plot orientation\n\
7415\n\
7416DESCRIPTION:\n\
7417\n\
7418 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7419 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7420 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7421 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7422 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7423 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7424 not been called the default value pointed to by p_rot will be 0.\n\
7425\n\
7426 Redacted form: plgdiori(p_rot)\n\
7427\n\
7428 This function is not used in any examples.\n\
7429\n\
7430\n\
7431\n\
7432SYNOPSIS:\n\
7433\n\
7434plgdiori(p_rot)\n\
7435\n\
7436ARGUMENTS:\n\
7437\n\
7438 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7439 parameter.\n\
7440";
7441static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7442Simple routine to write labels\n\
7443\n\
7444DESCRIPTION:\n\
7445\n\
7446 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7447\n\
7448 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7449\n\
7450 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7451\n\
7452\n\
7453\n\
7454SYNOPSIS:\n\
7455\n\
7456pllab(xlabel, ylabel, tlabel)\n\
7457\n\
7458ARGUMENTS:\n\
7459\n\
7460 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7461 the label for the x axis.\n\
7462\n\
7463 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7464 the label for the y axis.\n\
7465\n\
7466 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7467 the title of the plot.\n\
7468";
7469static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7470Switch to text screen\n\
7471\n\
7472DESCRIPTION:\n\
7473\n\
7474 Sets an interactive device to text mode, used in conjunction with\n\
7475 plgra to allow graphics and text to be interspersed. On a device\n\
7476 which supports separate text and graphics windows, this command causes\n\
7477 control to be switched to the text window. This can be useful for\n\
7478 printing diagnostic messages or getting user input, which would\n\
7479 otherwise interfere with the plots. The program must switch back to\n\
7480 the graphics window before issuing plot commands, as the text (or\n\
7481 console) device will probably become quite confused otherwise. If\n\
7482 already in text mode, this command is ignored. It is also ignored on\n\
7483 devices which only support a single window or use a different method\n\
7484 for shifting focus (see also plgra).\n\
7485\n\
7486 Redacted form: pltext()\n\
7487\n\
7488 This function is used in example 1.\n\
7489\n\
7490\n\
7491\n\
7492SYNOPSIS:\n\
7493\n\
7494pltext()\n\
7495";
7496static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7497Plot all or a subset of Shapefile data using lines in world coordinates\n\
7498\n\
7499DESCRIPTION:\n\
7500\n\
7501 Plot all or a subset of Shapefile data using lines in world\n\
7502 coordinates. Our 19th standard example demonstrates how to use this\n\
7503 function. This function plots data from a Shapefile using lines as in\n\
7504 plmap, however it also has the option of also only drawing specified\n\
7505 elements from the Shapefile. The vector of indices of the required\n\
7506 elements are passed as a function argument. The Shapefile data should\n\
7507 include a metadata file (extension.dbf) listing all items within the\n\
7508 Shapefile. This file can be opened by most popular spreadsheet\n\
7509 programs and can be used to decide which indices to pass to this\n\
7510 function.\n\
7511\n\
7512 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7513 plotentries)\n\
7514\n\
7515 This function is used in example 19.\n\
7516\n\
7517\n\
7518\n\
7519SYNOPSIS:\n\
7520\n\
7521plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7522\n\
7523ARGUMENTS:\n\
7524\n\
7525 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7526 transform the coordinates given in the shapefile into a plot\n\
7527 coordinate system. By using this transform, we can change from a\n\
7528 longitude, latitude coordinate to a polar stereographic project,\n\
7529 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7530 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7531 mapform(), x[] and y[] should be replaced by the corresponding\n\
7532 plot coordinates. If no transform is desired, mapform can be\n\
7533 replaced by NULL.\n\
7534\n\
7535 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7536 the file name of a set of Shapefile files without the file\n\
7537 extension.\n\
7538\n\
7539 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7540 be in the same units as used by the Shapefile. You could use a\n\
7541 very large negative number to plot everything, but you can improve\n\
7542 performance by limiting the area drawn. The units must match those\n\
7543 of the Shapefile projection, which may be for example longitude or\n\
7544 distance. The value of minx must be less than the value of maxx.\n\
7545\n\
7546 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7547 use a very large number to plot everything, but you can improve\n\
7548 performance by limiting the area drawn.\n\
7549\n\
7550 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7551 be in the same units as used by the Shapefile. You could use a\n\
7552 very large negative number to plot everything, but you can improve\n\
7553 performance by limiting the area drawn. The units must match those\n\
7554 of the Shapefile projection, which may be for example latitude or\n\
7555 distance. The value of miny must be less than the value of maxy.\n\
7556\n\
7557 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7558 use a very large number to plot everything, but you can improve\n\
7559 performance by limiting the area drawn.\n\
7560\n\
7561 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7562 zero-based indices of the Shapefile elements which will be drawn.\n\
7563 Setting\n\
7564 plotentries to NULL will plot all elements of the Shapefile.\n\
7565\n\
7566 nplotentries (PLINT, input) : The number of items in\n\
7567 plotentries. Ignored if\n\
7568 plotentries is NULL.\n\
7569";
7570static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7571Set precision in numeric labels\n\
7572\n\
7573DESCRIPTION:\n\
7574\n\
7575 Sets the number of places after the decimal point in numeric labels.\n\
7576\n\
7577 Redacted form: plprec(setp, prec)\n\
7578\n\
7579 This function is used in example 29.\n\
7580\n\
7581\n\
7582\n\
7583SYNOPSIS:\n\
7584\n\
7585plprec(setp, prec)\n\
7586\n\
7587ARGUMENTS:\n\
7588\n\
7589 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7590 automatically determines the number of places to use after the\n\
7591 decimal point in numeric labels (like those used to label axes).\n\
7592 If setp is 1 then prec sets the number of places.\n\
7593\n\
7594 prec (PLINT, input) : The number of characters to draw after the\n\
7595 decimal point in numeric labels.\n\
7596";
7597static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7598Draw a line between two points\n\
7599\n\
7600DESCRIPTION:\n\
7601\n\
7602 Joins the point (\n\
7603 x1,\n\
7604 y1) to (\n\
7605 x2,\n\
7606 y2).\n\
7607\n\
7608 Redacted form: pljoin(x1,y1,x2,y2)\n\
7609\n\
7610 This function is used in examples 3 and 14.\n\
7611\n\
7612\n\
7613\n\
7614SYNOPSIS:\n\
7615\n\
7616pljoin(x1, y1, x2, y2)\n\
7617\n\
7618ARGUMENTS:\n\
7619\n\
7620 x1 (PLFLT, input) : x coordinate of first point.\n\
7621\n\
7622 y1 (PLFLT, input) : y coordinate of first point.\n\
7623\n\
7624 x2 (PLFLT, input) : x coordinate of second point.\n\
7625\n\
7626 y2 (PLFLT, input) : y coordinate of second point.\n\
7627";
7628static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7629Set the device (keyword) name\n\
7630\n\
7631DESCRIPTION:\n\
7632\n\
7633 Set the device (keyword) name.\n\
7634\n\
7635 Redacted form: plsdev(devname)\n\
7636\n\
7637 This function is used in examples 1, 14, and 20.\n\
7638\n\
7639\n\
7640\n\
7641SYNOPSIS:\n\
7642\n\
7643plsdev(devname)\n\
7644\n\
7645ARGUMENTS:\n\
7646\n\
7647 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7648 containing the device name keyword of the required output device.\n\
7649 If\n\
7650 devname is NULL or if the first character of the string is a ``?\'\',\n\
7651 the normal (prompted) start up is used.\n\
7652";
7653static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7654Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7655\n\
7656DESCRIPTION:\n\
7657\n\
7658 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7659 (see the PLplot documentation) index. Overwrites the previous color\n\
7660 value for the given index and, thus, does not result in any additional\n\
7661 allocation of space for colors.\n\
7662\n\
7663 This function is used in example 30.\n\
7664\n\
7665\n\
7666\n\
7667SYNOPSIS:\n\
7668\n\
7669plscol0a(icol0, r, g, b, alpha)\n\
7670\n\
7671ARGUMENTS:\n\
7672\n\
7673 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7674 number of colors (which is set by default, by plscmap0n, or even\n\
7675 by plscmap0).\n\
7676\n\
7677 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7678 degree of red in the color.\n\
7679\n\
7680 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7681 degree of green in the color.\n\
7682\n\
7683 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7684 degree of blue in the color.\n\
7685\n\
7686 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7687 (0.0-1.0).\n\
7688";
7689static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7690Draw filled polygon in 3D\n\
7691\n\
7692DESCRIPTION:\n\
7693\n\
7694 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7695 vectors using the pattern defined by plpsty or plpat. The routine\n\
7696 will automatically close the polygon between the last and first\n\
7697 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7698 plfill3 will fill in between them.\n\
7699\n\
7700 Redacted form: General: plfill3(x, y, z)\n\
7701\n\
7702\n\
7703 This function is used in example 15.\n\
7704\n\
7705\n\
7706\n\
7707SYNOPSIS:\n\
7708\n\
7709plfill3(n, x, y, z)\n\
7710\n\
7711ARGUMENTS:\n\
7712\n\
7713 n (PLINT, input) : Number of vertices in polygon.\n\
7714\n\
7715 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7716 vertices.\n\
7717\n\
7718 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7719 vertices.\n\
7720\n\
7721 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7722 vertices.\n\
7723";
7724static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7725Specify window\n\
7726\n\
7727DESCRIPTION:\n\
7728\n\
7729 Specify the window, i.e., the world coordinates of the edges of the\n\
7730 viewport.\n\
7731\n\
7732 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7733\n\
7734 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7735 29, and 31.\n\
7736\n\
7737\n\
7738\n\
7739SYNOPSIS:\n\
7740\n\
7741plwind(xmin, xmax, ymin, ymax)\n\
7742\n\
7743ARGUMENTS:\n\
7744\n\
7745 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7746 of the viewport.\n\
7747\n\
7748 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7749 of the viewport.\n\
7750\n\
7751 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7752 the viewport.\n\
7753\n\
7754 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7755 viewport.\n\
7756";
7757static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7758Draw text at points defined by Shapefile data in world coordinates\n\
7759\n\
7760DESCRIPTION:\n\
7761\n\
7762 As per plmapline, however the items are plotted as text in the same\n\
7763 way as plptex.\n\
7764\n\
7765 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7766 miny, maxy, plotentry)\n\
7767\n\
7768 This function is used in example 19.\n\
7769\n\
7770\n\
7771\n\
7772SYNOPSIS:\n\
7773\n\
7774plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7775\n\
7776ARGUMENTS:\n\
7777\n\
7778 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7779 transform the coordinates given in the shapefile into a plot\n\
7780 coordinate system. By using this transform, we can change from a\n\
7781 longitude, latitude coordinate to a polar stereographic project,\n\
7782 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7783 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7784 mapform(), x[] and y[] should be replaced by the corresponding\n\
7785 plot coordinates. If no transform is desired, mapform can be\n\
7786 replaced by NULL.\n\
7787\n\
7788 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7789 the file name of a set of Shapefile files without the file\n\
7790 extension.\n\
7791\n\
7792 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7793 dy/dx.\n\
7794\n\
7795 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7796 dy/dx.\n\
7797\n\
7798 just (PLFLT, input) : Set the justification of the text. The value\n\
7799 given will be the fraction of the distance along the string that\n\
7800 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7801 centralized text and 1.0 gives right aligned text.\n\
7802\n\
7803 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7804\n\
7805 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7806 be in the same units as used by the Shapefile. You could use a\n\
7807 very large negative number to plot everything, but you can improve\n\
7808 performance by limiting the area drawn. The units must match those\n\
7809 of the Shapefile projection, which may be for example longitude or\n\
7810 distance. The value of minx must be less than the value of maxx.\n\
7811\n\
7812 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7813 use a very large number to plot everything, but you can improve\n\
7814 performance by limiting the area drawn.\n\
7815\n\
7816 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7817 be in the same units as used by the Shapefile. You could use a\n\
7818 very large negative number to plot everything, but you can improve\n\
7819 performance by limiting the area drawn. The units must match those\n\
7820 of the Shapefile projection, which may be for example latitude or\n\
7821 distance. The value of miny must be less than the value of maxy.\n\
7822\n\
7823 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7824 use a very large number to plot everything, but you can improve\n\
7825 performance by limiting the area drawn.\n\
7826\n\
7827 plotentry (PLINT, input) : An integer indicating which text string\n\
7828 of the Shapefile (zero indexed) will be drawn.\n\
7829";
7830static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7831Switch to graphics screen\n\
7832\n\
7833DESCRIPTION:\n\
7834\n\
7835 Sets an interactive device to graphics mode, used in conjunction with\n\
7836 pltext to allow graphics and text to be interspersed. On a device\n\
7837 which supports separate text and graphics windows, this command causes\n\
7838 control to be switched to the graphics window. If already in graphics\n\
7839 mode, this command is ignored. It is also ignored on devices which\n\
7840 only support a single window or use a different method for shifting\n\
7841 focus. See also pltext.\n\
7842\n\
7843 Redacted form: plgra()\n\
7844\n\
7845 This function is used in example 1.\n\
7846\n\
7847\n\
7848\n\
7849SYNOPSIS:\n\
7850\n\
7851plgra()\n\
7852";
7853static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7854Set parameters of contour labelling other than format of numerical label\n\
7855\n\
7856DESCRIPTION:\n\
7857\n\
7858 Set parameters of contour labelling other than those handled by\n\
7859 pl_setcontlabelformat.\n\
7860\n\
7861 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7862\n\
7863 This function is used in example 9.\n\
7864\n\
7865\n\
7866\n\
7867SYNOPSIS:\n\
7868\n\
7869pl_setcontlabelparam(offset, size, spacing, active)\n\
7870\n\
7871ARGUMENTS:\n\
7872\n\
7873 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7874 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7875\n\
7876 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7877 Default value is 0.3.\n\
7878\n\
7879 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7880 Default value is 0.1.\n\
7881\n\
7882 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7883 contour labels on. Default is off (0).\n\
7884";
7885static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7886Get family, style and weight of the current font\n\
7887\n\
7888DESCRIPTION:\n\
7889\n\
7890 Gets information about current font. See the PLplot documentation for\n\
7891 more information on font selection.\n\
7892\n\
7893 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7894\n\
7895 This function is used in example 23.\n\
7896\n\
7897\n\
7898\n\
7899SYNOPSIS:\n\
7900\n\
7901plgfont(p_family, p_style, p_weight)\n\
7902\n\
7903ARGUMENTS:\n\
7904\n\
7905 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7906 font family. The available values are given by the PL_FCI_*\n\
7907 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7908 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7909 p_family is NULL then the font family is not returned.\n\
7910\n\
7911 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7912 font style. The available values are given by the PL_FCI_*\n\
7913 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7914 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7915 style is not returned.\n\
7916\n\
7917 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7918 font weight. The available values are given by the PL_FCI_*\n\
7919 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7920 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7921 returned.\n\
7922";
7923static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7924Plot a histogram from unbinned data\n\
7925\n\
7926DESCRIPTION:\n\
7927\n\
7928 Plots a histogram from n data points stored in the data vector. This\n\
7929 routine bins the data into nbin bins equally spaced between datmin and\n\
7930 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7931 opt allows, among other things, the histogram either to be plotted in\n\
7932 an existing window or causes plhist to call plenv with suitable limits\n\
7933 before plotting the histogram.\n\
7934\n\
7935 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7936\n\
7937 This function is used in example 5.\n\
7938\n\
7939\n\
7940\n\
7941SYNOPSIS:\n\
7942\n\
7943plhist(n, data, datmin, datmax, nbin, opt)\n\
7944\n\
7945ARGUMENTS:\n\
7946\n\
7947 n (PLINT, input) : Number of data points.\n\
7948\n\
7949 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7950 n data points.\n\
7951\n\
7952 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7953\n\
7954 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7955\n\
7956 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7957 divide the interval xmin to xmax.\n\
7958\n\
7959 opt (PLINT, input) : Is a combination of several flags:\n\
7960 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7961 the histogram data, the outer bins are expanded to fill up the\n\
7962 entire x-axis, data outside the given extremes are assigned to the\n\
7963 outer bins and bins of zero height are simply drawn.\n\
7964 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7965 to fit the histogram data, without this flag, plenv is called\n\
7966 to set the world coordinates.\n\
7967 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7968 extremes are not taken into account. This option should\n\
7969 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7970 properly present the data.\n\
7971 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7972 size as the ones inside.\n\
7973 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7974 (there is a gap for such bins).\n\
7975";
7976static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7977Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7978\n\
7979DESCRIPTION:\n\
7980\n\
7981 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7982 alpha transparency value.\n\
7983\n\
7984 This function is used in example 31.\n\
7985\n\
7986\n\
7987\n\
7988SYNOPSIS:\n\
7989\n\
7990plgcolbga(r, g, b, alpha)\n\
7991\n\
7992ARGUMENTS:\n\
7993\n\
7994 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7995 in the range from 0 to 255.\n\
7996\n\
7997 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7998 in the range from 0 to 255.\n\
7999\n\
8000 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
8001 in the range from 0 to 255.\n\
8002\n\
8003 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8004 transparency in the range (0.0-1.0).\n\
8005";
8006static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
8007Set orientation\n\
8008\n\
8009DESCRIPTION:\n\
8010\n\
8011 Set integer plot orientation parameter. This function is identical to\n\
8012 plsdiori except for the type of the argument, and should be used in\n\
8013 the same way. See the documentation of plsdiori for details.\n\
8014\n\
8015 Redacted form: plsori(ori)\n\
8016\n\
8017 This function is used in example 3.\n\
8018\n\
8019\n\
8020\n\
8021SYNOPSIS:\n\
8022\n\
8023plsori(ori)\n\
8024\n\
8025ARGUMENTS:\n\
8026\n\
8027 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8028 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8029 angle.\n\
8030";
8031static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
8032Plot latitude and longitude lines\n\
8033\n\
8034DESCRIPTION:\n\
8035\n\
8036 Displays latitude and longitude on the current plot. The lines are\n\
8037 plotted in the current color and line style.\n\
8038\n\
8039 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8040 minlat, maxlat)\n\
8041\n\
8042 This function is used in example 19.\n\
8043\n\
8044\n\
8045\n\
8046SYNOPSIS:\n\
8047\n\
8048plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8049\n\
8050ARGUMENTS:\n\
8051\n\
8052 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8053 transform the coordinate longitudes and latitudes to a plot\n\
8054 coordinate system. By using this transform, we can change from a\n\
8055 longitude, latitude coordinate to a polar stereographic project,\n\
8056 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8057 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8058 mapform(), x[] and y[] should be replaced by the corresponding\n\
8059 plot coordinates. If no transform is desired, mapform can be\n\
8060 replaced by NULL.\n\
8061\n\
8062 dlong (PLFLT, input) : The interval in degrees at which the\n\
8063 longitude lines are to be plotted.\n\
8064\n\
8065 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8066 lines are to be plotted.\n\
8067\n\
8068 minlong (PLFLT, input) : The value of the longitude on the left\n\
8069 side of the plot. The value of minlong must be less than the value\n\
8070 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8071 equal to 360.\n\
8072\n\
8073 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8074 side of the plot.\n\
8075\n\
8076 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8077 background. One can always use -90.0 as the boundary outside the\n\
8078 plot window will be automatically eliminated. However, the\n\
8079 program will be faster if one can reduce the size of the\n\
8080 background plotted.\n\
8081\n\
8082 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8083 background. One can always use 90.0 as the boundary outside the\n\
8084 plot window will be automatically eliminated.\n\
8085";
8086static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8087Clear current (sub)page\n\
8088\n\
8089DESCRIPTION:\n\
8090\n\
8091 Clears the current page, effectively erasing everything that have been\n\
8092 drawn. This command only works with interactive drivers; if the\n\
8093 driver does not support this, the page is filled with the background\n\
8094 color in use. If the current page is divided into subpages, only the\n\
8095 current subpage is erased. The nth subpage can be selected with\n\
8096 pladv(n).\n\
8097\n\
8098 Redacted form: General: plclear()\n\
8099\n\
8100\n\
8101 This function is not used in any examples.\n\
8102\n\
8103\n\
8104\n\
8105SYNOPSIS:\n\
8106\n\
8107plclear()\n\
8108";
8109static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8110Initialization\n\
8111\n\
8112DESCRIPTION:\n\
8113\n\
8114 Initializing the plotting package. The program prompts for the device\n\
8115 keyword or number of the desired output device. Hitting a RETURN in\n\
8116 response to the prompt is the same as selecting the first device. If\n\
8117 only one device is enabled when PLplot is installed, plstar will issue\n\
8118 no prompt. The output device is divided into nx by ny subpages, each\n\
8119 of which may be used independently. The subroutine pladv is used to\n\
8120 advance from one subpage to the next.\n\
8121\n\
8122 Redacted form: plstar(nx, ny)\n\
8123\n\
8124 This function is used in example 1.\n\
8125\n\
8126\n\
8127\n\
8128SYNOPSIS:\n\
8129\n\
8130plstar(nx, ny)\n\
8131\n\
8132ARGUMENTS:\n\
8133\n\
8134 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8135 x direction.\n\
8136\n\
8137 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8138 y direction.\n\
8139";
8140static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8141Write text relative to viewport boundaries\n\
8142\n\
8143DESCRIPTION:\n\
8144\n\
8145 Writes text at a specified position relative to the viewport\n\
8146 boundaries. Text may be written inside or outside the viewport, but\n\
8147 is clipped at the subpage boundaries. The reference point of a string\n\
8148 lies along a line passing through the string at half the height of a\n\
8149 capital letter. The position of the reference point along this line\n\
8150 is determined by just, and the position of the reference point\n\
8151 relative to the viewport is set by disp and pos.\n\
8152\n\
8153 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8154\n\
8155\n\
8156 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8157 26.\n\
8158\n\
8159\n\
8160\n\
8161SYNOPSIS:\n\
8162\n\
8163plmtex(side, disp, pos, just, text)\n\
8164\n\
8165ARGUMENTS:\n\
8166\n\
8167 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8168 the side of the viewport along which the text is to be written.\n\
8169 The string must be one of: b: Bottom of viewport, text written\n\
8170 parallel to edge.\n\
8171 bv: Bottom of viewport, text written at right angles to edge.\n\
8172 l: Left of viewport, text written parallel to edge.\n\
8173 lv: Left of viewport, text written at right angles to edge.\n\
8174 r: Right of viewport, text written parallel to edge.\n\
8175 rv: Right of viewport, text written at right angles to edge.\n\
8176 t: Top of viewport, text written parallel to edge.\n\
8177 tv: Top of viewport, text written at right angles to edge.\n\
8178\n\
8179\n\
8180 disp (PLFLT, input) : Position of the reference point of string,\n\
8181 measured outwards from the specified viewport edge in units of the\n\
8182 current character height. Use negative disp to write within the\n\
8183 viewport.\n\
8184\n\
8185 pos (PLFLT, input) : Position of the reference point of string\n\
8186 along the specified edge, expressed as a fraction of the length of\n\
8187 the edge.\n\
8188\n\
8189 just (PLFLT, input) : Specifies the position of the string relative\n\
8190 to its reference point. If just=0. , the reference point is at\n\
8191 the left and if just=1. , it is at the right of the string. Other\n\
8192 values of just give intermediate justifications.\n\
8193\n\
8194 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8195 written out.\n\
8196";
8197static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8198Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8199\n\
8200DESCRIPTION:\n\
8201\n\
8202 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8203 PLFLT alpha transparency value (see the PLplot documentation).\n\
8204\n\
8205 This function is used in example 31.\n\
8206\n\
8207\n\
8208\n\
8209SYNOPSIS:\n\
8210\n\
8211plscolbga(r, g, b, alpha)\n\
8212\n\
8213ARGUMENTS:\n\
8214\n\
8215 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8216 degree of red in the color.\n\
8217\n\
8218 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8219 degree of green in the color.\n\
8220\n\
8221 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8222 degree of blue in the color.\n\
8223\n\
8224 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8225 (0.0-1.0).\n\
8226";
8227static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8228Replays contents of plot buffer to current device/file\n\
8229\n\
8230DESCRIPTION:\n\
8231\n\
8232 Replays contents of plot buffer to current device/file.\n\
8233\n\
8234 Redacted form: plreplot()\n\
8235\n\
8236 This function is used in example 1,20.\n\
8237\n\
8238\n\
8239\n\
8240SYNOPSIS:\n\
8241\n\
8242plreplot()\n\
8243";
8244static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8245Plot a glyph at the specified 3D points\n\
8246\n\
8247DESCRIPTION:\n\
8248\n\
8249 Plot a glyph at the specified 3D points. (This function is largely\n\
8250 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8251 Set up the call to this function similar to what is done for plline3.\n\
8252 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8253 and a draw at the same place. Not ideal, since a sufficiently\n\
8254 intelligent output device may optimize it away, or there may be faster\n\
8255 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8256 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8257 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8258 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8259 code <= 127 the corresponding printable ASCII character is plotted.\n\
8260\n\
8261 Redacted form: plpoin3(x, y, z, code)\n\
8262\n\
8263 This function is not used in any example.\n\
8264\n\
8265\n\
8266\n\
8267SYNOPSIS:\n\
8268\n\
8269plpoin3(n, x, y, z, code)\n\
8270\n\
8271ARGUMENTS:\n\
8272\n\
8273 n (PLINT, input) : Number of points in the x and y vectors.\n\
8274\n\
8275 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8276 points.\n\
8277\n\
8278 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8279 points.\n\
8280\n\
8281 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8282 points.\n\
8283\n\
8284 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8285 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8286 each of the n points.\n\
8287";
8288static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8289Set family, style and weight of the current font\n\
8290\n\
8291DESCRIPTION:\n\
8292\n\
8293 Sets the current font. See the PLplot documentation for more\n\
8294 information on font selection.\n\
8295\n\
8296 Redacted form: plsfont(family, style, weight)\n\
8297\n\
8298 This function is used in example 23.\n\
8299\n\
8300\n\
8301\n\
8302SYNOPSIS:\n\
8303\n\
8304plsfont(family, style, weight)\n\
8305\n\
8306ARGUMENTS:\n\
8307\n\
8308 family (PLINT, input) : Font family to select for the current font.\n\
8309 The available values are given by the PL_FCI_* constants in\n\
8310 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8311 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8312 signifies that the font family should not be altered.\n\
8313\n\
8314 style (PLINT, input) : Font style to select for the current font.\n\
8315 The available values are given by the PL_FCI_* constants in\n\
8316 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8317 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8318 should not be altered.\n\
8319\n\
8320 weight (PLINT, input) : Font weight to select for the current font.\n\
8321 The available values are given by the PL_FCI_* constants in\n\
8322 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8323 negative value signifies that the font weight should not be\n\
8324 altered.\n\
8325";
8326static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8327Draw a box with axes, etc. with arbitrary origin\n\
8328\n\
8329DESCRIPTION:\n\
8330\n\
8331 Draws a box around the currently defined viewport with arbitrary\n\
8332 world-coordinate origin specified by x0 and y0 and labels it with\n\
8333 world coordinate values appropriate to the window. Thus plaxes should\n\
8334 only be called after defining both viewport and window. The ascii\n\
8335 character strings xopt and yopt specify how the box should be drawn as\n\
8336 described below. If ticks and/or subticks are to be drawn for a\n\
8337 particular axis, the tick intervals and number of subintervals may be\n\
8338 specified explicitly, or they may be defaulted by setting the\n\
8339 appropriate arguments to zero.\n\
8340\n\
8341 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8342 ytick, nysub)\n\
8343\n\
8344\n\
8345 This function is not used in any examples.\n\
8346\n\
8347\n\
8348\n\
8349SYNOPSIS:\n\
8350\n\
8351plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8352\n\
8353ARGUMENTS:\n\
8354\n\
8355 x0 (PLFLT, input) : World X coordinate of origin.\n\
8356\n\
8357 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8358\n\
8359 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8360 options for the x axis. The string can include any combination of\n\
8361 the following letters (upper or lower case) in any order: a: Draws\n\
8362 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8363 (x=0).\n\
8364 b: Draws bottom (X) or left (Y) edge of frame.\n\
8365 c: Draws top (X) or right (Y) edge of frame.\n\
8366 d: Plot labels as date / time. Values are assumed to be\n\
8367 seconds since the epoch (as used by gmtime).\n\
8368 f: Always use fixed point numeric labels.\n\
8369 g: Draws a grid at the major tick interval.\n\
8370 h: Draws a grid at the minor tick interval.\n\
8371 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8372 inwards.\n\
8373 l: Labels axis logarithmically. This only affects the labels,\n\
8374 not the data, and so it is necessary to compute the logarithms\n\
8375 of data points before passing them to any of the drawing\n\
8376 routines.\n\
8377 m: Writes numeric labels at major tick intervals in the\n\
8378 unconventional location (above box for X, right of box for Y).\n\
8379 n: Writes numeric labels at major tick intervals in the\n\
8380 conventional location (below box for X, left of box for Y).\n\
8381 o: Use custom labelling function to generate axis label text.\n\
8382 The custom labelling function can be defined with the\n\
8383 plslabelfunc command.\n\
8384 s: Enables subticks between major ticks, only valid if t is\n\
8385 also specified.\n\
8386 t: Draws major ticks.\n\
8387 u: Exactly like \"b\" except don\'t draw edge line.\n\
8388 w: Exactly like \"c\" except don\'t draw edge line.\n\
8389 x: Exactly like \"t\" (including the side effect of the\n\
8390 numerical labels for the major ticks) except exclude drawing\n\
8391 the major and minor tick marks.\n\
8392\n\
8393\n\
8394 xtick (PLFLT, input) : World coordinate interval between major\n\
8395 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8396 generates a suitable tick interval.\n\
8397\n\
8398 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8399 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8400 generates a suitable minor tick interval.\n\
8401\n\
8402 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8403 options for the y axis. The string can include any combination of\n\
8404 the letters defined above for xopt, and in addition may contain:\n\
8405 v: Write numeric labels for the y axis parallel to the base of the\n\
8406 graph, rather than parallel to the axis.\n\
8407\n\
8408\n\
8409 ytick (PLFLT, input) : World coordinate interval between major\n\
8410 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8411 generates a suitable tick interval.\n\
8412\n\
8413 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8414 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8415 generates a suitable minor tick interval.\n\
8416";
8417static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8418Begin a new page\n\
8419\n\
8420DESCRIPTION:\n\
8421\n\
8422 Begins a new page. For a file driver, the output file is opened if\n\
8423 necessary. Advancing the page via pleop and plbop is useful when a\n\
8424 page break is desired at a particular point when plotting to subpages.\n\
8425 Another use for pleop and plbop is when plotting pages to different\n\
8426 files, since you can manually set the file name by calling plsfnam\n\
8427 after the call to pleop. (In fact some drivers may only support a\n\
8428 single page per file, making this a necessity.) One way to handle\n\
8429 this case automatically is to page advance via pladv, but enable\n\
8430 familying (see plsfam) with a small limit on the file size so that a\n\
8431 new family member file will be created on each page break.\n\
8432\n\
8433 Redacted form: plbop()\n\
8434\n\
8435 This function is used in examples 2 and 20.\n\
8436\n\
8437\n\
8438\n\
8439SYNOPSIS:\n\
8440\n\
8441plbop()\n\
8442";
8443static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8444Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8445\n\
8446DESCRIPTION:\n\
8447\n\
8448 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8449 and PLFLT alpha transparency value. This sets the entire color map --\n\
8450 only as many colors as specified will be allocated.\n\
8451\n\
8452 Redacted form: plscmap0a(r, g, b, alpha)\n\
8453\n\
8454 This function is used in examples 30.\n\
8455\n\
8456\n\
8457\n\
8458SYNOPSIS:\n\
8459\n\
8460plscmap0a(r, g, b, alpha, ncol0)\n\
8461\n\
8462ARGUMENTS:\n\
8463\n\
8464 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8465 integers (0-255) representing the degree of red in the color.\n\
8466\n\
8467 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8468 integers (0-255) representing the degree of green in the color.\n\
8469\n\
8470 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8471 integers (0-255) representing the degree of blue in the color.\n\
8472\n\
8473 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8474 representing the alpha transparency of the color.\n\
8475\n\
8476 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8477 vectors.\n\
8478";
8479static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8480Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8481\n\
8482DESCRIPTION:\n\
8483\n\
8484 This is a variant of plscmap1l that supports alpha channel\n\
8485 transparency. It sets cmap1 colors using a piece-wise linear\n\
8486 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8487 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8488 transparency value (0.0-1.0). It may be called at any time.\n\
8489\n\
8490 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8491 alpha, alt_hue_path)\n\
8492\n\
8493 This function is used in example 30.\n\
8494\n\
8495\n\
8496\n\
8497SYNOPSIS:\n\
8498\n\
8499plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8500\n\
8501ARGUMENTS:\n\
8502\n\
8503 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8504\n\
8505 npts (PLINT, input) : number of control points.\n\
8506\n\
8507 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8508 intensity index (0.0-1.0) in ascending order for each control\n\
8509 point.\n\
8510\n\
8511 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8512 coordinate (H or R) for each control point.\n\
8513\n\
8514 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8515 coordinate (L or G) for each control point.\n\
8516\n\
8517 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8518 coordinate (S or B) for each control point.\n\
8519\n\
8520 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8521 transparency value (0.0-1.0) for each control point.\n\
8522\n\
8523 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8524 npts - 1 elements) containing the alternative interpolation method\n\
8525 Boolean value for each control point interval. (alt_hue_path[i]\n\
8526 refers to the interpolation interval between the i and i + 1\n\
8527 control points).\n\
8528";
8529static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8530Enter or leave xor mode\n\
8531\n\
8532DESCRIPTION:\n\
8533\n\
8534 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8535 those drivers (e.g., the xwin driver) that support it. Enables\n\
8536 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8537 is not capable of xor operation it returns a status of false.\n\
8538\n\
8539 Redacted form: plxormod(mode, status)\n\
8540\n\
8541 This function is used in examples 1 and 20.\n\
8542\n\
8543\n\
8544\n\
8545SYNOPSIS:\n\
8546\n\
8547plxormod(mode, status)\n\
8548\n\
8549ARGUMENTS:\n\
8550\n\
8551 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8552 is false means leave xor mode.\n\
8553\n\
8554 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8555 modestatus of true (false) means driver is capable (incapable) of\n\
8556 xor mode.\n\
8557";
8558static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8559Eject current page\n\
8560\n\
8561DESCRIPTION:\n\
8562\n\
8563 Clears the graphics screen of an interactive device, or ejects a page\n\
8564 on a plotter. See plbop for more information.\n\
8565\n\
8566 Redacted form: pleop()\n\
8567\n\
8568 This function is used in example 2,14.\n\
8569\n\
8570\n\
8571\n\
8572SYNOPSIS:\n\
8573\n\
8574pleop()\n\
8575";
8576static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8577Draw a box with axes, etc\n\
8578\n\
8579DESCRIPTION:\n\
8580\n\
8581 Draws a box around the currently defined viewport, and labels it with\n\
8582 world coordinate values appropriate to the window. Thus plbox should\n\
8583 only be called after defining both viewport and window. The ascii\n\
8584 character strings xopt and yopt specify how the box should be drawn as\n\
8585 described below. If ticks and/or subticks are to be drawn for a\n\
8586 particular axis, the tick intervals and number of subintervals may be\n\
8587 specified explicitly, or they may be defaulted by setting the\n\
8588 appropriate arguments to zero.\n\
8589\n\
8590 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8591\n\
8592\n\
8593 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8594 and 29.\n\
8595\n\
8596\n\
8597\n\
8598SYNOPSIS:\n\
8599\n\
8600plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8601\n\
8602ARGUMENTS:\n\
8603\n\
8604 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8605 options for the x axis. The string can include any combination of\n\
8606 the following letters (upper or lower case) in any order: a: Draws\n\
8607 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8608 (x=0).\n\
8609 b: Draws bottom (X) or left (Y) edge of frame.\n\
8610 c: Draws top (X) or right (Y) edge of frame.\n\
8611 d: Plot labels as date / time. Values are assumed to be\n\
8612 seconds since the epoch (as used by gmtime).\n\
8613 f: Always use fixed point numeric labels.\n\
8614 g: Draws a grid at the major tick interval.\n\
8615 h: Draws a grid at the minor tick interval.\n\
8616 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8617 inwards.\n\
8618 l: Labels axis logarithmically. This only affects the labels,\n\
8619 not the data, and so it is necessary to compute the logarithms\n\
8620 of data points before passing them to any of the drawing\n\
8621 routines.\n\
8622 m: Writes numeric labels at major tick intervals in the\n\
8623 unconventional location (above box for X, right of box for Y).\n\
8624 n: Writes numeric labels at major tick intervals in the\n\
8625 conventional location (below box for X, left of box for Y).\n\
8626 o: Use custom labelling function to generate axis label text.\n\
8627 The custom labelling function can be defined with the\n\
8628 plslabelfunc command.\n\
8629 s: Enables subticks between major ticks, only valid if t is\n\
8630 also specified.\n\
8631 t: Draws major ticks.\n\
8632 u: Exactly like \"b\" except don\'t draw edge line.\n\
8633 w: Exactly like \"c\" except don\'t draw edge line.\n\
8634 x: Exactly like \"t\" (including the side effect of the\n\
8635 numerical labels for the major ticks) except exclude drawing\n\
8636 the major and minor tick marks.\n\
8637\n\
8638\n\
8639 xtick (PLFLT, input) : World coordinate interval between major\n\
8640 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8641 generates a suitable tick interval.\n\
8642\n\
8643 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8644 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8645 generates a suitable minor tick interval.\n\
8646\n\
8647 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8648 options for the y axis. The string can include any combination of\n\
8649 the letters defined above for xopt, and in addition may contain:\n\
8650 v: Write numeric labels for the y axis parallel to the base of the\n\
8651 graph, rather than parallel to the axis.\n\
8652\n\
8653\n\
8654 ytick (PLFLT, input) : World coordinate interval between major\n\
8655 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8656 generates a suitable tick interval.\n\
8657\n\
8658 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8659 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8660 generates a suitable minor tick interval.\n\
8661";
8662static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8663Get x axis parameters\n\
8664\n\
8665DESCRIPTION:\n\
8666\n\
8667 Returns current values of the p_digmax and p_digits flags for the x\n\
8668 axis. p_digits is updated after the plot is drawn, so this routine\n\
8669 should only be called after the call to plbox (or plbox3) is complete.\n\
8670 See the PLplot documentation for more information.\n\
8671\n\
8672 Redacted form: plgxax(p_digmax, p_digits)\n\
8673\n\
8674 This function is used in example 31.\n\
8675\n\
8676\n\
8677\n\
8678SYNOPSIS:\n\
8679\n\
8680plgxax(p_digmax, p_digits)\n\
8681\n\
8682ARGUMENTS:\n\
8683\n\
8684 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8685 number of digits for the x axis. If nonzero, the printed label\n\
8686 has been switched to a floating-point representation when the\n\
8687 number of digits exceeds this value.\n\
8688\n\
8689 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8690 number of digits for the numeric labels (x axis) from the last\n\
8691 plot.\n\
8692";
8693static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8694Set font\n\
8695\n\
8696DESCRIPTION:\n\
8697\n\
8698 Sets the font used for subsequent text and symbols. For devices that\n\
8699 still use Hershey fonts this routine has no effect unless the Hershey\n\
8700 fonts with extended character set are loaded (see plfontld). For\n\
8701 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8702 this routine calls the plsfci routine with argument set up\n\
8703 appropriately for the various cases below. However, this method of\n\
8704 specifying the font for unicode-aware devices is deprecated, and the\n\
8705 much more flexible method of calling plsfont directly is recommended\n\
8706 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8707\n\
8708 Redacted form: plfont(ifont)\n\
8709\n\
8710 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8711\n\
8712\n\
8713\n\
8714SYNOPSIS:\n\
8715\n\
8716plfont(ifont)\n\
8717\n\
8718ARGUMENTS:\n\
8719\n\
8720 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8721 (simplest and fastest)\n\
8722 2: Serif font\n\
8723 3: Italic font\n\
8724 4: Script font\n\
8725";
8726static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8727Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8728\n\
8729DESCRIPTION:\n\
8730\n\
8731 Routine for creating a discrete plot legend with a plotted filled box,\n\
8732 line, and/or line of symbols for each annotated legend entry. (See\n\
8733 plcolorbar for similar functionality for creating continuous color\n\
8734 bars.) The arguments of pllegend provide control over the location\n\
8735 and size of the legend as well as the location and characteristics of\n\
8736 the elements (most of which are optional) within that legend. The\n\
8737 resulting legend is clipped at the boundaries of the current subpage.\n\
8738 (N.B. the adopted coordinate system used for some of the parameters is\n\
8739 defined in the documentation of the position parameter.)\n\
8740\n\
8741 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8742 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8743 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8744 test_justification, text_colors, text, box_colors, box_patterns,\n\
8745 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8746 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8747\n\
8748 This function is used in examples 4, 26, and 33.\n\
8749\n\
8750\n\
8751\n\
8752SYNOPSIS:\n\
8753\n\
8754pllegend(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\
8755\n\
8756ARGUMENTS:\n\
8757\n\
8758 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8759 legend width in adopted coordinates. This quantity is calculated\n\
8760 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8761 the routine depending on nlegend and nrow), and the length\n\
8762 (calculated internally) of the longest text string.\n\
8763\n\
8764 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8765 legend height in adopted coordinates. This quantity is calculated\n\
8766 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8767 the routine depending on nlegend and nrow).\n\
8768\n\
8769 opt (PLINT, input) : opt contains bits controlling the overall\n\
8770 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8771 on the left of the legend and the plotted area on the right.\n\
8772 Otherwise, put the text area on the right of the legend and the\n\
8773 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8774 plot a (semitransparent) background for the legend. If the\n\
8775 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8776 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8777 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8778 plot the resulting array of legend entries in row-major order.\n\
8779 Otherwise, plot the legend entries in column-major order.\n\
8780\n\
8781 position (PLINT, input) : position contains bits which control the\n\
8782 overall position of the legend and the definition of the adopted\n\
8783 coordinates used for positions just like what is done for the\n\
8784 position argument for plcolorbar. However, note that the defaults\n\
8785 for the position bits (see below) are different than the\n\
8786 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8787 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8788 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8789 the 16 possible standard positions (the 4 corners and centers of\n\
8790 the 4 sides for both the inside and outside cases) of the legend\n\
8791 relative to the adopted coordinate system. The corner positions\n\
8792 are specified by the appropriate combination of two of the\n\
8793 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8794 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8795 value of one of those bits. The adopted coordinates are\n\
8796 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8797 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8798 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8799 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8800 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8801 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8802 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8803 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8804\n\
8805 x (PLFLT, input) : X offset of the legend position in adopted\n\
8806 coordinates from the specified standard position of the legend.\n\
8807 For positive x, the direction of motion away from the standard\n\
8808 position is inward/outward from the standard corner positions or\n\
8809 standard left or right positions if the\n\
8810 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8811 For the standard top or bottom positions, the direction of motion\n\
8812 is toward positive X.\n\
8813\n\
8814 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8815 coordinates from the specified standard position of the legend.\n\
8816 For positive y, the direction of motion away from the standard\n\
8817 position is inward/outward from the standard corner positions or\n\
8818 standard top or bottom positions if the\n\
8819 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8820 the standard left or right positions, the direction of motion is\n\
8821 toward positive Y.\n\
8822\n\
8823 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8824 of the plot area (where the colored boxes, lines, and/or lines of\n\
8825 symbols are drawn) of the legend.\n\
8826\n\
8827 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8828 legend (PL_LEGEND_BACKGROUND).\n\
8829\n\
8830 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8831 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8832\n\
8833 bb_style (PLINT, input) : The pllsty style number for the\n\
8834 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8835\n\
8836 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8837 render the\n\
8838 nlegend legend entries. For internal transformations of\n\
8839 nrow, see further remarks under\n\
8840 nlegend.\n\
8841\n\
8842 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8843 to render the\n\
8844 nlegend legend entries. For internal transformations of\n\
8845 ncolumn, see further remarks under\n\
8846 nlegend.\n\
8847\n\
8848 nlegend (PLINT, input) : Number of legend entries. The above\n\
8849 nrow and\n\
8850 ncolumn values are transformed internally to be consistent with\n\
8851 nlegend. If either\n\
8852 nrow or\n\
8853 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8854 of\n\
8855 nrow and\n\
8856 ncolumn is less than\n\
8857 nlegend, the smaller of the two (or\n\
8858 nrow, if\n\
8859 nrow ==\n\
8860 ncolumn) is increased so the product is >=\n\
8861 nlegend. Thus, for example, the common\n\
8862 nrow = 0,\n\
8863 ncolumn = 0 case is transformed internally to\n\
8864 nrow =\n\
8865 nlegend,\n\
8866 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8867 column.\n\
8868\n\
8869 opt_array (PLINT_VECTOR, input) : A vector of\n\
8870 nlegend values of options to control each individual plotted area\n\
8871 corresponding to a legend entry. If the\n\
8872 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8873 area. If the\n\
8874 PL_LEGEND_COLOR_BOX,\n\
8875 PL_LEGEND_LINE, and/or\n\
8876 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8877 entry is plotted with a colored box; a line; and/or a line of\n\
8878 symbols.\n\
8879\n\
8880 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8881 area in units of character width.\n\
8882\n\
8883 text_scale (PLFLT, input) : Character height scale for text\n\
8884 annotations.\n\
8885\n\
8886 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8887 character height from one legend entry to the next.\n\
8888\n\
8889 text_justification (PLFLT, input) : Justification parameter used\n\
8890 for text justification. The most common values of\n\
8891 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8892 is left justified, centred, or right justified within the text\n\
8893 area, but other values are allowed as well.\n\
8894\n\
8895 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8896 nlegend cmap0 text colors.\n\
8897\n\
8898 text (PLCHAR_MATRIX, input) : A vector of\n\
8899 nlegend UTF-8 character strings containing the legend annotations.\n\
8900\n\
8901 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8902 nlegend cmap0 colors for the discrete colored boxes (\n\
8903 PL_LEGEND_COLOR_BOX).\n\
8904\n\
8905 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8906 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8907 PL_LEGEND_COLOR_BOX).\n\
8908\n\
8909 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8910 nlegend scales (units of fraction of character height) for the height\n\
8911 of the discrete colored boxes (\n\
8912 PL_LEGEND_COLOR_BOX).\n\
8913\n\
8914 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8915 nlegend line widths for the patterns specified by box_patterns (\n\
8916 PL_LEGEND_COLOR_BOX).\n\
8917\n\
8918 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8919 nlegend cmap0 line colors (\n\
8920 PL_LEGEND_LINE).\n\
8921\n\
8922 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8923 nlegend line styles (plsty indices) (\n\
8924 PL_LEGEND_LINE).\n\
8925\n\
8926 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8927 nlegend line widths (\n\
8928 PL_LEGEND_LINE).\n\
8929\n\
8930 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8931 nlegend cmap0 symbol colors (\n\
8932 PL_LEGEND_SYMBOL).\n\
8933\n\
8934 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8935 nlegend scale values for the symbol height (\n\
8936 PL_LEGEND_SYMBOL).\n\
8937\n\
8938 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8939 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8940 area (\n\
8941 PL_LEGEND_SYMBOL).\n\
8942\n\
8943 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8944 nlegend UTF-8 character strings containing the legend symbols. (\n\
8945 PL_LEGEND_SYMBOL).\n\
8946";
8947static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8948Set the background color by 8-bit RGB value\n\
8949\n\
8950DESCRIPTION:\n\
8951\n\
8952 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8953 the PLplot documentation).\n\
8954\n\
8955 Redacted form: plscolbg(r, g, b)\n\
8956\n\
8957 This function is used in examples 15 and 31.\n\
8958\n\
8959\n\
8960\n\
8961SYNOPSIS:\n\
8962\n\
8963plscolbg(r, g, b)\n\
8964\n\
8965ARGUMENTS:\n\
8966\n\
8967 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8968 degree of red in the color.\n\
8969\n\
8970 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8971 degree of green in the color.\n\
8972\n\
8973 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8974 degree of blue in the color.\n\
8975";
8976static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8977Set parameters that define current device-space window\n\
8978\n\
8979DESCRIPTION:\n\
8980\n\
8981 Set relative margin width, aspect ratio, and relative justification\n\
8982 that define current device-space window. If you want to just use the\n\
8983 previous value for any of these, just pass in the magic value\n\
8984 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8985 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8986 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8987 to a device-specific value.\n\
8988\n\
8989 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8990\n\
8991 This function is used in example 31.\n\
8992\n\
8993\n\
8994\n\
8995SYNOPSIS:\n\
8996\n\
8997plsdidev(mar, aspect, jx, jy)\n\
8998\n\
8999ARGUMENTS:\n\
9000\n\
9001 mar (PLFLT, input) : Relative margin width.\n\
9002\n\
9003 aspect (PLFLT, input) : Aspect ratio.\n\
9004\n\
9005 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9006 the range -0.5 to 0.5.\n\
9007\n\
9008 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9009 the range -0.5 to 0.5.\n\
9010";
9011static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9012Specify viewport using aspect ratio only\n\
9013\n\
9014DESCRIPTION:\n\
9015\n\
9016 Selects the largest viewport with the given aspect ratio within the\n\
9017 subpage that leaves a standard margin (left-hand margin of eight\n\
9018 character heights, and a margin around the other three sides of five\n\
9019 character heights).\n\
9020\n\
9021 Redacted form: plvasp(aspect)\n\
9022\n\
9023 This function is used in example 13.\n\
9024\n\
9025\n\
9026\n\
9027SYNOPSIS:\n\
9028\n\
9029plvasp(aspect)\n\
9030\n\
9031ARGUMENTS:\n\
9032\n\
9033 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9034 axis of resulting viewport.\n\
9035";
9036static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
9037Configure the transformations required for projecting a 3D surface on a 2D window\n\
9038\n\
9039DESCRIPTION:\n\
9040\n\
9041 Configure the transformations required for projecting a 3D surface on\n\
9042 an existing 2D window. Those transformations (see the PLplot\n\
9043 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9044 surface which has its limits expressed in 3D world coordinates and\n\
9045 also normalized 3D coordinates (used for interpreting the altitude and\n\
9046 azimuth of the viewing angle). The transformations consist of the\n\
9047 linear transform from 3D world coordinates to normalized 3D\n\
9048 coordinates, and the 3D rotation of normalized coordinates required to\n\
9049 align the pole of the new 3D coordinate system with the viewing\n\
9050 direction specified by altitude and azimuth so that x and y of the\n\
9051 surface elements in that transformed coordinate system are the\n\
9052 projection of the 3D surface with given viewing direction on the 2D\n\
9053 window.\n\
9054\n\
9055 The enclosing rectangular cuboid for the surface plot is defined by\n\
9056 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9057 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9058 sizes of basex by basey by height so that xmin maps to -\n\
9059 basex/2, xmax maps to basex/2, ymin maps to -\n\
9060 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9061 The resulting rectangular cuboid in normalized coordinates is then\n\
9062 viewed by an observer at altitude alt and azimuth az. This routine\n\
9063 must be called before plbox3 or any of the 3D surface plotting\n\
9064 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9065 plsurf3dl or plfill3.\n\
9066\n\
9067 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9068 zmin, zmax, alt, az)\n\
9069\n\
9070 This function is examples 8, 11, 18, and 21.\n\
9071\n\
9072\n\
9073\n\
9074SYNOPSIS:\n\
9075\n\
9076plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9077\n\
9078ARGUMENTS:\n\
9079\n\
9080 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9081 rectangular cuboid.\n\
9082\n\
9083 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9084 rectangular cuboid.\n\
9085\n\
9086 height (PLFLT, input) : The normalized z coordinate size of the\n\
9087 rectangular cuboid.\n\
9088\n\
9089 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9090 rectangular cuboid.\n\
9091\n\
9092 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9093 rectangular cuboid.\n\
9094\n\
9095 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9096 rectangular cuboid.\n\
9097\n\
9098 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9099 rectangular cuboid.\n\
9100\n\
9101 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9102 rectangular cuboid.\n\
9103\n\
9104 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9105 rectangular cuboid.\n\
9106\n\
9107 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9108 plane of the rectangular cuboid in normalized coordinates.\n\
9109\n\
9110 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9111 rectangular cuboid in normalized coordinates. When az=0, the\n\
9112 observer is looking face onto the zx plane of the rectangular\n\
9113 cuboid in normalized coordinates, and as az is increased, the\n\
9114 observer moves clockwise around that cuboid when viewed from above\n\
9115 the xy plane.\n\
9116";
9117static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9118Wait for graphics input event and translate to world coordinates.\n\
9119\n\
9120DESCRIPTION:\n\
9121\n\
9122 Wait for graphics input event and translate to world coordinates.\n\
9123 Returns 0 if no translation to world coordinates is possible.\n\
9124\n\
9125 This function returns 1 on success and 0 if no translation to world\n\
9126 coordinates is possible.\n\
9127\n\
9128 Redacted form: plGetCursor(gin)\n\
9129\n\
9130 This function is used in examples 1 and 20.\n\
9131\n\
9132\n\
9133\n\
9134SYNOPSIS:\n\
9135\n\
9136PLINT plGetCursor(gin)\n\
9137\n\
9138ARGUMENTS:\n\
9139\n\
9140 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9141 which will contain the output. The structure is not allocated by\n\
9142 the routine and must exist before the function is called.\n\
9143";
9144static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9145Set number of colors in cmap0\n\
9146\n\
9147DESCRIPTION:\n\
9148\n\
9149 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9150 (or reallocate) cmap0, and fill with default values for those colors\n\
9151 not previously allocated. The first 16 default colors are given in\n\
9152 the plcol0 documentation. For larger indices the default color is\n\
9153 red.\n\
9154\n\
9155 The drivers are not guaranteed to support more than 16 colors.\n\
9156\n\
9157 Redacted form: plscmap0n(ncol0)\n\
9158\n\
9159 This function is used in examples 15, 16, and 24.\n\
9160\n\
9161\n\
9162\n\
9163SYNOPSIS:\n\
9164\n\
9165plscmap0n(ncol0)\n\
9166\n\
9167ARGUMENTS:\n\
9168\n\
9169 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9170 the cmap0 palette. If this number is zero or less, then the value\n\
9171 from the previous call to plscmap0n is used and if there is no\n\
9172 previous call, then a default value is used.\n\
9173";
9174static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9175Set z axis parameters\n\
9176\n\
9177DESCRIPTION:\n\
9178\n\
9179 Identical to plsxax, except that arguments are flags for z axis. See\n\
9180 the description of plsxax for more detail.\n\
9181\n\
9182 Redacted form: plszax(digmax, digits)\n\
9183\n\
9184 This function is used in example 31.\n\
9185\n\
9186\n\
9187\n\
9188SYNOPSIS:\n\
9189\n\
9190plszax(digmax, digits)\n\
9191\n\
9192ARGUMENTS:\n\
9193\n\
9194 digmax (PLINT, input) : Variable to set the maximum number of\n\
9195 digits for the z axis. If nonzero, the printed label will be\n\
9196 switched to a floating-point representation when the number of\n\
9197 digits exceeds digmax.\n\
9198\n\
9199 digits (PLINT, input) : Field digits value. Currently, changing\n\
9200 its value here has no effect since it is set only by plbox or\n\
9201 plbox3. However, the user may obtain its value after a call to\n\
9202 either of these functions by calling plgzax.\n\
9203";
9204static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9205Get FCI (font characterization integer)\n\
9206\n\
9207DESCRIPTION:\n\
9208\n\
9209 Gets information about the current font using the FCI approach. See\n\
9210 the PLplot documentation for more information.\n\
9211\n\
9212 Redacted form: plgfci(p_fci)\n\
9213\n\
9214 This function is used in example 23.\n\
9215\n\
9216\n\
9217\n\
9218SYNOPSIS:\n\
9219\n\
9220plgfci(p_fci)\n\
9221\n\
9222ARGUMENTS:\n\
9223\n\
9224 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9225 FCI value.\n\
9226";
9227static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9228Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9229\n\
9230DESCRIPTION:\n\
9231\n\
9232 Sets up plotter environment for simple graphs by calling pladv and\n\
9233 setting up viewport and window to sensible default values. plenv0\n\
9234 leaves a standard margin (left-hand margin of eight character heights,\n\
9235 and a margin around the other three sides of five character heights)\n\
9236 around most graphs for axis labels and a title. When these defaults\n\
9237 are not suitable, use the individual routines plvpas, plvpor, or\n\
9238 plvasp for setting up the viewport, plwind for defining the window,\n\
9239 and plbox for drawing the box.\n\
9240\n\
9241 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9242\n\
9243 This function is used in example 21.\n\
9244\n\
9245\n\
9246\n\
9247SYNOPSIS:\n\
9248\n\
9249plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9250\n\
9251ARGUMENTS:\n\
9252\n\
9253 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9254 world coordinates).\n\
9255\n\
9256 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9257 world coordinates).\n\
9258\n\
9259 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9260 coordinates).\n\
9261\n\
9262 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9263 coordinates).\n\
9264\n\
9265 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9266 scales will not be set, the user must set up the scale before\n\
9267 calling plenv0 using plsvpa, plvasp or other.\n\
9268 0: the x and y axes are scaled independently to use as much of\n\
9269 the screen as possible.\n\
9270 1: the scales of the x and y axes are made equal.\n\
9271 2: the axis of the x and y axes are made equal, and the plot\n\
9272 box will be square.\n\
9273\n\
9274\n\
9275 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9276 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9277 -1: draw box only.\n\
9278 0: draw box, ticks, and numeric tick labels.\n\
9279 1: also draw coordinate axes at x=0 and y=0.\n\
9280 2: also draw a grid at major tick positions in both\n\
9281 coordinates.\n\
9282 3: also draw a grid at minor tick positions in both\n\
9283 coordinates.\n\
9284 10: same as 0 except logarithmic x tick marks. (The x data\n\
9285 have to be converted to logarithms separately.)\n\
9286 11: same as 1 except logarithmic x tick marks. (The x data\n\
9287 have to be converted to logarithms separately.)\n\
9288 12: same as 2 except logarithmic x tick marks. (The x data\n\
9289 have to be converted to logarithms separately.)\n\
9290 13: same as 3 except logarithmic x tick marks. (The x data\n\
9291 have to be converted to logarithms separately.)\n\
9292 20: same as 0 except logarithmic y tick marks. (The y data\n\
9293 have to be converted to logarithms separately.)\n\
9294 21: same as 1 except logarithmic y tick marks. (The y data\n\
9295 have to be converted to logarithms separately.)\n\
9296 22: same as 2 except logarithmic y tick marks. (The y data\n\
9297 have to be converted to logarithms separately.)\n\
9298 23: same as 3 except logarithmic y tick marks. (The y data\n\
9299 have to be converted to logarithms separately.)\n\
9300 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9301 and y data have to be converted to logarithms separately.)\n\
9302 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9303 and y data have to be converted to logarithms separately.)\n\
9304 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9305 and y data have to be converted to logarithms separately.)\n\
9306 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9307 and y data have to be converted to logarithms separately.)\n\
9308 40: same as 0 except date / time x labels.\n\
9309 41: same as 1 except date / time x labels.\n\
9310 42: same as 2 except date / time x labels.\n\
9311 43: same as 3 except date / time x labels.\n\
9312 50: same as 0 except date / time y labels.\n\
9313 51: same as 1 except date / time y labels.\n\
9314 52: same as 2 except date / time y labels.\n\
9315 53: same as 3 except date / time y labels.\n\
9316 60: same as 0 except date / time x and y labels.\n\
9317 61: same as 1 except date / time x and y labels.\n\
9318 62: same as 2 except date / time x and y labels.\n\
9319 63: same as 3 except date / time x and y labels.\n\
9320 70: same as 0 except custom x and y labels.\n\
9321 71: same as 1 except custom x and y labels.\n\
9322 72: same as 2 except custom x and y labels.\n\
9323 73: same as 3 except custom x and y labels.\n\
9324";
9325static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9326Set symbol size\n\
9327\n\
9328DESCRIPTION:\n\
9329\n\
9330 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9331 plsym. The actual height of a symbol is the product of the default\n\
9332 symbol size and a scaling factor as for the character height.\n\
9333\n\
9334 Redacted form: plssym(def, scale)\n\
9335\n\
9336 This function is used in example 29.\n\
9337\n\
9338\n\
9339\n\
9340SYNOPSIS:\n\
9341\n\
9342plssym(def, scale)\n\
9343\n\
9344ARGUMENTS:\n\
9345\n\
9346 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9347 should be set to zero if the default height is to remain\n\
9348 unchanged.\n\
9349\n\
9350 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9351 actual symbol height.\n\
9352";
9353static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9354Set plot orientation\n\
9355\n\
9356DESCRIPTION:\n\
9357\n\
9358 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9359 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9360 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9361 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9362 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9363 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9364 not called the default value of rot is 0.\n\
9365\n\
9366 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9367 probably want to change the aspect ratio to a value suitable for the\n\
9368 plot orientation using a call to plsdidev or the command-line options\n\
9369 -a or -freeaspect. For more documentation of those options see the\n\
9370 PLplot documentation. Such command-line options can be set internally\n\
9371 using plsetopt or set directly using the command line and parsed using\n\
9372 a call to plparseopts.\n\
9373\n\
9374 Redacted form: plsdiori(rot)\n\
9375\n\
9376 This function is not used in any examples.\n\
9377\n\
9378\n\
9379\n\
9380SYNOPSIS:\n\
9381\n\
9382plsdiori(rot)\n\
9383\n\
9384ARGUMENTS:\n\
9385\n\
9386 rot (PLFLT, input) : Plot orientation parameter.\n\
9387";
9388static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9389Advance the (sub-)page\n\
9390\n\
9391DESCRIPTION:\n\
9392\n\
9393 Advances to the next subpage if sub=0, performing a page advance if\n\
9394 there are no remaining subpages on the current page. If subpages\n\
9395 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9396 PLplot switches to the specified subpage. Note that this allows you\n\
9397 to overwrite a plot on the specified subpage; if this is not what you\n\
9398 intended, use pleop followed by plbop to first advance the page. This\n\
9399 routine is called automatically (with page=0) by plenv, but if plenv\n\
9400 is not used, pladv must be called after initializing PLplot but before\n\
9401 defining the viewport.\n\
9402\n\
9403 Redacted form: pladv(page)\n\
9404\n\
9405 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9406 29, and 31.\n\
9407\n\
9408\n\
9409\n\
9410SYNOPSIS:\n\
9411\n\
9412pladv(page)\n\
9413\n\
9414ARGUMENTS:\n\
9415\n\
9416 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9417 in the top left corner and increasing along the rows) to which to\n\
9418 advance. Set to zero to advance to the next subpage (or to the\n\
9419 next page if subpages are not being used).\n\
9420";
9421static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9422Set cmap0 colors by 8-bit RGB values\n\
9423\n\
9424DESCRIPTION:\n\
9425\n\
9426 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9427 documentation). This sets the entire color map -- only as many colors\n\
9428 as specified will be allocated.\n\
9429\n\
9430 Redacted form: plscmap0(r, g, b)\n\
9431\n\
9432 This function is used in examples 2 and 24.\n\
9433\n\
9434\n\
9435\n\
9436SYNOPSIS:\n\
9437\n\
9438plscmap0(r, g, b, ncol0)\n\
9439\n\
9440ARGUMENTS:\n\
9441\n\
9442 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9443 integers (0-255) representing the degree of red in the color.\n\
9444\n\
9445 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9446 integers (0-255) representing the degree of green in the color.\n\
9447\n\
9448 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9449 integers (0-255) representing the degree of blue in the color.\n\
9450\n\
9451 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9452";
9453static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9454Get character default height and current (scaled) height\n\
9455\n\
9456DESCRIPTION:\n\
9457\n\
9458 Get character default height and current (scaled) height.\n\
9459\n\
9460 Redacted form: plgchr(p_def, p_ht)\n\
9461\n\
9462 This function is used in example 23.\n\
9463\n\
9464\n\
9465\n\
9466SYNOPSIS:\n\
9467\n\
9468plgchr(p_def, p_ht)\n\
9469\n\
9470ARGUMENTS:\n\
9471\n\
9472 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9473 character height (mm).\n\
9474\n\
9475 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9476 character height (mm).\n\
9477";
9478static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9479Set opaque RGB cmap1 colors values\n\
9480\n\
9481DESCRIPTION:\n\
9482\n\
9483 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9484 vector values. This function also sets the number of cmap1 colors.\n\
9485 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9486 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9487 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9488 to\n\
9489 ncol1-1. So in order for this continuous color model to work\n\
9490 properly, it is the responsibility of the user of plscmap1 to insure\n\
9491 that these RGB vectors are continuous functions of their integer\n\
9492 indices.\n\
9493\n\
9494 Redacted form: plscmap1(r, g, b)\n\
9495\n\
9496 This function is used in example 31.\n\
9497\n\
9498\n\
9499\n\
9500SYNOPSIS:\n\
9501\n\
9502plscmap1(r, g, b, ncol1)\n\
9503\n\
9504ARGUMENTS:\n\
9505\n\
9506 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9507 8-bit integers in the range from 0-255) the degree of red in the\n\
9508 color as a continuous function of the integer index of the vector.\n\
9509\n\
9510 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9511 8-bit integers in the range from 0-255) the degree of green in the\n\
9512 color as a continuous function of the integer index of the vector.\n\
9513\n\
9514 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9515 8-bit integers in the range from 0-255) the degree of blue in the\n\
9516 color as a continuous function of the integer index of the vector.\n\
9517\n\
9518 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9519";
9520static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9521Set any command-line option\n\
9522\n\
9523DESCRIPTION:\n\
9524\n\
9525 Set any command-line option internally from a program before it\n\
9526 invokes plinit. opt is the name of the command-line option and optarg\n\
9527 is the corresponding command-line option argument.\n\
9528\n\
9529 This function returns 0 on success.\n\
9530\n\
9531 Redacted form: plsetopt(opt, optarg)\n\
9532\n\
9533 This function is used in example 14.\n\
9534\n\
9535\n\
9536\n\
9537SYNOPSIS:\n\
9538\n\
9539PLINT plsetopt(opt, optarg)\n\
9540\n\
9541ARGUMENTS:\n\
9542\n\
9543 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9544 the command-line option.\n\
9545\n\
9546 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9547 containing the argument of the command-line option.\n\
9548";
9549static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9550Draw linear gradient inside polygon\n\
9551\n\
9552DESCRIPTION:\n\
9553\n\
9554 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9555 points (\n\
9556 x[i],\n\
9557 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9558 polygon coordinates and the gradient angle are all expressed in world\n\
9559 coordinates. The angle from the x axis for both the rotated\n\
9560 coordinate system and the gradient vector is specified by angle. The\n\
9561 magnitude of the gradient vector is the difference between the maximum\n\
9562 and minimum values of x for the vertices in the rotated coordinate\n\
9563 system. The origin of the gradient vector can be interpreted as being\n\
9564 anywhere on the line corresponding to the minimum x value for the\n\
9565 vertices in the rotated coordinate system. The distance along the\n\
9566 gradient vector is linearly transformed to the independent variable of\n\
9567 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9568 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9569 color corresponding to the independent variable of cmap1. For more\n\
9570 information about cmap1 (see the PLplot documentation).\n\
9571\n\
9572 Redacted form: plgradient(x,y,angle)\n\
9573\n\
9574 This function is used in examples 25 and 30.\n\
9575\n\
9576\n\
9577\n\
9578SYNOPSIS:\n\
9579\n\
9580plgradient(n, x, y, angle)\n\
9581\n\
9582ARGUMENTS:\n\
9583\n\
9584 n (PLINT, input) : Number of vertices in polygon.\n\
9585\n\
9586 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9587 vertices.\n\
9588\n\
9589 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9590 vertices.\n\
9591\n\
9592 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9593 axis.\n\
9594";
9595static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9596Set length of major ticks\n\
9597\n\
9598DESCRIPTION:\n\
9599\n\
9600 This sets up the length of the major ticks. The actual length is the\n\
9601 product of the default length and a scaling factor as for character\n\
9602 height.\n\
9603\n\
9604 Redacted form: plsmaj(def, scale)\n\
9605\n\
9606 This function is used in example 29.\n\
9607\n\
9608\n\
9609\n\
9610SYNOPSIS:\n\
9611\n\
9612plsmaj(def, scale)\n\
9613\n\
9614ARGUMENTS:\n\
9615\n\
9616 def (PLFLT, input) : The default length of a major tick in\n\
9617 millimeters, should be set to zero if the default length is to\n\
9618 remain unchanged.\n\
9619\n\
9620 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9621 actual tick length.\n\
9622";
9623static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9624Set a global coordinate transform function\n\
9625\n\
9626DESCRIPTION:\n\
9627\n\
9628 This function can be used to define a coordinate transformation which\n\
9629 affects all elements drawn within the current plot window. The\n\
9630 coordinate_transform callback function is similar to that provided for\n\
9631 the plmap and plmeridians functions. The coordinate_transform_data\n\
9632 parameter may be used to pass extra data to coordinate_transform.\n\
9633\n\
9634 Redacted form: General: plstransform(coordinate_transform,\n\
9635 coordinate_transform_data)\n\
9636\n\
9637\n\
9638 This function is used in examples 19 and 22.\n\
9639\n\
9640\n\
9641\n\
9642SYNOPSIS:\n\
9643\n\
9644plstransform(coordinate_transform, coordinate_transform_data)\n\
9645\n\
9646ARGUMENTS:\n\
9647\n\
9648 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9649 function that defines the transformation from the input (x, y)\n\
9650 world coordinates to new PLplot world coordinates. If\n\
9651 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9652 case), then no transform is applied.\n\
9653\n\
9654 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9655 for\n\
9656 coordinate_transform.\n\
9657";
9658static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9659Configure the transformation between continuous and broken-down time for the current stream\n\
9660\n\
9661DESCRIPTION:\n\
9662\n\
9663 Configure the transformation between continuous and broken-down time\n\
9664 for the current stream. This transformation is used by both plbtime\n\
9665 and plctime.\n\
9666\n\
9667 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9668 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9669\n\
9670\n\
9671 This function is used in example 29.\n\
9672\n\
9673\n\
9674\n\
9675SYNOPSIS:\n\
9676\n\
9677plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9678\n\
9679ARGUMENTS:\n\
9680\n\
9681 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9682 As a special case, if\n\
9683 scale is 0., then all other arguments are ignored, and the result (the\n\
9684 default used by PLplot) is the equivalent of a call to\n\
9685 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9686 That is, for this special case broken-down time is calculated with\n\
9687 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9688 and the continuous time is defined as the number of seconds since\n\
9689 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9690\n\
9691 offset1 (PLFLT, input) : If\n\
9692 ifbtime_offset is true, the parameters\n\
9693 offset1 and\n\
9694 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9695 (with units in days) specify the epoch of the continuous time\n\
9696 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9697 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9698 are used to specify the origin to allow users (by specifying\n\
9699 offset1 as an integer that can be exactly represented by a\n\
9700 floating-point variable and specifying\n\
9701 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9702 the numerical errors of the continuous time representation.\n\
9703\n\
9704 offset2 (PLFLT, input) : See documentation of\n\
9705 offset1.\n\
9706\n\
9707 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9708 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9709 calendar is used for broken-down time rather than the proleptic\n\
9710 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9711 have been historically used to define UTC are inserted into the\n\
9712 broken-down time. Other possibilities for additional control bits\n\
9713 for ccontrol exist such as making the historical time corrections\n\
9714 in the broken-down time corresponding to ET (ephemeris time) or\n\
9715 making the (slightly non-constant) corrections from international\n\
9716 atomic time (TAI) to what astronomers define as terrestrial time\n\
9717 (TT). But those additional possibilities have not been\n\
9718 implemented yet in the qsastime library (one of the PLplot utility\n\
9719 libraries).\n\
9720\n\
9721 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9722 epoch of the continuous time scale is specified by the user. If\n\
9723 ifbtime_offset is false, then\n\
9724 offset1 and\n\
9725 offset2 are used to specify the epoch, and the following broken-down\n\
9726 time parameters are completely ignored. If\n\
9727 ifbtime_offset is true, then\n\
9728 offset1 and\n\
9729 offset2 are completely ignored, and the following broken-down time\n\
9730 parameters are used to specify the epoch.\n\
9731\n\
9732 year (PLINT, input) : Year of epoch.\n\
9733\n\
9734 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9735 11 (December).\n\
9736\n\
9737 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9738\n\
9739 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9740\n\
9741 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9742\n\
9743 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9744";
9745static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9746Flushes the output stream\n\
9747\n\
9748DESCRIPTION:\n\
9749\n\
9750 Flushes the output stream. Use sparingly, if at all.\n\
9751\n\
9752 Redacted form: plflush()\n\
9753\n\
9754 This function is used in examples 1 and 14.\n\
9755\n\
9756\n\
9757\n\
9758SYNOPSIS:\n\
9759\n\
9760plflush()\n\
9761";
9762static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9763Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9764\n\
9765DESCRIPTION:\n\
9766\n\
9767 This variant of plsurf3d (see that function\'s documentation for more\n\
9768 details) should be suitable for the case where the area of the x, y\n\
9769 coordinate grid where z is defined can be non-rectangular. The limits\n\
9770 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9771 indexymin, and indexymax.\n\
9772\n\
9773 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9774 indexymax)\n\
9775\n\
9776 This function is used in example 8.\n\
9777\n\
9778\n\
9779\n\
9780SYNOPSIS:\n\
9781\n\
9782plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9783\n\
9784ARGUMENTS:\n\
9785\n\
9786 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9787 which the function is evaluated.\n\
9788\n\
9789 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9790 which the function is evaluated.\n\
9791\n\
9792 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9793 plot. Should have dimensions of\n\
9794 nx by\n\
9795 ny.\n\
9796\n\
9797 nx (PLINT, input) : Number of x values at which function is\n\
9798 evaluated.\n\
9799\n\
9800 ny (PLINT, input) : Number of y values at which function is\n\
9801 evaluated.\n\
9802\n\
9803 opt (PLINT, input) : Determines the way in which the surface is\n\
9804 represented. To specify more than one option just add the options,\n\
9805 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9806 connecting points at which function is defined.\n\
9807 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9808 using parameters\n\
9809 nlevel and\n\
9810 clevel.\n\
9811 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9812 using parameters\n\
9813 nlevel and\n\
9814 clevel.\n\
9815 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9816 the borders of the plotted function.\n\
9817 opt=MAG_COLOR : the surface is colored according to the value\n\
9818 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9819 according to the intensity of the reflected light in the\n\
9820 surface from a light source whose position is set using\n\
9821 pllightsource.\n\
9822\n\
9823\n\
9824 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9825 levels.\n\
9826\n\
9827 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9828\n\
9829 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9830 corresponds to the first x index where z is defined.\n\
9831\n\
9832 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9833 which corresponds (by convention) to one more than the last x\n\
9834 index value where z is defined.\n\
9835\n\
9836 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9837 values which all must be ≥ 0. These values are the first y index\n\
9838 where z is defined for a particular x index in the range from\n\
9839 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9840 indexxmax.\n\
9841\n\
9842 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9843 values which all must be ≤ ny. These values correspond (by\n\
9844 convention) to one more than the last y index where z is defined\n\
9845 for a particular x index in the range from indexxmin to indexxmax\n\
9846 - 1. The dimension of indexymax is indexxmax.\n\
9847";
9848static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9849Set semitransparent cmap1 RGBA colors.\n\
9850\n\
9851DESCRIPTION:\n\
9852\n\
9853 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9854 RGBA vector values. This function also sets the number of cmap1\n\
9855 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9856 floating-point index in the range from 0.0-1.0 which is linearly\n\
9857 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9858 vectors in the range from 0 to\n\
9859 ncol1-1. So in order for this continuous color model to work\n\
9860 properly, it is the responsibility of the user of plscmap1 to insure\n\
9861 that these RGBA vectors are continuous functions of their integer\n\
9862 indices.\n\
9863\n\
9864 Redacted form: plscmap1a(r, g, b, alpha)\n\
9865\n\
9866 This function is used in example 31.\n\
9867\n\
9868\n\
9869\n\
9870SYNOPSIS:\n\
9871\n\
9872plscmap1a(r, g, b, alpha, ncol1)\n\
9873\n\
9874ARGUMENTS:\n\
9875\n\
9876 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9877 8-bit integers in the range from 0-255) the degree of red in the\n\
9878 color as a continuous function of the integer index of the vector.\n\
9879\n\
9880 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9881 8-bit integers in the range from 0-255) the degree of green in the\n\
9882 color as a continuous function of the integer index of the vector.\n\
9883\n\
9884 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9885 8-bit integers in the range from 0-255) the degree of blue in the\n\
9886 color as a continuous function of the integer index of the vector.\n\
9887\n\
9888 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9889 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9890 completely transparent and 1.0 corresponds to completely opaque)\n\
9891 the alpha transparency of the color as a continuous function of\n\
9892 the integer index of the vector.\n\
9893\n\
9894 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9895 vectors.\n\
9896";
9897static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9898Calculate broken-down time from continuous time for the current stream\n\
9899\n\
9900DESCRIPTION:\n\
9901\n\
9902 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9903 continuous time, ctime for the current stream. This function is the\n\
9904 inverse of plctime.\n\
9905\n\
9906 The PLplot definition of broken-down time is a calendar time that\n\
9907 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9908 responsibility to apply those offsets (if so desired) before using the\n\
9909 PLplot time API. By default broken-down time is defined using the\n\
9910 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9911 continuous time is defined as the number of seconds since the Unix\n\
9912 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9913 broken-down and continuous time are possible, see plconfigtime.\n\
9914\n\
9915 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9916 ctime)\n\
9917\n\
9918\n\
9919 This function is used in example 29.\n\
9920\n\
9921\n\
9922\n\
9923SYNOPSIS:\n\
9924\n\
9925plbtime(year, month, day, hour, min, sec, ctime)\n\
9926\n\
9927ARGUMENTS:\n\
9928\n\
9929 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9930 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9931 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9932 BCE, etc.)\n\
9933\n\
9934 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9935 the year in the range from 0 (January) to 11 (December).\n\
9936\n\
9937 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9938 month in the range from 1 to 31.\n\
9939\n\
9940 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9941 day in the range from 0 to 23.\n\
9942\n\
9943 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9944 hour in the range from 0 to 59\n\
9945\n\
9946 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9947 minute in range from 0. to 60.\n\
9948\n\
9949 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9950 time is calculated.\n\
9951";
9952static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9953Convert RGB color to HLS\n\
9954\n\
9955DESCRIPTION:\n\
9956\n\
9957 Convert RGB color coordinates to HLS\n\
9958\n\
9959 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9960\n\
9961\n\
9962 This function is used in example 2.\n\
9963\n\
9964\n\
9965\n\
9966SYNOPSIS:\n\
9967\n\
9968plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9969\n\
9970ARGUMENTS:\n\
9971\n\
9972 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9973\n\
9974 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9975\n\
9976 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9977\n\
9978 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9979 degrees (0.0-360.0) on the color cylinder.\n\
9980\n\
9981 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9982 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9983 cylinder.\n\
9984\n\
9985 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9986 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9987 cylinder.\n\
9988";
9989static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9990Get the current device (keyword) name\n\
9991\n\
9992DESCRIPTION:\n\
9993\n\
9994 Get the current device (keyword) name. Note: you must have allocated\n\
9995 space for this (80 characters is safe).\n\
9996\n\
9997 Redacted form: plgdev(p_dev)\n\
9998\n\
9999 This function is used in example 14.\n\
10000\n\
10001\n\
10002\n\
10003SYNOPSIS:\n\
10004\n\
10005plgdev(p_dev)\n\
10006\n\
10007ARGUMENTS:\n\
10008\n\
10009 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10010 (with preallocated length of 80 characters or more) containing the\n\
10011 device (keyword) name.\n\
10012";
10013static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
10014Set the number of subpages in x and y\n\
10015\n\
10016DESCRIPTION:\n\
10017\n\
10018 Set the number of subpages in x and y.\n\
10019\n\
10020 Redacted form: plssub(nx, ny)\n\
10021\n\
10022 This function is examples 1,2,14,21,25,27.\n\
10023\n\
10024\n\
10025\n\
10026SYNOPSIS:\n\
10027\n\
10028plssub(nx, ny)\n\
10029\n\
10030ARGUMENTS:\n\
10031\n\
10032 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10033 of window columns).\n\
10034\n\
10035 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10036 of window rows).\n\
10037";
10038static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
10039Get current stream number\n\
10040\n\
10041DESCRIPTION:\n\
10042\n\
10043 Gets the number of the current output stream. See also plsstrm.\n\
10044\n\
10045 Redacted form: plgstrm(p_strm)\n\
10046\n\
10047 This function is used in example 1,20.\n\
10048\n\
10049\n\
10050\n\
10051SYNOPSIS:\n\
10052\n\
10053plgstrm(p_strm)\n\
10054\n\
10055ARGUMENTS:\n\
10056\n\
10057 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10058 stream value.\n\
10059";
10060static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
10061Random number generator returning a real random number in the range [0,1]\n\
10062\n\
10063DESCRIPTION:\n\
10064\n\
10065 Random number generator returning a real random number in the range\n\
10066 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10067 / compilers provide their own random number generator, and so this is\n\
10068 provided purely for convenience and to give a consistent random number\n\
10069 generator across all languages supported by PLplot. This is\n\
10070 particularly useful for comparing results from the test suite of\n\
10071 examples.\n\
10072\n\
10073 Redacted form: plrandd()\n\
10074\n\
10075 This function is used in examples 17 and 21.\n\
10076\n\
10077\n\
10078\n\
10079SYNOPSIS:\n\
10080\n\
10081plrandd()\n\
10082";
10083static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10084Add a point to a strip chart\n\
10085\n\
10086DESCRIPTION:\n\
10087\n\
10088 Add a point to a given pen of a given strip chart. There is no need\n\
10089 for all pens to have the same number of points or to be equally\n\
10090 sampled in the x coordinate. Allocates memory and rescales as\n\
10091 necessary.\n\
10092\n\
10093 Redacted form: plstripa(id, pen, x, y)\n\
10094\n\
10095 This function is used in example 17.\n\
10096\n\
10097\n\
10098\n\
10099SYNOPSIS:\n\
10100\n\
10101plstripa(id, pen, x, y)\n\
10102\n\
10103ARGUMENTS:\n\
10104\n\
10105 id (PLINT, input) : Identification number of the strip chart (set\n\
10106 up in plstripc).\n\
10107\n\
10108 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10109\n\
10110 x (PLFLT, input) : X coordinate of point to plot.\n\
10111\n\
10112 y (PLFLT, input) : Y coordinate of point to plot.\n\
10113";
10114static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10115Set device-compression level\n\
10116\n\
10117DESCRIPTION:\n\
10118\n\
10119 Set device-compression level. Only used for drivers that provide\n\
10120 compression. This function, if used, should be invoked before a call\n\
10121 to plinit.\n\
10122\n\
10123 Redacted form: plscompression(compression)\n\
10124\n\
10125 This function is used in example 31.\n\
10126\n\
10127\n\
10128\n\
10129SYNOPSIS:\n\
10130\n\
10131plscompression(compression)\n\
10132\n\
10133ARGUMENTS:\n\
10134\n\
10135 compression (PLINT, input) : The desired compression level. This is\n\
10136 a device-dependent value. Currently only the jpeg and png devices\n\
10137 use these values. For jpeg value is the jpeg quality which should\n\
10138 normally be in the range 0-95. Higher values denote higher quality\n\
10139 and hence larger image sizes. For png values are in the range -1\n\
10140 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10141 A value of -1 denotes the default zlib compression level. Values\n\
10142 in the range 10-99 are divided by 10 and then used as the zlib\n\
10143 compression level. Higher compression levels correspond to greater\n\
10144 compression and small file sizes at the expense of more\n\
10145 computation.\n\
10146";
10147static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10148Specify viewport in absolute coordinates\n\
10149\n\
10150DESCRIPTION:\n\
10151\n\
10152 Alternate routine to plvpor for setting up the viewport. This routine\n\
10153 should be used only if the viewport is required to have a definite\n\
10154 size in millimeters. The routine plgspa is useful for finding out the\n\
10155 size of the current subpage.\n\
10156\n\
10157 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10158\n\
10159 This function is used in example 10.\n\
10160\n\
10161\n\
10162\n\
10163SYNOPSIS:\n\
10164\n\
10165plsvpa(xmin, xmax, ymin, ymax)\n\
10166\n\
10167ARGUMENTS:\n\
10168\n\
10169 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10170 viewport from the left-hand edge of the subpage in millimeters.\n\
10171\n\
10172 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10173 viewport from the left-hand edge of the subpage in millimeters.\n\
10174\n\
10175 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10176 viewport from the bottom edge of the subpage in millimeters.\n\
10177\n\
10178 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10179 from the bottom edge of the subpage in millimeters.\n\
10180";
10181static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10182Draw a polygon in 3 space\n\
10183\n\
10184DESCRIPTION:\n\
10185\n\
10186 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10187 like plline3, but differs from that function in that plpoly3 attempts\n\
10188 to determine if the polygon is viewable depending on the order of the\n\
10189 points within the vector and the value of ifcc. If the back of\n\
10190 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10191 you want, then use plline3 instead.\n\
10192\n\
10193 The points are assumed to be in a plane, and the directionality of the\n\
10194 plane is determined from the first three points. Additional points do\n\
10195 not have to lie on the plane defined by the first three, but if they\n\
10196 do not, then the determination of visibility obviously can\'t be 100%\n\
10197 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10198 consider breaking them into smaller polygons. 3 points define a plane\n\
10199 :-).\n\
10200\n\
10201 Bugs: If one of the first two segments is of zero length, or if they\n\
10202 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10203 being correct. Avoid such situations :-). See x18c.c for an example\n\
10204 of this problem. (Search for 20.1).\n\
10205\n\
10206 Redacted form: plpoly3(x, y, z, code)\n\
10207\n\
10208 This function is used in example 18.\n\
10209\n\
10210\n\
10211\n\
10212SYNOPSIS:\n\
10213\n\
10214plpoly3(n, x, y, z, draw, ifcc)\n\
10215\n\
10216ARGUMENTS:\n\
10217\n\
10218 n (PLINT, input) : Number of points defining line.\n\
10219\n\
10220 x (PLFLT_VECTOR, input) : A vector containing\n\
10221 n x coordinates of points.\n\
10222\n\
10223 y (PLFLT_VECTOR, input) : A vector containing\n\
10224 n y coordinates of points.\n\
10225\n\
10226 z (PLFLT_VECTOR, input) : A vector containing\n\
10227 n z coordinates of points.\n\
10228\n\
10229 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10230 n-1 Boolean values which control drawing the segments of the polygon.\n\
10231 If draw[i] is true, then the polygon segment from index [i] to\n\
10232 [i+1] is drawn, otherwise, not.\n\
10233\n\
10234 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10235 polygon is determined by assuming the points are laid out in a\n\
10236 counter-clockwise order. Otherwise, the directionality of the\n\
10237 polygon is determined by assuming the points are laid out in a\n\
10238 clockwise order.\n\
10239";
10240static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10241Magnitude colored plot surface with contour\n\
10242\n\
10243DESCRIPTION:\n\
10244\n\
10245 Aside from dropping the\n\
10246 side functionality this is a more powerful form of plot3d: the surface\n\
10247 mesh can be colored accordingly to the current z value being plotted,\n\
10248 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10249 drawn between the plotted function border and the base XY plane. The\n\
10250 arguments are identical to those of plmeshc. The only difference\n\
10251 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10252 the surface, while plot3dc only draws the surface as viewed from the\n\
10253 top.\n\
10254\n\
10255 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10256\n\
10257\n\
10258 This function is used in example 21.\n\
10259\n\
10260\n\
10261\n\
10262SYNOPSIS:\n\
10263\n\
10264plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10265\n\
10266ARGUMENTS:\n\
10267\n\
10268 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10269 which the function is evaluated.\n\
10270\n\
10271 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10272 which the function is evaluated.\n\
10273\n\
10274 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10275 plot. Should have dimensions of\n\
10276 nx by\n\
10277 ny.\n\
10278\n\
10279 nx (PLINT, input) : Number of x values at which function is\n\
10280 evaluated.\n\
10281\n\
10282 ny (PLINT, input) : Number of y values at which function is\n\
10283 evaluated.\n\
10284\n\
10285 opt (PLINT, input) : Determines the way in which the surface is\n\
10286 represented. To specify more than one option just add the options,\n\
10287 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10288 showing z as a function of x for each value of y[j] .\n\
10289 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10290 for each value of x[i] .\n\
10291 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10292 at which function is defined.\n\
10293 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10294 the z value being plotted. The color is used from the current\n\
10295 cmap1.\n\
10296 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10297 using parameters\n\
10298 nlevel and\n\
10299 clevel.\n\
10300 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10301 the borders of the plotted function.\n\
10302\n\
10303\n\
10304 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10305 levels.\n\
10306\n\
10307 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10308";
10309static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10310Create a 4-pen strip chart\n\
10311\n\
10312DESCRIPTION:\n\
10313\n\
10314 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10315\n\
10316 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10317 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10318 styline, legline, labx, laby, labz)\n\
10319\n\
10320\n\
10321 This function is used in example 17.\n\
10322\n\
10323\n\
10324\n\
10325SYNOPSIS:\n\
10326\n\
10327plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10328\n\
10329ARGUMENTS:\n\
10330\n\
10331 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10332 number of the strip chart to use on plstripa and plstripd.\n\
10333\n\
10334 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10335 the x-axis specification as in plbox.\n\
10336\n\
10337 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10338 the y-axis specification as in plbox.\n\
10339\n\
10340 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10341 change as data are added.\n\
10342\n\
10343 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10344 change as data are added.\n\
10345\n\
10346 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10347 is multiplied by the factor (1 +\n\
10348 xjump) .\n\
10349\n\
10350 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10351 change as data are added.\n\
10352\n\
10353 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10354 change as data are added.\n\
10355\n\
10356 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10357\n\
10358 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10359\n\
10360 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10361 true, otherwise not.\n\
10362\n\
10363 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10364 otherwise slide display.\n\
10365\n\
10366 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10367\n\
10368 collab (PLINT, input) : Legend color index (cmap0).\n\
10369\n\
10370 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10371 indices for the 4 pens.\n\
10372\n\
10373 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10374 indices for the 4 pens.\n\
10375\n\
10376 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10377 strings containing legends for the 4 pens.\n\
10378\n\
10379 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10380 the label for the x axis.\n\
10381\n\
10382 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10383 the label for the y axis.\n\
10384\n\
10385 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10386 the plot title.\n\
10387";
10388static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10389Deletes and releases memory used by a strip chart\n\
10390\n\
10391DESCRIPTION:\n\
10392\n\
10393 Deletes and releases memory used by a strip chart.\n\
10394\n\
10395 Redacted form: plstripd(id)\n\
10396\n\
10397 This function is used in example 17.\n\
10398\n\
10399\n\
10400\n\
10401SYNOPSIS:\n\
10402\n\
10403plstripd(id)\n\
10404\n\
10405ARGUMENTS:\n\
10406\n\
10407 id (PLINT, input) : Identification number of strip chart to delete.\n\
10408";
10409static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10410Set cmap1 colors using a piece-wise linear relationship\n\
10411\n\
10412DESCRIPTION:\n\
10413\n\
10414 Set cmap1 colors using a piece-wise linear relationship between the\n\
10415 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10416 (see the PLplot documentation). May be called at any time.\n\
10417\n\
10418 The idea here is to specify a number of control points that define the\n\
10419 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10420 these points, linear interpolation is used which gives a smooth\n\
10421 variation of color with intensity index. Any number of control points\n\
10422 may be specified, located at arbitrary positions, although typically 2\n\
10423 - 4 are enough. Another way of stating this is that we are traversing\n\
10424 a given number of lines through HLS or RGB space as we move through\n\
10425 cmap1 intensity indices. The control points at the minimum and\n\
10426 maximum position (0 and 1) must always be specified. By adding more\n\
10427 control points you can get more variation. One good technique for\n\
10428 plotting functions that vary about some expected average is to use an\n\
10429 additional 2 control points in the center (position ~= 0.5) that are\n\
10430 the same lightness as the background (typically white for paper\n\
10431 output, black for crt), and same hue as the boundary control points.\n\
10432 This allows the highs and lows to be very easily distinguished.\n\
10433\n\
10434 Each control point must specify the cmap1 intensity index and the\n\
10435 associated three coordinates in HLS or RGB space. The first point\n\
10436 must correspond to position = 0, and the last to position = 1.\n\
10437\n\
10438 If RGB colors are provided then the interpolation takes place in RGB\n\
10439 space and is trivial. However if HLS colors are provided then, because\n\
10440 of the circular nature of the color wheel for the hue coordinate, the\n\
10441 interpolation could be performed in either direction around the color\n\
10442 wheel. The default behaviour is for the hue to be linearly\n\
10443 interpolated ignoring this circular property of hue. So for example,\n\
10444 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10445 green and cyan. If instead you wish to interpolate the other way\n\
10446 around the color wheel you have two options. You may provide hues\n\
10447 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10448 for red the interpolation will proceed via magenta. Alternatively you\n\
10449 can utilise the alt_hue_path variable to reverse the direction of\n\
10450 interpolation if you need to provide hues within the [0-360) range.\n\
10451\n\
10452 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10453 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10454 -120]falsegreen-yellow-red-magenta-blue[240\n\
10455 480]falseblue-magenta-red-yellow-green[120\n\
10456 240]truegreen-yellow-red-magenta-blue[240\n\
10457 120]trueblue-magenta-red-yellow-green\n\
10458\n\
10459 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10460 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10461 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10462\n\
10463 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10464 alt_hue_path)\n\
10465\n\
10466 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10467\n\
10468\n\
10469\n\
10470SYNOPSIS:\n\
10471\n\
10472plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10473\n\
10474ARGUMENTS:\n\
10475\n\
10476 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10477\n\
10478 npts (PLINT, input) : number of control points\n\
10479\n\
10480 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10481 intensity index (0.0-1.0) in ascending order for each control\n\
10482 point.\n\
10483\n\
10484 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10485 coordinate (H or R) for each control point.\n\
10486\n\
10487 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10488 coordinate (L or G) for each control point.\n\
10489\n\
10490 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10491 coordinate (S or B) for each control point.\n\
10492\n\
10493 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10494 npts - 1 elements), each containing either true to use the reversed\n\
10495 HLS interpolation or false to use the regular HLS interpolation.\n\
10496 (alt_hue_path[i] refers to the interpolation interval between the\n\
10497 i and i + 1 control points). This parameter is not used for RGB\n\
10498 colors (\n\
10499 itype = true).\n\
10500";
10501static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10502Shade individual region on the basis of value\n\
10503\n\
10504DESCRIPTION:\n\
10505\n\
10506 Shade individual region on the basis of value. Use plshades if you\n\
10507 want to shade a number of contiguous regions using continuous colors.\n\
10508 In particular the edge contours are treated properly in plshades. If\n\
10509 you attempt to do contiguous regions with plshade the contours at the\n\
10510 edge of the shade are partially obliterated by subsequent plots of\n\
10511 contiguous shaded regions.\n\
10512\n\
10513 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10514 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10515 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10516\n\
10517\n\
10518 This function is used in example 15.\n\
10519\n\
10520\n\
10521\n\
10522SYNOPSIS:\n\
10523\n\
10524plshade(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\
10525\n\
10526ARGUMENTS:\n\
10527\n\
10528 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10529 plot. Should have dimensions of\n\
10530 nx by\n\
10531 ny.\n\
10532\n\
10533 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10534\n\
10535 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10536\n\
10537 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10538 the region that should be plotted in the shade plot. This\n\
10539 function accepts x and y coordinates as input arguments and must\n\
10540 return 1 if the point is to be included in the shade plot and 0\n\
10541 otherwise. If you want to plot the entire shade plot (the usual\n\
10542 case), this argument should be set to NULL.\n\
10543\n\
10544 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10545 pltr below for how these arguments are used (only for the special case\n\
10546 when the callback function\n\
10547 pltr is not supplied).\n\
10548\n\
10549 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10550 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10551\n\
10552 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10553 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10554\n\
10555 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10556 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10557 then sh_color is interpreted as a cmap1 argument in the range\n\
10558 (0.0-1.0).\n\
10559\n\
10560 sh_color (PLFLT, input) : Defines color map index with integer\n\
10561 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10562\n\
10563 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10564\n\
10565 min_color (PLINT, input) : Defines pen color, width used by the\n\
10566 boundary of shaded region. The min values are used for the\n\
10567 shade_min boundary, and the max values are used on the shade_max\n\
10568 boundary. Set color and width to zero for no plotted boundaries.\n\
10569\n\
10570 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10571 boundary of shaded region. The min values are used for the\n\
10572 shade_min boundary, and the max values are used on the shade_max\n\
10573 boundary. Set color and width to zero for no plotted boundaries.\n\
10574\n\
10575 max_color (PLINT, input) : Defines pen color, width used by the\n\
10576 boundary of shaded region. The min values are used for the\n\
10577 shade_min boundary, and the max values are used on the shade_max\n\
10578 boundary. Set color and width to zero for no plotted boundaries.\n\
10579\n\
10580 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10581 boundary of shaded region. The min values are used for the\n\
10582 shade_min boundary, and the max values are used on the shade_max\n\
10583 boundary. Set color and width to zero for no plotted boundaries.\n\
10584\n\
10585 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10586 Use plfill. Future version of PLplot may have other fill\n\
10587 routines.\n\
10588\n\
10589 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10590 map to rectangles after coordinate transformation with pltrl.\n\
10591 Otherwise, set rectangular to false. If rectangular is set to\n\
10592 true, plshade tries to save time by filling large rectangles.\n\
10593 This optimization fails if the coordinate transformation distorts\n\
10594 the shape of rectangles. For example a plot in polar coordinates\n\
10595 has to have rectangular set to false.\n\
10596\n\
10597 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10598 defines the transformation between the zero-based indices of the\n\
10599 matrix a and world coordinates. If\n\
10600 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10601 indices of a are mapped to the range\n\
10602 xmin through\n\
10603 xmax and the y indices of a are mapped to the range\n\
10604 ymin through\n\
10605 ymax.For the C case, transformation functions are provided in the\n\
10606 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10607 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10608 matrices. In addition, C callback routines for the transformation\n\
10609 can be supplied by the user such as the mypltr function in\n\
10610 examples/c/x09c.c which provides a general linear transformation\n\
10611 between index coordinates and world coordinates.For languages\n\
10612 other than C you should consult the PLplot documentation for the\n\
10613 details concerning how PLTRANSFORM_callback arguments are\n\
10614 interfaced. However, in general, a particular pattern of\n\
10615 callback-associated arguments such as a tr vector with 6 elements;\n\
10616 xg and yg vectors; or xg and yg matrices are respectively\n\
10617 interfaced to a linear-transformation routine similar to the above\n\
10618 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10619 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10620 support native language callbacks for handling index to\n\
10621 world-coordinate transformations. Examples of these various\n\
10622 approaches are given in examples/<language>x09*,\n\
10623 examples/<language>x16*, examples/<language>x20*,\n\
10624 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10625 supported languages.\n\
10626\n\
10627 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10628 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10629 externally supplied.\n\
10630";
10631static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10632Set number of colors in cmap1\n\
10633\n\
10634DESCRIPTION:\n\
10635\n\
10636 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10637 values if this is the first allocation (see the PLplot documentation).\n\
10638\n\
10639 Redacted form: plscmap1n(ncol1)\n\
10640\n\
10641 This function is used in examples 8, 11, 20, and 21.\n\
10642\n\
10643\n\
10644\n\
10645SYNOPSIS:\n\
10646\n\
10647plscmap1n(ncol1)\n\
10648\n\
10649ARGUMENTS:\n\
10650\n\
10651 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10652 the cmap1 palette. If this number is zero or less, then the value\n\
10653 from the previous call to plscmap1n is used and if there is no\n\
10654 previous call, then a default value is used.\n\
10655";
10656static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10657Advance to the next family file on the next new page\n\
10658\n\
10659DESCRIPTION:\n\
10660\n\
10661 Advance to the next family file on the next new page.\n\
10662\n\
10663 Redacted form: plfamadv()\n\
10664\n\
10665 This function is not used in any examples.\n\
10666\n\
10667\n\
10668\n\
10669SYNOPSIS:\n\
10670\n\
10671plfamadv()\n\
10672";
10673static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10674Set the escape character for text strings\n\
10675\n\
10676DESCRIPTION:\n\
10677\n\
10678 Set the escape character for text strings. From C (in contrast to\n\
10679 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10680 characters are allowed to prevent the user from shooting himself in\n\
10681 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10682 use of backslash as a character escape). Here are the allowed escape\n\
10683 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10684 #, ASCII 35\n\
10685 $, ASCII 36\n\
10686 %, ASCII 37\n\
10687 &, ASCII 38\n\
10688 *, ASCII 42\n\
10689 @, ASCII 64\n\
10690 ^, ASCII 94\n\
10691 ~, ASCII 126\n\
10692\n\
10693\n\
10694 Redacted form: General: plsesc(esc)\n\
10695\n\
10696\n\
10697 This function is used in example 29.\n\
10698\n\
10699\n\
10700\n\
10701SYNOPSIS:\n\
10702\n\
10703plsesc(esc)\n\
10704\n\
10705ARGUMENTS:\n\
10706\n\
10707 esc (char, input) : Escape character.\n\
10708";
10709static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10710Plot color bar for image, shade or gradient plots\n\
10711\n\
10712DESCRIPTION:\n\
10713\n\
10714 Routine for creating a continuous color bar for image, shade, or\n\
10715 gradient plots. (See pllegend for similar functionality for creating\n\
10716 legends with discrete elements). The arguments of plcolorbar provide\n\
10717 control over the location and size of the color bar as well as the\n\
10718 location and characteristics of the elements (most of which are\n\
10719 optional) within that color bar. The resulting color bar is clipped\n\
10720 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10721 system used for some of the parameters is defined in the documentation\n\
10722 of the position parameter.)\n\
10723\n\
10724 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10725 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10726 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10727 labels, axis_opts, ticks, sub_ticks, values)\n\
10728\n\
10729 This function is used in examples 16 and 33.\n\
10730\n\
10731\n\
10732\n\
10733SYNOPSIS:\n\
10734\n\
10735plcolorbar(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\
10736\n\
10737ARGUMENTS:\n\
10738\n\
10739 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10740 labelled and decorated color bar width in adopted coordinates.\n\
10741\n\
10742 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10743 labelled and decorated color bar height in adopted coordinates.\n\
10744\n\
10745 opt (PLINT, input) : opt contains bits controlling the overall\n\
10746 color bar. The orientation (direction of the maximum value) of\n\
10747 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10748 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10749 specified, the default orientation is toward the top if the\n\
10750 colorbar is placed on the left or right of the viewport or toward\n\
10751 the right if the colorbar is placed on the top or bottom of the\n\
10752 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10753 (semitransparent) background for the color bar. If the\n\
10754 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10755 color bar. The type of color bar must be specified with one of\n\
10756 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10757 more than one of those bits is set only the first one in the above\n\
10758 list is honored. The position of the (optional) label/title can be\n\
10759 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10760 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10761 will be drawn. If more than one of this list of bits is specified,\n\
10762 only the first one on the list is honored. End-caps for the color\n\
10763 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10764 If a particular color bar cap option is not specified then no cap\n\
10765 will be drawn for that end. As a special case for\n\
10766 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10767 specified. If this option is provided then any tick marks and tick\n\
10768 labels will be placed at the breaks between shaded segments. TODO:\n\
10769 This should be expanded to support custom placement of tick marks\n\
10770 and tick labels at custom value locations for any color bar type.\n\
10771\n\
10772 position (PLINT, input) : position contains bits which control the\n\
10773 overall position of the color bar and the definition of the\n\
10774 adopted coordinates used for positions just like what is done for\n\
10775 the position argument for pllegend. However, note that the\n\
10776 defaults for the position bits (see below) are different than the\n\
10777 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10778 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10779 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10780 the 16 possible standard positions (the 4 corners and centers of\n\
10781 the 4 sides for both the inside and outside cases) of the color\n\
10782 bar relative to the adopted coordinate system. The corner\n\
10783 positions are specified by the appropriate combination of two of\n\
10784 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10785 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10786 value of one of those bits. The adopted coordinates are\n\
10787 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10788 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10789 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10790 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10791 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10792 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10793 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10794 PL_POSITION_VIEWPORT.\n\
10795\n\
10796 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10797 coordinates from the specified standard position of the color bar.\n\
10798 For positive x, the direction of motion away from the standard\n\
10799 position is inward/outward from the standard corner positions or\n\
10800 standard left or right positions if the\n\
10801 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10802 For the standard top or bottom positions, the direction of motion\n\
10803 is toward positive X.\n\
10804\n\
10805 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10806 coordinates from the specified standard position of the color bar.\n\
10807 For positive y, the direction of motion away from the standard\n\
10808 position is inward/outward from the standard corner positions or\n\
10809 standard top or bottom positions if the\n\
10810 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10811 For the standard left or right positions, the direction of motion\n\
10812 is toward positive Y.\n\
10813\n\
10814 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10815 the X direction in adopted coordinates.\n\
10816\n\
10817 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10818 the Y direction in adopted coordinates.\n\
10819\n\
10820 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10821 color bar (PL_COLORBAR_BACKGROUND).\n\
10822\n\
10823 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10824 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10825\n\
10826 bb_style (PLINT, input) : The pllsty style number for the\n\
10827 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10828\n\
10829 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10830 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10831\n\
10832 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10833 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10834\n\
10835 cont_color (PLINT, input) : The cmap0 contour color for\n\
10836 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10837 it will be interpreted according to the design of plshades.\n\
10838\n\
10839 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10840 plots. This is passed directly to plshades, so it will be\n\
10841 interpreted according to the design of plshades.\n\
10842\n\
10843 n_labels (PLINT, input) : Number of labels to place around the\n\
10844 color bar.\n\
10845\n\
10846 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10847 n_labels labels.\n\
10848\n\
10849 labels (PLCHAR_MATRIX, input) : A vector of\n\
10850 n_labels UTF-8 character strings containing the labels for the color\n\
10851 bar. Ignored if no label position is specified with one of the\n\
10852 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10853 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10854 corresponding label_opts field.\n\
10855\n\
10856 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10857 value must be greater than 0. It is typically 1 (numerical axis\n\
10858 labels are provided for one of the long edges of the color bar),\n\
10859 but it can be larger if multiple numerical axis labels for the\n\
10860 long edges of the color bar are desired.\n\
10861\n\
10862 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10863 n_axes ascii character strings containing options (interpreted as for\n\
10864 plbox) for the color bar\'s axis definitions.\n\
10865\n\
10866 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10867 spacing of the major tick marks (interpreted as for plbox) for the\n\
10868 color bar\'s axis definitions.\n\
10869\n\
10870 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10871 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10872 axis definitions.\n\
10873\n\
10874 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10875 elements in each of the n_axes rows of the values matrix.\n\
10876\n\
10877 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10878 values for the data range represented by the color bar. For a row\n\
10879 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10880 elements in the row is specified by n_values[i_axis]. For\n\
10881 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10882 is 2, and the corresponding row elements of the values matrix are\n\
10883 the minimum and maximum value represented by the colorbar. For\n\
10884 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10885 of the values matrix is interpreted the same as the nlevel and\n\
10886 clevel arguments of plshades.\n\
10887";
10888static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10889Set current output stream\n\
10890\n\
10891DESCRIPTION:\n\
10892\n\
10893 Sets the number of the current output stream. The stream number\n\
10894 defaults to 0 unless changed by this routine. The first use of this\n\
10895 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10896\n\
10897 Redacted form: plsstrm(strm)\n\
10898\n\
10899 This function is examples 1,14,20.\n\
10900\n\
10901\n\
10902\n\
10903SYNOPSIS:\n\
10904\n\
10905plsstrm(strm)\n\
10906\n\
10907ARGUMENTS:\n\
10908\n\
10909 strm (PLINT, input) : The current stream number.\n\
10910";
10911static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10912Get the current device-compression setting\n\
10913\n\
10914DESCRIPTION:\n\
10915\n\
10916 Get the current device-compression setting. This parameter is only\n\
10917 used for drivers that provide compression.\n\
10918\n\
10919 Redacted form: plgcompression(compression)\n\
10920\n\
10921 This function is used in example 31.\n\
10922\n\
10923\n\
10924\n\
10925SYNOPSIS:\n\
10926\n\
10927plgcompression(compression)\n\
10928\n\
10929ARGUMENTS:\n\
10930\n\
10931 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10932 compression setting for the current device.\n\
10933";
10934static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10935Grid data from irregularly sampled data\n\
10936\n\
10937DESCRIPTION:\n\
10938\n\
10939 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10940 require data organized as a grid, i.e., with x sample point values\n\
10941 independent of y coordinate and vice versa. This function takes\n\
10942 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10943 vectors; reads the desired grid location from the input vectors\n\
10944 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10945 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10946 interpolate the data to the grid is specified with the argument type\n\
10947 which can have one parameter specified in argument data.\n\
10948\n\
10949 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10950 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10951\n\
10952\n\
10953 This function is used in example 21.\n\
10954\n\
10955\n\
10956\n\
10957SYNOPSIS:\n\
10958\n\
10959plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10960\n\
10961ARGUMENTS:\n\
10962\n\
10963 x (PLFLT_VECTOR, input) : The input x vector.\n\
10964\n\
10965 y (PLFLT_VECTOR, input) : The input y vector.\n\
10966\n\
10967 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10968 y[i], z[i] represents one data sample coordinate.\n\
10969\n\
10970 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10971 vectors.\n\
10972\n\
10973 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10974 in the x direction. Usually xg has nptsx equally spaced values\n\
10975 from the minimum to the maximum values of the x input vector.\n\
10976\n\
10977 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10978\n\
10979 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10980 in the y direction. Similar to the xg parameter.\n\
10981\n\
10982 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10983\n\
10984 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10985 where data lies in the grid specified by xg and yg. Therefore the\n\
10986 zg matrix must be dimensioned\n\
10987 nptsx by\n\
10988 nptsy.\n\
10989\n\
10990 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10991 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10992 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10993 GRID_NNI: Natural Neighbors Interpolation\n\
10994 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10995 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10996 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10997 Weighted\n\
10998 For details of the algorithms read the source file plgridd.c.\n\
10999\n\
11000 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
11001 which can be specified through this argument. Currently, for\n\
11002 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11003 use, the lower the value, the noisier (more local) the\n\
11004 approximation is.\n\
11005 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11006 range [1. .. 2.]. High values enable the usage of very thin\n\
11007 triangles for interpolation, possibly resulting in error in\n\
11008 the approximation.\n\
11009 GRID_NNI, only weights greater than data will be accepted. If\n\
11010 0, all weights will be accepted.\n\
11011";
11012
11013SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
11014 PLINT arg1 ;
11015 PLINT *arg2 = (PLINT *) 0 ;
11016 char **arg3 = (char **) 0 ;
11017 Matrix temp1 ;
11018 octave_value_list _out;
11019 octave_value_list *_outp=&_out;
11020 octave_value _outv;
11021
11022 try {
11023 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
11024 SWIG_fail;
11025 }
11026 {
11027 if ( _n_dims( args(0) ) > 1 )
11028 {
11029 error( "argument must be a scalar or vector" ); SWIG_fail;
11030 }
11031 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
11032 arg2 = new PLINT[Alen];
11033 temp1 = args(0).matrix_value();
11034 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
11035 }
11036 {
11037 charMatrix temp_matrix;
11038 Cell temp_cell;
11039 char *tmp_cstring;
11040 std::string str;
11041 size_t max_length = 0, non_blank_length;
11042 int i, ifcell;
11043 if ( _n_dims( args(1) ) > 2 )
11044 {
11045 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11046 }
11047#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11048 if ( !args(1).isempty() )
11049#else
11050 if ( !args(1).is_empty() )
11051#endif
11052 {
11053 if ( _dim( args(1), 0 ) != Alen )
11054 {
11055 error( "first dimension must be same length as previous vector" ); SWIG_fail;
11056 }
11057 arg3 = new char*[Alen];
11058#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11059 ifcell = args(1).iscell();
11060#else
11061 ifcell = args(1).is_cell();
11062#endif
11063 if ( ifcell )
11064 {
11065 temp_cell = args(1).cell_value();
11066 }
11067 else
11068 {
11069 temp_matrix = args(1).char_matrix_value();
11070 // Allow one extra space for null termination.
11071 max_length = _dim( args(1), 1 ) + 1;
11072 }
11073
11074 for ( i = 0; i < Alen; i++ )
11075 {
11076 // Must copy string to "permanent" location because the string
11077 // location corresponding to tmp_cstring gets
11078 // overwritten for each iteration of loop.
11079 if ( ifcell )
11080 {
11081 if ( temp_cell.elem( i ).is_string() )
11082 {
11083 str = temp_cell.elem( i ).string_value();
11084 // leave room for null termination.
11085 max_length = str.size() + 1;
11086 tmp_cstring = (char *) str.c_str();
11087 }
11088 else
11089 {
11090 // Use null string if user attempts to pass a cell array
11091 // with a non-string element (likely an empty element
11092 // since that should be allowed by the PLplot interface
11093 // if that element is going to be unused).
11094 // leave room for null termination.
11095 max_length = 1;
11096 tmp_cstring = (char *) "";
11097 }
11098 }
11099 else
11100 {
11101 str = temp_matrix.row_as_string( i );
11102 tmp_cstring = (char *) str.c_str();
11103 }
11104 arg3[i] = new char[max_length];
11105 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11106 arg3[i][max_length - 1] = '\0';
11107 // All the trailing blank crapola should not be needed for
11108 // string cell arrays.
11109 if ( !ifcell )
11110 {
11111 // remove trailing-blank padding that is used by the
11112 // charMatrix class to insure all strings in a given
11113 // charMatrix instance have the same length.
11114 // This transformation also removes legitimate trailing
11115 // blanks but there is nothing we can do about that
11116 // for the charMatrix class.
11117
11118 // Look for trailing nulls first (just in case, although that
11119 // shouldn't happen if charMatrix implemented as documented)
11120 // before looking for trailing blanks.
11121 non_blank_length = max_length - 2;
11122 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11123 {
11124 non_blank_length--;
11125 }
11126 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11127 {
11128 non_blank_length--;
11129 }
11130 arg3[i][non_blank_length + 1] = '\0';
11131 }
11132 }
11133 }
11134 else
11135 {
11136 arg3 = NULL;
11137 }
11138 }
11139 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11140 _outv = octave_value();
11141 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11142 {
11143 delete [] arg2;
11144 }
11145 {
11146 int i;
11147 if ( arg3 != NULL )
11148 {
11149 for ( i = 0; i < Alen; i++ )
11150 {
11151 delete[] arg3[i];
11152 }
11153 delete[] arg3;
11154 }
11155 }
11156 return _out;
11157 fail:
11158 {
11159 delete [] arg2;
11160 }
11161 {
11162 int i;
11163 if ( arg3 != NULL )
11164 {
11165 for ( i = 0; i < Alen; i++ )
11166 {
11167 delete[] arg3[i];
11168 }
11169 delete[] arg3;
11170 }
11171 }
11172 return octave_value_list();
11173 }
11174 catch(...) {
11175 {
11176 delete [] arg2;
11177 }
11178 {
11179 int i;
11180 if ( arg3 != NULL )
11181 {
11182 for ( i = 0; i < Alen; i++ )
11183 {
11184 delete[] arg3[i];
11185 }
11186 delete[] arg3;
11187 }
11188 }
11189 throw;
11190 }
11191}
11192
11193
11195 int *arg1 = (int *) 0 ;
11196 int *arg2 = (int *) 0 ;
11197 int *arg3 = (int *) 0 ;
11198 char *arg4 = (char *) 0 ;
11199 int *arg5 = (int *) 0 ;
11200 int *arg6 = (int *) 0 ;
11201 PLFLT *arg7 = (PLFLT *) 0 ;
11202 PLFLT *arg8 = (PLFLT *) 0 ;
11203 PLFLT *arg9 = (PLFLT *) 0 ;
11204 PLFLT *arg10 = (PLFLT *) 0 ;
11205 int *arg11 = (int *) 0 ;
11206 int temp1 ;
11207 int res1 = SWIG_TMPOBJ ;
11208 int temp2 ;
11209 int res2 = SWIG_TMPOBJ ;
11210 int temp3 ;
11211 int res3 = SWIG_TMPOBJ ;
11212 char local_string4[80] ;
11213 int temp5 ;
11214 int res5 = SWIG_TMPOBJ ;
11215 int temp6 ;
11216 int res6 = SWIG_TMPOBJ ;
11217 PLFLT temp7 ;
11218 int res7 = SWIG_TMPOBJ ;
11219 PLFLT temp8 ;
11220 int res8 = SWIG_TMPOBJ ;
11221 PLFLT temp9 ;
11222 int res9 = SWIG_TMPOBJ ;
11223 PLFLT temp10 ;
11224 int res10 = SWIG_TMPOBJ ;
11225 int temp11 ;
11226 int res11 = SWIG_TMPOBJ ;
11227 size_t local_string_length4 ;
11228 charMatrix local_charMatrix4 ;
11229 octave_value_list retval4 ;
11230 octave_value_list _out;
11231 octave_value_list *_outp=&_out;
11232 octave_value _outv;
11233 int result;
11234
11235 try {
11236 arg1 = &temp1;
11237 arg2 = &temp2;
11238 arg3 = &temp3;
11239 {
11240 arg4 = local_string4;
11241 }
11242 arg5 = &temp5;
11243 arg6 = &temp6;
11244 arg7 = &temp7;
11245 arg8 = &temp8;
11246 arg9 = &temp9;
11247 arg10 = &temp10;
11248 arg11 = &temp11;
11249 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11250 SWIG_fail;
11251 }
11252 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11253 _outv = SWIG_From_int(static_cast< int >(result));
11254 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11255 if (SWIG_IsTmpObj(res1)) {
11256 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11257 } else {
11258 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11260 }
11261 if (SWIG_IsTmpObj(res2)) {
11262 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11263 } else {
11264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11265 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11266 }
11267 if (SWIG_IsTmpObj(res3)) {
11268 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11269 } else {
11270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11271 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11272 }
11273 {
11274 local_string_length4 = strlen( local_string4 );
11275 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11276 local_charMatrix4.insert( local_string4, 0, 0 );
11277 retval4( 0 ) = octave_value( local_charMatrix4 );
11278 _outp = SWIG_Octave_AppendOutput(_outp, retval4( 0 ));
11279 }
11280 if (SWIG_IsTmpObj(res5)) {
11281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11282 } else {
11283 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11285 }
11286 if (SWIG_IsTmpObj(res6)) {
11287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11288 } else {
11289 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11291 }
11292 if (SWIG_IsTmpObj(res7)) {
11293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11294 } else {
11295 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11296 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11297 }
11298 if (SWIG_IsTmpObj(res8)) {
11299 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11300 } else {
11301 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11302 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11303 }
11304 if (SWIG_IsTmpObj(res9)) {
11305 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11306 } else {
11307 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11308 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11309 }
11310 if (SWIG_IsTmpObj(res10)) {
11311 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11312 } else {
11313 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11314 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11315 }
11316 if (SWIG_IsTmpObj(res11)) {
11317 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11318 } else {
11319 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11320 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11321 }
11322 return _out;
11323 fail:
11324 return octave_value_list();
11325 }
11326 catch(...) {
11327 throw;
11328 }
11329}
11330
11331
11332SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11333 PLFLT *arg1 = (PLFLT *) 0 ;
11334 PLFLT *arg2 = (PLFLT *) 0 ;
11335 PLFLT arg3 ;
11336 PLFLT arg4 ;
11337 PLFLT temp1 ;
11338 int res1 = SWIG_TMPOBJ ;
11339 PLFLT temp2 ;
11340 int res2 = SWIG_TMPOBJ ;
11341 double val3 ;
11342 int ecode3 = 0 ;
11343 double val4 ;
11344 int ecode4 = 0 ;
11345 octave_value_list _out;
11346 octave_value_list *_outp=&_out;
11347 octave_value _outv;
11348 int result;
11349
11350 try {
11351 arg1 = &temp1;
11352 arg2 = &temp2;
11353 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11354 SWIG_fail;
11355 }
11356 ecode3 = SWIG_AsVal_double(args(0), &val3);
11357 if (!SWIG_IsOK(ecode3)) {
11358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11359 }
11360 arg3 = static_cast< PLFLT >(val3);
11361 ecode4 = SWIG_AsVal_double(args(1), &val4);
11362 if (!SWIG_IsOK(ecode4)) {
11363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11364 }
11365 arg4 = static_cast< PLFLT >(val4);
11366 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11367 _outv = SWIG_From_int(static_cast< int >(result));
11368 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11369 if (SWIG_IsTmpObj(res1)) {
11370 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11371 } else {
11372 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11373 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11374 }
11375 if (SWIG_IsTmpObj(res2)) {
11376 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11377 } else {
11378 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11379 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11380 }
11381 return _out;
11382 fail:
11383 return octave_value_list();
11384 }
11385 catch(...) {
11386 throw;
11387 }
11388}
11389
11390
11392 PLINT *arg1 = (PLINT *) 0 ;
11393 char *arg2 = (char *) 0 ;
11394 char *arg3 = (char *) 0 ;
11395 PLFLT arg4 ;
11396 PLFLT arg5 ;
11397 PLFLT arg6 ;
11398 PLFLT arg7 ;
11399 PLFLT arg8 ;
11400 PLFLT arg9 ;
11401 PLFLT arg10 ;
11402 PLBOOL arg11 ;
11403 PLBOOL arg12 ;
11404 PLINT arg13 ;
11405 PLINT arg14 ;
11406 PLINT *arg15 = (PLINT *) 0 ;
11407 PLINT *arg16 = (PLINT *) 0 ;
11408 char *arg17 = (char *) 0 ;
11409 char *arg18 = (char *) 0 ;
11410 char *arg19 = (char *) 0 ;
11411 char *arg20 = (char *) 0 ;
11412 char *arg21 = (char *) 0 ;
11413 char *arg22 = (char *) 0 ;
11414 char *arg23 = (char *) 0 ;
11415 PLINT temp1 ;
11416 int res1 = SWIG_TMPOBJ ;
11417 int res2 ;
11418 char *buf2 = 0 ;
11419 int alloc2 = 0 ;
11420 int res3 ;
11421 char *buf3 = 0 ;
11422 int alloc3 = 0 ;
11423 double val4 ;
11424 int ecode4 = 0 ;
11425 double val5 ;
11426 int ecode5 = 0 ;
11427 double val6 ;
11428 int ecode6 = 0 ;
11429 double val7 ;
11430 int ecode7 = 0 ;
11431 double val8 ;
11432 int ecode8 = 0 ;
11433 double val9 ;
11434 int ecode9 = 0 ;
11435 double val10 ;
11436 int ecode10 = 0 ;
11437 int val11 ;
11438 int ecode11 = 0 ;
11439 int val12 ;
11440 int ecode12 = 0 ;
11441 int val13 ;
11442 int ecode13 = 0 ;
11443 int val14 ;
11444 int ecode14 = 0 ;
11445 Matrix temp15 ;
11446 Matrix temp16 ;
11447 int res17 ;
11448 char *buf17 = 0 ;
11449 int alloc17 = 0 ;
11450 int res18 ;
11451 char *buf18 = 0 ;
11452 int alloc18 = 0 ;
11453 int res19 ;
11454 char *buf19 = 0 ;
11455 int alloc19 = 0 ;
11456 int res20 ;
11457 char *buf20 = 0 ;
11458 int alloc20 = 0 ;
11459 int res21 ;
11460 char *buf21 = 0 ;
11461 int alloc21 = 0 ;
11462 int res22 ;
11463 char *buf22 = 0 ;
11464 int alloc22 = 0 ;
11465 int res23 ;
11466 char *buf23 = 0 ;
11467 int alloc23 = 0 ;
11468 octave_value_list _out;
11469 octave_value_list *_outp=&_out;
11470 octave_value _outv;
11471
11472 try {
11473 arg1 = &temp1;
11474 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11475 SWIG_fail;
11476 }
11477 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11478 if (!SWIG_IsOK(res2)) {
11479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11480 }
11481 arg2 = reinterpret_cast< char * >(buf2);
11482 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11483 if (!SWIG_IsOK(res3)) {
11484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11485 }
11486 arg3 = reinterpret_cast< char * >(buf3);
11487 ecode4 = SWIG_AsVal_double(args(2), &val4);
11488 if (!SWIG_IsOK(ecode4)) {
11489 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11490 }
11491 arg4 = static_cast< PLFLT >(val4);
11492 ecode5 = SWIG_AsVal_double(args(3), &val5);
11493 if (!SWIG_IsOK(ecode5)) {
11494 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11495 }
11496 arg5 = static_cast< PLFLT >(val5);
11497 ecode6 = SWIG_AsVal_double(args(4), &val6);
11498 if (!SWIG_IsOK(ecode6)) {
11499 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11500 }
11501 arg6 = static_cast< PLFLT >(val6);
11502 ecode7 = SWIG_AsVal_double(args(5), &val7);
11503 if (!SWIG_IsOK(ecode7)) {
11504 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11505 }
11506 arg7 = static_cast< PLFLT >(val7);
11507 ecode8 = SWIG_AsVal_double(args(6), &val8);
11508 if (!SWIG_IsOK(ecode8)) {
11509 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11510 }
11511 arg8 = static_cast< PLFLT >(val8);
11512 ecode9 = SWIG_AsVal_double(args(7), &val9);
11513 if (!SWIG_IsOK(ecode9)) {
11514 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11515 }
11516 arg9 = static_cast< PLFLT >(val9);
11517 ecode10 = SWIG_AsVal_double(args(8), &val10);
11518 if (!SWIG_IsOK(ecode10)) {
11519 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11520 }
11521 arg10 = static_cast< PLFLT >(val10);
11522 ecode11 = SWIG_AsVal_int(args(9), &val11);
11523 if (!SWIG_IsOK(ecode11)) {
11524 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11525 }
11526 arg11 = static_cast< PLBOOL >(val11);
11527 ecode12 = SWIG_AsVal_int(args(10), &val12);
11528 if (!SWIG_IsOK(ecode12)) {
11529 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11530 }
11531 arg12 = static_cast< PLBOOL >(val12);
11532 ecode13 = SWIG_AsVal_int(args(11), &val13);
11533 if (!SWIG_IsOK(ecode13)) {
11534 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11535 }
11536 arg13 = static_cast< PLINT >(val13);
11537 ecode14 = SWIG_AsVal_int(args(12), &val14);
11538 if (!SWIG_IsOK(ecode14)) {
11539 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11540 }
11541 arg14 = static_cast< PLINT >(val14);
11542 {
11543 if ( _n_dims( args(13) ) > 1 )
11544 {
11545 error( "argument must be a scalar or vector" ); SWIG_fail;
11546 }
11547 Alen = (PLINT) ( _dim( args(13), 0 ) );
11548 temp15 = args(13).matrix_value();
11549 arg15 = new PLINT[Alen];
11550 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11551 }
11552 {
11553 if ( _n_dims( args(14) ) > 1 )
11554 {
11555 error( "argument must be a scalar or vector" ); SWIG_fail;
11556 }
11557 if ( _dim( args(14), 0 ) != Alen )
11558 {
11559 error( "argument vectors must be same length" ); SWIG_fail;
11560 }
11561 temp16 = args(14).matrix_value();
11562 arg16 = new PLINT[Alen];
11563 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11564 }
11565 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11566 if (!SWIG_IsOK(res17)) {
11567 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11568 }
11569 arg17 = reinterpret_cast< char * >(buf17);
11570 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11571 if (!SWIG_IsOK(res18)) {
11572 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11573 }
11574 arg18 = reinterpret_cast< char * >(buf18);
11575 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11576 if (!SWIG_IsOK(res19)) {
11577 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11578 }
11579 arg19 = reinterpret_cast< char * >(buf19);
11580 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11581 if (!SWIG_IsOK(res20)) {
11582 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11583 }
11584 arg20 = reinterpret_cast< char * >(buf20);
11585 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11586 if (!SWIG_IsOK(res21)) {
11587 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11588 }
11589 arg21 = reinterpret_cast< char * >(buf21);
11590 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11591 if (!SWIG_IsOK(res22)) {
11592 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11593 }
11594 arg22 = reinterpret_cast< char * >(buf22);
11595 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11596 if (!SWIG_IsOK(res23)) {
11597 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11598 }
11599 arg23 = reinterpret_cast< char * >(buf23);
11600 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);
11601 _outv = octave_value();
11602 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11603 if (SWIG_IsTmpObj(res1)) {
11604 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11605 } else {
11606 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11607 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11608 }
11609 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11610 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11611 {
11612 delete [] arg15;
11613 }
11614 {
11615 delete [] arg16;
11616 }
11617 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11618 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11619 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11620 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11621 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11622 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11623 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11624 return _out;
11625 fail:
11626 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11627 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11628 {
11629 delete [] arg15;
11630 }
11631 {
11632 delete [] arg16;
11633 }
11634 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11635 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11636 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11637 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11638 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11639 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11640 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11641 return octave_value_list();
11642 }
11643 catch(...) {
11644 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11645 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11646 {
11647 delete [] arg15;
11648 }
11649 {
11650 delete [] arg16;
11651 }
11652 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11653 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11654 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11655 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11656 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11657 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11658 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11659 throw;
11660 }
11661}
11662
11663
11665 PLFLT *arg1 = (PLFLT *) 0 ;
11666 PLINT arg2 ;
11667 PLINT arg3 ;
11668 PLINT arg4 ;
11669 PLINT arg5 ;
11670 PLINT arg6 ;
11671 PLINT arg7 ;
11672 PLFLT *arg8 = (PLFLT *) 0 ;
11673 PLINT arg9 ;
11674 PLFLT *arg10 = (PLFLT *) 0 ;
11675 Matrix temp1 ;
11676 int val4 ;
11677 int ecode4 = 0 ;
11678 int val5 ;
11679 int ecode5 = 0 ;
11680 int val6 ;
11681 int ecode6 = 0 ;
11682 int val7 ;
11683 int ecode7 = 0 ;
11684 Matrix temp8 ;
11685 Matrix temp10 ;
11686 octave_value_list _out;
11687 octave_value_list *_outp=&_out;
11688 octave_value _outv;
11689
11690 try {
11691 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11692 SWIG_fail;
11693 }
11694 {
11695 if ( _n_dims( args(0) ) > 2 )
11696 {
11697 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11698 }
11699 temp1 = args(0).matrix_value();
11700 arg1 = &temp1( 0, 0 );
11701 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11702 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11703 }
11704 ecode4 = SWIG_AsVal_int(args(1), &val4);
11705 if (!SWIG_IsOK(ecode4)) {
11706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11707 }
11708 arg4 = static_cast< PLINT >(val4);
11709 ecode5 = SWIG_AsVal_int(args(2), &val5);
11710 if (!SWIG_IsOK(ecode5)) {
11711 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11712 }
11713 arg5 = static_cast< PLINT >(val5);
11714 ecode6 = SWIG_AsVal_int(args(3), &val6);
11715 if (!SWIG_IsOK(ecode6)) {
11716 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11717 }
11718 arg6 = static_cast< PLINT >(val6);
11719 ecode7 = SWIG_AsVal_int(args(4), &val7);
11720 if (!SWIG_IsOK(ecode7)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11722 }
11723 arg7 = static_cast< PLINT >(val7);
11724 {
11725 if ( _n_dims( args(5) ) > 1 )
11726 {
11727 error( "argument must be a scalar or vector" ); SWIG_fail;
11728 }
11729 temp8 = args(5).matrix_value();
11730 arg8 = &temp8( 0, 0 );
11731 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11732 }
11733 {
11734 if ( _n_dims( args(6) ) > 1 )
11735 {
11736 error( "argument must be a scalar or vector" ); SWIG_fail;
11737 }
11738 if ( _dim( args(6), 0 ) != 6 )
11739 {
11740 error( "argument vectors must have length of 6" ); SWIG_fail;
11741 }
11742 temp10 = args(6).matrix_value();
11743 arg10 = &temp10( 0, 0 );
11744 }
11745 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11746 _outv = octave_value();
11747 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11748 {
11749
11750 }
11751 {
11752
11753 }
11754 {
11755
11756 }
11757 return _out;
11758 fail:
11759 {
11760
11761 }
11762 {
11763
11764 }
11765 {
11766
11767 }
11768 return octave_value_list();
11769 }
11770 catch(...) {
11771 {
11772
11773 }
11774 {
11775
11776 }
11777 {
11778
11779 }
11780 throw;
11781 }
11782}
11783
11784
11785SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11786 PLFLT *arg1 = (PLFLT *) 0 ;
11787 PLINT arg2 ;
11788 PLINT arg3 ;
11789 PLINT arg4 ;
11790 PLINT arg5 ;
11791 PLINT arg6 ;
11792 PLINT arg7 ;
11793 PLFLT *arg8 = (PLFLT *) 0 ;
11794 PLINT arg9 ;
11795 Matrix temp1 ;
11796 int val4 ;
11797 int ecode4 = 0 ;
11798 int val5 ;
11799 int ecode5 = 0 ;
11800 int val6 ;
11801 int ecode6 = 0 ;
11802 int val7 ;
11803 int ecode7 = 0 ;
11804 Matrix temp8 ;
11805 octave_value_list _out;
11806 octave_value_list *_outp=&_out;
11807 octave_value _outv;
11808
11809 try {
11810 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11811 SWIG_fail;
11812 }
11813 {
11814 if ( _n_dims( args(0) ) > 2 )
11815 {
11816 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11817 }
11818 temp1 = args(0).matrix_value();
11819 arg1 = &temp1( 0, 0 );
11820 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11821 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11822 }
11823 ecode4 = SWIG_AsVal_int(args(1), &val4);
11824 if (!SWIG_IsOK(ecode4)) {
11825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11826 }
11827 arg4 = static_cast< PLINT >(val4);
11828 ecode5 = SWIG_AsVal_int(args(2), &val5);
11829 if (!SWIG_IsOK(ecode5)) {
11830 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11831 }
11832 arg5 = static_cast< PLINT >(val5);
11833 ecode6 = SWIG_AsVal_int(args(3), &val6);
11834 if (!SWIG_IsOK(ecode6)) {
11835 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11836 }
11837 arg6 = static_cast< PLINT >(val6);
11838 ecode7 = SWIG_AsVal_int(args(4), &val7);
11839 if (!SWIG_IsOK(ecode7)) {
11840 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11841 }
11842 arg7 = static_cast< PLINT >(val7);
11843 {
11844 if ( _n_dims( args(5) ) > 1 )
11845 {
11846 error( "argument must be a scalar or vector" ); SWIG_fail;
11847 }
11848 temp8 = args(5).matrix_value();
11849 arg8 = &temp8( 0, 0 );
11850 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11851 }
11852 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11853 _outv = octave_value();
11854 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11855 {
11856
11857 }
11858 {
11859
11860 }
11861 return _out;
11862 fail:
11863 {
11864
11865 }
11866 {
11867
11868 }
11869 return octave_value_list();
11870 }
11871 catch(...) {
11872 {
11873
11874 }
11875 {
11876
11877 }
11878 throw;
11879 }
11880}
11881
11882
11883SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11884 PLFLT *arg1 = (PLFLT *) 0 ;
11885 PLINT arg2 ;
11886 PLINT arg3 ;
11887 PLINT arg4 ;
11888 PLINT arg5 ;
11889 PLINT arg6 ;
11890 PLINT arg7 ;
11891 PLFLT *arg8 = (PLFLT *) 0 ;
11892 PLINT arg9 ;
11893 PLFLT *arg10 = (PLFLT *) 0 ;
11894 PLFLT *arg11 = (PLFLT *) 0 ;
11895 Matrix temp1 ;
11896 int val4 ;
11897 int ecode4 = 0 ;
11898 int val5 ;
11899 int ecode5 = 0 ;
11900 int val6 ;
11901 int ecode6 = 0 ;
11902 int val7 ;
11903 int ecode7 = 0 ;
11904 Matrix temp8 ;
11905 Matrix temp10 ;
11906 Matrix temp11 ;
11907 octave_value_list _out;
11908 octave_value_list *_outp=&_out;
11909 octave_value _outv;
11910
11911 try {
11912 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11913 SWIG_fail;
11914 }
11915 {
11916 if ( _n_dims( args(0) ) > 2 )
11917 {
11918 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11919 }
11920 temp1 = args(0).matrix_value();
11921 arg1 = &temp1( 0, 0 );
11922 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11923 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11924 }
11925 ecode4 = SWIG_AsVal_int(args(1), &val4);
11926 if (!SWIG_IsOK(ecode4)) {
11927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11928 }
11929 arg4 = static_cast< PLINT >(val4);
11930 ecode5 = SWIG_AsVal_int(args(2), &val5);
11931 if (!SWIG_IsOK(ecode5)) {
11932 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11933 }
11934 arg5 = static_cast< PLINT >(val5);
11935 ecode6 = SWIG_AsVal_int(args(3), &val6);
11936 if (!SWIG_IsOK(ecode6)) {
11937 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11938 }
11939 arg6 = static_cast< PLINT >(val6);
11940 ecode7 = SWIG_AsVal_int(args(4), &val7);
11941 if (!SWIG_IsOK(ecode7)) {
11942 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11943 }
11944 arg7 = static_cast< PLINT >(val7);
11945 {
11946 if ( _n_dims( args(5) ) > 1 )
11947 {
11948 error( "argument must be a scalar or vector" ); SWIG_fail;
11949 }
11950 temp8 = args(5).matrix_value();
11951 arg8 = &temp8( 0, 0 );
11952 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11953 }
11954 {
11955 if ( _n_dims( args(6) ) > 1 )
11956 {
11957 error( "argument must be a scalar or vector" ); SWIG_fail;
11958 }
11959 if ( _dim( args(6), 0 ) != Xlen )
11960 {
11961 error( "argument vectors must be same length" ); SWIG_fail;
11962 }
11963 temp10 = args(6).matrix_value();
11964 arg10 = &temp10( 0, 0 );
11965 }
11966 {
11967 if ( _n_dims( args(7) ) > 1 )
11968 {
11969 error( "argument must be a scalar or vector" ); SWIG_fail;
11970 }
11971 if ( _dim( args(7), 0 ) != Ylen )
11972 {
11973 error( "argument vectors must be same length" ); SWIG_fail;
11974 }
11975 temp11 = args(7).matrix_value();
11976 arg11 = &temp11( 0, 0 );
11977 }
11978 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11979 _outv = octave_value();
11980 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11981 {
11982
11983 }
11984 {
11985
11986 }
11987 {
11988
11989 }
11990 {
11991
11992 }
11993 return _out;
11994 fail:
11995 {
11996
11997 }
11998 {
11999
12000 }
12001 {
12002
12003 }
12004 {
12005
12006 }
12007 return octave_value_list();
12008 }
12009 catch(...) {
12010 {
12011
12012 }
12013 {
12014
12015 }
12016 {
12017
12018 }
12019 {
12020
12021 }
12022 throw;
12023 }
12024}
12025
12026
12027SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
12028 PLFLT *arg1 = (PLFLT *) 0 ;
12029 PLINT arg2 ;
12030 PLINT arg3 ;
12031 PLINT arg4 ;
12032 PLINT arg5 ;
12033 PLINT arg6 ;
12034 PLINT arg7 ;
12035 PLFLT *arg8 = (PLFLT *) 0 ;
12036 PLINT arg9 ;
12037 PLFLT *arg10 = (PLFLT *) 0 ;
12038 PLFLT *arg11 = (PLFLT *) 0 ;
12039 Matrix temp1 ;
12040 int val4 ;
12041 int ecode4 = 0 ;
12042 int val5 ;
12043 int ecode5 = 0 ;
12044 int val6 ;
12045 int ecode6 = 0 ;
12046 int val7 ;
12047 int ecode7 = 0 ;
12048 Matrix temp8 ;
12049 Matrix temp10 ;
12050 Matrix temp11 ;
12051 octave_value_list _out;
12052 octave_value_list *_outp=&_out;
12053 octave_value _outv;
12054
12055 try {
12056 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
12057 SWIG_fail;
12058 }
12059 {
12060 if ( _n_dims( args(0) ) > 2 )
12061 {
12062 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12063 }
12064 temp1 = args(0).matrix_value();
12065 arg1 = &temp1( 0, 0 );
12066 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12067 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12068 }
12069 ecode4 = SWIG_AsVal_int(args(1), &val4);
12070 if (!SWIG_IsOK(ecode4)) {
12071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
12072 }
12073 arg4 = static_cast< PLINT >(val4);
12074 ecode5 = SWIG_AsVal_int(args(2), &val5);
12075 if (!SWIG_IsOK(ecode5)) {
12076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
12077 }
12078 arg5 = static_cast< PLINT >(val5);
12079 ecode6 = SWIG_AsVal_int(args(3), &val6);
12080 if (!SWIG_IsOK(ecode6)) {
12081 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
12082 }
12083 arg6 = static_cast< PLINT >(val6);
12084 ecode7 = SWIG_AsVal_int(args(4), &val7);
12085 if (!SWIG_IsOK(ecode7)) {
12086 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12087 }
12088 arg7 = static_cast< PLINT >(val7);
12089 {
12090 if ( _n_dims( args(5) ) > 1 )
12091 {
12092 error( "argument must be a scalar or vector" ); SWIG_fail;
12093 }
12094 temp8 = args(5).matrix_value();
12095 arg8 = &temp8( 0, 0 );
12096 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12097 }
12098 {
12099 if ( _n_dims( args(6) ) > 2 )
12100 {
12101 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12102 }
12103 if ( _dim( args(6), 0 ) != Xlen )
12104 {
12105 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12106 }
12107 if ( _dim( args(6), 1 ) != Ylen )
12108 {
12109 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12110 }
12111 temp10 = args(6).matrix_value();
12112 arg10 = &temp10( 0, 0 );
12113 }
12114 {
12115 if ( _n_dims( args(7) ) > 2 )
12116 {
12117 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12118 }
12119 if ( _dim( args(7), 0 ) != Xlen )
12120 {
12121 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12122 }
12123 if ( _dim( args(7), 1 ) != Ylen )
12124 {
12125 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12126 }
12127 temp11 = args(7).matrix_value();
12128 arg11 = &temp11( 0, 0 );
12129 }
12130 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12131 _outv = octave_value();
12132 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12133 {
12134
12135 }
12136 {
12137
12138 }
12139 {
12140
12141 }
12142 {
12143
12144 }
12145 return _out;
12146 fail:
12147 {
12148
12149 }
12150 {
12151
12152 }
12153 {
12154
12155 }
12156 {
12157
12158 }
12159 return octave_value_list();
12160 }
12161 catch(...) {
12162 {
12163
12164 }
12165 {
12166
12167 }
12168 {
12169
12170 }
12171 {
12172
12173 }
12174 throw;
12175 }
12176}
12177
12178
12179SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12180 PLFLT *arg1 = (PLFLT *) 0 ;
12181 PLINT arg2 ;
12182 PLINT arg3 ;
12183 PLINT arg4 ;
12184 PLINT arg5 ;
12185 PLINT arg6 ;
12186 PLINT arg7 ;
12187 PLFLT *arg8 = (PLFLT *) 0 ;
12188 PLINT arg9 ;
12189 PLFLT *arg10 = (PLFLT *) 0 ;
12190 PLFLT *arg11 = (PLFLT *) 0 ;
12191 Matrix temp1 ;
12192 int val4 ;
12193 int ecode4 = 0 ;
12194 int val5 ;
12195 int ecode5 = 0 ;
12196 int val6 ;
12197 int ecode6 = 0 ;
12198 int val7 ;
12199 int ecode7 = 0 ;
12200 Matrix temp8 ;
12201 Matrix temp10 ;
12202 Matrix temp11 ;
12203 octave_value_list _out;
12204 octave_value_list *_outp=&_out;
12205 octave_value _outv;
12206
12207 try {
12208 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12209 SWIG_fail;
12210 }
12211 {
12212 if ( _n_dims( args(0) ) > 2 )
12213 {
12214 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12215 }
12216 temp1 = args(0).matrix_value();
12217 arg1 = &temp1( 0, 0 );
12218 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12219 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12220 }
12221 ecode4 = SWIG_AsVal_int(args(1), &val4);
12222 if (!SWIG_IsOK(ecode4)) {
12223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12224 }
12225 arg4 = static_cast< PLINT >(val4);
12226 ecode5 = SWIG_AsVal_int(args(2), &val5);
12227 if (!SWIG_IsOK(ecode5)) {
12228 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12229 }
12230 arg5 = static_cast< PLINT >(val5);
12231 ecode6 = SWIG_AsVal_int(args(3), &val6);
12232 if (!SWIG_IsOK(ecode6)) {
12233 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12234 }
12235 arg6 = static_cast< PLINT >(val6);
12236 ecode7 = SWIG_AsVal_int(args(4), &val7);
12237 if (!SWIG_IsOK(ecode7)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12239 }
12240 arg7 = static_cast< PLINT >(val7);
12241 {
12242 if ( _n_dims( args(5) ) > 1 )
12243 {
12244 error( "argument must be a scalar or vector" ); SWIG_fail;
12245 }
12246 temp8 = args(5).matrix_value();
12247 arg8 = &temp8( 0, 0 );
12248 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12249 }
12250 {
12251 if ( _n_dims( args(6) ) > 2 )
12252 {
12253 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12254 }
12255 if ( _dim( args(6), 0 ) != Xlen )
12256 {
12257 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12258 }
12259 if ( _dim( args(6), 1 ) != Ylen )
12260 {
12261 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12262 }
12263 temp10 = args(6).matrix_value();
12264 arg10 = &temp10( 0, 0 );
12265 }
12266 {
12267 if ( _n_dims( args(7) ) > 2 )
12268 {
12269 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12270 }
12271 if ( _dim( args(7), 0 ) != Xlen )
12272 {
12273 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12274 }
12275 if ( _dim( args(7), 1 ) != Ylen )
12276 {
12277 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12278 }
12279 temp11 = args(7).matrix_value();
12280 arg11 = &temp11( 0, 0 );
12281 }
12282 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12283 _outv = octave_value();
12284 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12285 {
12286
12287 }
12288 {
12289
12290 }
12291 {
12292
12293 }
12294 {
12295
12296 }
12297 return _out;
12298 fail:
12299 {
12300
12301 }
12302 {
12303
12304 }
12305 {
12306
12307 }
12308 {
12309
12310 }
12311 return octave_value_list();
12312 }
12313 catch(...) {
12314 {
12315
12316 }
12317 {
12318
12319 }
12320 {
12321
12322 }
12323 {
12324
12325 }
12326 throw;
12327 }
12328}
12329
12330
12331SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12332 PLFLT *arg1 = (PLFLT *) 0 ;
12333 PLFLT *arg2 = (PLFLT *) 0 ;
12334 PLFLT *arg3 = (PLFLT *) 0 ;
12335 PLINT arg4 ;
12336 PLFLT *arg5 = (PLFLT *) 0 ;
12337 PLINT arg6 ;
12338 PLFLT *arg7 = (PLFLT *) 0 ;
12339 PLINT arg8 ;
12340 PLFLT *arg9 = (PLFLT *) 0 ;
12341 PLINT arg10 ;
12342 PLFLT arg11 ;
12343 Matrix temp1 ;
12344 Matrix temp2 ;
12345 Matrix temp3 ;
12346 Matrix temp5 ;
12347 Matrix temp7 ;
12348 octave_value_list retval7 ;
12349 int val10 ;
12350 int ecode10 = 0 ;
12351 double val11 ;
12352 int ecode11 = 0 ;
12353 octave_value_list _out;
12354 octave_value_list *_outp=&_out;
12355 octave_value _outv;
12356
12357 try {
12358 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12359 SWIG_fail;
12360 }
12361 {
12362 if ( _n_dims( args(0) ) > 1 )
12363 {
12364 error( "argument must be a scalar or vector" ); SWIG_fail;
12365 }
12366 Alen = (PLINT) ( _dim( args(0), 0 ) );
12367 temp1 = args(0).matrix_value();
12368 arg1 = &temp1( 0, 0 );
12369 }
12370 {
12371 if ( _n_dims( args(1) ) > 1 )
12372 {
12373 error( "argument must be a scalar or vector" ); SWIG_fail;
12374 }
12375 if ( _dim( args(1), 0 ) != Alen )
12376 {
12377 error( "argument vectors must be same length" ); SWIG_fail;
12378 }
12379 temp2 = args(1).matrix_value();
12380 arg2 = &temp2( 0, 0 );
12381 }
12382 {
12383 if ( _n_dims( args(2) ) > 1 )
12384 {
12385 error( "argument must be a scalar or vector" ); SWIG_fail;
12386 }
12387 if ( _dim( args(2), 0 ) != Alen )
12388 {
12389 error( "argument vectors must be same length" ); SWIG_fail;
12390 }
12391 temp3 = args(2).matrix_value();
12392 arg3 = &temp3( 0, 0 );
12393 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12394 }
12395 {
12396 if ( _n_dims( args(3) ) > 1 )
12397 {
12398 error( "argument must be a scalar or vector" ); SWIG_fail;
12399 }
12400 temp5 = args(3).matrix_value();
12401 arg5 = &temp5( 0, 0 );
12402 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12403 }
12404 {
12405 if ( _n_dims( args(4) ) > 1 )
12406 {
12407 error( "argument must be a scalar or vector" ); SWIG_fail;
12408 }
12409 temp7 = args(4).matrix_value();
12410 arg7 = &temp7( 0, 0 );
12411 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12412 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12413 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12414 }
12415 ecode10 = SWIG_AsVal_int(args(5), &val10);
12416 if (!SWIG_IsOK(ecode10)) {
12417 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12418 }
12419 arg10 = static_cast< PLINT >(val10);
12420 ecode11 = SWIG_AsVal_double(args(6), &val11);
12421 if (!SWIG_IsOK(ecode11)) {
12422 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12423 }
12424 arg11 = static_cast< PLFLT >(val11);
12425 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12426 _outv = octave_value();
12427 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12428 {
12429 _outp = SWIG_Octave_AppendOutput(_outp, retval7( 0 ));
12430 }
12431 {
12432
12433 }
12434 {
12435
12436 }
12437 {
12438
12439 }
12440 {
12441
12442 }
12443 {
12444
12445 }
12446 return _out;
12447 fail:
12448 {
12449
12450 }
12451 {
12452
12453 }
12454 {
12455
12456 }
12457 {
12458
12459 }
12460 {
12461
12462 }
12463 return octave_value_list();
12464 }
12465 catch(...) {
12466 {
12467
12468 }
12469 {
12470
12471 }
12472 {
12473
12474 }
12475 {
12476
12477 }
12478 {
12479
12480 }
12481 throw;
12482 }
12483}
12484
12485
12487 PLFLT *arg1 = (PLFLT *) 0 ;
12488 PLFLT *arg2 = (PLFLT *) 0 ;
12489 PLFLT *arg3 = (PLFLT *) 0 ;
12490 PLINT arg4 ;
12491 PLINT arg5 ;
12492 PLINT arg6 ;
12493 Matrix temp1 ;
12494 Matrix temp2 ;
12495 Matrix temp3 ;
12496 int val6 ;
12497 int ecode6 = 0 ;
12498 octave_value_list _out;
12499 octave_value_list *_outp=&_out;
12500 octave_value _outv;
12501
12502 try {
12503 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12504 SWIG_fail;
12505 }
12506 {
12507 if ( _n_dims( args(0) ) > 1 )
12508 {
12509 error( "argument must be a scalar or vector" ); SWIG_fail;
12510 }
12511 temp1 = args(0).matrix_value();
12512 arg1 = &temp1( 0, 0 );
12513 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12514 }
12515 {
12516 if ( _n_dims( args(1) ) > 1 )
12517 {
12518 error( "argument must be a scalar or vector" ); SWIG_fail;
12519 }
12520 temp2 = args(1).matrix_value();
12521 arg2 = &temp2( 0, 0 );
12522 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12523 }
12524 {
12525 if ( _n_dims( args(2) ) > 2 )
12526 {
12527 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12528 }
12529 if ( _dim( args(2), 0 ) != Xlen )
12530 {
12531 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12532 }
12533 if ( _dim( args(2), 1 ) != Ylen )
12534 {
12535 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12536 }
12537 temp3 = args(2).matrix_value();
12538 arg3 = &temp3( 0, 0 );
12539 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12540 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12541 }
12542 ecode6 = SWIG_AsVal_int(args(3), &val6);
12543 if (!SWIG_IsOK(ecode6)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12545 }
12546 arg6 = static_cast< PLINT >(val6);
12547 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12548 _outv = octave_value();
12549 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12550 {
12551
12552 }
12553 {
12554
12555 }
12556 {
12557
12558 }
12559 return _out;
12560 fail:
12561 {
12562
12563 }
12564 {
12565
12566 }
12567 {
12568
12569 }
12570 return octave_value_list();
12571 }
12572 catch(...) {
12573 {
12574
12575 }
12576 {
12577
12578 }
12579 {
12580
12581 }
12582 throw;
12583 }
12584}
12585
12586
12588 PLFLT *arg1 = (PLFLT *) 0 ;
12589 PLFLT *arg2 = (PLFLT *) 0 ;
12590 PLFLT *arg3 = (PLFLT *) 0 ;
12591 PLINT arg4 ;
12592 PLINT arg5 ;
12593 PLINT arg6 ;
12594 PLFLT *arg7 = (PLFLT *) 0 ;
12595 PLINT arg8 ;
12596 Matrix temp1 ;
12597 Matrix temp2 ;
12598 Matrix temp3 ;
12599 int val6 ;
12600 int ecode6 = 0 ;
12601 Matrix temp7 ;
12602 octave_value_list _out;
12603 octave_value_list *_outp=&_out;
12604 octave_value _outv;
12605
12606 try {
12607 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12608 SWIG_fail;
12609 }
12610 {
12611 if ( _n_dims( args(0) ) > 1 )
12612 {
12613 error( "argument must be a scalar or vector" ); SWIG_fail;
12614 }
12615 temp1 = args(0).matrix_value();
12616 arg1 = &temp1( 0, 0 );
12617 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12618 }
12619 {
12620 if ( _n_dims( args(1) ) > 1 )
12621 {
12622 error( "argument must be a scalar or vector" ); SWIG_fail;
12623 }
12624 temp2 = args(1).matrix_value();
12625 arg2 = &temp2( 0, 0 );
12626 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12627 }
12628 {
12629 if ( _n_dims( args(2) ) > 2 )
12630 {
12631 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12632 }
12633 if ( _dim( args(2), 0 ) != Xlen )
12634 {
12635 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12636 }
12637 if ( _dim( args(2), 1 ) != Ylen )
12638 {
12639 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12640 }
12641 temp3 = args(2).matrix_value();
12642 arg3 = &temp3( 0, 0 );
12643 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12644 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12645 }
12646 ecode6 = SWIG_AsVal_int(args(3), &val6);
12647 if (!SWIG_IsOK(ecode6)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12649 }
12650 arg6 = static_cast< PLINT >(val6);
12651 {
12652 if ( _n_dims( args(4) ) > 1 )
12653 {
12654 error( "argument must be a scalar or vector" ); SWIG_fail;
12655 }
12656 temp7 = args(4).matrix_value();
12657 arg7 = &temp7( 0, 0 );
12658 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12659 }
12660 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12661 _outv = octave_value();
12662 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12663 {
12664
12665 }
12666 {
12667
12668 }
12669 {
12670
12671 }
12672 {
12673
12674 }
12675 return _out;
12676 fail:
12677 {
12678
12679 }
12680 {
12681
12682 }
12683 {
12684
12685 }
12686 {
12687
12688 }
12689 return octave_value_list();
12690 }
12691 catch(...) {
12692 {
12693
12694 }
12695 {
12696
12697 }
12698 {
12699
12700 }
12701 {
12702
12703 }
12704 throw;
12705 }
12706}
12707
12708
12710 PLFLT *arg1 = (PLFLT *) 0 ;
12711 PLFLT *arg2 = (PLFLT *) 0 ;
12712 PLFLT *arg3 = (PLFLT *) 0 ;
12713 PLINT arg4 ;
12714 PLINT arg5 ;
12715 PLINT arg6 ;
12716 PLBOOL arg7 ;
12717 Matrix temp1 ;
12718 Matrix temp2 ;
12719 Matrix temp3 ;
12720 int val6 ;
12721 int ecode6 = 0 ;
12722 int val7 ;
12723 int ecode7 = 0 ;
12724 octave_value_list _out;
12725 octave_value_list *_outp=&_out;
12726 octave_value _outv;
12727
12728 try {
12729 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12730 SWIG_fail;
12731 }
12732 {
12733 if ( _n_dims( args(0) ) > 1 )
12734 {
12735 error( "argument must be a scalar or vector" ); SWIG_fail;
12736 }
12737 temp1 = args(0).matrix_value();
12738 arg1 = &temp1( 0, 0 );
12739 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12740 }
12741 {
12742 if ( _n_dims( args(1) ) > 1 )
12743 {
12744 error( "argument must be a scalar or vector" ); SWIG_fail;
12745 }
12746 temp2 = args(1).matrix_value();
12747 arg2 = &temp2( 0, 0 );
12748 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12749 }
12750 {
12751 if ( _n_dims( args(2) ) > 2 )
12752 {
12753 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12754 }
12755 if ( _dim( args(2), 0 ) != Xlen )
12756 {
12757 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12758 }
12759 if ( _dim( args(2), 1 ) != Ylen )
12760 {
12761 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12762 }
12763 temp3 = args(2).matrix_value();
12764 arg3 = &temp3( 0, 0 );
12765 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12766 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12767 }
12768 ecode6 = SWIG_AsVal_int(args(3), &val6);
12769 if (!SWIG_IsOK(ecode6)) {
12770 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12771 }
12772 arg6 = static_cast< PLINT >(val6);
12773 ecode7 = SWIG_AsVal_int(args(4), &val7);
12774 if (!SWIG_IsOK(ecode7)) {
12775 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12776 }
12777 arg7 = static_cast< PLBOOL >(val7);
12778 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12779 _outv = octave_value();
12780 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12781 {
12782
12783 }
12784 {
12785
12786 }
12787 {
12788
12789 }
12790 return _out;
12791 fail:
12792 {
12793
12794 }
12795 {
12796
12797 }
12798 {
12799
12800 }
12801 return octave_value_list();
12802 }
12803 catch(...) {
12804 {
12805
12806 }
12807 {
12808
12809 }
12810 {
12811
12812 }
12813 throw;
12814 }
12815}
12816
12817
12819 PLFLT *arg1 = (PLFLT *) 0 ;
12820 PLFLT *arg2 = (PLFLT *) 0 ;
12821 PLFLT *arg3 = (PLFLT *) 0 ;
12822 PLINT arg4 ;
12823 PLINT arg5 ;
12824 PLINT arg6 ;
12825 PLFLT *arg7 = (PLFLT *) 0 ;
12826 PLINT arg8 ;
12827 Matrix temp1 ;
12828 Matrix temp2 ;
12829 Matrix temp3 ;
12830 int val6 ;
12831 int ecode6 = 0 ;
12832 Matrix temp7 ;
12833 octave_value_list _out;
12834 octave_value_list *_outp=&_out;
12835 octave_value _outv;
12836
12837 try {
12838 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12839 SWIG_fail;
12840 }
12841 {
12842 if ( _n_dims( args(0) ) > 1 )
12843 {
12844 error( "argument must be a scalar or vector" ); SWIG_fail;
12845 }
12846 temp1 = args(0).matrix_value();
12847 arg1 = &temp1( 0, 0 );
12848 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12849 }
12850 {
12851 if ( _n_dims( args(1) ) > 1 )
12852 {
12853 error( "argument must be a scalar or vector" ); SWIG_fail;
12854 }
12855 temp2 = args(1).matrix_value();
12856 arg2 = &temp2( 0, 0 );
12857 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12858 }
12859 {
12860 if ( _n_dims( args(2) ) > 2 )
12861 {
12862 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12863 }
12864 if ( _dim( args(2), 0 ) != Xlen )
12865 {
12866 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12867 }
12868 if ( _dim( args(2), 1 ) != Ylen )
12869 {
12870 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12871 }
12872 temp3 = args(2).matrix_value();
12873 arg3 = &temp3( 0, 0 );
12874 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12875 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12876 }
12877 ecode6 = SWIG_AsVal_int(args(3), &val6);
12878 if (!SWIG_IsOK(ecode6)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12880 }
12881 arg6 = static_cast< PLINT >(val6);
12882 {
12883 if ( _n_dims( args(4) ) > 1 )
12884 {
12885 error( "argument must be a scalar or vector" ); SWIG_fail;
12886 }
12887 temp7 = args(4).matrix_value();
12888 arg7 = &temp7( 0, 0 );
12889 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12890 }
12891 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12892 _outv = octave_value();
12893 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12894 {
12895
12896 }
12897 {
12898
12899 }
12900 {
12901
12902 }
12903 {
12904
12905 }
12906 return _out;
12907 fail:
12908 {
12909
12910 }
12911 {
12912
12913 }
12914 {
12915
12916 }
12917 {
12918
12919 }
12920 return octave_value_list();
12921 }
12922 catch(...) {
12923 {
12924
12925 }
12926 {
12927
12928 }
12929 {
12930
12931 }
12932 {
12933
12934 }
12935 throw;
12936 }
12937}
12938
12939
12941 PLFLT *arg1 = (PLFLT *) 0 ;
12942 PLFLT *arg2 = (PLFLT *) 0 ;
12943 PLFLT *arg3 = (PLFLT *) 0 ;
12944 PLINT arg4 ;
12945 PLINT arg5 ;
12946 PLINT arg6 ;
12947 PLFLT *arg7 = (PLFLT *) 0 ;
12948 PLINT arg8 ;
12949 PLINT arg9 ;
12950 PLINT arg10 ;
12951 PLINT *arg11 = (PLINT *) 0 ;
12952 PLINT *arg12 = (PLINT *) 0 ;
12953 Matrix temp1 ;
12954 Matrix temp2 ;
12955 Matrix temp3 ;
12956 int val6 ;
12957 int ecode6 = 0 ;
12958 Matrix temp7 ;
12959 int val9 ;
12960 int ecode9 = 0 ;
12961 Matrix temp10 ;
12962 Matrix temp12 ;
12963 octave_value_list _out;
12964 octave_value_list *_outp=&_out;
12965 octave_value _outv;
12966
12967 try {
12968 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12969 SWIG_fail;
12970 }
12971 {
12972 if ( _n_dims( args(0) ) > 1 )
12973 {
12974 error( "argument must be a scalar or vector" ); SWIG_fail;
12975 }
12976 temp1 = args(0).matrix_value();
12977 arg1 = &temp1( 0, 0 );
12978 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12979 }
12980 {
12981 if ( _n_dims( args(1) ) > 1 )
12982 {
12983 error( "argument must be a scalar or vector" ); SWIG_fail;
12984 }
12985 temp2 = args(1).matrix_value();
12986 arg2 = &temp2( 0, 0 );
12987 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12988 }
12989 {
12990 if ( _n_dims( args(2) ) > 2 )
12991 {
12992 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12993 }
12994 if ( _dim( args(2), 0 ) != Xlen )
12995 {
12996 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12997 }
12998 if ( _dim( args(2), 1 ) != Ylen )
12999 {
13000 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13001 }
13002 temp3 = args(2).matrix_value();
13003 arg3 = &temp3( 0, 0 );
13004 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13005 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13006 }
13007 ecode6 = SWIG_AsVal_int(args(3), &val6);
13008 if (!SWIG_IsOK(ecode6)) {
13009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
13010 }
13011 arg6 = static_cast< PLINT >(val6);
13012 {
13013 if ( _n_dims( args(4) ) > 1 )
13014 {
13015 error( "argument must be a scalar or vector" ); SWIG_fail;
13016 }
13017 temp7 = args(4).matrix_value();
13018 arg7 = &temp7( 0, 0 );
13019 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13020 }
13021 ecode9 = SWIG_AsVal_int(args(5), &val9);
13022 if (!SWIG_IsOK(ecode9)) {
13023 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
13024 }
13025 arg9 = static_cast< PLINT >(val9);
13026 {
13027 if ( _n_dims( args(6) ) > 1 )
13028 {
13029 error( "argument must be a scalar or vector" ); SWIG_fail;
13030 }
13031 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13032 arg11 = new PLINT[Alen];
13033 temp10 = args(6).matrix_value();
13034 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13035 }
13036 {
13037 if ( _n_dims( args(7) ) > 1 )
13038 {
13039 error( "argument must be a scalar or vector" ); SWIG_fail;
13040 }
13041 if ( _dim( args(7), 0 ) != Alen )
13042 {
13043 error( "argument vectors must be same length" ); SWIG_fail;
13044 }
13045 temp12 = args(7).matrix_value();
13046 arg12 = new PLINT[Alen];
13047 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13048 }
13049 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);
13050 _outv = octave_value();
13051 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13052 {
13053
13054 }
13055 {
13056
13057 }
13058 {
13059
13060 }
13061 {
13062
13063 }
13064 {
13065 delete [] arg11;
13066 }
13067 {
13068 delete [] arg12;
13069 }
13070 return _out;
13071 fail:
13072 {
13073
13074 }
13075 {
13076
13077 }
13078 {
13079
13080 }
13081 {
13082
13083 }
13084 {
13085 delete [] arg11;
13086 }
13087 {
13088 delete [] arg12;
13089 }
13090 return octave_value_list();
13091 }
13092 catch(...) {
13093 {
13094
13095 }
13096 {
13097
13098 }
13099 {
13100
13101 }
13102 {
13103
13104 }
13105 {
13106 delete [] arg11;
13107 }
13108 {
13109 delete [] arg12;
13110 }
13111 throw;
13112 }
13113}
13114
13115
13117 PLFLT *arg1 = (PLFLT *) 0 ;
13118 PLFLT *arg2 = (PLFLT *) 0 ;
13119 PLFLT *arg3 = (PLFLT *) 0 ;
13120 PLINT arg4 ;
13121 PLINT arg5 ;
13122 PLINT arg6 ;
13123 PLFLT *arg7 = (PLFLT *) 0 ;
13124 PLINT arg8 ;
13125 Matrix temp1 ;
13126 Matrix temp2 ;
13127 Matrix temp3 ;
13128 int val6 ;
13129 int ecode6 = 0 ;
13130 Matrix temp7 ;
13131 octave_value_list _out;
13132 octave_value_list *_outp=&_out;
13133 octave_value _outv;
13134
13135 try {
13136 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13137 SWIG_fail;
13138 }
13139 {
13140 if ( _n_dims( args(0) ) > 1 )
13141 {
13142 error( "argument must be a scalar or vector" ); SWIG_fail;
13143 }
13144 temp1 = args(0).matrix_value();
13145 arg1 = &temp1( 0, 0 );
13146 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13147 }
13148 {
13149 if ( _n_dims( args(1) ) > 1 )
13150 {
13151 error( "argument must be a scalar or vector" ); SWIG_fail;
13152 }
13153 temp2 = args(1).matrix_value();
13154 arg2 = &temp2( 0, 0 );
13155 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13156 }
13157 {
13158 if ( _n_dims( args(2) ) > 2 )
13159 {
13160 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13161 }
13162 if ( _dim( args(2), 0 ) != Xlen )
13163 {
13164 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13165 }
13166 if ( _dim( args(2), 1 ) != Ylen )
13167 {
13168 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13169 }
13170 temp3 = args(2).matrix_value();
13171 arg3 = &temp3( 0, 0 );
13172 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13173 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13174 }
13175 ecode6 = SWIG_AsVal_int(args(3), &val6);
13176 if (!SWIG_IsOK(ecode6)) {
13177 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13178 }
13179 arg6 = static_cast< PLINT >(val6);
13180 {
13181 if ( _n_dims( args(4) ) > 1 )
13182 {
13183 error( "argument must be a scalar or vector" ); SWIG_fail;
13184 }
13185 temp7 = args(4).matrix_value();
13186 arg7 = &temp7( 0, 0 );
13187 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13188 }
13189 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13190 _outv = octave_value();
13191 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13192 {
13193
13194 }
13195 {
13196
13197 }
13198 {
13199
13200 }
13201 {
13202
13203 }
13204 return _out;
13205 fail:
13206 {
13207
13208 }
13209 {
13210
13211 }
13212 {
13213
13214 }
13215 {
13216
13217 }
13218 return octave_value_list();
13219 }
13220 catch(...) {
13221 {
13222
13223 }
13224 {
13225
13226 }
13227 {
13228
13229 }
13230 {
13231
13232 }
13233 throw;
13234 }
13235}
13236
13237
13239 PLFLT *arg1 = (PLFLT *) 0 ;
13240 PLFLT *arg2 = (PLFLT *) 0 ;
13241 PLFLT *arg3 = (PLFLT *) 0 ;
13242 PLINT arg4 ;
13243 PLINT arg5 ;
13244 PLINT arg6 ;
13245 PLFLT *arg7 = (PLFLT *) 0 ;
13246 PLINT arg8 ;
13247 PLINT arg9 ;
13248 PLINT arg10 ;
13249 PLINT *arg11 = (PLINT *) 0 ;
13250 PLINT *arg12 = (PLINT *) 0 ;
13251 Matrix temp1 ;
13252 Matrix temp2 ;
13253 Matrix temp3 ;
13254 int val6 ;
13255 int ecode6 = 0 ;
13256 Matrix temp7 ;
13257 int val9 ;
13258 int ecode9 = 0 ;
13259 Matrix temp10 ;
13260 Matrix temp12 ;
13261 octave_value_list _out;
13262 octave_value_list *_outp=&_out;
13263 octave_value _outv;
13264
13265 try {
13266 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13267 SWIG_fail;
13268 }
13269 {
13270 if ( _n_dims( args(0) ) > 1 )
13271 {
13272 error( "argument must be a scalar or vector" ); SWIG_fail;
13273 }
13274 temp1 = args(0).matrix_value();
13275 arg1 = &temp1( 0, 0 );
13276 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13277 }
13278 {
13279 if ( _n_dims( args(1) ) > 1 )
13280 {
13281 error( "argument must be a scalar or vector" ); SWIG_fail;
13282 }
13283 temp2 = args(1).matrix_value();
13284 arg2 = &temp2( 0, 0 );
13285 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13286 }
13287 {
13288 if ( _n_dims( args(2) ) > 2 )
13289 {
13290 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13291 }
13292 if ( _dim( args(2), 0 ) != Xlen )
13293 {
13294 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13295 }
13296 if ( _dim( args(2), 1 ) != Ylen )
13297 {
13298 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13299 }
13300 temp3 = args(2).matrix_value();
13301 arg3 = &temp3( 0, 0 );
13302 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13303 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13304 }
13305 ecode6 = SWIG_AsVal_int(args(3), &val6);
13306 if (!SWIG_IsOK(ecode6)) {
13307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13308 }
13309 arg6 = static_cast< PLINT >(val6);
13310 {
13311 if ( _n_dims( args(4) ) > 1 )
13312 {
13313 error( "argument must be a scalar or vector" ); SWIG_fail;
13314 }
13315 temp7 = args(4).matrix_value();
13316 arg7 = &temp7( 0, 0 );
13317 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13318 }
13319 ecode9 = SWIG_AsVal_int(args(5), &val9);
13320 if (!SWIG_IsOK(ecode9)) {
13321 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13322 }
13323 arg9 = static_cast< PLINT >(val9);
13324 {
13325 if ( _n_dims( args(6) ) > 1 )
13326 {
13327 error( "argument must be a scalar or vector" ); SWIG_fail;
13328 }
13329 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13330 arg11 = new PLINT[Alen];
13331 temp10 = args(6).matrix_value();
13332 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13333 }
13334 {
13335 if ( _n_dims( args(7) ) > 1 )
13336 {
13337 error( "argument must be a scalar or vector" ); SWIG_fail;
13338 }
13339 if ( _dim( args(7), 0 ) != Alen )
13340 {
13341 error( "argument vectors must be same length" ); SWIG_fail;
13342 }
13343 temp12 = args(7).matrix_value();
13344 arg12 = new PLINT[Alen];
13345 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13346 }
13347 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);
13348 _outv = octave_value();
13349 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13350 {
13351
13352 }
13353 {
13354
13355 }
13356 {
13357
13358 }
13359 {
13360
13361 }
13362 {
13363 delete [] arg11;
13364 }
13365 {
13366 delete [] arg12;
13367 }
13368 return _out;
13369 fail:
13370 {
13371
13372 }
13373 {
13374
13375 }
13376 {
13377
13378 }
13379 {
13380
13381 }
13382 {
13383 delete [] arg11;
13384 }
13385 {
13386 delete [] arg12;
13387 }
13388 return octave_value_list();
13389 }
13390 catch(...) {
13391 {
13392
13393 }
13394 {
13395
13396 }
13397 {
13398
13399 }
13400 {
13401
13402 }
13403 {
13404 delete [] arg11;
13405 }
13406 {
13407 delete [] arg12;
13408 }
13409 throw;
13410 }
13411}
13412
13413
13415 PLFLT *arg1 = (PLFLT *) 0 ;
13416 PLINT arg2 ;
13417 PLINT arg3 ;
13418 PLFLT *arg4 = (PLFLT *) 0 ;
13419 PLFLT arg5 ;
13420 PLFLT arg6 ;
13421 PLFLT arg7 ;
13422 PLFLT arg8 ;
13423 PLFLT arg9 ;
13424 PLFLT arg10 ;
13425 PLINT arg11 ;
13426 PLFLT arg12 ;
13427 PLINT arg13 ;
13428 PLINT arg14 ;
13429 PLINT arg15 ;
13430 PLINT arg16 ;
13431 PLINT arg17 ;
13432 PLBOOL arg18 ;
13433 PLFLT *arg19 = (PLFLT *) 0 ;
13434 Matrix temp1 ;
13435 Matrix temp4 ;
13436 double val5 ;
13437 int ecode5 = 0 ;
13438 double val6 ;
13439 int ecode6 = 0 ;
13440 double val7 ;
13441 int ecode7 = 0 ;
13442 double val8 ;
13443 int ecode8 = 0 ;
13444 double val9 ;
13445 int ecode9 = 0 ;
13446 double val10 ;
13447 int ecode10 = 0 ;
13448 int val11 ;
13449 int ecode11 = 0 ;
13450 double val12 ;
13451 int ecode12 = 0 ;
13452 int val13 ;
13453 int ecode13 = 0 ;
13454 int val14 ;
13455 int ecode14 = 0 ;
13456 int val15 ;
13457 int ecode15 = 0 ;
13458 int val16 ;
13459 int ecode16 = 0 ;
13460 int val17 ;
13461 int ecode17 = 0 ;
13462 int val18 ;
13463 int ecode18 = 0 ;
13464 Matrix temp19 ;
13465 octave_value_list _out;
13466 octave_value_list *_outp=&_out;
13467 octave_value _outv;
13468
13469 try {
13470 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13471 SWIG_fail;
13472 }
13473 {
13474 if ( _n_dims( args(0) ) > 2 )
13475 {
13476 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13477 }
13478 temp1 = args(0).matrix_value();
13479 arg1 = &temp1( 0, 0 );
13480 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13481 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13482 }
13483 {
13484 if ( _n_dims( args(1) ) > 1 )
13485 {
13486 error( "argument must be a scalar or vector" ); SWIG_fail;
13487 }
13488 Alen = (PLINT) ( _dim( args(1), 0 ) );
13489 temp4 = args(1).matrix_value();
13490 arg4 = &temp4( 0, 0 );
13491 }
13492 ecode5 = SWIG_AsVal_double(args(2), &val5);
13493 if (!SWIG_IsOK(ecode5)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13495 }
13496 arg5 = static_cast< PLFLT >(val5);
13497 ecode6 = SWIG_AsVal_double(args(3), &val6);
13498 if (!SWIG_IsOK(ecode6)) {
13499 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13500 }
13501 arg6 = static_cast< PLFLT >(val6);
13502 ecode7 = SWIG_AsVal_double(args(4), &val7);
13503 if (!SWIG_IsOK(ecode7)) {
13504 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13505 }
13506 arg7 = static_cast< PLFLT >(val7);
13507 ecode8 = SWIG_AsVal_double(args(5), &val8);
13508 if (!SWIG_IsOK(ecode8)) {
13509 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13510 }
13511 arg8 = static_cast< PLFLT >(val8);
13512 ecode9 = SWIG_AsVal_double(args(6), &val9);
13513 if (!SWIG_IsOK(ecode9)) {
13514 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13515 }
13516 arg9 = static_cast< PLFLT >(val9);
13517 ecode10 = SWIG_AsVal_double(args(7), &val10);
13518 if (!SWIG_IsOK(ecode10)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13520 }
13521 arg10 = static_cast< PLFLT >(val10);
13522 ecode11 = SWIG_AsVal_int(args(8), &val11);
13523 if (!SWIG_IsOK(ecode11)) {
13524 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13525 }
13526 arg11 = static_cast< PLINT >(val11);
13527 ecode12 = SWIG_AsVal_double(args(9), &val12);
13528 if (!SWIG_IsOK(ecode12)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13530 }
13531 arg12 = static_cast< PLFLT >(val12);
13532 ecode13 = SWIG_AsVal_int(args(10), &val13);
13533 if (!SWIG_IsOK(ecode13)) {
13534 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13535 }
13536 arg13 = static_cast< PLINT >(val13);
13537 ecode14 = SWIG_AsVal_int(args(11), &val14);
13538 if (!SWIG_IsOK(ecode14)) {
13539 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13540 }
13541 arg14 = static_cast< PLINT >(val14);
13542 ecode15 = SWIG_AsVal_int(args(12), &val15);
13543 if (!SWIG_IsOK(ecode15)) {
13544 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13545 }
13546 arg15 = static_cast< PLINT >(val15);
13547 ecode16 = SWIG_AsVal_int(args(13), &val16);
13548 if (!SWIG_IsOK(ecode16)) {
13549 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13550 }
13551 arg16 = static_cast< PLINT >(val16);
13552 ecode17 = SWIG_AsVal_int(args(14), &val17);
13553 if (!SWIG_IsOK(ecode17)) {
13554 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13555 }
13556 arg17 = static_cast< PLINT >(val17);
13557 ecode18 = SWIG_AsVal_int(args(15), &val18);
13558 if (!SWIG_IsOK(ecode18)) {
13559 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13560 }
13561 arg18 = static_cast< PLBOOL >(val18);
13562 {
13563 if ( _n_dims( args(16) ) > 1 )
13564 {
13565 error( "argument must be a scalar or vector" ); SWIG_fail;
13566 }
13567 if ( _dim( args(16), 0 ) != 6 )
13568 {
13569 error( "argument vectors must have length of 6" ); SWIG_fail;
13570 }
13571 temp19 = args(16).matrix_value();
13572 arg19 = &temp19( 0, 0 );
13573 }
13574 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);
13575 _outv = octave_value();
13576 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13577 {
13578
13579 }
13580 {
13581
13582 }
13583 {
13584
13585 }
13586 return _out;
13587 fail:
13588 {
13589
13590 }
13591 {
13592
13593 }
13594 {
13595
13596 }
13597 return octave_value_list();
13598 }
13599 catch(...) {
13600 {
13601
13602 }
13603 {
13604
13605 }
13606 {
13607
13608 }
13609 throw;
13610 }
13611}
13612
13613
13614SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13615 PLFLT *arg1 = (PLFLT *) 0 ;
13616 PLINT arg2 ;
13617 PLINT arg3 ;
13618 char *arg4 = (char *) 0 ;
13619 PLFLT arg5 ;
13620 PLFLT arg6 ;
13621 PLFLT arg7 ;
13622 PLFLT arg8 ;
13623 PLFLT arg9 ;
13624 PLFLT arg10 ;
13625 PLINT arg11 ;
13626 PLFLT arg12 ;
13627 PLINT arg13 ;
13628 PLINT arg14 ;
13629 PLINT arg15 ;
13630 PLINT arg16 ;
13631 PLINT arg17 ;
13632 PLBOOL arg18 ;
13633 PLFLT *arg19 = (PLFLT *) 0 ;
13634 PLFLT *arg20 = (PLFLT *) 0 ;
13635 Matrix temp1 ;
13636 int res4 ;
13637 char *buf4 = 0 ;
13638 int alloc4 = 0 ;
13639 double val5 ;
13640 int ecode5 = 0 ;
13641 double val6 ;
13642 int ecode6 = 0 ;
13643 double val7 ;
13644 int ecode7 = 0 ;
13645 double val8 ;
13646 int ecode8 = 0 ;
13647 double val9 ;
13648 int ecode9 = 0 ;
13649 double val10 ;
13650 int ecode10 = 0 ;
13651 int val11 ;
13652 int ecode11 = 0 ;
13653 double val12 ;
13654 int ecode12 = 0 ;
13655 int val13 ;
13656 int ecode13 = 0 ;
13657 int val14 ;
13658 int ecode14 = 0 ;
13659 int val15 ;
13660 int ecode15 = 0 ;
13661 int val16 ;
13662 int ecode16 = 0 ;
13663 int val17 ;
13664 int ecode17 = 0 ;
13665 int val18 ;
13666 int ecode18 = 0 ;
13667 Matrix temp19 ;
13668 Matrix temp20 ;
13669 octave_value_list _out;
13670 octave_value_list *_outp=&_out;
13671 octave_value _outv;
13672
13673 try {
13674 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13675 SWIG_fail;
13676 }
13677 {
13678 if ( _n_dims( args(0) ) > 2 )
13679 {
13680 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13681 }
13682 temp1 = args(0).matrix_value();
13683 arg1 = &temp1( 0, 0 );
13684 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13685 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13686 }
13687 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13688 if (!SWIG_IsOK(res4)) {
13689 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13690 }
13691 arg4 = reinterpret_cast< char * >(buf4);
13692 ecode5 = SWIG_AsVal_double(args(2), &val5);
13693 if (!SWIG_IsOK(ecode5)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13695 }
13696 arg5 = static_cast< PLFLT >(val5);
13697 ecode6 = SWIG_AsVal_double(args(3), &val6);
13698 if (!SWIG_IsOK(ecode6)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13700 }
13701 arg6 = static_cast< PLFLT >(val6);
13702 ecode7 = SWIG_AsVal_double(args(4), &val7);
13703 if (!SWIG_IsOK(ecode7)) {
13704 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13705 }
13706 arg7 = static_cast< PLFLT >(val7);
13707 ecode8 = SWIG_AsVal_double(args(5), &val8);
13708 if (!SWIG_IsOK(ecode8)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13710 }
13711 arg8 = static_cast< PLFLT >(val8);
13712 ecode9 = SWIG_AsVal_double(args(6), &val9);
13713 if (!SWIG_IsOK(ecode9)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13715 }
13716 arg9 = static_cast< PLFLT >(val9);
13717 ecode10 = SWIG_AsVal_double(args(7), &val10);
13718 if (!SWIG_IsOK(ecode10)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13720 }
13721 arg10 = static_cast< PLFLT >(val10);
13722 ecode11 = SWIG_AsVal_int(args(8), &val11);
13723 if (!SWIG_IsOK(ecode11)) {
13724 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13725 }
13726 arg11 = static_cast< PLINT >(val11);
13727 ecode12 = SWIG_AsVal_double(args(9), &val12);
13728 if (!SWIG_IsOK(ecode12)) {
13729 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13730 }
13731 arg12 = static_cast< PLFLT >(val12);
13732 ecode13 = SWIG_AsVal_int(args(10), &val13);
13733 if (!SWIG_IsOK(ecode13)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13735 }
13736 arg13 = static_cast< PLINT >(val13);
13737 ecode14 = SWIG_AsVal_int(args(11), &val14);
13738 if (!SWIG_IsOK(ecode14)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13740 }
13741 arg14 = static_cast< PLINT >(val14);
13742 ecode15 = SWIG_AsVal_int(args(12), &val15);
13743 if (!SWIG_IsOK(ecode15)) {
13744 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13745 }
13746 arg15 = static_cast< PLINT >(val15);
13747 ecode16 = SWIG_AsVal_int(args(13), &val16);
13748 if (!SWIG_IsOK(ecode16)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13750 }
13751 arg16 = static_cast< PLINT >(val16);
13752 ecode17 = SWIG_AsVal_int(args(14), &val17);
13753 if (!SWIG_IsOK(ecode17)) {
13754 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13755 }
13756 arg17 = static_cast< PLINT >(val17);
13757 ecode18 = SWIG_AsVal_int(args(15), &val18);
13758 if (!SWIG_IsOK(ecode18)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13760 }
13761 arg18 = static_cast< PLBOOL >(val18);
13762 {
13763 if ( _n_dims( args(16) ) > 1 )
13764 {
13765 error( "argument must be a scalar or vector" ); SWIG_fail;
13766 }
13767 if ( _dim( args(16), 0 ) != Xlen )
13768 {
13769 error( "argument vectors must be same length" ); SWIG_fail;
13770 }
13771 temp19 = args(16).matrix_value();
13772 arg19 = &temp19( 0, 0 );
13773 }
13774 {
13775 if ( _n_dims( args(17) ) > 1 )
13776 {
13777 error( "argument must be a scalar or vector" ); SWIG_fail;
13778 }
13779 if ( _dim( args(17), 0 ) != Ylen )
13780 {
13781 error( "argument vectors must be same length" ); SWIG_fail;
13782 }
13783 temp20 = args(17).matrix_value();
13784 arg20 = &temp20( 0, 0 );
13785 }
13786 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);
13787 _outv = octave_value();
13788 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13789 {
13790
13791 }
13792 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13793 {
13794
13795 }
13796 {
13797
13798 }
13799 return _out;
13800 fail:
13801 {
13802
13803 }
13804 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13805 {
13806
13807 }
13808 {
13809
13810 }
13811 return octave_value_list();
13812 }
13813 catch(...) {
13814 {
13815
13816 }
13817 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13818 {
13819
13820 }
13821 {
13822
13823 }
13824 throw;
13825 }
13826}
13827
13828
13829SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13830 PLFLT *arg1 = (PLFLT *) 0 ;
13831 PLINT arg2 ;
13832 PLINT arg3 ;
13833 char *arg4 = (char *) 0 ;
13834 PLFLT arg5 ;
13835 PLFLT arg6 ;
13836 PLFLT arg7 ;
13837 PLFLT arg8 ;
13838 PLFLT arg9 ;
13839 PLFLT arg10 ;
13840 PLINT arg11 ;
13841 PLFLT arg12 ;
13842 PLINT arg13 ;
13843 PLINT arg14 ;
13844 PLINT arg15 ;
13845 PLINT arg16 ;
13846 PLINT arg17 ;
13847 PLBOOL arg18 ;
13848 PLFLT *arg19 = (PLFLT *) 0 ;
13849 PLFLT *arg20 = (PLFLT *) 0 ;
13850 Matrix temp1 ;
13851 int res4 ;
13852 char *buf4 = 0 ;
13853 int alloc4 = 0 ;
13854 double val5 ;
13855 int ecode5 = 0 ;
13856 double val6 ;
13857 int ecode6 = 0 ;
13858 double val7 ;
13859 int ecode7 = 0 ;
13860 double val8 ;
13861 int ecode8 = 0 ;
13862 double val9 ;
13863 int ecode9 = 0 ;
13864 double val10 ;
13865 int ecode10 = 0 ;
13866 int val11 ;
13867 int ecode11 = 0 ;
13868 double val12 ;
13869 int ecode12 = 0 ;
13870 int val13 ;
13871 int ecode13 = 0 ;
13872 int val14 ;
13873 int ecode14 = 0 ;
13874 int val15 ;
13875 int ecode15 = 0 ;
13876 int val16 ;
13877 int ecode16 = 0 ;
13878 int val17 ;
13879 int ecode17 = 0 ;
13880 int val18 ;
13881 int ecode18 = 0 ;
13882 Matrix temp19 ;
13883 Matrix temp20 ;
13884 octave_value_list _out;
13885 octave_value_list *_outp=&_out;
13886 octave_value _outv;
13887
13888 try {
13889 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13890 SWIG_fail;
13891 }
13892 {
13893 if ( _n_dims( args(0) ) > 2 )
13894 {
13895 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13896 }
13897 temp1 = args(0).matrix_value();
13898 arg1 = &temp1( 0, 0 );
13899 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13900 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13901 }
13902 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13903 if (!SWIG_IsOK(res4)) {
13904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13905 }
13906 arg4 = reinterpret_cast< char * >(buf4);
13907 ecode5 = SWIG_AsVal_double(args(2), &val5);
13908 if (!SWIG_IsOK(ecode5)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13910 }
13911 arg5 = static_cast< PLFLT >(val5);
13912 ecode6 = SWIG_AsVal_double(args(3), &val6);
13913 if (!SWIG_IsOK(ecode6)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13915 }
13916 arg6 = static_cast< PLFLT >(val6);
13917 ecode7 = SWIG_AsVal_double(args(4), &val7);
13918 if (!SWIG_IsOK(ecode7)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13920 }
13921 arg7 = static_cast< PLFLT >(val7);
13922 ecode8 = SWIG_AsVal_double(args(5), &val8);
13923 if (!SWIG_IsOK(ecode8)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13925 }
13926 arg8 = static_cast< PLFLT >(val8);
13927 ecode9 = SWIG_AsVal_double(args(6), &val9);
13928 if (!SWIG_IsOK(ecode9)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13930 }
13931 arg9 = static_cast< PLFLT >(val9);
13932 ecode10 = SWIG_AsVal_double(args(7), &val10);
13933 if (!SWIG_IsOK(ecode10)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13935 }
13936 arg10 = static_cast< PLFLT >(val10);
13937 ecode11 = SWIG_AsVal_int(args(8), &val11);
13938 if (!SWIG_IsOK(ecode11)) {
13939 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13940 }
13941 arg11 = static_cast< PLINT >(val11);
13942 ecode12 = SWIG_AsVal_double(args(9), &val12);
13943 if (!SWIG_IsOK(ecode12)) {
13944 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13945 }
13946 arg12 = static_cast< PLFLT >(val12);
13947 ecode13 = SWIG_AsVal_int(args(10), &val13);
13948 if (!SWIG_IsOK(ecode13)) {
13949 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13950 }
13951 arg13 = static_cast< PLINT >(val13);
13952 ecode14 = SWIG_AsVal_int(args(11), &val14);
13953 if (!SWIG_IsOK(ecode14)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13955 }
13956 arg14 = static_cast< PLINT >(val14);
13957 ecode15 = SWIG_AsVal_int(args(12), &val15);
13958 if (!SWIG_IsOK(ecode15)) {
13959 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13960 }
13961 arg15 = static_cast< PLINT >(val15);
13962 ecode16 = SWIG_AsVal_int(args(13), &val16);
13963 if (!SWIG_IsOK(ecode16)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13965 }
13966 arg16 = static_cast< PLINT >(val16);
13967 ecode17 = SWIG_AsVal_int(args(14), &val17);
13968 if (!SWIG_IsOK(ecode17)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13970 }
13971 arg17 = static_cast< PLINT >(val17);
13972 ecode18 = SWIG_AsVal_int(args(15), &val18);
13973 if (!SWIG_IsOK(ecode18)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13975 }
13976 arg18 = static_cast< PLBOOL >(val18);
13977 {
13978 if ( _n_dims( args(16) ) > 2 )
13979 {
13980 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13981 }
13982 temp19 = args(16).matrix_value();
13983 arg19 = &temp19( 0, 0 );
13984 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13985 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13986 }
13987 {
13988 if ( _n_dims( args(17) ) > 2 )
13989 {
13990 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13991 }
13992 temp20 = args(17).matrix_value();
13993 arg20 = &temp20( 0, 0 );
13994 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13995 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13996 }
13997 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);
13998 _outv = octave_value();
13999 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14000 {
14001
14002 }
14003 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14004 {
14005
14006 }
14007 {
14008
14009 }
14010 return _out;
14011 fail:
14012 {
14013
14014 }
14015 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14016 {
14017
14018 }
14019 {
14020
14021 }
14022 return octave_value_list();
14023 }
14024 catch(...) {
14025 {
14026
14027 }
14028 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14029 {
14030
14031 }
14032 {
14033
14034 }
14035 throw;
14036 }
14037}
14038
14039
14041 PLFLT *arg1 = (PLFLT *) 0 ;
14042 PLINT arg2 ;
14043 PLINT arg3 ;
14044 PLFLT arg4 ;
14045 PLFLT arg5 ;
14046 PLFLT arg6 ;
14047 PLFLT arg7 ;
14048 PLFLT *arg8 = (PLFLT *) 0 ;
14049 PLINT arg9 ;
14050 PLINT arg10 ;
14051 PLINT arg11 ;
14052 PLINT arg12 ;
14053 PLBOOL arg13 ;
14054 Matrix temp1 ;
14055 double val4 ;
14056 int ecode4 = 0 ;
14057 double val5 ;
14058 int ecode5 = 0 ;
14059 double val6 ;
14060 int ecode6 = 0 ;
14061 double val7 ;
14062 int ecode7 = 0 ;
14063 Matrix temp8 ;
14064 int val10 ;
14065 int ecode10 = 0 ;
14066 int val11 ;
14067 int ecode11 = 0 ;
14068 int val12 ;
14069 int ecode12 = 0 ;
14070 int val13 ;
14071 int ecode13 = 0 ;
14072 octave_value_list _out;
14073 octave_value_list *_outp=&_out;
14074 octave_value _outv;
14075
14076 try {
14077 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
14078 SWIG_fail;
14079 }
14080 {
14081 if ( _n_dims( args(0) ) > 2 )
14082 {
14083 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14084 }
14085 temp1 = args(0).matrix_value();
14086 arg1 = &temp1( 0, 0 );
14087 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14088 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14089 }
14090 ecode4 = SWIG_AsVal_double(args(1), &val4);
14091 if (!SWIG_IsOK(ecode4)) {
14092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14093 }
14094 arg4 = static_cast< PLFLT >(val4);
14095 ecode5 = SWIG_AsVal_double(args(2), &val5);
14096 if (!SWIG_IsOK(ecode5)) {
14097 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14098 }
14099 arg5 = static_cast< PLFLT >(val5);
14100 ecode6 = SWIG_AsVal_double(args(3), &val6);
14101 if (!SWIG_IsOK(ecode6)) {
14102 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14103 }
14104 arg6 = static_cast< PLFLT >(val6);
14105 ecode7 = SWIG_AsVal_double(args(4), &val7);
14106 if (!SWIG_IsOK(ecode7)) {
14107 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14108 }
14109 arg7 = static_cast< PLFLT >(val7);
14110 {
14111 if ( _n_dims( args(5) ) > 1 )
14112 {
14113 error( "argument must be a scalar or vector" ); SWIG_fail;
14114 }
14115 temp8 = args(5).matrix_value();
14116 arg8 = &temp8( 0, 0 );
14117 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14118 }
14119 ecode10 = SWIG_AsVal_int(args(6), &val10);
14120 if (!SWIG_IsOK(ecode10)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14122 }
14123 arg10 = static_cast< PLINT >(val10);
14124 ecode11 = SWIG_AsVal_int(args(7), &val11);
14125 if (!SWIG_IsOK(ecode11)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14127 }
14128 arg11 = static_cast< PLINT >(val11);
14129 ecode12 = SWIG_AsVal_int(args(8), &val12);
14130 if (!SWIG_IsOK(ecode12)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14132 }
14133 arg12 = static_cast< PLINT >(val12);
14134 ecode13 = SWIG_AsVal_int(args(9), &val13);
14135 if (!SWIG_IsOK(ecode13)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14137 }
14138 arg13 = static_cast< PLBOOL >(val13);
14139 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14140 _outv = octave_value();
14141 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14142 {
14143
14144 }
14145 {
14146
14147 }
14148 return _out;
14149 fail:
14150 {
14151
14152 }
14153 {
14154
14155 }
14156 return octave_value_list();
14157 }
14158 catch(...) {
14159 {
14160
14161 }
14162 {
14163
14164 }
14165 throw;
14166 }
14167}
14168
14169
14170SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14171 PLFLT *arg1 = (PLFLT *) 0 ;
14172 PLINT arg2 ;
14173 PLINT arg3 ;
14174 PLFLT arg4 ;
14175 PLFLT arg5 ;
14176 PLFLT arg6 ;
14177 PLFLT arg7 ;
14178 PLFLT *arg8 = (PLFLT *) 0 ;
14179 PLINT arg9 ;
14180 PLINT arg10 ;
14181 PLINT arg11 ;
14182 PLINT arg12 ;
14183 PLBOOL arg13 ;
14184 PLFLT *arg14 = (PLFLT *) 0 ;
14185 Matrix temp1 ;
14186 double val4 ;
14187 int ecode4 = 0 ;
14188 double val5 ;
14189 int ecode5 = 0 ;
14190 double val6 ;
14191 int ecode6 = 0 ;
14192 double val7 ;
14193 int ecode7 = 0 ;
14194 Matrix temp8 ;
14195 int val10 ;
14196 int ecode10 = 0 ;
14197 int val11 ;
14198 int ecode11 = 0 ;
14199 int val12 ;
14200 int ecode12 = 0 ;
14201 int val13 ;
14202 int ecode13 = 0 ;
14203 Matrix temp14 ;
14204 octave_value_list _out;
14205 octave_value_list *_outp=&_out;
14206 octave_value _outv;
14207
14208 try {
14209 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14210 SWIG_fail;
14211 }
14212 {
14213 if ( _n_dims( args(0) ) > 2 )
14214 {
14215 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14216 }
14217 temp1 = args(0).matrix_value();
14218 arg1 = &temp1( 0, 0 );
14219 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14220 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14221 }
14222 ecode4 = SWIG_AsVal_double(args(1), &val4);
14223 if (!SWIG_IsOK(ecode4)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14225 }
14226 arg4 = static_cast< PLFLT >(val4);
14227 ecode5 = SWIG_AsVal_double(args(2), &val5);
14228 if (!SWIG_IsOK(ecode5)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14230 }
14231 arg5 = static_cast< PLFLT >(val5);
14232 ecode6 = SWIG_AsVal_double(args(3), &val6);
14233 if (!SWIG_IsOK(ecode6)) {
14234 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14235 }
14236 arg6 = static_cast< PLFLT >(val6);
14237 ecode7 = SWIG_AsVal_double(args(4), &val7);
14238 if (!SWIG_IsOK(ecode7)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14240 }
14241 arg7 = static_cast< PLFLT >(val7);
14242 {
14243 if ( _n_dims( args(5) ) > 1 )
14244 {
14245 error( "argument must be a scalar or vector" ); SWIG_fail;
14246 }
14247 temp8 = args(5).matrix_value();
14248 arg8 = &temp8( 0, 0 );
14249 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14250 }
14251 ecode10 = SWIG_AsVal_int(args(6), &val10);
14252 if (!SWIG_IsOK(ecode10)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14254 }
14255 arg10 = static_cast< PLINT >(val10);
14256 ecode11 = SWIG_AsVal_int(args(7), &val11);
14257 if (!SWIG_IsOK(ecode11)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14259 }
14260 arg11 = static_cast< PLINT >(val11);
14261 ecode12 = SWIG_AsVal_int(args(8), &val12);
14262 if (!SWIG_IsOK(ecode12)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14264 }
14265 arg12 = static_cast< PLINT >(val12);
14266 ecode13 = SWIG_AsVal_int(args(9), &val13);
14267 if (!SWIG_IsOK(ecode13)) {
14268 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14269 }
14270 arg13 = static_cast< PLBOOL >(val13);
14271 {
14272 if ( _n_dims( args(10) ) > 1 )
14273 {
14274 error( "argument must be a scalar or vector" ); SWIG_fail;
14275 }
14276 if ( _dim( args(10), 0 ) != 6 )
14277 {
14278 error( "argument vectors must have length of 6" ); SWIG_fail;
14279 }
14280 temp14 = args(10).matrix_value();
14281 arg14 = &temp14( 0, 0 );
14282 }
14283 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14284 _outv = octave_value();
14285 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14286 {
14287
14288 }
14289 {
14290
14291 }
14292 {
14293
14294 }
14295 return _out;
14296 fail:
14297 {
14298
14299 }
14300 {
14301
14302 }
14303 {
14304
14305 }
14306 return octave_value_list();
14307 }
14308 catch(...) {
14309 {
14310
14311 }
14312 {
14313
14314 }
14315 {
14316
14317 }
14318 throw;
14319 }
14320}
14321
14322
14323SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14324 PLFLT *arg1 = (PLFLT *) 0 ;
14325 PLINT arg2 ;
14326 PLINT arg3 ;
14327 PLFLT arg4 ;
14328 PLFLT arg5 ;
14329 PLFLT arg6 ;
14330 PLFLT arg7 ;
14331 PLFLT *arg8 = (PLFLT *) 0 ;
14332 PLINT arg9 ;
14333 PLINT arg10 ;
14334 PLINT arg11 ;
14335 PLINT arg12 ;
14336 PLBOOL arg13 ;
14337 PLFLT *arg14 = (PLFLT *) 0 ;
14338 PLFLT *arg15 = (PLFLT *) 0 ;
14339 Matrix temp1 ;
14340 double val4 ;
14341 int ecode4 = 0 ;
14342 double val5 ;
14343 int ecode5 = 0 ;
14344 double val6 ;
14345 int ecode6 = 0 ;
14346 double val7 ;
14347 int ecode7 = 0 ;
14348 Matrix temp8 ;
14349 int val10 ;
14350 int ecode10 = 0 ;
14351 int val11 ;
14352 int ecode11 = 0 ;
14353 int val12 ;
14354 int ecode12 = 0 ;
14355 int val13 ;
14356 int ecode13 = 0 ;
14357 Matrix temp14 ;
14358 Matrix temp15 ;
14359 octave_value_list _out;
14360 octave_value_list *_outp=&_out;
14361 octave_value _outv;
14362
14363 try {
14364 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14365 SWIG_fail;
14366 }
14367 {
14368 if ( _n_dims( args(0) ) > 2 )
14369 {
14370 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14371 }
14372 temp1 = args(0).matrix_value();
14373 arg1 = &temp1( 0, 0 );
14374 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14375 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14376 }
14377 ecode4 = SWIG_AsVal_double(args(1), &val4);
14378 if (!SWIG_IsOK(ecode4)) {
14379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14380 }
14381 arg4 = static_cast< PLFLT >(val4);
14382 ecode5 = SWIG_AsVal_double(args(2), &val5);
14383 if (!SWIG_IsOK(ecode5)) {
14384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14385 }
14386 arg5 = static_cast< PLFLT >(val5);
14387 ecode6 = SWIG_AsVal_double(args(3), &val6);
14388 if (!SWIG_IsOK(ecode6)) {
14389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14390 }
14391 arg6 = static_cast< PLFLT >(val6);
14392 ecode7 = SWIG_AsVal_double(args(4), &val7);
14393 if (!SWIG_IsOK(ecode7)) {
14394 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14395 }
14396 arg7 = static_cast< PLFLT >(val7);
14397 {
14398 if ( _n_dims( args(5) ) > 1 )
14399 {
14400 error( "argument must be a scalar or vector" ); SWIG_fail;
14401 }
14402 temp8 = args(5).matrix_value();
14403 arg8 = &temp8( 0, 0 );
14404 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14405 }
14406 ecode10 = SWIG_AsVal_int(args(6), &val10);
14407 if (!SWIG_IsOK(ecode10)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14409 }
14410 arg10 = static_cast< PLINT >(val10);
14411 ecode11 = SWIG_AsVal_int(args(7), &val11);
14412 if (!SWIG_IsOK(ecode11)) {
14413 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14414 }
14415 arg11 = static_cast< PLINT >(val11);
14416 ecode12 = SWIG_AsVal_int(args(8), &val12);
14417 if (!SWIG_IsOK(ecode12)) {
14418 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14419 }
14420 arg12 = static_cast< PLINT >(val12);
14421 ecode13 = SWIG_AsVal_int(args(9), &val13);
14422 if (!SWIG_IsOK(ecode13)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14424 }
14425 arg13 = static_cast< PLBOOL >(val13);
14426 {
14427 if ( _n_dims( args(10) ) > 1 )
14428 {
14429 error( "argument must be a scalar or vector" ); SWIG_fail;
14430 }
14431 if ( _dim( args(10), 0 ) != Xlen )
14432 {
14433 error( "argument vectors must be same length" ); SWIG_fail;
14434 }
14435 temp14 = args(10).matrix_value();
14436 arg14 = &temp14( 0, 0 );
14437 }
14438 {
14439 if ( _n_dims( args(11) ) > 1 )
14440 {
14441 error( "argument must be a scalar or vector" ); SWIG_fail;
14442 }
14443 if ( _dim( args(11), 0 ) != Ylen )
14444 {
14445 error( "argument vectors must be same length" ); SWIG_fail;
14446 }
14447 temp15 = args(11).matrix_value();
14448 arg15 = &temp15( 0, 0 );
14449 }
14450 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);
14451 _outv = octave_value();
14452 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14453 {
14454
14455 }
14456 {
14457
14458 }
14459 {
14460
14461 }
14462 {
14463
14464 }
14465 return _out;
14466 fail:
14467 {
14468
14469 }
14470 {
14471
14472 }
14473 {
14474
14475 }
14476 {
14477
14478 }
14479 return octave_value_list();
14480 }
14481 catch(...) {
14482 {
14483
14484 }
14485 {
14486
14487 }
14488 {
14489
14490 }
14491 {
14492
14493 }
14494 throw;
14495 }
14496}
14497
14498
14499SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14500 PLFLT *arg1 = (PLFLT *) 0 ;
14501 PLINT arg2 ;
14502 PLINT arg3 ;
14503 PLFLT arg4 ;
14504 PLFLT arg5 ;
14505 PLFLT arg6 ;
14506 PLFLT arg7 ;
14507 PLFLT *arg8 = (PLFLT *) 0 ;
14508 PLINT arg9 ;
14509 PLINT arg10 ;
14510 PLINT arg11 ;
14511 PLINT arg12 ;
14512 PLBOOL arg13 ;
14513 PLFLT *arg14 = (PLFLT *) 0 ;
14514 PLFLT *arg15 = (PLFLT *) 0 ;
14515 Matrix temp1 ;
14516 double val4 ;
14517 int ecode4 = 0 ;
14518 double val5 ;
14519 int ecode5 = 0 ;
14520 double val6 ;
14521 int ecode6 = 0 ;
14522 double val7 ;
14523 int ecode7 = 0 ;
14524 Matrix temp8 ;
14525 int val10 ;
14526 int ecode10 = 0 ;
14527 int val11 ;
14528 int ecode11 = 0 ;
14529 int val12 ;
14530 int ecode12 = 0 ;
14531 int val13 ;
14532 int ecode13 = 0 ;
14533 Matrix temp14 ;
14534 Matrix temp15 ;
14535 octave_value_list _out;
14536 octave_value_list *_outp=&_out;
14537 octave_value _outv;
14538
14539 try {
14540 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14541 SWIG_fail;
14542 }
14543 {
14544 if ( _n_dims( args(0) ) > 2 )
14545 {
14546 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14547 }
14548 temp1 = args(0).matrix_value();
14549 arg1 = &temp1( 0, 0 );
14550 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14551 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14552 }
14553 ecode4 = SWIG_AsVal_double(args(1), &val4);
14554 if (!SWIG_IsOK(ecode4)) {
14555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14556 }
14557 arg4 = static_cast< PLFLT >(val4);
14558 ecode5 = SWIG_AsVal_double(args(2), &val5);
14559 if (!SWIG_IsOK(ecode5)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14561 }
14562 arg5 = static_cast< PLFLT >(val5);
14563 ecode6 = SWIG_AsVal_double(args(3), &val6);
14564 if (!SWIG_IsOK(ecode6)) {
14565 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14566 }
14567 arg6 = static_cast< PLFLT >(val6);
14568 ecode7 = SWIG_AsVal_double(args(4), &val7);
14569 if (!SWIG_IsOK(ecode7)) {
14570 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14571 }
14572 arg7 = static_cast< PLFLT >(val7);
14573 {
14574 if ( _n_dims( args(5) ) > 1 )
14575 {
14576 error( "argument must be a scalar or vector" ); SWIG_fail;
14577 }
14578 temp8 = args(5).matrix_value();
14579 arg8 = &temp8( 0, 0 );
14580 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14581 }
14582 ecode10 = SWIG_AsVal_int(args(6), &val10);
14583 if (!SWIG_IsOK(ecode10)) {
14584 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14585 }
14586 arg10 = static_cast< PLINT >(val10);
14587 ecode11 = SWIG_AsVal_int(args(7), &val11);
14588 if (!SWIG_IsOK(ecode11)) {
14589 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14590 }
14591 arg11 = static_cast< PLINT >(val11);
14592 ecode12 = SWIG_AsVal_int(args(8), &val12);
14593 if (!SWIG_IsOK(ecode12)) {
14594 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14595 }
14596 arg12 = static_cast< PLINT >(val12);
14597 ecode13 = SWIG_AsVal_int(args(9), &val13);
14598 if (!SWIG_IsOK(ecode13)) {
14599 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14600 }
14601 arg13 = static_cast< PLBOOL >(val13);
14602 {
14603 if ( _n_dims( args(10) ) > 2 )
14604 {
14605 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14606 }
14607 temp14 = args(10).matrix_value();
14608 arg14 = &temp14( 0, 0 );
14609 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14610 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14611 }
14612 {
14613 if ( _n_dims( args(11) ) > 2 )
14614 {
14615 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14616 }
14617 temp15 = args(11).matrix_value();
14618 arg15 = &temp15( 0, 0 );
14619 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14620 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14621 }
14622 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);
14623 _outv = octave_value();
14624 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14625 {
14626
14627 }
14628 {
14629
14630 }
14631 {
14632
14633 }
14634 {
14635
14636 }
14637 return _out;
14638 fail:
14639 {
14640
14641 }
14642 {
14643
14644 }
14645 {
14646
14647 }
14648 {
14649
14650 }
14651 return octave_value_list();
14652 }
14653 catch(...) {
14654 {
14655
14656 }
14657 {
14658
14659 }
14660 {
14661
14662 }
14663 {
14664
14665 }
14666 throw;
14667 }
14668}
14669
14670
14672 PLFLT *arg1 = (PLFLT *) 0 ;
14673 PLFLT *arg2 = (PLFLT *) 0 ;
14674 PLINT arg3 ;
14675 PLINT arg4 ;
14676 PLFLT arg5 ;
14677 PLFLT *arg6 = (PLFLT *) 0 ;
14678 Matrix temp1 ;
14679 Matrix temp2 ;
14680 double val5 ;
14681 int ecode5 = 0 ;
14682 Matrix temp6 ;
14683 octave_value_list _out;
14684 octave_value_list *_outp=&_out;
14685 octave_value _outv;
14686
14687 try {
14688 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14689 SWIG_fail;
14690 }
14691 {
14692 if ( _n_dims( args(0) ) > 2 )
14693 {
14694 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14695 }
14696 temp1 = args(0).matrix_value();
14697 arg1 = &temp1( 0, 0 );
14698 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14699 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14700 }
14701 {
14702 if ( _n_dims( args(1) ) > 2 )
14703 {
14704 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14705 }
14706 if ( _dim( args(1), 0 ) != Xlen )
14707 {
14708 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14709 }
14710 if ( _dim( args(1), 1 ) != Ylen )
14711 {
14712 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14713 }
14714 temp2 = args(1).matrix_value();
14715 arg2 = &temp2( 0, 0 );
14716 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14717 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14718 }
14719 ecode5 = SWIG_AsVal_double(args(2), &val5);
14720 if (!SWIG_IsOK(ecode5)) {
14721 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14722 }
14723 arg5 = static_cast< PLFLT >(val5);
14724 {
14725 if ( _n_dims( args(3) ) > 1 )
14726 {
14727 error( "argument must be a scalar or vector" ); SWIG_fail;
14728 }
14729 if ( _dim( args(3), 0 ) != 6 )
14730 {
14731 error( "argument vectors must have length of 6" ); SWIG_fail;
14732 }
14733 temp6 = args(3).matrix_value();
14734 arg6 = &temp6( 0, 0 );
14735 }
14736 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14737 _outv = octave_value();
14738 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14739 {
14740
14741 }
14742 {
14743
14744 }
14745 {
14746
14747 }
14748 return _out;
14749 fail:
14750 {
14751
14752 }
14753 {
14754
14755 }
14756 {
14757
14758 }
14759 return octave_value_list();
14760 }
14761 catch(...) {
14762 {
14763
14764 }
14765 {
14766
14767 }
14768 {
14769
14770 }
14771 throw;
14772 }
14773}
14774
14775
14776SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14777 PLFLT *arg1 = (PLFLT *) 0 ;
14778 PLFLT *arg2 = (PLFLT *) 0 ;
14779 PLINT arg3 ;
14780 PLINT arg4 ;
14781 PLFLT arg5 ;
14782 PLFLT *arg6 = (PLFLT *) 0 ;
14783 PLFLT *arg7 = (PLFLT *) 0 ;
14784 Matrix temp1 ;
14785 Matrix temp2 ;
14786 double val5 ;
14787 int ecode5 = 0 ;
14788 Matrix temp6 ;
14789 Matrix temp7 ;
14790 octave_value_list _out;
14791 octave_value_list *_outp=&_out;
14792 octave_value _outv;
14793
14794 try {
14795 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14796 SWIG_fail;
14797 }
14798 {
14799 if ( _n_dims( args(0) ) > 2 )
14800 {
14801 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14802 }
14803 temp1 = args(0).matrix_value();
14804 arg1 = &temp1( 0, 0 );
14805 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14806 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14807 }
14808 {
14809 if ( _n_dims( args(1) ) > 2 )
14810 {
14811 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14812 }
14813 if ( _dim( args(1), 0 ) != Xlen )
14814 {
14815 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14816 }
14817 if ( _dim( args(1), 1 ) != Ylen )
14818 {
14819 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14820 }
14821 temp2 = args(1).matrix_value();
14822 arg2 = &temp2( 0, 0 );
14823 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14824 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14825 }
14826 ecode5 = SWIG_AsVal_double(args(2), &val5);
14827 if (!SWIG_IsOK(ecode5)) {
14828 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14829 }
14830 arg5 = static_cast< PLFLT >(val5);
14831 {
14832 if ( _n_dims( args(3) ) > 1 )
14833 {
14834 error( "argument must be a scalar or vector" ); SWIG_fail;
14835 }
14836 if ( _dim( args(3), 0 ) != Xlen )
14837 {
14838 error( "argument vectors must be same length" ); SWIG_fail;
14839 }
14840 temp6 = args(3).matrix_value();
14841 arg6 = &temp6( 0, 0 );
14842 }
14843 {
14844 if ( _n_dims( args(4) ) > 1 )
14845 {
14846 error( "argument must be a scalar or vector" ); SWIG_fail;
14847 }
14848 if ( _dim( args(4), 0 ) != Ylen )
14849 {
14850 error( "argument vectors must be same length" ); SWIG_fail;
14851 }
14852 temp7 = args(4).matrix_value();
14853 arg7 = &temp7( 0, 0 );
14854 }
14855 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14856 _outv = octave_value();
14857 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14858 {
14859
14860 }
14861 {
14862
14863 }
14864 {
14865
14866 }
14867 {
14868
14869 }
14870 return _out;
14871 fail:
14872 {
14873
14874 }
14875 {
14876
14877 }
14878 {
14879
14880 }
14881 {
14882
14883 }
14884 return octave_value_list();
14885 }
14886 catch(...) {
14887 {
14888
14889 }
14890 {
14891
14892 }
14893 {
14894
14895 }
14896 {
14897
14898 }
14899 throw;
14900 }
14901}
14902
14903
14904SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14905 PLFLT *arg1 = (PLFLT *) 0 ;
14906 PLFLT *arg2 = (PLFLT *) 0 ;
14907 PLINT arg3 ;
14908 PLINT arg4 ;
14909 PLFLT arg5 ;
14910 PLFLT *arg6 = (PLFLT *) 0 ;
14911 PLFLT *arg7 = (PLFLT *) 0 ;
14912 Matrix temp1 ;
14913 Matrix temp2 ;
14914 double val5 ;
14915 int ecode5 = 0 ;
14916 Matrix temp6 ;
14917 Matrix temp7 ;
14918 octave_value_list _out;
14919 octave_value_list *_outp=&_out;
14920 octave_value _outv;
14921
14922 try {
14923 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14924 SWIG_fail;
14925 }
14926 {
14927 if ( _n_dims( args(0) ) > 2 )
14928 {
14929 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14930 }
14931 temp1 = args(0).matrix_value();
14932 arg1 = &temp1( 0, 0 );
14933 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14934 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14935 }
14936 {
14937 if ( _n_dims( args(1) ) > 2 )
14938 {
14939 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14940 }
14941 if ( _dim( args(1), 0 ) != Xlen )
14942 {
14943 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14944 }
14945 if ( _dim( args(1), 1 ) != Ylen )
14946 {
14947 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14948 }
14949 temp2 = args(1).matrix_value();
14950 arg2 = &temp2( 0, 0 );
14951 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14952 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14953 }
14954 ecode5 = SWIG_AsVal_double(args(2), &val5);
14955 if (!SWIG_IsOK(ecode5)) {
14956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14957 }
14958 arg5 = static_cast< PLFLT >(val5);
14959 {
14960 if ( _n_dims( args(3) ) > 2 )
14961 {
14962 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14963 }
14964 temp6 = args(3).matrix_value();
14965 arg6 = &temp6( 0, 0 );
14966 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14967 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14968 }
14969 {
14970 if ( _n_dims( args(4) ) > 2 )
14971 {
14972 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14973 }
14974 temp7 = args(4).matrix_value();
14975 arg7 = &temp7( 0, 0 );
14976 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14977 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14978 }
14979 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14980 _outv = octave_value();
14981 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14982 {
14983
14984 }
14985 {
14986
14987 }
14988 {
14989
14990 }
14991 {
14992
14993 }
14994 return _out;
14995 fail:
14996 {
14997
14998 }
14999 {
15000
15001 }
15002 {
15003
15004 }
15005 {
15006
15007 }
15008 return octave_value_list();
15009 }
15010 catch(...) {
15011 {
15012
15013 }
15014 {
15015
15016 }
15017 {
15018
15019 }
15020 {
15021
15022 }
15023 throw;
15024 }
15025}
15026
15027
15028SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
15029 PLFLT *arg1 = (PLFLT *) 0 ;
15030 PLINT arg2 ;
15031 PLINT arg3 ;
15032 PLFLT arg4 ;
15033 PLFLT arg5 ;
15034 PLFLT arg6 ;
15035 PLFLT arg7 ;
15036 PLFLT arg8 ;
15037 PLFLT arg9 ;
15038 PLFLT arg10 ;
15039 PLFLT arg11 ;
15040 PLFLT arg12 ;
15041 PLFLT arg13 ;
15042 Matrix temp1 ;
15043 double val4 ;
15044 int ecode4 = 0 ;
15045 double val5 ;
15046 int ecode5 = 0 ;
15047 double val6 ;
15048 int ecode6 = 0 ;
15049 double val7 ;
15050 int ecode7 = 0 ;
15051 double val8 ;
15052 int ecode8 = 0 ;
15053 double val9 ;
15054 int ecode9 = 0 ;
15055 double val10 ;
15056 int ecode10 = 0 ;
15057 double val11 ;
15058 int ecode11 = 0 ;
15059 double val12 ;
15060 int ecode12 = 0 ;
15061 double val13 ;
15062 int ecode13 = 0 ;
15063 octave_value_list _out;
15064 octave_value_list *_outp=&_out;
15065 octave_value _outv;
15066
15067 try {
15068 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
15069 SWIG_fail;
15070 }
15071 {
15072 if ( _n_dims( args(0) ) > 2 )
15073 {
15074 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15075 }
15076 temp1 = args(0).matrix_value();
15077 arg1 = &temp1( 0, 0 );
15078 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15079 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15080 }
15081 ecode4 = SWIG_AsVal_double(args(1), &val4);
15082 if (!SWIG_IsOK(ecode4)) {
15083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15084 }
15085 arg4 = static_cast< PLFLT >(val4);
15086 ecode5 = SWIG_AsVal_double(args(2), &val5);
15087 if (!SWIG_IsOK(ecode5)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15089 }
15090 arg5 = static_cast< PLFLT >(val5);
15091 ecode6 = SWIG_AsVal_double(args(3), &val6);
15092 if (!SWIG_IsOK(ecode6)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15094 }
15095 arg6 = static_cast< PLFLT >(val6);
15096 ecode7 = SWIG_AsVal_double(args(4), &val7);
15097 if (!SWIG_IsOK(ecode7)) {
15098 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15099 }
15100 arg7 = static_cast< PLFLT >(val7);
15101 ecode8 = SWIG_AsVal_double(args(5), &val8);
15102 if (!SWIG_IsOK(ecode8)) {
15103 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15104 }
15105 arg8 = static_cast< PLFLT >(val8);
15106 ecode9 = SWIG_AsVal_double(args(6), &val9);
15107 if (!SWIG_IsOK(ecode9)) {
15108 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15109 }
15110 arg9 = static_cast< PLFLT >(val9);
15111 ecode10 = SWIG_AsVal_double(args(7), &val10);
15112 if (!SWIG_IsOK(ecode10)) {
15113 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15114 }
15115 arg10 = static_cast< PLFLT >(val10);
15116 ecode11 = SWIG_AsVal_double(args(8), &val11);
15117 if (!SWIG_IsOK(ecode11)) {
15118 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15119 }
15120 arg11 = static_cast< PLFLT >(val11);
15121 ecode12 = SWIG_AsVal_double(args(9), &val12);
15122 if (!SWIG_IsOK(ecode12)) {
15123 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15124 }
15125 arg12 = static_cast< PLFLT >(val12);
15126 ecode13 = SWIG_AsVal_double(args(10), &val13);
15127 if (!SWIG_IsOK(ecode13)) {
15128 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15129 }
15130 arg13 = static_cast< PLFLT >(val13);
15131 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15132 _outv = octave_value();
15133 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15134 {
15135
15136 }
15137 return _out;
15138 fail:
15139 {
15140
15141 }
15142 return octave_value_list();
15143 }
15144 catch(...) {
15145 {
15146
15147 }
15148 throw;
15149 }
15150}
15151
15152
15154 PLFLT *arg1 = (PLFLT *) 0 ;
15155 PLINT arg2 ;
15156 PLINT arg3 ;
15157 PLFLT arg4 ;
15158 PLFLT arg5 ;
15159 PLFLT arg6 ;
15160 PLFLT arg7 ;
15161 PLFLT arg8 ;
15162 PLFLT arg9 ;
15163 PLFLT arg10 ;
15164 PLFLT arg11 ;
15165 Matrix temp1 ;
15166 double val4 ;
15167 int ecode4 = 0 ;
15168 double val5 ;
15169 int ecode5 = 0 ;
15170 double val6 ;
15171 int ecode6 = 0 ;
15172 double val7 ;
15173 int ecode7 = 0 ;
15174 double val8 ;
15175 int ecode8 = 0 ;
15176 double val9 ;
15177 int ecode9 = 0 ;
15178 double val10 ;
15179 int ecode10 = 0 ;
15180 double val11 ;
15181 int ecode11 = 0 ;
15182 octave_value_list _out;
15183 octave_value_list *_outp=&_out;
15184 octave_value _outv;
15185
15186 try {
15187 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15188 SWIG_fail;
15189 }
15190 {
15191 if ( _n_dims( args(0) ) > 2 )
15192 {
15193 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15194 }
15195 temp1 = args(0).matrix_value();
15196 arg1 = &temp1( 0, 0 );
15197 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15198 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15199 }
15200 ecode4 = SWIG_AsVal_double(args(1), &val4);
15201 if (!SWIG_IsOK(ecode4)) {
15202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15203 }
15204 arg4 = static_cast< PLFLT >(val4);
15205 ecode5 = SWIG_AsVal_double(args(2), &val5);
15206 if (!SWIG_IsOK(ecode5)) {
15207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15208 }
15209 arg5 = static_cast< PLFLT >(val5);
15210 ecode6 = SWIG_AsVal_double(args(3), &val6);
15211 if (!SWIG_IsOK(ecode6)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15213 }
15214 arg6 = static_cast< PLFLT >(val6);
15215 ecode7 = SWIG_AsVal_double(args(4), &val7);
15216 if (!SWIG_IsOK(ecode7)) {
15217 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15218 }
15219 arg7 = static_cast< PLFLT >(val7);
15220 ecode8 = SWIG_AsVal_double(args(5), &val8);
15221 if (!SWIG_IsOK(ecode8)) {
15222 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15223 }
15224 arg8 = static_cast< PLFLT >(val8);
15225 ecode9 = SWIG_AsVal_double(args(6), &val9);
15226 if (!SWIG_IsOK(ecode9)) {
15227 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15228 }
15229 arg9 = static_cast< PLFLT >(val9);
15230 ecode10 = SWIG_AsVal_double(args(7), &val10);
15231 if (!SWIG_IsOK(ecode10)) {
15232 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15233 }
15234 arg10 = static_cast< PLFLT >(val10);
15235 ecode11 = SWIG_AsVal_double(args(8), &val11);
15236 if (!SWIG_IsOK(ecode11)) {
15237 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15238 }
15239 arg11 = static_cast< PLFLT >(val11);
15240 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15241 _outv = octave_value();
15242 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15243 {
15244
15245 }
15246 return _out;
15247 fail:
15248 {
15249
15250 }
15251 return octave_value_list();
15252 }
15253 catch(...) {
15254 {
15255
15256 }
15257 throw;
15258 }
15259}
15260
15261
15262SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15263 PLFLT *arg1 = (PLFLT *) 0 ;
15264 PLINT arg2 ;
15265 PLINT arg3 ;
15266 PLFLT arg4 ;
15267 PLFLT arg5 ;
15268 PLFLT arg6 ;
15269 PLFLT arg7 ;
15270 PLFLT arg8 ;
15271 PLFLT arg9 ;
15272 PLFLT arg10 ;
15273 PLFLT arg11 ;
15274 PLFLT *arg12 = (PLFLT *) 0 ;
15275 Matrix temp1 ;
15276 double val4 ;
15277 int ecode4 = 0 ;
15278 double val5 ;
15279 int ecode5 = 0 ;
15280 double val6 ;
15281 int ecode6 = 0 ;
15282 double val7 ;
15283 int ecode7 = 0 ;
15284 double val8 ;
15285 int ecode8 = 0 ;
15286 double val9 ;
15287 int ecode9 = 0 ;
15288 double val10 ;
15289 int ecode10 = 0 ;
15290 double val11 ;
15291 int ecode11 = 0 ;
15292 Matrix temp12 ;
15293 octave_value_list _out;
15294 octave_value_list *_outp=&_out;
15295 octave_value _outv;
15296
15297 try {
15298 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15299 SWIG_fail;
15300 }
15301 {
15302 if ( _n_dims( args(0) ) > 2 )
15303 {
15304 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15305 }
15306 temp1 = args(0).matrix_value();
15307 arg1 = &temp1( 0, 0 );
15308 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15309 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15310 }
15311 ecode4 = SWIG_AsVal_double(args(1), &val4);
15312 if (!SWIG_IsOK(ecode4)) {
15313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15314 }
15315 arg4 = static_cast< PLFLT >(val4);
15316 ecode5 = SWIG_AsVal_double(args(2), &val5);
15317 if (!SWIG_IsOK(ecode5)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15319 }
15320 arg5 = static_cast< PLFLT >(val5);
15321 ecode6 = SWIG_AsVal_double(args(3), &val6);
15322 if (!SWIG_IsOK(ecode6)) {
15323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15324 }
15325 arg6 = static_cast< PLFLT >(val6);
15326 ecode7 = SWIG_AsVal_double(args(4), &val7);
15327 if (!SWIG_IsOK(ecode7)) {
15328 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15329 }
15330 arg7 = static_cast< PLFLT >(val7);
15331 ecode8 = SWIG_AsVal_double(args(5), &val8);
15332 if (!SWIG_IsOK(ecode8)) {
15333 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15334 }
15335 arg8 = static_cast< PLFLT >(val8);
15336 ecode9 = SWIG_AsVal_double(args(6), &val9);
15337 if (!SWIG_IsOK(ecode9)) {
15338 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15339 }
15340 arg9 = static_cast< PLFLT >(val9);
15341 ecode10 = SWIG_AsVal_double(args(7), &val10);
15342 if (!SWIG_IsOK(ecode10)) {
15343 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15344 }
15345 arg10 = static_cast< PLFLT >(val10);
15346 ecode11 = SWIG_AsVal_double(args(8), &val11);
15347 if (!SWIG_IsOK(ecode11)) {
15348 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15349 }
15350 arg11 = static_cast< PLFLT >(val11);
15351 {
15352 if ( _n_dims( args(9) ) > 1 )
15353 {
15354 error( "argument must be a scalar or vector" ); SWIG_fail;
15355 }
15356 if ( _dim( args(9), 0 ) != 6 )
15357 {
15358 error( "argument vectors must have length of 6" ); SWIG_fail;
15359 }
15360 temp12 = args(9).matrix_value();
15361 arg12 = &temp12( 0, 0 );
15362 }
15363 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15364 _outv = octave_value();
15365 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15366 {
15367
15368 }
15369 {
15370
15371 }
15372 return _out;
15373 fail:
15374 {
15375
15376 }
15377 {
15378
15379 }
15380 return octave_value_list();
15381 }
15382 catch(...) {
15383 {
15384
15385 }
15386 {
15387
15388 }
15389 throw;
15390 }
15391}
15392
15393
15394SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15395 PLFLT *arg1 = (PLFLT *) 0 ;
15396 PLINT arg2 ;
15397 PLINT arg3 ;
15398 PLFLT arg4 ;
15399 PLFLT arg5 ;
15400 PLFLT arg6 ;
15401 PLFLT arg7 ;
15402 PLFLT arg8 ;
15403 PLFLT arg9 ;
15404 PLFLT arg10 ;
15405 PLFLT arg11 ;
15406 PLFLT *arg12 = (PLFLT *) 0 ;
15407 PLFLT *arg13 = (PLFLT *) 0 ;
15408 Matrix temp1 ;
15409 double val4 ;
15410 int ecode4 = 0 ;
15411 double val5 ;
15412 int ecode5 = 0 ;
15413 double val6 ;
15414 int ecode6 = 0 ;
15415 double val7 ;
15416 int ecode7 = 0 ;
15417 double val8 ;
15418 int ecode8 = 0 ;
15419 double val9 ;
15420 int ecode9 = 0 ;
15421 double val10 ;
15422 int ecode10 = 0 ;
15423 double val11 ;
15424 int ecode11 = 0 ;
15425 Matrix temp12 ;
15426 Matrix temp13 ;
15427 octave_value_list _out;
15428 octave_value_list *_outp=&_out;
15429 octave_value _outv;
15430
15431 try {
15432 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15433 SWIG_fail;
15434 }
15435 {
15436 if ( _n_dims( args(0) ) > 2 )
15437 {
15438 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15439 }
15440 temp1 = args(0).matrix_value();
15441 arg1 = &temp1( 0, 0 );
15442 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15443 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15444 }
15445 ecode4 = SWIG_AsVal_double(args(1), &val4);
15446 if (!SWIG_IsOK(ecode4)) {
15447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15448 }
15449 arg4 = static_cast< PLFLT >(val4);
15450 ecode5 = SWIG_AsVal_double(args(2), &val5);
15451 if (!SWIG_IsOK(ecode5)) {
15452 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15453 }
15454 arg5 = static_cast< PLFLT >(val5);
15455 ecode6 = SWIG_AsVal_double(args(3), &val6);
15456 if (!SWIG_IsOK(ecode6)) {
15457 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15458 }
15459 arg6 = static_cast< PLFLT >(val6);
15460 ecode7 = SWIG_AsVal_double(args(4), &val7);
15461 if (!SWIG_IsOK(ecode7)) {
15462 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15463 }
15464 arg7 = static_cast< PLFLT >(val7);
15465 ecode8 = SWIG_AsVal_double(args(5), &val8);
15466 if (!SWIG_IsOK(ecode8)) {
15467 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15468 }
15469 arg8 = static_cast< PLFLT >(val8);
15470 ecode9 = SWIG_AsVal_double(args(6), &val9);
15471 if (!SWIG_IsOK(ecode9)) {
15472 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15473 }
15474 arg9 = static_cast< PLFLT >(val9);
15475 ecode10 = SWIG_AsVal_double(args(7), &val10);
15476 if (!SWIG_IsOK(ecode10)) {
15477 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15478 }
15479 arg10 = static_cast< PLFLT >(val10);
15480 ecode11 = SWIG_AsVal_double(args(8), &val11);
15481 if (!SWIG_IsOK(ecode11)) {
15482 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15483 }
15484 arg11 = static_cast< PLFLT >(val11);
15485 {
15486 if ( _n_dims( args(9) ) > 1 )
15487 {
15488 error( "argument must be a scalar or vector" ); SWIG_fail;
15489 }
15490 if ( _dim( args(9), 0 ) != Xlen )
15491 {
15492 error( "argument vectors must be same length" ); SWIG_fail;
15493 }
15494 temp12 = args(9).matrix_value();
15495 arg12 = &temp12( 0, 0 );
15496 }
15497 {
15498 if ( _n_dims( args(10) ) > 1 )
15499 {
15500 error( "argument must be a scalar or vector" ); SWIG_fail;
15501 }
15502 if ( _dim( args(10), 0 ) != Ylen )
15503 {
15504 error( "argument vectors must be same length" ); SWIG_fail;
15505 }
15506 temp13 = args(10).matrix_value();
15507 arg13 = &temp13( 0, 0 );
15508 }
15509 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15510 _outv = octave_value();
15511 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15512 {
15513
15514 }
15515 {
15516
15517 }
15518 {
15519
15520 }
15521 return _out;
15522 fail:
15523 {
15524
15525 }
15526 {
15527
15528 }
15529 {
15530
15531 }
15532 return octave_value_list();
15533 }
15534 catch(...) {
15535 {
15536
15537 }
15538 {
15539
15540 }
15541 {
15542
15543 }
15544 throw;
15545 }
15546}
15547
15548
15549SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15550 PLFLT *arg1 = (PLFLT *) 0 ;
15551 PLINT arg2 ;
15552 PLINT arg3 ;
15553 PLFLT arg4 ;
15554 PLFLT arg5 ;
15555 PLFLT arg6 ;
15556 PLFLT arg7 ;
15557 PLFLT arg8 ;
15558 PLFLT arg9 ;
15559 PLFLT arg10 ;
15560 PLFLT arg11 ;
15561 PLFLT *arg12 = (PLFLT *) 0 ;
15562 PLFLT *arg13 = (PLFLT *) 0 ;
15563 Matrix temp1 ;
15564 double val4 ;
15565 int ecode4 = 0 ;
15566 double val5 ;
15567 int ecode5 = 0 ;
15568 double val6 ;
15569 int ecode6 = 0 ;
15570 double val7 ;
15571 int ecode7 = 0 ;
15572 double val8 ;
15573 int ecode8 = 0 ;
15574 double val9 ;
15575 int ecode9 = 0 ;
15576 double val10 ;
15577 int ecode10 = 0 ;
15578 double val11 ;
15579 int ecode11 = 0 ;
15580 Matrix temp12 ;
15581 Matrix temp13 ;
15582 octave_value_list _out;
15583 octave_value_list *_outp=&_out;
15584 octave_value _outv;
15585
15586 try {
15587 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15588 SWIG_fail;
15589 }
15590 {
15591 if ( _n_dims( args(0) ) > 2 )
15592 {
15593 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15594 }
15595 temp1 = args(0).matrix_value();
15596 arg1 = &temp1( 0, 0 );
15597 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15598 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15599 }
15600 ecode4 = SWIG_AsVal_double(args(1), &val4);
15601 if (!SWIG_IsOK(ecode4)) {
15602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15603 }
15604 arg4 = static_cast< PLFLT >(val4);
15605 ecode5 = SWIG_AsVal_double(args(2), &val5);
15606 if (!SWIG_IsOK(ecode5)) {
15607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15608 }
15609 arg5 = static_cast< PLFLT >(val5);
15610 ecode6 = SWIG_AsVal_double(args(3), &val6);
15611 if (!SWIG_IsOK(ecode6)) {
15612 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15613 }
15614 arg6 = static_cast< PLFLT >(val6);
15615 ecode7 = SWIG_AsVal_double(args(4), &val7);
15616 if (!SWIG_IsOK(ecode7)) {
15617 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15618 }
15619 arg7 = static_cast< PLFLT >(val7);
15620 ecode8 = SWIG_AsVal_double(args(5), &val8);
15621 if (!SWIG_IsOK(ecode8)) {
15622 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15623 }
15624 arg8 = static_cast< PLFLT >(val8);
15625 ecode9 = SWIG_AsVal_double(args(6), &val9);
15626 if (!SWIG_IsOK(ecode9)) {
15627 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15628 }
15629 arg9 = static_cast< PLFLT >(val9);
15630 ecode10 = SWIG_AsVal_double(args(7), &val10);
15631 if (!SWIG_IsOK(ecode10)) {
15632 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15633 }
15634 arg10 = static_cast< PLFLT >(val10);
15635 ecode11 = SWIG_AsVal_double(args(8), &val11);
15636 if (!SWIG_IsOK(ecode11)) {
15637 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15638 }
15639 arg11 = static_cast< PLFLT >(val11);
15640 {
15641 if ( _n_dims( args(9) ) > 2 )
15642 {
15643 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15644 }
15645 temp12 = args(9).matrix_value();
15646 arg12 = &temp12( 0, 0 );
15647 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15648 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15649 }
15650 {
15651 if ( _n_dims( args(10) ) > 2 )
15652 {
15653 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15654 }
15655 temp13 = args(10).matrix_value();
15656 arg13 = &temp13( 0, 0 );
15657 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15658 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15659 }
15660 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15661 _outv = octave_value();
15662 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15663 {
15664
15665 }
15666 {
15667
15668 }
15669 {
15670
15671 }
15672 return _out;
15673 fail:
15674 {
15675
15676 }
15677 {
15678
15679 }
15680 {
15681
15682 }
15683 return octave_value_list();
15684 }
15685 catch(...) {
15686 {
15687
15688 }
15689 {
15690
15691 }
15692 {
15693
15694 }
15695 throw;
15696 }
15697}
15698
15699
15700SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15701 PLFLT *arg1 = (PLFLT *) 0 ;
15702 PLFLT *arg2 = (PLFLT *) 0 ;
15703 PLINT arg3 ;
15704 PLINT arg4 ;
15705 PLFLT arg5 ;
15706 PLFLT arg6 ;
15707 PLFLT arg7 ;
15708 PLFLT arg8 ;
15709 PLINT arg9 ;
15710 PLINT arg10 ;
15711 PLINT arg11 ;
15712 PLFLT arg12 ;
15713 PLFLT arg13 ;
15714 PLINT arg14 ;
15715 PLFLT arg15 ;
15716 PLINT arg16 ;
15717 PLINT *arg17 = (PLINT *) 0 ;
15718 char **arg18 = (char **) 0 ;
15719 PLINT arg19 ;
15720 char **arg20 = (char **) 0 ;
15721 PLFLT *arg21 = (PLFLT *) 0 ;
15722 PLINT *arg22 = (PLINT *) 0 ;
15723 PLINT *arg23 = (PLINT *) 0 ;
15724 PLFLT *arg24 = (PLFLT *) 0 ;
15725 PLFLT temp1 ;
15726 int res1 = SWIG_TMPOBJ ;
15727 PLFLT temp2 ;
15728 int res2 = SWIG_TMPOBJ ;
15729 int val3 ;
15730 int ecode3 = 0 ;
15731 int val4 ;
15732 int ecode4 = 0 ;
15733 double val5 ;
15734 int ecode5 = 0 ;
15735 double val6 ;
15736 int ecode6 = 0 ;
15737 double val7 ;
15738 int ecode7 = 0 ;
15739 double val8 ;
15740 int ecode8 = 0 ;
15741 int val9 ;
15742 int ecode9 = 0 ;
15743 int val10 ;
15744 int ecode10 = 0 ;
15745 int val11 ;
15746 int ecode11 = 0 ;
15747 double val12 ;
15748 int ecode12 = 0 ;
15749 double val13 ;
15750 int ecode13 = 0 ;
15751 int val14 ;
15752 int ecode14 = 0 ;
15753 double val15 ;
15754 int ecode15 = 0 ;
15755 Matrix temp16 ;
15756 Matrix temp21 ;
15757 Matrix temp22 ;
15758 Matrix temp23 ;
15759 Matrix temp24 ;
15760 octave_value_list _out;
15761 octave_value_list *_outp=&_out;
15762 octave_value _outv;
15763
15764 try {
15765 arg1 = &temp1;
15766 arg2 = &temp2;
15767 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15768 SWIG_fail;
15769 }
15770 ecode3 = SWIG_AsVal_int(args(0), &val3);
15771 if (!SWIG_IsOK(ecode3)) {
15772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15773 }
15774 arg3 = static_cast< PLINT >(val3);
15775 ecode4 = SWIG_AsVal_int(args(1), &val4);
15776 if (!SWIG_IsOK(ecode4)) {
15777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15778 }
15779 arg4 = static_cast< PLINT >(val4);
15780 ecode5 = SWIG_AsVal_double(args(2), &val5);
15781 if (!SWIG_IsOK(ecode5)) {
15782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15783 }
15784 arg5 = static_cast< PLFLT >(val5);
15785 ecode6 = SWIG_AsVal_double(args(3), &val6);
15786 if (!SWIG_IsOK(ecode6)) {
15787 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15788 }
15789 arg6 = static_cast< PLFLT >(val6);
15790 ecode7 = SWIG_AsVal_double(args(4), &val7);
15791 if (!SWIG_IsOK(ecode7)) {
15792 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15793 }
15794 arg7 = static_cast< PLFLT >(val7);
15795 ecode8 = SWIG_AsVal_double(args(5), &val8);
15796 if (!SWIG_IsOK(ecode8)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15798 }
15799 arg8 = static_cast< PLFLT >(val8);
15800 ecode9 = SWIG_AsVal_int(args(6), &val9);
15801 if (!SWIG_IsOK(ecode9)) {
15802 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15803 }
15804 arg9 = static_cast< PLINT >(val9);
15805 ecode10 = SWIG_AsVal_int(args(7), &val10);
15806 if (!SWIG_IsOK(ecode10)) {
15807 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15808 }
15809 arg10 = static_cast< PLINT >(val10);
15810 ecode11 = SWIG_AsVal_int(args(8), &val11);
15811 if (!SWIG_IsOK(ecode11)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15813 }
15814 arg11 = static_cast< PLINT >(val11);
15815 ecode12 = SWIG_AsVal_double(args(9), &val12);
15816 if (!SWIG_IsOK(ecode12)) {
15817 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15818 }
15819 arg12 = static_cast< PLFLT >(val12);
15820 ecode13 = SWIG_AsVal_double(args(10), &val13);
15821 if (!SWIG_IsOK(ecode13)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15823 }
15824 arg13 = static_cast< PLFLT >(val13);
15825 ecode14 = SWIG_AsVal_int(args(11), &val14);
15826 if (!SWIG_IsOK(ecode14)) {
15827 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15828 }
15829 arg14 = static_cast< PLINT >(val14);
15830 ecode15 = SWIG_AsVal_double(args(12), &val15);
15831 if (!SWIG_IsOK(ecode15)) {
15832 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15833 }
15834 arg15 = static_cast< PLFLT >(val15);
15835 {
15836 if ( _n_dims( args(13) ) > 1 )
15837 {
15838 error( "argument must be a scalar or vector" ); SWIG_fail;
15839 }
15840 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15841 arg17 = new PLINT[Alen];
15842 temp16 = args(13).matrix_value();
15843 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15844 }
15845 {
15846 charMatrix temp_matrix;
15847 Cell temp_cell;
15848 char *tmp_cstring;
15849 std::string str;
15850 size_t max_length = 0, non_blank_length;
15851 int i, ifcell;
15852 if ( _n_dims( args(14) ) > 2 )
15853 {
15854 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15855 }
15856#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15857 if ( !args(14).isempty() )
15858#else
15859 if ( !args(14).is_empty() )
15860#endif
15861 {
15862 if ( _dim( args(14), 0 ) != Alen )
15863 {
15864 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15865 }
15866 arg18 = new char*[Alen];
15867#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15868 ifcell = args(14).iscell();
15869#else
15870 ifcell = args(14).is_cell();
15871#endif
15872 if ( ifcell )
15873 {
15874 temp_cell = args(14).cell_value();
15875 }
15876 else
15877 {
15878 temp_matrix = args(14).char_matrix_value();
15879 // Allow one extra space for null termination.
15880 max_length = _dim( args(14), 1 ) + 1;
15881 }
15882
15883 for ( i = 0; i < Alen; i++ )
15884 {
15885 // Must copy string to "permanent" location because the string
15886 // location corresponding to tmp_cstring gets
15887 // overwritten for each iteration of loop.
15888 if ( ifcell )
15889 {
15890 if ( temp_cell.elem( i ).is_string() )
15891 {
15892 str = temp_cell.elem( i ).string_value();
15893 // leave room for null termination.
15894 max_length = str.size() + 1;
15895 tmp_cstring = (char *) str.c_str();
15896 }
15897 else
15898 {
15899 // Use null string if user attempts to pass a cell array
15900 // with a non-string element (likely an empty element
15901 // since that should be allowed by the PLplot interface
15902 // if that element is going to be unused).
15903 // leave room for null termination.
15904 max_length = 1;
15905 tmp_cstring = (char *) "";
15906 }
15907 }
15908 else
15909 {
15910 str = temp_matrix.row_as_string( i );
15911 tmp_cstring = (char *) str.c_str();
15912 }
15913 arg18[i] = new char[max_length];
15914 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15915 arg18[i][max_length - 1] = '\0';
15916 // All the trailing blank crapola should not be needed for
15917 // string cell arrays.
15918 if ( !ifcell )
15919 {
15920 // remove trailing-blank padding that is used by the
15921 // charMatrix class to insure all strings in a given
15922 // charMatrix instance have the same length.
15923 // This transformation also removes legitimate trailing
15924 // blanks but there is nothing we can do about that
15925 // for the charMatrix class.
15926
15927 // Look for trailing nulls first (just in case, although that
15928 // shouldn't happen if charMatrix implemented as documented)
15929 // before looking for trailing blanks.
15930 non_blank_length = max_length - 2;
15931 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15932 {
15933 non_blank_length--;
15934 }
15935 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15936 {
15937 non_blank_length--;
15938 }
15939 arg18[i][non_blank_length + 1] = '\0';
15940 }
15941 }
15942 }
15943 else
15944 {
15945 arg18 = NULL;
15946 }
15947 }
15948 {
15949 charMatrix temp_matrix;
15950 Cell temp_cell;
15951 char *tmp_cstring;
15952 std::string str;
15953 size_t max_length = 0, non_blank_length;
15954 int i, ifcell;
15955 if ( _n_dims( args(15) ) > 2 )
15956 {
15957 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15958 }
15959#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15960 if ( !args(15).isempty() )
15961#else
15962 if ( !args(15).is_empty() )
15963#endif
15964 {
15965 Alen = _dim( args(15), 0 );
15966 arg19 = Alen;
15967 arg20 = new char*[Alen];
15968#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15969 ifcell = args(15).iscell();
15970#else
15971 ifcell = args(15).is_cell();
15972#endif
15973 if ( ifcell )
15974 {
15975 temp_cell = args(15).cell_value();
15976 }
15977 else
15978 {
15979 temp_matrix = args(15).char_matrix_value();
15980 // Allow one extra space for null termination.
15981 max_length = _dim( args(15), 1 ) + 1;
15982 }
15983
15984 for ( i = 0; i < Alen; i++ )
15985 {
15986 // Must copy string to "permanent" location because the string
15987 // location corresponding to tmp_cstring gets
15988 // overwritten for each iteration of loop.
15989 if ( ifcell )
15990 {
15991 if ( temp_cell.elem( i ).is_string() )
15992 {
15993 str = temp_cell.elem( i ).string_value();
15994 // leave room for null termination.
15995 max_length = str.size() + 1;
15996 tmp_cstring = (char *) str.c_str();
15997 }
15998 else
15999 {
16000 // Use null string if user attempts to pass a cell array
16001 // with a non-string element (likely an empty element
16002 // since that should be allowed by the PLplot interface
16003 // if that element is going to be unused).
16004 // leave room for null termination.
16005 max_length = 1;
16006 tmp_cstring = (char *) "";
16007 }
16008 }
16009 else
16010 {
16011 str = temp_matrix.row_as_string( i );
16012 tmp_cstring = (char *) str.c_str();
16013 }
16014 arg20[i] = new char[max_length];
16015 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16016 arg20[i][max_length - 1] = '\0';
16017 // All the trailing blank crapola should not be needed for
16018 // string cell arrays.
16019 if ( !ifcell )
16020 {
16021 // remove trailing-blank padding that is used by the
16022 // charMatrix class to insure all strings in a given
16023 // charMatrix instance have the same length.
16024 // This transformation also removes legitimate trailing
16025 // blanks but there is nothing we can do about that
16026 // for the charMatrix class.
16027
16028 // Look for trailing nulls first (just in case, although that
16029 // shouldn't happen if charMatrix implemented as documented)
16030 // before looking for trailing blanks.
16031 non_blank_length = max_length - 2;
16032 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16033 {
16034 non_blank_length--;
16035 }
16036 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16037 {
16038 non_blank_length--;
16039 }
16040 arg20[i][non_blank_length + 1] = '\0';
16041 }
16042 }
16043 }
16044 else
16045 {
16046 arg19 = 0;
16047 arg20 = NULL;
16048 }
16049 }
16050 {
16051 if ( _n_dims( args(16) ) > 1 )
16052 {
16053 error( "argument must be a scalar or vector" ); SWIG_fail;
16054 }
16055 if ( _dim( args(16), 0 ) != Alen )
16056 {
16057 error( "argument vectors must be same length" ); SWIG_fail;
16058 }
16059 temp21 = args(16).matrix_value();
16060 arg21 = &temp21( 0, 0 );
16061 }
16062 {
16063 if ( _n_dims( args(17) ) > 1 )
16064 {
16065 error( "argument must be a scalar or vector" ); SWIG_fail;
16066 }
16067 if ( _dim( args(17), 0 ) != Alen )
16068 {
16069 error( "argument vectors must be same length" ); SWIG_fail;
16070 }
16071 temp22 = args(17).matrix_value();
16072 arg22 = new PLINT[Alen];
16073 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16074 }
16075 {
16076 int i;
16077 if ( _n_dims( args(18) ) > 1 )
16078 {
16079 error( "argument must be a scalar or vector" ); SWIG_fail;
16080 }
16081 if ( _dim( args(18), 0 ) != Alen )
16082 {
16083 error( "argument vectors must be same length" ); SWIG_fail;
16084 }
16085 Xlen = Alen;
16086 temp23 = args(18).matrix_value();
16087 arg23 = new PLINT[Alen];
16088 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16089 Ylen = -1;
16090 for ( i = 0; i < Xlen; i++ )
16091 if ( arg23[i] > Ylen )
16092 Ylen = arg23[i];
16093 }
16094 {
16095 if ( _n_dims( args(19) ) > 2 )
16096 {
16097 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16098 }
16099 if ( _dim( args(19), 0 ) != Xlen )
16100 {
16101 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16102 }
16103 if ( _dim( args(19), 1 ) != Ylen )
16104 {
16105 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16106 }
16107 temp24 = args(19).matrix_value();
16108 arg24 = &temp24( 0, 0 );
16109 }
16110 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);
16111 _outv = octave_value();
16112 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16113 if (SWIG_IsTmpObj(res1)) {
16114 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16115 } else {
16116 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16117 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16118 }
16119 if (SWIG_IsTmpObj(res2)) {
16120 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16121 } else {
16122 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16123 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16124 }
16125 {
16126 delete [] arg17;
16127 }
16128 {
16129 int i;
16130 if ( arg18 != NULL )
16131 {
16132 for ( i = 0; i < Alen; i++ )
16133 {
16134 delete[] arg18[i];
16135 }
16136 delete[] arg18;
16137 }
16138 }
16139 {
16140 int i;
16141 if ( arg20 != NULL )
16142 {
16143 for ( i = 0; i < Alen; i++ )
16144 {
16145 delete[] arg20[i];
16146 }
16147 delete[] arg20;
16148 }
16149 }
16150 {
16151
16152 }
16153 {
16154 delete [] arg22;
16155 }
16156 {
16157 delete [] arg23;
16158 }
16159 {
16160
16161 }
16162 return _out;
16163 fail:
16164 {
16165 delete [] arg17;
16166 }
16167 {
16168 int i;
16169 if ( arg18 != NULL )
16170 {
16171 for ( i = 0; i < Alen; i++ )
16172 {
16173 delete[] arg18[i];
16174 }
16175 delete[] arg18;
16176 }
16177 }
16178 {
16179 int i;
16180 if ( arg20 != NULL )
16181 {
16182 for ( i = 0; i < Alen; i++ )
16183 {
16184 delete[] arg20[i];
16185 }
16186 delete[] arg20;
16187 }
16188 }
16189 {
16190
16191 }
16192 {
16193 delete [] arg22;
16194 }
16195 {
16196 delete [] arg23;
16197 }
16198 {
16199
16200 }
16201 return octave_value_list();
16202 }
16203 catch(...) {
16204 {
16205 delete [] arg17;
16206 }
16207 {
16208 int i;
16209 if ( arg18 != NULL )
16210 {
16211 for ( i = 0; i < Alen; i++ )
16212 {
16213 delete[] arg18[i];
16214 }
16215 delete[] arg18;
16216 }
16217 }
16218 {
16219 int i;
16220 if ( arg20 != NULL )
16221 {
16222 for ( i = 0; i < Alen; i++ )
16223 {
16224 delete[] arg20[i];
16225 }
16226 delete[] arg20;
16227 }
16228 }
16229 {
16230
16231 }
16232 {
16233 delete [] arg22;
16234 }
16235 {
16236 delete [] arg23;
16237 }
16238 {
16239
16240 }
16241 throw;
16242 }
16243}
16244
16245
16246SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16247 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16248 int arg2 ;
16249 void *argp1 = 0 ;
16250 int res1 = 0 ;
16251 int val2 ;
16252 int ecode2 = 0 ;
16253 octave_value_list _out;
16254 octave_value_list *_outp=&_out;
16255 octave_value _outv;
16256
16257 try {
16258 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16259 SWIG_fail;
16260 }
16261 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16262 if (!SWIG_IsOK(res1)) {
16263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16264 }
16265 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16266 ecode2 = SWIG_AsVal_int(args(1), &val2);
16267 if (!SWIG_IsOK(ecode2)) {
16268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16269 }
16270 arg2 = static_cast< int >(val2);
16271 if (arg1) (arg1)->type = arg2;
16272 _outv = octave_value();
16273 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16274 return _out;
16275 fail:
16276 return octave_value_list();
16277 }
16278 catch(...) {
16279 throw;
16280 }
16281}
16282
16283
16284SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16285 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 octave_value_list _out;
16289 octave_value_list *_outp=&_out;
16290 octave_value _outv;
16291 int result;
16292
16293 try {
16294 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16295 SWIG_fail;
16296 }
16297 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16298 if (!SWIG_IsOK(res1)) {
16299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16300 }
16301 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16302 result = (int) ((arg1)->type);
16303 _outv = SWIG_From_int(static_cast< int >(result));
16304 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16305 return _out;
16306 fail:
16307 return octave_value_list();
16308 }
16309 catch(...) {
16310 throw;
16311 }
16312}
16313
16314
16315SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16316 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16317 unsigned int arg2 ;
16318 void *argp1 = 0 ;
16319 int res1 = 0 ;
16320 unsigned int val2 ;
16321 int ecode2 = 0 ;
16322 octave_value_list _out;
16323 octave_value_list *_outp=&_out;
16324 octave_value _outv;
16325
16326 try {
16327 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16328 SWIG_fail;
16329 }
16330 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16331 if (!SWIG_IsOK(res1)) {
16332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16333 }
16334 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16335 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16336 if (!SWIG_IsOK(ecode2)) {
16337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16338 }
16339 arg2 = static_cast< unsigned int >(val2);
16340 if (arg1) (arg1)->state = arg2;
16341 _outv = octave_value();
16342 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16343 return _out;
16344 fail:
16345 return octave_value_list();
16346 }
16347 catch(...) {
16348 throw;
16349 }
16350}
16351
16352
16353SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16354 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16355 void *argp1 = 0 ;
16356 int res1 = 0 ;
16357 octave_value_list _out;
16358 octave_value_list *_outp=&_out;
16359 octave_value _outv;
16360 unsigned int result;
16361
16362 try {
16363 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16364 SWIG_fail;
16365 }
16366 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16367 if (!SWIG_IsOK(res1)) {
16368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16369 }
16370 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16371 result = (unsigned int) ((arg1)->state);
16372 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16373 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16374 return _out;
16375 fail:
16376 return octave_value_list();
16377 }
16378 catch(...) {
16379 throw;
16380 }
16381}
16382
16383
16384SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16385 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16386 unsigned int arg2 ;
16387 void *argp1 = 0 ;
16388 int res1 = 0 ;
16389 unsigned int val2 ;
16390 int ecode2 = 0 ;
16391 octave_value_list _out;
16392 octave_value_list *_outp=&_out;
16393 octave_value _outv;
16394
16395 try {
16396 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16397 SWIG_fail;
16398 }
16399 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16400 if (!SWIG_IsOK(res1)) {
16401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16402 }
16403 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16404 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16405 if (!SWIG_IsOK(ecode2)) {
16406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16407 }
16408 arg2 = static_cast< unsigned int >(val2);
16409 if (arg1) (arg1)->keysym = arg2;
16410 _outv = octave_value();
16411 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16412 return _out;
16413 fail:
16414 return octave_value_list();
16415 }
16416 catch(...) {
16417 throw;
16418 }
16419}
16420
16421
16422SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16423 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 octave_value_list _out;
16427 octave_value_list *_outp=&_out;
16428 octave_value _outv;
16429 unsigned int result;
16430
16431 try {
16432 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16433 SWIG_fail;
16434 }
16435 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16436 if (!SWIG_IsOK(res1)) {
16437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16438 }
16439 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16440 result = (unsigned int) ((arg1)->keysym);
16441 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16442 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16443 return _out;
16444 fail:
16445 return octave_value_list();
16446 }
16447 catch(...) {
16448 throw;
16449 }
16450}
16451
16452
16453SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16454 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16455 unsigned int arg2 ;
16456 void *argp1 = 0 ;
16457 int res1 = 0 ;
16458 unsigned int val2 ;
16459 int ecode2 = 0 ;
16460 octave_value_list _out;
16461 octave_value_list *_outp=&_out;
16462 octave_value _outv;
16463
16464 try {
16465 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16466 SWIG_fail;
16467 }
16468 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16471 }
16472 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16473 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16474 if (!SWIG_IsOK(ecode2)) {
16475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16476 }
16477 arg2 = static_cast< unsigned int >(val2);
16478 if (arg1) (arg1)->button = arg2;
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_button_get, _wrap_PLGraphicsIn_button_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 unsigned int result;
16499
16500 try {
16501 if (!SWIG_check_num_args("PLGraphicsIn_button_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_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16507 }
16508 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16509 result = (unsigned int) ((arg1)->button);
16510 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16511 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16512 return _out;
16513 fail:
16514 return octave_value_list();
16515 }
16516 catch(...) {
16517 throw;
16518 }
16519}
16520
16521
16522SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16523 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16524 PLINT arg2 ;
16525 void *argp1 = 0 ;
16526 int res1 = 0 ;
16527 int val2 ;
16528 int ecode2 = 0 ;
16529 octave_value_list _out;
16530 octave_value_list *_outp=&_out;
16531 octave_value _outv;
16532
16533 try {
16534 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16535 SWIG_fail;
16536 }
16537 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16540 }
16541 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16542 ecode2 = SWIG_AsVal_int(args(1), &val2);
16543 if (!SWIG_IsOK(ecode2)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16545 }
16546 arg2 = static_cast< PLINT >(val2);
16547 if (arg1) (arg1)->subwindow = arg2;
16548 _outv = octave_value();
16549 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16550 return _out;
16551 fail:
16552 return octave_value_list();
16553 }
16554 catch(...) {
16555 throw;
16556 }
16557}
16558
16559
16560SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16561 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 octave_value_list _out;
16565 octave_value_list *_outp=&_out;
16566 octave_value _outv;
16567 PLINT result;
16568
16569 try {
16570 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16571 SWIG_fail;
16572 }
16573 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16576 }
16577 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16578 result = (PLINT) ((arg1)->subwindow);
16579 _outv = SWIG_From_int(static_cast< int >(result));
16580 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16581 return _out;
16582 fail:
16583 return octave_value_list();
16584 }
16585 catch(...) {
16586 throw;
16587 }
16588}
16589
16590
16591SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16592 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16593 char *arg2 = (char *) (char *)0 ;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 char temp2[16] ;
16597 int res2 ;
16598 octave_value_list _out;
16599 octave_value_list *_outp=&_out;
16600 octave_value _outv;
16601
16602 try {
16603 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16604 SWIG_fail;
16605 }
16606 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16607 if (!SWIG_IsOK(res1)) {
16608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16609 }
16610 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16611 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16612 if (!SWIG_IsOK(res2)) {
16613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16614 }
16615 arg2 = reinterpret_cast< char * >(temp2);
16616 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16617 else memset(arg1->string,0,16*sizeof(char));
16618 _outv = octave_value();
16619 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16620 return _out;
16621 fail:
16622 return octave_value_list();
16623 }
16624 catch(...) {
16625 throw;
16626 }
16627}
16628
16629
16630SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16631 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16632 void *argp1 = 0 ;
16633 int res1 = 0 ;
16634 octave_value_list _out;
16635 octave_value_list *_outp=&_out;
16636 octave_value _outv;
16637 char *result = 0 ;
16638
16639 try {
16640 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16641 SWIG_fail;
16642 }
16643 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16644 if (!SWIG_IsOK(res1)) {
16645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16646 }
16647 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16648 result = (char *)(char *) ((arg1)->string);
16649 {
16650 size_t size = SWIG_strnlen(result, 16);
16651
16652
16653
16654 _outv = SWIG_FromCharPtrAndSize(result, size);
16655 }
16656 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16657 return _out;
16658 fail:
16659 return octave_value_list();
16660 }
16661 catch(...) {
16662 throw;
16663 }
16664}
16665
16666
16667SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16668 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16669 int arg2 ;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 int val2 ;
16673 int ecode2 = 0 ;
16674 octave_value_list _out;
16675 octave_value_list *_outp=&_out;
16676 octave_value _outv;
16677
16678 try {
16679 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16680 SWIG_fail;
16681 }
16682 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16683 if (!SWIG_IsOK(res1)) {
16684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16685 }
16686 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16687 ecode2 = SWIG_AsVal_int(args(1), &val2);
16688 if (!SWIG_IsOK(ecode2)) {
16689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16690 }
16691 arg2 = static_cast< int >(val2);
16692 if (arg1) (arg1)->pX = arg2;
16693 _outv = octave_value();
16694 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16695 return _out;
16696 fail:
16697 return octave_value_list();
16698 }
16699 catch(...) {
16700 throw;
16701 }
16702}
16703
16704
16705SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16706 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16707 void *argp1 = 0 ;
16708 int res1 = 0 ;
16709 octave_value_list _out;
16710 octave_value_list *_outp=&_out;
16711 octave_value _outv;
16712 int result;
16713
16714 try {
16715 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16716 SWIG_fail;
16717 }
16718 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16719 if (!SWIG_IsOK(res1)) {
16720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16721 }
16722 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16723 result = (int) ((arg1)->pX);
16724 _outv = SWIG_From_int(static_cast< int >(result));
16725 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16726 return _out;
16727 fail:
16728 return octave_value_list();
16729 }
16730 catch(...) {
16731 throw;
16732 }
16733}
16734
16735
16736SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16737 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16738 int arg2 ;
16739 void *argp1 = 0 ;
16740 int res1 = 0 ;
16741 int val2 ;
16742 int ecode2 = 0 ;
16743 octave_value_list _out;
16744 octave_value_list *_outp=&_out;
16745 octave_value _outv;
16746
16747 try {
16748 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16749 SWIG_fail;
16750 }
16751 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16752 if (!SWIG_IsOK(res1)) {
16753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16754 }
16755 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16756 ecode2 = SWIG_AsVal_int(args(1), &val2);
16757 if (!SWIG_IsOK(ecode2)) {
16758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16759 }
16760 arg2 = static_cast< int >(val2);
16761 if (arg1) (arg1)->pY = arg2;
16762 _outv = octave_value();
16763 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16764 return _out;
16765 fail:
16766 return octave_value_list();
16767 }
16768 catch(...) {
16769 throw;
16770 }
16771}
16772
16773
16774SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16775 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16776 void *argp1 = 0 ;
16777 int res1 = 0 ;
16778 octave_value_list _out;
16779 octave_value_list *_outp=&_out;
16780 octave_value _outv;
16781 int result;
16782
16783 try {
16784 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16785 SWIG_fail;
16786 }
16787 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16788 if (!SWIG_IsOK(res1)) {
16789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16790 }
16791 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16792 result = (int) ((arg1)->pY);
16793 _outv = SWIG_From_int(static_cast< int >(result));
16794 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16795 return _out;
16796 fail:
16797 return octave_value_list();
16798 }
16799 catch(...) {
16800 throw;
16801 }
16802}
16803
16804
16805SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16806 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16807 PLFLT arg2 ;
16808 void *argp1 = 0 ;
16809 int res1 = 0 ;
16810 double val2 ;
16811 int ecode2 = 0 ;
16812 octave_value_list _out;
16813 octave_value_list *_outp=&_out;
16814 octave_value _outv;
16815
16816 try {
16817 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16818 SWIG_fail;
16819 }
16820 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16823 }
16824 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16825 ecode2 = SWIG_AsVal_double(args(1), &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16828 }
16829 arg2 = static_cast< PLFLT >(val2);
16830 if (arg1) (arg1)->dX = arg2;
16831 _outv = octave_value();
16832 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16833 return _out;
16834 fail:
16835 return octave_value_list();
16836 }
16837 catch(...) {
16838 throw;
16839 }
16840}
16841
16842
16843SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16844 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16845 void *argp1 = 0 ;
16846 int res1 = 0 ;
16847 octave_value_list _out;
16848 octave_value_list *_outp=&_out;
16849 octave_value _outv;
16850 PLFLT result;
16851
16852 try {
16853 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16854 SWIG_fail;
16855 }
16856 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16859 }
16860 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16861 result = (PLFLT) ((arg1)->dX);
16862 _outv = SWIG_From_double(static_cast< double >(result));
16863 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16864 return _out;
16865 fail:
16866 return octave_value_list();
16867 }
16868 catch(...) {
16869 throw;
16870 }
16871}
16872
16873
16874SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16875 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16876 PLFLT arg2 ;
16877 void *argp1 = 0 ;
16878 int res1 = 0 ;
16879 double val2 ;
16880 int ecode2 = 0 ;
16881 octave_value_list _out;
16882 octave_value_list *_outp=&_out;
16883 octave_value _outv;
16884
16885 try {
16886 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16887 SWIG_fail;
16888 }
16889 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16892 }
16893 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16894 ecode2 = SWIG_AsVal_double(args(1), &val2);
16895 if (!SWIG_IsOK(ecode2)) {
16896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16897 }
16898 arg2 = static_cast< PLFLT >(val2);
16899 if (arg1) (arg1)->dY = arg2;
16900 _outv = octave_value();
16901 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16902 return _out;
16903 fail:
16904 return octave_value_list();
16905 }
16906 catch(...) {
16907 throw;
16908 }
16909}
16910
16911
16912SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16913 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16914 void *argp1 = 0 ;
16915 int res1 = 0 ;
16916 octave_value_list _out;
16917 octave_value_list *_outp=&_out;
16918 octave_value _outv;
16919 PLFLT result;
16920
16921 try {
16922 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16923 SWIG_fail;
16924 }
16925 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16926 if (!SWIG_IsOK(res1)) {
16927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16928 }
16929 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16930 result = (PLFLT) ((arg1)->dY);
16931 _outv = SWIG_From_double(static_cast< double >(result));
16932 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16933 return _out;
16934 fail:
16935 return octave_value_list();
16936 }
16937 catch(...) {
16938 throw;
16939 }
16940}
16941
16942
16943SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16944 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16945 PLFLT arg2 ;
16946 void *argp1 = 0 ;
16947 int res1 = 0 ;
16948 double val2 ;
16949 int ecode2 = 0 ;
16950 octave_value_list _out;
16951 octave_value_list *_outp=&_out;
16952 octave_value _outv;
16953
16954 try {
16955 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16956 SWIG_fail;
16957 }
16958 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16959 if (!SWIG_IsOK(res1)) {
16960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16961 }
16962 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16963 ecode2 = SWIG_AsVal_double(args(1), &val2);
16964 if (!SWIG_IsOK(ecode2)) {
16965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16966 }
16967 arg2 = static_cast< PLFLT >(val2);
16968 if (arg1) (arg1)->wX = arg2;
16969 _outv = octave_value();
16970 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16971 return _out;
16972 fail:
16973 return octave_value_list();
16974 }
16975 catch(...) {
16976 throw;
16977 }
16978}
16979
16980
16981SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16982 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16983 void *argp1 = 0 ;
16984 int res1 = 0 ;
16985 octave_value_list _out;
16986 octave_value_list *_outp=&_out;
16987 octave_value _outv;
16988 PLFLT result;
16989
16990 try {
16991 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16992 SWIG_fail;
16993 }
16994 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16997 }
16998 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16999 result = (PLFLT) ((arg1)->wX);
17000 _outv = SWIG_From_double(static_cast< double >(result));
17001 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17002 return _out;
17003 fail:
17004 return octave_value_list();
17005 }
17006 catch(...) {
17007 throw;
17008 }
17009}
17010
17011
17012SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
17013 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17014 PLFLT arg2 ;
17015 void *argp1 = 0 ;
17016 int res1 = 0 ;
17017 double val2 ;
17018 int ecode2 = 0 ;
17019 octave_value_list _out;
17020 octave_value_list *_outp=&_out;
17021 octave_value _outv;
17022
17023 try {
17024 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
17025 SWIG_fail;
17026 }
17027 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17028 if (!SWIG_IsOK(res1)) {
17029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17030 }
17031 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17032 ecode2 = SWIG_AsVal_double(args(1), &val2);
17033 if (!SWIG_IsOK(ecode2)) {
17034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
17035 }
17036 arg2 = static_cast< PLFLT >(val2);
17037 if (arg1) (arg1)->wY = arg2;
17038 _outv = octave_value();
17039 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17040 return _out;
17041 fail:
17042 return octave_value_list();
17043 }
17044 catch(...) {
17045 throw;
17046 }
17047}
17048
17049
17050SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
17051 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17052 void *argp1 = 0 ;
17053 int res1 = 0 ;
17054 octave_value_list _out;
17055 octave_value_list *_outp=&_out;
17056 octave_value _outv;
17057 PLFLT result;
17058
17059 try {
17060 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
17061 SWIG_fail;
17062 }
17063 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17064 if (!SWIG_IsOK(res1)) {
17065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17066 }
17067 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17068 result = (PLFLT) ((arg1)->wY);
17069 _outv = SWIG_From_double(static_cast< double >(result));
17070 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17071 return _out;
17072 fail:
17073 return octave_value_list();
17074 }
17075 catch(...) {
17076 throw;
17077 }
17078}
17079
17080
17081SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
17082 octave_value_list _out;
17083 octave_value_list *_outp=&_out;
17084 octave_value _outv;
17085 PLGraphicsIn *result = 0 ;
17086
17087 try {
17088 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17089 SWIG_fail;
17090 }
17091 result = (PLGraphicsIn *)new PLGraphicsIn();
17093 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17094 return _out;
17095 fail:
17096 return octave_value_list();
17097 }
17098 catch(...) {
17099 throw;
17100 }
17101}
17102
17103
17104SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17105 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17106 void *argp1 = 0 ;
17107 int res1 = 0 ;
17108 octave_value_list _out;
17109 octave_value_list *_outp=&_out;
17110 octave_value _outv;
17111
17112 try {
17113 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17114 SWIG_fail;
17115 }
17116 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17117 if (!SWIG_IsOK(res1)) {
17118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17119 }
17120 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17121 delete arg1;
17122 _outv = octave_value();
17123 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17124 return _out;
17125 fail:
17126 return octave_value_list();
17127 }
17128 catch(...) {
17129 throw;
17130 }
17131}
17132
17133
17149static const char *swig_PLGraphicsIn_base_names[] = {0};
17152
17154 PLINT arg1 ;
17155 PLINT arg2 ;
17156 int val1 ;
17157 int ecode1 = 0 ;
17158 int val2 ;
17159 int ecode2 = 0 ;
17160 octave_value_list _out;
17161 octave_value_list *_outp=&_out;
17162 octave_value _outv;
17163
17164 try {
17165 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17166 SWIG_fail;
17167 }
17168 ecode1 = SWIG_AsVal_int(args(0), &val1);
17169 if (!SWIG_IsOK(ecode1)) {
17170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17171 }
17172 arg1 = static_cast< PLINT >(val1);
17173 ecode2 = SWIG_AsVal_int(args(1), &val2);
17174 if (!SWIG_IsOK(ecode2)) {
17175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17176 }
17177 arg2 = static_cast< PLINT >(val2);
17178 pl_setcontlabelformat(arg1,arg2);
17179 _outv = octave_value();
17180 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17181 return _out;
17182 fail:
17183 return octave_value_list();
17184 }
17185 catch(...) {
17186 throw;
17187 }
17188}
17189
17190
17192 PLFLT arg1 ;
17193 PLFLT arg2 ;
17194 PLFLT arg3 ;
17195 PLINT arg4 ;
17196 double val1 ;
17197 int ecode1 = 0 ;
17198 double val2 ;
17199 int ecode2 = 0 ;
17200 double val3 ;
17201 int ecode3 = 0 ;
17202 int val4 ;
17203 int ecode4 = 0 ;
17204 octave_value_list _out;
17205 octave_value_list *_outp=&_out;
17206 octave_value _outv;
17207
17208 try {
17209 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17210 SWIG_fail;
17211 }
17212 ecode1 = SWIG_AsVal_double(args(0), &val1);
17213 if (!SWIG_IsOK(ecode1)) {
17214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17215 }
17216 arg1 = static_cast< PLFLT >(val1);
17217 ecode2 = SWIG_AsVal_double(args(1), &val2);
17218 if (!SWIG_IsOK(ecode2)) {
17219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17220 }
17221 arg2 = static_cast< PLFLT >(val2);
17222 ecode3 = SWIG_AsVal_double(args(2), &val3);
17223 if (!SWIG_IsOK(ecode3)) {
17224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17225 }
17226 arg3 = static_cast< PLFLT >(val3);
17227 ecode4 = SWIG_AsVal_int(args(3), &val4);
17228 if (!SWIG_IsOK(ecode4)) {
17229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17230 }
17231 arg4 = static_cast< PLINT >(val4);
17232 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17233 _outv = octave_value();
17234 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17235 return _out;
17236 fail:
17237 return octave_value_list();
17238 }
17239 catch(...) {
17240 throw;
17241 }
17242}
17243
17244
17246 PLINT arg1 ;
17247 int val1 ;
17248 int ecode1 = 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("pladv",args.length(),1,1,0)) {
17255 SWIG_fail;
17256 }
17257 ecode1 = SWIG_AsVal_int(args(0), &val1);
17258 if (!SWIG_IsOK(ecode1)) {
17259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17260 }
17261 arg1 = static_cast< PLINT >(val1);
17262 pladv(arg1);
17263 _outv = octave_value();
17264 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17265 return _out;
17266 fail:
17267 return octave_value_list();
17268 }
17269 catch(...) {
17270 throw;
17271 }
17272}
17273
17274
17276 PLFLT arg1 ;
17277 PLFLT arg2 ;
17278 PLFLT arg3 ;
17279 PLFLT arg4 ;
17280 PLFLT arg5 ;
17281 PLFLT arg6 ;
17282 PLFLT arg7 ;
17283 PLBOOL arg8 ;
17284 double val1 ;
17285 int ecode1 = 0 ;
17286 double val2 ;
17287 int ecode2 = 0 ;
17288 double val3 ;
17289 int ecode3 = 0 ;
17290 double val4 ;
17291 int ecode4 = 0 ;
17292 double val5 ;
17293 int ecode5 = 0 ;
17294 double val6 ;
17295 int ecode6 = 0 ;
17296 double val7 ;
17297 int ecode7 = 0 ;
17298 int val8 ;
17299 int ecode8 = 0 ;
17300 octave_value_list _out;
17301 octave_value_list *_outp=&_out;
17302 octave_value _outv;
17303
17304 try {
17305 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17306 SWIG_fail;
17307 }
17308 ecode1 = SWIG_AsVal_double(args(0), &val1);
17309 if (!SWIG_IsOK(ecode1)) {
17310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17311 }
17312 arg1 = static_cast< PLFLT >(val1);
17313 ecode2 = SWIG_AsVal_double(args(1), &val2);
17314 if (!SWIG_IsOK(ecode2)) {
17315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17316 }
17317 arg2 = static_cast< PLFLT >(val2);
17318 ecode3 = SWIG_AsVal_double(args(2), &val3);
17319 if (!SWIG_IsOK(ecode3)) {
17320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17321 }
17322 arg3 = static_cast< PLFLT >(val3);
17323 ecode4 = SWIG_AsVal_double(args(3), &val4);
17324 if (!SWIG_IsOK(ecode4)) {
17325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17326 }
17327 arg4 = static_cast< PLFLT >(val4);
17328 ecode5 = SWIG_AsVal_double(args(4), &val5);
17329 if (!SWIG_IsOK(ecode5)) {
17330 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17331 }
17332 arg5 = static_cast< PLFLT >(val5);
17333 ecode6 = SWIG_AsVal_double(args(5), &val6);
17334 if (!SWIG_IsOK(ecode6)) {
17335 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17336 }
17337 arg6 = static_cast< PLFLT >(val6);
17338 ecode7 = SWIG_AsVal_double(args(6), &val7);
17339 if (!SWIG_IsOK(ecode7)) {
17340 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17341 }
17342 arg7 = static_cast< PLFLT >(val7);
17343 ecode8 = SWIG_AsVal_int(args(7), &val8);
17344 if (!SWIG_IsOK(ecode8)) {
17345 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17346 }
17347 arg8 = static_cast< PLBOOL >(val8);
17348 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17349 _outv = octave_value();
17350 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17351 return _out;
17352 fail:
17353 return octave_value_list();
17354 }
17355 catch(...) {
17356 throw;
17357 }
17358}
17359
17360
17362 PLFLT arg1 ;
17363 PLFLT arg2 ;
17364 char *arg3 = (char *) 0 ;
17365 PLFLT arg4 ;
17366 PLINT arg5 ;
17367 char *arg6 = (char *) 0 ;
17368 PLFLT arg7 ;
17369 PLINT arg8 ;
17370 double val1 ;
17371 int ecode1 = 0 ;
17372 double val2 ;
17373 int ecode2 = 0 ;
17374 int res3 ;
17375 char *buf3 = 0 ;
17376 int alloc3 = 0 ;
17377 double val4 ;
17378 int ecode4 = 0 ;
17379 int val5 ;
17380 int ecode5 = 0 ;
17381 int res6 ;
17382 char *buf6 = 0 ;
17383 int alloc6 = 0 ;
17384 double val7 ;
17385 int ecode7 = 0 ;
17386 int val8 ;
17387 int ecode8 = 0 ;
17388 octave_value_list _out;
17389 octave_value_list *_outp=&_out;
17390 octave_value _outv;
17391
17392 try {
17393 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17394 SWIG_fail;
17395 }
17396 ecode1 = SWIG_AsVal_double(args(0), &val1);
17397 if (!SWIG_IsOK(ecode1)) {
17398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17399 }
17400 arg1 = static_cast< PLFLT >(val1);
17401 ecode2 = SWIG_AsVal_double(args(1), &val2);
17402 if (!SWIG_IsOK(ecode2)) {
17403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17404 }
17405 arg2 = static_cast< PLFLT >(val2);
17406 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17407 if (!SWIG_IsOK(res3)) {
17408 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17409 }
17410 arg3 = reinterpret_cast< char * >(buf3);
17411 ecode4 = SWIG_AsVal_double(args(3), &val4);
17412 if (!SWIG_IsOK(ecode4)) {
17413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17414 }
17415 arg4 = static_cast< PLFLT >(val4);
17416 ecode5 = SWIG_AsVal_int(args(4), &val5);
17417 if (!SWIG_IsOK(ecode5)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17419 }
17420 arg5 = static_cast< PLINT >(val5);
17421 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17422 if (!SWIG_IsOK(res6)) {
17423 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17424 }
17425 arg6 = reinterpret_cast< char * >(buf6);
17426 ecode7 = SWIG_AsVal_double(args(6), &val7);
17427 if (!SWIG_IsOK(ecode7)) {
17428 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17429 }
17430 arg7 = static_cast< PLFLT >(val7);
17431 ecode8 = SWIG_AsVal_int(args(7), &val8);
17432 if (!SWIG_IsOK(ecode8)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17434 }
17435 arg8 = static_cast< PLINT >(val8);
17436 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17437 _outv = octave_value();
17438 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17439 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17440 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17441 return _out;
17442 fail:
17443 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17444 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17445 return octave_value_list();
17446 }
17447 catch(...) {
17448 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17449 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17450 throw;
17451 }
17452}
17453
17454
17456 PLINT arg1 ;
17457 PLFLT *arg2 = (PLFLT *) 0 ;
17458 PLFLT *arg3 = (PLFLT *) 0 ;
17459 PLINT arg4 ;
17460 Matrix temp1 ;
17461 Matrix temp3 ;
17462 int val4 ;
17463 int ecode4 = 0 ;
17464 octave_value_list _out;
17465 octave_value_list *_outp=&_out;
17466 octave_value _outv;
17467
17468 try {
17469 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17470 SWIG_fail;
17471 }
17472 {
17473 if ( _n_dims( args(0) ) > 1 )
17474 {
17475 error( "argument must be a scalar or vector" ); SWIG_fail;
17476 }
17477 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17478 temp1 = args(0).matrix_value();
17479 arg2 = &temp1( 0, 0 );
17480 }
17481 {
17482 if ( _n_dims( args(1) ) > 1 )
17483 {
17484 error( "argument must be a scalar or vector" ); SWIG_fail;
17485 }
17486 if ( _dim( args(1), 0 ) != Alen )
17487 {
17488 error( "argument vectors must be same length" ); SWIG_fail;
17489 }
17490 temp3 = args(1).matrix_value();
17491 arg3 = &temp3( 0, 0 );
17492 }
17493 ecode4 = SWIG_AsVal_int(args(2), &val4);
17494 if (!SWIG_IsOK(ecode4)) {
17495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17496 }
17497 arg4 = static_cast< PLINT >(val4);
17498 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17499 _outv = octave_value();
17500 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17501 {
17502
17503 }
17504 {
17505
17506 }
17507 return _out;
17508 fail:
17509 {
17510
17511 }
17512 {
17513
17514 }
17515 return octave_value_list();
17516 }
17517 catch(...) {
17518 {
17519
17520 }
17521 {
17522
17523 }
17524 throw;
17525 }
17526}
17527
17528
17530 PLINT *arg1 = (PLINT *) 0 ;
17531 PLINT *arg2 = (PLINT *) 0 ;
17532 PLINT *arg3 = (PLINT *) 0 ;
17533 PLINT *arg4 = (PLINT *) 0 ;
17534 PLINT *arg5 = (PLINT *) 0 ;
17535 PLFLT *arg6 = (PLFLT *) 0 ;
17536 PLFLT arg7 ;
17537 PLINT temp1 ;
17538 int res1 = SWIG_TMPOBJ ;
17539 PLINT temp2 ;
17540 int res2 = SWIG_TMPOBJ ;
17541 PLINT temp3 ;
17542 int res3 = SWIG_TMPOBJ ;
17543 PLINT temp4 ;
17544 int res4 = SWIG_TMPOBJ ;
17545 PLINT temp5 ;
17546 int res5 = SWIG_TMPOBJ ;
17547 PLFLT temp6 ;
17548 int res6 = SWIG_TMPOBJ ;
17549 double val7 ;
17550 int ecode7 = 0 ;
17551 octave_value_list _out;
17552 octave_value_list *_outp=&_out;
17553 octave_value _outv;
17554
17555 try {
17556 arg1 = &temp1;
17557 arg2 = &temp2;
17558 arg3 = &temp3;
17559 arg4 = &temp4;
17560 arg5 = &temp5;
17561 arg6 = &temp6;
17562 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17563 SWIG_fail;
17564 }
17565 ecode7 = SWIG_AsVal_double(args(0), &val7);
17566 if (!SWIG_IsOK(ecode7)) {
17567 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17568 }
17569 arg7 = static_cast< PLFLT >(val7);
17570 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17571 _outv = octave_value();
17572 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17573 if (SWIG_IsTmpObj(res1)) {
17574 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17575 } else {
17576 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17577 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17578 }
17579 if (SWIG_IsTmpObj(res2)) {
17580 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17581 } else {
17582 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17583 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17584 }
17585 if (SWIG_IsTmpObj(res3)) {
17586 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17587 } else {
17588 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17589 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17590 }
17591 if (SWIG_IsTmpObj(res4)) {
17592 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17593 } else {
17594 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17595 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17596 }
17597 if (SWIG_IsTmpObj(res5)) {
17598 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17599 } else {
17600 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17601 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17602 }
17603 if (SWIG_IsTmpObj(res6)) {
17604 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17605 } else {
17606 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17607 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17608 }
17609 return _out;
17610 fail:
17611 return octave_value_list();
17612 }
17613 catch(...) {
17614 throw;
17615 }
17616}
17617
17618
17620 octave_value_list _out;
17621 octave_value_list *_outp=&_out;
17622 octave_value _outv;
17623
17624 try {
17625 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17626 SWIG_fail;
17627 }
17628 plbop();
17629 _outv = octave_value();
17630 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17631 return _out;
17632 fail:
17633 return octave_value_list();
17634 }
17635 catch(...) {
17636 throw;
17637 }
17638}
17639
17640
17642 char *arg1 = (char *) 0 ;
17643 PLFLT arg2 ;
17644 PLINT arg3 ;
17645 char *arg4 = (char *) 0 ;
17646 PLFLT arg5 ;
17647 PLINT arg6 ;
17648 int res1 ;
17649 char *buf1 = 0 ;
17650 int alloc1 = 0 ;
17651 double val2 ;
17652 int ecode2 = 0 ;
17653 int val3 ;
17654 int ecode3 = 0 ;
17655 int res4 ;
17656 char *buf4 = 0 ;
17657 int alloc4 = 0 ;
17658 double val5 ;
17659 int ecode5 = 0 ;
17660 int val6 ;
17661 int ecode6 = 0 ;
17662 octave_value_list _out;
17663 octave_value_list *_outp=&_out;
17664 octave_value _outv;
17665
17666 try {
17667 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17668 SWIG_fail;
17669 }
17670 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17671 if (!SWIG_IsOK(res1)) {
17672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17673 }
17674 arg1 = reinterpret_cast< char * >(buf1);
17675 ecode2 = SWIG_AsVal_double(args(1), &val2);
17676 if (!SWIG_IsOK(ecode2)) {
17677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17678 }
17679 arg2 = static_cast< PLFLT >(val2);
17680 ecode3 = SWIG_AsVal_int(args(2), &val3);
17681 if (!SWIG_IsOK(ecode3)) {
17682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17683 }
17684 arg3 = static_cast< PLINT >(val3);
17685 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17686 if (!SWIG_IsOK(res4)) {
17687 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17688 }
17689 arg4 = reinterpret_cast< char * >(buf4);
17690 ecode5 = SWIG_AsVal_double(args(4), &val5);
17691 if (!SWIG_IsOK(ecode5)) {
17692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17693 }
17694 arg5 = static_cast< PLFLT >(val5);
17695 ecode6 = SWIG_AsVal_int(args(5), &val6);
17696 if (!SWIG_IsOK(ecode6)) {
17697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17698 }
17699 arg6 = static_cast< PLINT >(val6);
17700 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17701 _outv = octave_value();
17702 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17703 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17704 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17705 return _out;
17706 fail:
17707 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17708 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17709 return octave_value_list();
17710 }
17711 catch(...) {
17712 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17713 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17714 throw;
17715 }
17716}
17717
17718
17720 char *arg1 = (char *) 0 ;
17721 char *arg2 = (char *) 0 ;
17722 PLFLT arg3 ;
17723 PLINT arg4 ;
17724 char *arg5 = (char *) 0 ;
17725 char *arg6 = (char *) 0 ;
17726 PLFLT arg7 ;
17727 PLINT arg8 ;
17728 char *arg9 = (char *) 0 ;
17729 char *arg10 = (char *) 0 ;
17730 PLFLT arg11 ;
17731 PLINT arg12 ;
17732 int res1 ;
17733 char *buf1 = 0 ;
17734 int alloc1 = 0 ;
17735 int res2 ;
17736 char *buf2 = 0 ;
17737 int alloc2 = 0 ;
17738 double val3 ;
17739 int ecode3 = 0 ;
17740 int val4 ;
17741 int ecode4 = 0 ;
17742 int res5 ;
17743 char *buf5 = 0 ;
17744 int alloc5 = 0 ;
17745 int res6 ;
17746 char *buf6 = 0 ;
17747 int alloc6 = 0 ;
17748 double val7 ;
17749 int ecode7 = 0 ;
17750 int val8 ;
17751 int ecode8 = 0 ;
17752 int res9 ;
17753 char *buf9 = 0 ;
17754 int alloc9 = 0 ;
17755 int res10 ;
17756 char *buf10 = 0 ;
17757 int alloc10 = 0 ;
17758 double val11 ;
17759 int ecode11 = 0 ;
17760 int val12 ;
17761 int ecode12 = 0 ;
17762 octave_value_list _out;
17763 octave_value_list *_outp=&_out;
17764 octave_value _outv;
17765
17766 try {
17767 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17768 SWIG_fail;
17769 }
17770 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17771 if (!SWIG_IsOK(res1)) {
17772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17773 }
17774 arg1 = reinterpret_cast< char * >(buf1);
17775 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17776 if (!SWIG_IsOK(res2)) {
17777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17778 }
17779 arg2 = reinterpret_cast< char * >(buf2);
17780 ecode3 = SWIG_AsVal_double(args(2), &val3);
17781 if (!SWIG_IsOK(ecode3)) {
17782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17783 }
17784 arg3 = static_cast< PLFLT >(val3);
17785 ecode4 = SWIG_AsVal_int(args(3), &val4);
17786 if (!SWIG_IsOK(ecode4)) {
17787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17788 }
17789 arg4 = static_cast< PLINT >(val4);
17790 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17791 if (!SWIG_IsOK(res5)) {
17792 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17793 }
17794 arg5 = reinterpret_cast< char * >(buf5);
17795 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17796 if (!SWIG_IsOK(res6)) {
17797 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17798 }
17799 arg6 = reinterpret_cast< char * >(buf6);
17800 ecode7 = SWIG_AsVal_double(args(6), &val7);
17801 if (!SWIG_IsOK(ecode7)) {
17802 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17803 }
17804 arg7 = static_cast< PLFLT >(val7);
17805 ecode8 = SWIG_AsVal_int(args(7), &val8);
17806 if (!SWIG_IsOK(ecode8)) {
17807 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17808 }
17809 arg8 = static_cast< PLINT >(val8);
17810 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17811 if (!SWIG_IsOK(res9)) {
17812 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17813 }
17814 arg9 = reinterpret_cast< char * >(buf9);
17815 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17816 if (!SWIG_IsOK(res10)) {
17817 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17818 }
17819 arg10 = reinterpret_cast< char * >(buf10);
17820 ecode11 = SWIG_AsVal_double(args(10), &val11);
17821 if (!SWIG_IsOK(ecode11)) {
17822 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17823 }
17824 arg11 = static_cast< PLFLT >(val11);
17825 ecode12 = SWIG_AsVal_int(args(11), &val12);
17826 if (!SWIG_IsOK(ecode12)) {
17827 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17828 }
17829 arg12 = static_cast< PLINT >(val12);
17830 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);
17831 _outv = octave_value();
17832 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17833 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17834 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17835 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17836 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17837 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17838 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17839 return _out;
17840 fail:
17841 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17842 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17843 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17844 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17845 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17846 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17847 return octave_value_list();
17848 }
17849 catch(...) {
17850 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17851 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17852 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17853 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17854 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17855 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17856 throw;
17857 }
17858}
17859
17860
17862 PLFLT arg1 ;
17863 PLFLT arg2 ;
17864 PLFLT *arg3 = (PLFLT *) 0 ;
17865 PLFLT *arg4 = (PLFLT *) 0 ;
17866 PLINT *arg5 = (PLINT *) 0 ;
17867 double val1 ;
17868 int ecode1 = 0 ;
17869 double val2 ;
17870 int ecode2 = 0 ;
17871 PLFLT temp3 ;
17872 int res3 = SWIG_TMPOBJ ;
17873 PLFLT temp4 ;
17874 int res4 = SWIG_TMPOBJ ;
17875 PLINT temp5 ;
17876 int res5 = SWIG_TMPOBJ ;
17877 octave_value_list _out;
17878 octave_value_list *_outp=&_out;
17879 octave_value _outv;
17880
17881 try {
17882 arg3 = &temp3;
17883 arg4 = &temp4;
17884 arg5 = &temp5;
17885 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17886 SWIG_fail;
17887 }
17888 ecode1 = SWIG_AsVal_double(args(0), &val1);
17889 if (!SWIG_IsOK(ecode1)) {
17890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17891 }
17892 arg1 = static_cast< PLFLT >(val1);
17893 ecode2 = SWIG_AsVal_double(args(1), &val2);
17894 if (!SWIG_IsOK(ecode2)) {
17895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17896 }
17897 arg2 = static_cast< PLFLT >(val2);
17898 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17899 _outv = octave_value();
17900 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17901 if (SWIG_IsTmpObj(res3)) {
17902 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17903 } else {
17904 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17905 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17906 }
17907 if (SWIG_IsTmpObj(res4)) {
17908 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17909 } else {
17910 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17911 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17912 }
17913 if (SWIG_IsTmpObj(res5)) {
17914 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17915 } else {
17916 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17917 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17918 }
17919 return _out;
17920 fail:
17921 return octave_value_list();
17922 }
17923 catch(...) {
17924 throw;
17925 }
17926}
17927
17928
17930 octave_value_list _out;
17931 octave_value_list *_outp=&_out;
17932 octave_value _outv;
17933
17934 try {
17935 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17936 SWIG_fail;
17937 }
17938 plclear();
17939 _outv = octave_value();
17940 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17941 return _out;
17942 fail:
17943 return octave_value_list();
17944 }
17945 catch(...) {
17946 throw;
17947 }
17948}
17949
17950
17952 PLINT arg1 ;
17953 int val1 ;
17954 int ecode1 = 0 ;
17955 octave_value_list _out;
17956 octave_value_list *_outp=&_out;
17957 octave_value _outv;
17958
17959 try {
17960 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17961 SWIG_fail;
17962 }
17963 ecode1 = SWIG_AsVal_int(args(0), &val1);
17964 if (!SWIG_IsOK(ecode1)) {
17965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17966 }
17967 arg1 = static_cast< PLINT >(val1);
17968 plcol0(arg1);
17969 _outv = octave_value();
17970 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17971 return _out;
17972 fail:
17973 return octave_value_list();
17974 }
17975 catch(...) {
17976 throw;
17977 }
17978}
17979
17980
17982 PLFLT arg1 ;
17983 double val1 ;
17984 int ecode1 = 0 ;
17985 octave_value_list _out;
17986 octave_value_list *_outp=&_out;
17987 octave_value _outv;
17988
17989 try {
17990 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17991 SWIG_fail;
17992 }
17993 ecode1 = SWIG_AsVal_double(args(0), &val1);
17994 if (!SWIG_IsOK(ecode1)) {
17995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17996 }
17997 arg1 = static_cast< PLFLT >(val1);
17998 plcol1(arg1);
17999 _outv = octave_value();
18000 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18001 return _out;
18002 fail:
18003 return octave_value_list();
18004 }
18005 catch(...) {
18006 throw;
18007 }
18008}
18009
18010
18012 PLFLT arg1 ;
18013 PLFLT arg2 ;
18014 PLFLT arg3 ;
18015 PLINT arg4 ;
18016 PLBOOL arg5 ;
18017 PLINT arg6 ;
18018 PLINT arg7 ;
18019 PLINT arg8 ;
18020 PLINT arg9 ;
18021 PLINT arg10 ;
18022 PLFLT arg11 ;
18023 double val1 ;
18024 int ecode1 = 0 ;
18025 double val2 ;
18026 int ecode2 = 0 ;
18027 double val3 ;
18028 int ecode3 = 0 ;
18029 int val4 ;
18030 int ecode4 = 0 ;
18031 int val5 ;
18032 int ecode5 = 0 ;
18033 int val6 ;
18034 int ecode6 = 0 ;
18035 int val7 ;
18036 int ecode7 = 0 ;
18037 int val8 ;
18038 int ecode8 = 0 ;
18039 int val9 ;
18040 int ecode9 = 0 ;
18041 int val10 ;
18042 int ecode10 = 0 ;
18043 double val11 ;
18044 int ecode11 = 0 ;
18045 octave_value_list _out;
18046 octave_value_list *_outp=&_out;
18047 octave_value _outv;
18048
18049 try {
18050 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
18051 SWIG_fail;
18052 }
18053 ecode1 = SWIG_AsVal_double(args(0), &val1);
18054 if (!SWIG_IsOK(ecode1)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
18056 }
18057 arg1 = static_cast< PLFLT >(val1);
18058 ecode2 = SWIG_AsVal_double(args(1), &val2);
18059 if (!SWIG_IsOK(ecode2)) {
18060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
18061 }
18062 arg2 = static_cast< PLFLT >(val2);
18063 ecode3 = SWIG_AsVal_double(args(2), &val3);
18064 if (!SWIG_IsOK(ecode3)) {
18065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
18066 }
18067 arg3 = static_cast< PLFLT >(val3);
18068 ecode4 = SWIG_AsVal_int(args(3), &val4);
18069 if (!SWIG_IsOK(ecode4)) {
18070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
18071 }
18072 arg4 = static_cast< PLINT >(val4);
18073 ecode5 = SWIG_AsVal_int(args(4), &val5);
18074 if (!SWIG_IsOK(ecode5)) {
18075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
18076 }
18077 arg5 = static_cast< PLBOOL >(val5);
18078 ecode6 = SWIG_AsVal_int(args(5), &val6);
18079 if (!SWIG_IsOK(ecode6)) {
18080 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
18081 }
18082 arg6 = static_cast< PLINT >(val6);
18083 ecode7 = SWIG_AsVal_int(args(6), &val7);
18084 if (!SWIG_IsOK(ecode7)) {
18085 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18086 }
18087 arg7 = static_cast< PLINT >(val7);
18088 ecode8 = SWIG_AsVal_int(args(7), &val8);
18089 if (!SWIG_IsOK(ecode8)) {
18090 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18091 }
18092 arg8 = static_cast< PLINT >(val8);
18093 ecode9 = SWIG_AsVal_int(args(8), &val9);
18094 if (!SWIG_IsOK(ecode9)) {
18095 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18096 }
18097 arg9 = static_cast< PLINT >(val9);
18098 ecode10 = SWIG_AsVal_int(args(9), &val10);
18099 if (!SWIG_IsOK(ecode10)) {
18100 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18101 }
18102 arg10 = static_cast< PLINT >(val10);
18103 ecode11 = SWIG_AsVal_double(args(10), &val11);
18104 if (!SWIG_IsOK(ecode11)) {
18105 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18106 }
18107 arg11 = static_cast< PLFLT >(val11);
18108 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18109 _outv = octave_value();
18110 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18111 return _out;
18112 fail:
18113 return octave_value_list();
18114 }
18115 catch(...) {
18116 throw;
18117 }
18118}
18119
18120
18122 PLINT arg1 ;
18123 PLINT arg2 ;
18124 PLINT arg3 ;
18125 PLINT arg4 ;
18126 PLINT arg5 ;
18127 PLFLT arg6 ;
18128 PLFLT *arg7 = (PLFLT *) 0 ;
18129 int val1 ;
18130 int ecode1 = 0 ;
18131 int val2 ;
18132 int ecode2 = 0 ;
18133 int val3 ;
18134 int ecode3 = 0 ;
18135 int val4 ;
18136 int ecode4 = 0 ;
18137 int val5 ;
18138 int ecode5 = 0 ;
18139 double val6 ;
18140 int ecode6 = 0 ;
18141 PLFLT temp7 ;
18142 int res7 = SWIG_TMPOBJ ;
18143 octave_value_list _out;
18144 octave_value_list *_outp=&_out;
18145 octave_value _outv;
18146
18147 try {
18148 arg7 = &temp7;
18149 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18150 SWIG_fail;
18151 }
18152 ecode1 = SWIG_AsVal_int(args(0), &val1);
18153 if (!SWIG_IsOK(ecode1)) {
18154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18155 }
18156 arg1 = static_cast< PLINT >(val1);
18157 ecode2 = SWIG_AsVal_int(args(1), &val2);
18158 if (!SWIG_IsOK(ecode2)) {
18159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18160 }
18161 arg2 = static_cast< PLINT >(val2);
18162 ecode3 = SWIG_AsVal_int(args(2), &val3);
18163 if (!SWIG_IsOK(ecode3)) {
18164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18165 }
18166 arg3 = static_cast< PLINT >(val3);
18167 ecode4 = SWIG_AsVal_int(args(3), &val4);
18168 if (!SWIG_IsOK(ecode4)) {
18169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18170 }
18171 arg4 = static_cast< PLINT >(val4);
18172 ecode5 = SWIG_AsVal_int(args(4), &val5);
18173 if (!SWIG_IsOK(ecode5)) {
18174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18175 }
18176 arg5 = static_cast< PLINT >(val5);
18177 ecode6 = SWIG_AsVal_double(args(5), &val6);
18178 if (!SWIG_IsOK(ecode6)) {
18179 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18180 }
18181 arg6 = static_cast< PLFLT >(val6);
18182 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18183 _outv = octave_value();
18184 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18185 if (SWIG_IsTmpObj(res7)) {
18186 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18187 } else {
18188 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18189 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18190 }
18191 return _out;
18192 fail:
18193 return octave_value_list();
18194 }
18195 catch(...) {
18196 throw;
18197 }
18198}
18199
18200
18202 PLINT arg1 ;
18203 PLBOOL arg2 ;
18204 int val1 ;
18205 int ecode1 = 0 ;
18206 int val2 ;
18207 int ecode2 = 0 ;
18208 octave_value_list _out;
18209 octave_value_list *_outp=&_out;
18210 octave_value _outv;
18211
18212 try {
18213 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18214 SWIG_fail;
18215 }
18216 ecode1 = SWIG_AsVal_int(args(0), &val1);
18217 if (!SWIG_IsOK(ecode1)) {
18218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18219 }
18220 arg1 = static_cast< PLINT >(val1);
18221 ecode2 = SWIG_AsVal_int(args(1), &val2);
18222 if (!SWIG_IsOK(ecode2)) {
18223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18224 }
18225 arg2 = static_cast< PLBOOL >(val2);
18226 plcpstrm(arg1,arg2);
18227 _outv = octave_value();
18228 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18229 return _out;
18230 fail:
18231 return octave_value_list();
18232 }
18233 catch(...) {
18234 throw;
18235 }
18236}
18237
18238
18240 octave_value_list _out;
18241 octave_value_list *_outp=&_out;
18242 octave_value _outv;
18243
18244 try {
18245 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18246 SWIG_fail;
18247 }
18248 plend();
18249 _outv = octave_value();
18250 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18251 return _out;
18252 fail:
18253 return octave_value_list();
18254 }
18255 catch(...) {
18256 throw;
18257 }
18258}
18259
18260
18262 octave_value_list _out;
18263 octave_value_list *_outp=&_out;
18264 octave_value _outv;
18265
18266 try {
18267 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18268 SWIG_fail;
18269 }
18270 plend1();
18271 _outv = octave_value();
18272 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18273 return _out;
18274 fail:
18275 return octave_value_list();
18276 }
18277 catch(...) {
18278 throw;
18279 }
18280}
18281
18282
18284 PLFLT arg1 ;
18285 PLFLT arg2 ;
18286 PLFLT arg3 ;
18287 PLFLT arg4 ;
18288 PLINT arg5 ;
18289 PLINT arg6 ;
18290 double val1 ;
18291 int ecode1 = 0 ;
18292 double val2 ;
18293 int ecode2 = 0 ;
18294 double val3 ;
18295 int ecode3 = 0 ;
18296 double val4 ;
18297 int ecode4 = 0 ;
18298 int val5 ;
18299 int ecode5 = 0 ;
18300 int val6 ;
18301 int ecode6 = 0 ;
18302 octave_value_list _out;
18303 octave_value_list *_outp=&_out;
18304 octave_value _outv;
18305
18306 try {
18307 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18308 SWIG_fail;
18309 }
18310 ecode1 = SWIG_AsVal_double(args(0), &val1);
18311 if (!SWIG_IsOK(ecode1)) {
18312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18313 }
18314 arg1 = static_cast< PLFLT >(val1);
18315 ecode2 = SWIG_AsVal_double(args(1), &val2);
18316 if (!SWIG_IsOK(ecode2)) {
18317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18318 }
18319 arg2 = static_cast< PLFLT >(val2);
18320 ecode3 = SWIG_AsVal_double(args(2), &val3);
18321 if (!SWIG_IsOK(ecode3)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18323 }
18324 arg3 = static_cast< PLFLT >(val3);
18325 ecode4 = SWIG_AsVal_double(args(3), &val4);
18326 if (!SWIG_IsOK(ecode4)) {
18327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18328 }
18329 arg4 = static_cast< PLFLT >(val4);
18330 ecode5 = SWIG_AsVal_int(args(4), &val5);
18331 if (!SWIG_IsOK(ecode5)) {
18332 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18333 }
18334 arg5 = static_cast< PLINT >(val5);
18335 ecode6 = SWIG_AsVal_int(args(5), &val6);
18336 if (!SWIG_IsOK(ecode6)) {
18337 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18338 }
18339 arg6 = static_cast< PLINT >(val6);
18340 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18341 _outv = octave_value();
18342 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18343 return _out;
18344 fail:
18345 return octave_value_list();
18346 }
18347 catch(...) {
18348 throw;
18349 }
18350}
18351
18352
18354 PLFLT arg1 ;
18355 PLFLT arg2 ;
18356 PLFLT arg3 ;
18357 PLFLT arg4 ;
18358 PLINT arg5 ;
18359 PLINT arg6 ;
18360 double val1 ;
18361 int ecode1 = 0 ;
18362 double val2 ;
18363 int ecode2 = 0 ;
18364 double val3 ;
18365 int ecode3 = 0 ;
18366 double val4 ;
18367 int ecode4 = 0 ;
18368 int val5 ;
18369 int ecode5 = 0 ;
18370 int val6 ;
18371 int ecode6 = 0 ;
18372 octave_value_list _out;
18373 octave_value_list *_outp=&_out;
18374 octave_value _outv;
18375
18376 try {
18377 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18378 SWIG_fail;
18379 }
18380 ecode1 = SWIG_AsVal_double(args(0), &val1);
18381 if (!SWIG_IsOK(ecode1)) {
18382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18383 }
18384 arg1 = static_cast< PLFLT >(val1);
18385 ecode2 = SWIG_AsVal_double(args(1), &val2);
18386 if (!SWIG_IsOK(ecode2)) {
18387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18388 }
18389 arg2 = static_cast< PLFLT >(val2);
18390 ecode3 = SWIG_AsVal_double(args(2), &val3);
18391 if (!SWIG_IsOK(ecode3)) {
18392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18393 }
18394 arg3 = static_cast< PLFLT >(val3);
18395 ecode4 = SWIG_AsVal_double(args(3), &val4);
18396 if (!SWIG_IsOK(ecode4)) {
18397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18398 }
18399 arg4 = static_cast< PLFLT >(val4);
18400 ecode5 = SWIG_AsVal_int(args(4), &val5);
18401 if (!SWIG_IsOK(ecode5)) {
18402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18403 }
18404 arg5 = static_cast< PLINT >(val5);
18405 ecode6 = SWIG_AsVal_int(args(5), &val6);
18406 if (!SWIG_IsOK(ecode6)) {
18407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18408 }
18409 arg6 = static_cast< PLINT >(val6);
18410 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18411 _outv = octave_value();
18412 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18413 return _out;
18414 fail:
18415 return octave_value_list();
18416 }
18417 catch(...) {
18418 throw;
18419 }
18420}
18421
18422
18424 octave_value_list _out;
18425 octave_value_list *_outp=&_out;
18426 octave_value _outv;
18427
18428 try {
18429 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18430 SWIG_fail;
18431 }
18432 pleop();
18433 _outv = octave_value();
18434 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18435 return _out;
18436 fail:
18437 return octave_value_list();
18438 }
18439 catch(...) {
18440 throw;
18441 }
18442}
18443
18444
18446 PLINT arg1 ;
18447 PLFLT *arg2 = (PLFLT *) 0 ;
18448 PLFLT *arg3 = (PLFLT *) 0 ;
18449 PLFLT *arg4 = (PLFLT *) 0 ;
18450 Matrix temp1 ;
18451 Matrix temp3 ;
18452 Matrix temp4 ;
18453 octave_value_list _out;
18454 octave_value_list *_outp=&_out;
18455 octave_value _outv;
18456
18457 try {
18458 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18459 SWIG_fail;
18460 }
18461 {
18462 if ( _n_dims( args(0) ) > 1 )
18463 {
18464 error( "argument must be a scalar or vector" ); SWIG_fail;
18465 }
18466 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18467 temp1 = args(0).matrix_value();
18468 arg2 = &temp1( 0, 0 );
18469 }
18470 {
18471 if ( _n_dims( args(1) ) > 1 )
18472 {
18473 error( "argument must be a scalar or vector" ); SWIG_fail;
18474 }
18475 if ( _dim( args(1), 0 ) != Alen )
18476 {
18477 error( "argument vectors must be same length" ); SWIG_fail;
18478 }
18479 temp3 = args(1).matrix_value();
18480 arg3 = &temp3( 0, 0 );
18481 }
18482 {
18483 if ( _n_dims( args(2) ) > 1 )
18484 {
18485 error( "argument must be a scalar or vector" ); SWIG_fail;
18486 }
18487 if ( _dim( args(2), 0 ) != Alen )
18488 {
18489 error( "argument vectors must be same length" ); SWIG_fail;
18490 }
18491 temp4 = args(2).matrix_value();
18492 arg4 = &temp4( 0, 0 );
18493 }
18494 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18495 _outv = octave_value();
18496 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18497 {
18498
18499 }
18500 {
18501
18502 }
18503 {
18504
18505 }
18506 return _out;
18507 fail:
18508 {
18509
18510 }
18511 {
18512
18513 }
18514 {
18515
18516 }
18517 return octave_value_list();
18518 }
18519 catch(...) {
18520 {
18521
18522 }
18523 {
18524
18525 }
18526 {
18527
18528 }
18529 throw;
18530 }
18531}
18532
18533
18535 PLINT arg1 ;
18536 PLFLT *arg2 = (PLFLT *) 0 ;
18537 PLFLT *arg3 = (PLFLT *) 0 ;
18538 PLFLT *arg4 = (PLFLT *) 0 ;
18539 Matrix temp1 ;
18540 Matrix temp3 ;
18541 Matrix temp4 ;
18542 octave_value_list _out;
18543 octave_value_list *_outp=&_out;
18544 octave_value _outv;
18545
18546 try {
18547 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18548 SWIG_fail;
18549 }
18550 {
18551 if ( _n_dims( args(0) ) > 1 )
18552 {
18553 error( "argument must be a scalar or vector" ); SWIG_fail;
18554 }
18555 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18556 temp1 = args(0).matrix_value();
18557 arg2 = &temp1( 0, 0 );
18558 }
18559 {
18560 if ( _n_dims( args(1) ) > 1 )
18561 {
18562 error( "argument must be a scalar or vector" ); SWIG_fail;
18563 }
18564 if ( _dim( args(1), 0 ) != Alen )
18565 {
18566 error( "argument vectors must be same length" ); SWIG_fail;
18567 }
18568 temp3 = args(1).matrix_value();
18569 arg3 = &temp3( 0, 0 );
18570 }
18571 {
18572 if ( _n_dims( args(2) ) > 1 )
18573 {
18574 error( "argument must be a scalar or vector" ); SWIG_fail;
18575 }
18576 if ( _dim( args(2), 0 ) != Alen )
18577 {
18578 error( "argument vectors must be same length" ); SWIG_fail;
18579 }
18580 temp4 = args(2).matrix_value();
18581 arg4 = &temp4( 0, 0 );
18582 }
18583 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18584 _outv = octave_value();
18585 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18586 {
18587
18588 }
18589 {
18590
18591 }
18592 {
18593
18594 }
18595 return _out;
18596 fail:
18597 {
18598
18599 }
18600 {
18601
18602 }
18603 {
18604
18605 }
18606 return octave_value_list();
18607 }
18608 catch(...) {
18609 {
18610
18611 }
18612 {
18613
18614 }
18615 {
18616
18617 }
18618 throw;
18619 }
18620}
18621
18622
18624 octave_value_list _out;
18625 octave_value_list *_outp=&_out;
18626 octave_value _outv;
18627
18628 try {
18629 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18630 SWIG_fail;
18631 }
18632 plfamadv();
18633 _outv = octave_value();
18634 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18635 return _out;
18636 fail:
18637 return octave_value_list();
18638 }
18639 catch(...) {
18640 throw;
18641 }
18642}
18643
18644
18646 PLINT arg1 ;
18647 PLFLT *arg2 = (PLFLT *) 0 ;
18648 PLFLT *arg3 = (PLFLT *) 0 ;
18649 Matrix temp1 ;
18650 Matrix temp3 ;
18651 octave_value_list _out;
18652 octave_value_list *_outp=&_out;
18653 octave_value _outv;
18654
18655 try {
18656 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18657 SWIG_fail;
18658 }
18659 {
18660 if ( _n_dims( args(0) ) > 1 )
18661 {
18662 error( "argument must be a scalar or vector" ); SWIG_fail;
18663 }
18664 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18665 temp1 = args(0).matrix_value();
18666 arg2 = &temp1( 0, 0 );
18667 }
18668 {
18669 if ( _n_dims( args(1) ) > 1 )
18670 {
18671 error( "argument must be a scalar or vector" ); SWIG_fail;
18672 }
18673 if ( _dim( args(1), 0 ) != Alen )
18674 {
18675 error( "argument vectors must be same length" ); SWIG_fail;
18676 }
18677 temp3 = args(1).matrix_value();
18678 arg3 = &temp3( 0, 0 );
18679 }
18680 plfill(arg1,(double const *)arg2,(double const *)arg3);
18681 _outv = octave_value();
18682 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18683 {
18684
18685 }
18686 {
18687
18688 }
18689 return _out;
18690 fail:
18691 {
18692
18693 }
18694 {
18695
18696 }
18697 return octave_value_list();
18698 }
18699 catch(...) {
18700 {
18701
18702 }
18703 {
18704
18705 }
18706 throw;
18707 }
18708}
18709
18710
18712 PLINT arg1 ;
18713 PLFLT *arg2 = (PLFLT *) 0 ;
18714 PLFLT *arg3 = (PLFLT *) 0 ;
18715 PLFLT *arg4 = (PLFLT *) 0 ;
18716 Matrix temp1 ;
18717 Matrix temp3 ;
18718 Matrix temp4 ;
18719 octave_value_list _out;
18720 octave_value_list *_outp=&_out;
18721 octave_value _outv;
18722
18723 try {
18724 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18725 SWIG_fail;
18726 }
18727 {
18728 if ( _n_dims( args(0) ) > 1 )
18729 {
18730 error( "argument must be a scalar or vector" ); SWIG_fail;
18731 }
18732 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18733 temp1 = args(0).matrix_value();
18734 arg2 = &temp1( 0, 0 );
18735 }
18736 {
18737 if ( _n_dims( args(1) ) > 1 )
18738 {
18739 error( "argument must be a scalar or vector" ); SWIG_fail;
18740 }
18741 if ( _dim( args(1), 0 ) != Alen )
18742 {
18743 error( "argument vectors must be same length" ); SWIG_fail;
18744 }
18745 temp3 = args(1).matrix_value();
18746 arg3 = &temp3( 0, 0 );
18747 }
18748 {
18749 if ( _n_dims( args(2) ) > 1 )
18750 {
18751 error( "argument must be a scalar or vector" ); SWIG_fail;
18752 }
18753 if ( _dim( args(2), 0 ) != Alen )
18754 {
18755 error( "argument vectors must be same length" ); SWIG_fail;
18756 }
18757 temp4 = args(2).matrix_value();
18758 arg4 = &temp4( 0, 0 );
18759 }
18760 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18761 _outv = octave_value();
18762 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18763 {
18764
18765 }
18766 {
18767
18768 }
18769 {
18770
18771 }
18772 return _out;
18773 fail:
18774 {
18775
18776 }
18777 {
18778
18779 }
18780 {
18781
18782 }
18783 return octave_value_list();
18784 }
18785 catch(...) {
18786 {
18787
18788 }
18789 {
18790
18791 }
18792 {
18793
18794 }
18795 throw;
18796 }
18797}
18798
18799
18801 PLINT arg1 ;
18802 PLFLT *arg2 = (PLFLT *) 0 ;
18803 PLFLT *arg3 = (PLFLT *) 0 ;
18804 PLFLT arg4 ;
18805 Matrix temp1 ;
18806 Matrix temp3 ;
18807 double val4 ;
18808 int ecode4 = 0 ;
18809 octave_value_list _out;
18810 octave_value_list *_outp=&_out;
18811 octave_value _outv;
18812
18813 try {
18814 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18815 SWIG_fail;
18816 }
18817 {
18818 if ( _n_dims( args(0) ) > 1 )
18819 {
18820 error( "argument must be a scalar or vector" ); SWIG_fail;
18821 }
18822 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18823 temp1 = args(0).matrix_value();
18824 arg2 = &temp1( 0, 0 );
18825 }
18826 {
18827 if ( _n_dims( args(1) ) > 1 )
18828 {
18829 error( "argument must be a scalar or vector" ); SWIG_fail;
18830 }
18831 if ( _dim( args(1), 0 ) != Alen )
18832 {
18833 error( "argument vectors must be same length" ); SWIG_fail;
18834 }
18835 temp3 = args(1).matrix_value();
18836 arg3 = &temp3( 0, 0 );
18837 }
18838 ecode4 = SWIG_AsVal_double(args(2), &val4);
18839 if (!SWIG_IsOK(ecode4)) {
18840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18841 }
18842 arg4 = static_cast< PLFLT >(val4);
18843 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18844 _outv = octave_value();
18845 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18846 {
18847
18848 }
18849 {
18850
18851 }
18852 return _out;
18853 fail:
18854 {
18855
18856 }
18857 {
18858
18859 }
18860 return octave_value_list();
18861 }
18862 catch(...) {
18863 {
18864
18865 }
18866 {
18867
18868 }
18869 throw;
18870 }
18871}
18872
18873
18875 octave_value_list _out;
18876 octave_value_list *_outp=&_out;
18877 octave_value _outv;
18878
18879 try {
18880 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18881 SWIG_fail;
18882 }
18883 plflush();
18884 _outv = octave_value();
18885 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18886 return _out;
18887 fail:
18888 return octave_value_list();
18889 }
18890 catch(...) {
18891 throw;
18892 }
18893}
18894
18895
18897 PLINT arg1 ;
18898 int val1 ;
18899 int ecode1 = 0 ;
18900 octave_value_list _out;
18901 octave_value_list *_outp=&_out;
18902 octave_value _outv;
18903
18904 try {
18905 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18906 SWIG_fail;
18907 }
18908 ecode1 = SWIG_AsVal_int(args(0), &val1);
18909 if (!SWIG_IsOK(ecode1)) {
18910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18911 }
18912 arg1 = static_cast< PLINT >(val1);
18913 plfont(arg1);
18914 _outv = octave_value();
18915 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18916 return _out;
18917 fail:
18918 return octave_value_list();
18919 }
18920 catch(...) {
18921 throw;
18922 }
18923}
18924
18925
18927 PLINT arg1 ;
18928 int val1 ;
18929 int ecode1 = 0 ;
18930 octave_value_list _out;
18931 octave_value_list *_outp=&_out;
18932 octave_value _outv;
18933
18934 try {
18935 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18936 SWIG_fail;
18937 }
18938 ecode1 = SWIG_AsVal_int(args(0), &val1);
18939 if (!SWIG_IsOK(ecode1)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18941 }
18942 arg1 = static_cast< PLINT >(val1);
18943 plfontld(arg1);
18944 _outv = octave_value();
18945 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18946 return _out;
18947 fail:
18948 return octave_value_list();
18949 }
18950 catch(...) {
18951 throw;
18952 }
18953}
18954
18955
18957 PLFLT *arg1 = (PLFLT *) 0 ;
18958 PLFLT *arg2 = (PLFLT *) 0 ;
18959 PLFLT temp1 ;
18960 int res1 = SWIG_TMPOBJ ;
18961 PLFLT temp2 ;
18962 int res2 = SWIG_TMPOBJ ;
18963 octave_value_list _out;
18964 octave_value_list *_outp=&_out;
18965 octave_value _outv;
18966
18967 try {
18968 arg1 = &temp1;
18969 arg2 = &temp2;
18970 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18971 SWIG_fail;
18972 }
18973 plgchr(arg1,arg2);
18974 _outv = octave_value();
18975 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18976 if (SWIG_IsTmpObj(res1)) {
18977 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18978 } else {
18979 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18980 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18981 }
18982 if (SWIG_IsTmpObj(res2)) {
18983 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18984 } else {
18985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18986 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18987 }
18988 return _out;
18989 fail:
18990 return octave_value_list();
18991 }
18992 catch(...) {
18993 throw;
18994 }
18995}
18996
18997
18999 PLINT arg1 ;
19000 PLINT *arg2 = (PLINT *) 0 ;
19001 PLINT *arg3 = (PLINT *) 0 ;
19002 PLINT *arg4 = (PLINT *) 0 ;
19003 int val1 ;
19004 int ecode1 = 0 ;
19005 PLINT temp2 ;
19006 int res2 = SWIG_TMPOBJ ;
19007 PLINT temp3 ;
19008 int res3 = SWIG_TMPOBJ ;
19009 PLINT temp4 ;
19010 int res4 = SWIG_TMPOBJ ;
19011 octave_value_list _out;
19012 octave_value_list *_outp=&_out;
19013 octave_value _outv;
19014
19015 try {
19016 arg2 = &temp2;
19017 arg3 = &temp3;
19018 arg4 = &temp4;
19019 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
19020 SWIG_fail;
19021 }
19022 ecode1 = SWIG_AsVal_int(args(0), &val1);
19023 if (!SWIG_IsOK(ecode1)) {
19024 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
19025 }
19026 arg1 = static_cast< PLINT >(val1);
19027 plgcol0(arg1,arg2,arg3,arg4);
19028 _outv = octave_value();
19029 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19030 if (SWIG_IsTmpObj(res2)) {
19031 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19032 } else {
19033 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19035 }
19036 if (SWIG_IsTmpObj(res3)) {
19037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19038 } else {
19039 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19041 }
19042 if (SWIG_IsTmpObj(res4)) {
19043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19044 } else {
19045 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19046 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19047 }
19048 return _out;
19049 fail:
19050 return octave_value_list();
19051 }
19052 catch(...) {
19053 throw;
19054 }
19055}
19056
19057
19059 PLINT arg1 ;
19060 PLINT *arg2 = (PLINT *) 0 ;
19061 PLINT *arg3 = (PLINT *) 0 ;
19062 PLINT *arg4 = (PLINT *) 0 ;
19063 PLFLT *arg5 = (PLFLT *) 0 ;
19064 int val1 ;
19065 int ecode1 = 0 ;
19066 PLINT temp2 ;
19067 int res2 = SWIG_TMPOBJ ;
19068 PLINT temp3 ;
19069 int res3 = SWIG_TMPOBJ ;
19070 PLINT temp4 ;
19071 int res4 = SWIG_TMPOBJ ;
19072 PLFLT temp5 ;
19073 int res5 = SWIG_TMPOBJ ;
19074 octave_value_list _out;
19075 octave_value_list *_outp=&_out;
19076 octave_value _outv;
19077
19078 try {
19079 arg2 = &temp2;
19080 arg3 = &temp3;
19081 arg4 = &temp4;
19082 arg5 = &temp5;
19083 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19084 SWIG_fail;
19085 }
19086 ecode1 = SWIG_AsVal_int(args(0), &val1);
19087 if (!SWIG_IsOK(ecode1)) {
19088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19089 }
19090 arg1 = static_cast< PLINT >(val1);
19091 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19092 _outv = octave_value();
19093 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19094 if (SWIG_IsTmpObj(res2)) {
19095 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19096 } else {
19097 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19098 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19099 }
19100 if (SWIG_IsTmpObj(res3)) {
19101 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19102 } else {
19103 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19104 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19105 }
19106 if (SWIG_IsTmpObj(res4)) {
19107 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19108 } else {
19109 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19110 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19111 }
19112 if (SWIG_IsTmpObj(res5)) {
19113 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19114 } else {
19115 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19116 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19117 }
19118 return _out;
19119 fail:
19120 return octave_value_list();
19121 }
19122 catch(...) {
19123 throw;
19124 }
19125}
19126
19127
19129 PLINT *arg1 = (PLINT *) 0 ;
19130 PLINT *arg2 = (PLINT *) 0 ;
19131 PLINT *arg3 = (PLINT *) 0 ;
19132 PLINT temp1 ;
19133 int res1 = SWIG_TMPOBJ ;
19134 PLINT temp2 ;
19135 int res2 = SWIG_TMPOBJ ;
19136 PLINT temp3 ;
19137 int res3 = SWIG_TMPOBJ ;
19138 octave_value_list _out;
19139 octave_value_list *_outp=&_out;
19140 octave_value _outv;
19141
19142 try {
19143 arg1 = &temp1;
19144 arg2 = &temp2;
19145 arg3 = &temp3;
19146 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19147 SWIG_fail;
19148 }
19149 plgcolbg(arg1,arg2,arg3);
19150 _outv = octave_value();
19151 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19152 if (SWIG_IsTmpObj(res1)) {
19153 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19154 } else {
19155 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19156 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19157 }
19158 if (SWIG_IsTmpObj(res2)) {
19159 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19160 } else {
19161 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19162 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19163 }
19164 if (SWIG_IsTmpObj(res3)) {
19165 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19166 } else {
19167 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19168 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19169 }
19170 return _out;
19171 fail:
19172 return octave_value_list();
19173 }
19174 catch(...) {
19175 throw;
19176 }
19177}
19178
19179
19181 PLINT *arg1 = (PLINT *) 0 ;
19182 PLINT *arg2 = (PLINT *) 0 ;
19183 PLINT *arg3 = (PLINT *) 0 ;
19184 PLFLT *arg4 = (PLFLT *) 0 ;
19185 PLINT temp1 ;
19186 int res1 = SWIG_TMPOBJ ;
19187 PLINT temp2 ;
19188 int res2 = SWIG_TMPOBJ ;
19189 PLINT temp3 ;
19190 int res3 = SWIG_TMPOBJ ;
19191 PLFLT temp4 ;
19192 int res4 = SWIG_TMPOBJ ;
19193 octave_value_list _out;
19194 octave_value_list *_outp=&_out;
19195 octave_value _outv;
19196
19197 try {
19198 arg1 = &temp1;
19199 arg2 = &temp2;
19200 arg3 = &temp3;
19201 arg4 = &temp4;
19202 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19203 SWIG_fail;
19204 }
19205 plgcolbga(arg1,arg2,arg3,arg4);
19206 _outv = octave_value();
19207 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19208 if (SWIG_IsTmpObj(res1)) {
19209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19210 } else {
19211 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19213 }
19214 if (SWIG_IsTmpObj(res2)) {
19215 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19216 } else {
19217 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19218 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19219 }
19220 if (SWIG_IsTmpObj(res3)) {
19221 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19222 } else {
19223 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19224 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19225 }
19226 if (SWIG_IsTmpObj(res4)) {
19227 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19228 } else {
19229 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19230 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19231 }
19232 return _out;
19233 fail:
19234 return octave_value_list();
19235 }
19236 catch(...) {
19237 throw;
19238 }
19239}
19240
19241
19242SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19243 PLINT *arg1 = (PLINT *) 0 ;
19244 PLINT temp1 ;
19245 int res1 = SWIG_TMPOBJ ;
19246 octave_value_list _out;
19247 octave_value_list *_outp=&_out;
19248 octave_value _outv;
19249
19250 try {
19251 arg1 = &temp1;
19252 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19253 SWIG_fail;
19254 }
19255 plgcompression(arg1);
19256 _outv = octave_value();
19257 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19258 if (SWIG_IsTmpObj(res1)) {
19259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19260 } else {
19261 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19262 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19263 }
19264 return _out;
19265 fail:
19266 return octave_value_list();
19267 }
19268 catch(...) {
19269 throw;
19270 }
19271}
19272
19273
19275 char *arg1 = (char *) 0 ;
19276 char local_string1[80] ;
19277 size_t local_string_length1 ;
19278 charMatrix local_charMatrix1 ;
19279 octave_value_list retval1 ;
19280 octave_value_list _out;
19281 octave_value_list *_outp=&_out;
19282 octave_value _outv;
19283
19284 try {
19285 {
19286 arg1 = local_string1;
19287 }
19288 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19289 SWIG_fail;
19290 }
19291 plgdev(arg1);
19292 _outv = octave_value();
19293 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19294 {
19295 local_string_length1 = strlen( local_string1 );
19296 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19297 local_charMatrix1.insert( local_string1, 0, 0 );
19298 retval1( 0 ) = octave_value( local_charMatrix1 );
19299 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19300 }
19301 return _out;
19302 fail:
19303 return octave_value_list();
19304 }
19305 catch(...) {
19306 throw;
19307 }
19308}
19309
19310
19312 PLFLT *arg1 = (PLFLT *) 0 ;
19313 PLFLT *arg2 = (PLFLT *) 0 ;
19314 PLFLT *arg3 = (PLFLT *) 0 ;
19315 PLFLT *arg4 = (PLFLT *) 0 ;
19316 PLFLT temp1 ;
19317 int res1 = SWIG_TMPOBJ ;
19318 PLFLT temp2 ;
19319 int res2 = SWIG_TMPOBJ ;
19320 PLFLT temp3 ;
19321 int res3 = SWIG_TMPOBJ ;
19322 PLFLT temp4 ;
19323 int res4 = SWIG_TMPOBJ ;
19324 octave_value_list _out;
19325 octave_value_list *_outp=&_out;
19326 octave_value _outv;
19327
19328 try {
19329 arg1 = &temp1;
19330 arg2 = &temp2;
19331 arg3 = &temp3;
19332 arg4 = &temp4;
19333 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19334 SWIG_fail;
19335 }
19336 plgdidev(arg1,arg2,arg3,arg4);
19337 _outv = octave_value();
19338 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19339 if (SWIG_IsTmpObj(res1)) {
19340 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19341 } else {
19342 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19343 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19344 }
19345 if (SWIG_IsTmpObj(res2)) {
19346 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19347 } else {
19348 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19349 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19350 }
19351 if (SWIG_IsTmpObj(res3)) {
19352 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19353 } else {
19354 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19355 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19356 }
19357 if (SWIG_IsTmpObj(res4)) {
19358 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19359 } else {
19360 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19361 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19362 }
19363 return _out;
19364 fail:
19365 return octave_value_list();
19366 }
19367 catch(...) {
19368 throw;
19369 }
19370}
19371
19372
19374 PLFLT *arg1 = (PLFLT *) 0 ;
19375 PLFLT temp1 ;
19376 int res1 = SWIG_TMPOBJ ;
19377 octave_value_list _out;
19378 octave_value_list *_outp=&_out;
19379 octave_value _outv;
19380
19381 try {
19382 arg1 = &temp1;
19383 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19384 SWIG_fail;
19385 }
19386 plgdiori(arg1);
19387 _outv = octave_value();
19388 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19389 if (SWIG_IsTmpObj(res1)) {
19390 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19391 } else {
19392 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19393 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19394 }
19395 return _out;
19396 fail:
19397 return octave_value_list();
19398 }
19399 catch(...) {
19400 throw;
19401 }
19402}
19403
19404
19406 PLFLT *arg1 = (PLFLT *) 0 ;
19407 PLFLT *arg2 = (PLFLT *) 0 ;
19408 PLFLT *arg3 = (PLFLT *) 0 ;
19409 PLFLT *arg4 = (PLFLT *) 0 ;
19410 PLFLT temp1 ;
19411 int res1 = SWIG_TMPOBJ ;
19412 PLFLT temp2 ;
19413 int res2 = SWIG_TMPOBJ ;
19414 PLFLT temp3 ;
19415 int res3 = SWIG_TMPOBJ ;
19416 PLFLT temp4 ;
19417 int res4 = SWIG_TMPOBJ ;
19418 octave_value_list _out;
19419 octave_value_list *_outp=&_out;
19420 octave_value _outv;
19421
19422 try {
19423 arg1 = &temp1;
19424 arg2 = &temp2;
19425 arg3 = &temp3;
19426 arg4 = &temp4;
19427 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19428 SWIG_fail;
19429 }
19430 plgdiplt(arg1,arg2,arg3,arg4);
19431 _outv = octave_value();
19432 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19433 if (SWIG_IsTmpObj(res1)) {
19434 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19435 } else {
19436 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19437 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19438 }
19439 if (SWIG_IsTmpObj(res2)) {
19440 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19441 } else {
19442 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19443 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19444 }
19445 if (SWIG_IsTmpObj(res3)) {
19446 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19447 } else {
19448 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19449 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19450 }
19451 if (SWIG_IsTmpObj(res4)) {
19452 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19453 } else {
19454 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19455 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19456 }
19457 return _out;
19458 fail:
19459 return octave_value_list();
19460 }
19461 catch(...) {
19462 throw;
19463 }
19464}
19465
19466
19468 PLINT *arg1 = (PLINT *) 0 ;
19469 PLINT *arg2 = (PLINT *) 0 ;
19470 PLINT *arg3 = (PLINT *) 0 ;
19471 PLINT temp1 ;
19472 int res1 = SWIG_TMPOBJ ;
19473 PLINT temp2 ;
19474 int res2 = SWIG_TMPOBJ ;
19475 PLINT temp3 ;
19476 int res3 = SWIG_TMPOBJ ;
19477 octave_value_list _out;
19478 octave_value_list *_outp=&_out;
19479 octave_value _outv;
19480
19481 try {
19482 arg1 = &temp1;
19483 arg2 = &temp2;
19484 arg3 = &temp3;
19485 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19486 SWIG_fail;
19487 }
19488 plgfam(arg1,arg2,arg3);
19489 _outv = octave_value();
19490 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19491 if (SWIG_IsTmpObj(res1)) {
19492 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19493 } else {
19494 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19495 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19496 }
19497 if (SWIG_IsTmpObj(res2)) {
19498 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19499 } else {
19500 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19501 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19502 }
19503 if (SWIG_IsTmpObj(res3)) {
19504 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19505 } else {
19506 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19507 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19508 }
19509 return _out;
19510 fail:
19511 return octave_value_list();
19512 }
19513 catch(...) {
19514 throw;
19515 }
19516}
19517
19518
19520 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19521 PLUNICODE temp1 ;
19522 int res1 = SWIG_TMPOBJ ;
19523 octave_value_list _out;
19524 octave_value_list *_outp=&_out;
19525 octave_value _outv;
19526
19527 try {
19528 arg1 = &temp1;
19529 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19530 SWIG_fail;
19531 }
19532 plgfci(arg1);
19533 _outv = octave_value();
19534 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19535 if (SWIG_IsTmpObj(res1)) {
19536 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19537 } else {
19538 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19539 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19540 }
19541 return _out;
19542 fail:
19543 return octave_value_list();
19544 }
19545 catch(...) {
19546 throw;
19547 }
19548}
19549
19550
19552 char *arg1 = (char *) 0 ;
19553 char local_string1[80] ;
19554 size_t local_string_length1 ;
19555 charMatrix local_charMatrix1 ;
19556 octave_value_list retval1 ;
19557 octave_value_list _out;
19558 octave_value_list *_outp=&_out;
19559 octave_value _outv;
19560
19561 try {
19562 {
19563 arg1 = local_string1;
19564 }
19565 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19566 SWIG_fail;
19567 }
19568 plgfnam(arg1);
19569 _outv = octave_value();
19570 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19571 {
19572 local_string_length1 = strlen( local_string1 );
19573 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19574 local_charMatrix1.insert( local_string1, 0, 0 );
19575 retval1( 0 ) = octave_value( local_charMatrix1 );
19576 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19577 }
19578 return _out;
19579 fail:
19580 return octave_value_list();
19581 }
19582 catch(...) {
19583 throw;
19584 }
19585}
19586
19587
19589 PLINT *arg1 = (PLINT *) 0 ;
19590 PLINT *arg2 = (PLINT *) 0 ;
19591 PLINT *arg3 = (PLINT *) 0 ;
19592 PLINT temp1 ;
19593 int res1 = SWIG_TMPOBJ ;
19594 PLINT temp2 ;
19595 int res2 = SWIG_TMPOBJ ;
19596 PLINT temp3 ;
19597 int res3 = SWIG_TMPOBJ ;
19598 octave_value_list _out;
19599 octave_value_list *_outp=&_out;
19600 octave_value _outv;
19601
19602 try {
19603 arg1 = &temp1;
19604 arg2 = &temp2;
19605 arg3 = &temp3;
19606 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19607 SWIG_fail;
19608 }
19609 plgfont(arg1,arg2,arg3);
19610 _outv = octave_value();
19611 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19612 if (SWIG_IsTmpObj(res1)) {
19613 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19614 } else {
19615 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19616 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19617 }
19618 if (SWIG_IsTmpObj(res2)) {
19619 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19620 } else {
19621 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19622 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19623 }
19624 if (SWIG_IsTmpObj(res3)) {
19625 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19626 } else {
19627 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19628 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19629 }
19630 return _out;
19631 fail:
19632 return octave_value_list();
19633 }
19634 catch(...) {
19635 throw;
19636 }
19637}
19638
19639
19641 PLINT *arg1 = (PLINT *) 0 ;
19642 PLINT temp1 ;
19643 int res1 = SWIG_TMPOBJ ;
19644 octave_value_list _out;
19645 octave_value_list *_outp=&_out;
19646 octave_value _outv;
19647
19648 try {
19649 arg1 = &temp1;
19650 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19651 SWIG_fail;
19652 }
19653 plglevel(arg1);
19654 _outv = octave_value();
19655 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19656 if (SWIG_IsTmpObj(res1)) {
19657 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19658 } else {
19659 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19660 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19661 }
19662 return _out;
19663 fail:
19664 return octave_value_list();
19665 }
19666 catch(...) {
19667 throw;
19668 }
19669}
19670
19671
19673 PLFLT *arg1 = (PLFLT *) 0 ;
19674 PLFLT *arg2 = (PLFLT *) 0 ;
19675 PLINT *arg3 = (PLINT *) 0 ;
19676 PLINT *arg4 = (PLINT *) 0 ;
19677 PLINT *arg5 = (PLINT *) 0 ;
19678 PLINT *arg6 = (PLINT *) 0 ;
19679 PLFLT temp1 ;
19680 int res1 = SWIG_TMPOBJ ;
19681 PLFLT temp2 ;
19682 int res2 = SWIG_TMPOBJ ;
19683 PLINT temp3 ;
19684 int res3 = SWIG_TMPOBJ ;
19685 PLINT temp4 ;
19686 int res4 = SWIG_TMPOBJ ;
19687 PLINT temp5 ;
19688 int res5 = SWIG_TMPOBJ ;
19689 PLINT temp6 ;
19690 int res6 = SWIG_TMPOBJ ;
19691 octave_value_list _out;
19692 octave_value_list *_outp=&_out;
19693 octave_value _outv;
19694
19695 try {
19696 arg1 = &temp1;
19697 arg2 = &temp2;
19698 arg3 = &temp3;
19699 arg4 = &temp4;
19700 arg5 = &temp5;
19701 arg6 = &temp6;
19702 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19703 SWIG_fail;
19704 }
19705 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19706 _outv = octave_value();
19707 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19708 if (SWIG_IsTmpObj(res1)) {
19709 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19710 } else {
19711 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19712 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19713 }
19714 if (SWIG_IsTmpObj(res2)) {
19715 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19716 } else {
19717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19718 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19719 }
19720 if (SWIG_IsTmpObj(res3)) {
19721 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19722 } else {
19723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19724 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19725 }
19726 if (SWIG_IsTmpObj(res4)) {
19727 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19728 } else {
19729 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19730 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19731 }
19732 if (SWIG_IsTmpObj(res5)) {
19733 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19734 } else {
19735 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19736 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19737 }
19738 if (SWIG_IsTmpObj(res6)) {
19739 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19740 } else {
19741 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19742 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19743 }
19744 return _out;
19745 fail:
19746 return octave_value_list();
19747 }
19748 catch(...) {
19749 throw;
19750 }
19751}
19752
19753
19755 octave_value_list _out;
19756 octave_value_list *_outp=&_out;
19757 octave_value _outv;
19758
19759 try {
19760 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19761 SWIG_fail;
19762 }
19763 plgra();
19764 _outv = octave_value();
19765 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19766 return _out;
19767 fail:
19768 return octave_value_list();
19769 }
19770 catch(...) {
19771 throw;
19772 }
19773}
19774
19775
19777 PLFLT *arg1 = (PLFLT *) 0 ;
19778 PLFLT *arg2 = (PLFLT *) 0 ;
19779 PLFLT *arg3 = (PLFLT *) 0 ;
19780 PLFLT *arg4 = (PLFLT *) 0 ;
19781 PLFLT temp1 ;
19782 int res1 = SWIG_TMPOBJ ;
19783 PLFLT temp2 ;
19784 int res2 = SWIG_TMPOBJ ;
19785 PLFLT temp3 ;
19786 int res3 = SWIG_TMPOBJ ;
19787 PLFLT temp4 ;
19788 int res4 = SWIG_TMPOBJ ;
19789 octave_value_list _out;
19790 octave_value_list *_outp=&_out;
19791 octave_value _outv;
19792
19793 try {
19794 arg1 = &temp1;
19795 arg2 = &temp2;
19796 arg3 = &temp3;
19797 arg4 = &temp4;
19798 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19799 SWIG_fail;
19800 }
19801 plgspa(arg1,arg2,arg3,arg4);
19802 _outv = octave_value();
19803 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19804 if (SWIG_IsTmpObj(res1)) {
19805 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19806 } else {
19807 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19808 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19809 }
19810 if (SWIG_IsTmpObj(res2)) {
19811 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19812 } else {
19813 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19814 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19815 }
19816 if (SWIG_IsTmpObj(res3)) {
19817 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19818 } else {
19819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19820 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19821 }
19822 if (SWIG_IsTmpObj(res4)) {
19823 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19824 } else {
19825 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19826 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19827 }
19828 return _out;
19829 fail:
19830 return octave_value_list();
19831 }
19832 catch(...) {
19833 throw;
19834 }
19835}
19836
19837
19839 PLINT *arg1 = (PLINT *) 0 ;
19840 PLINT temp1 ;
19841 int res1 = SWIG_TMPOBJ ;
19842 octave_value_list _out;
19843 octave_value_list *_outp=&_out;
19844 octave_value _outv;
19845
19846 try {
19847 arg1 = &temp1;
19848 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19849 SWIG_fail;
19850 }
19851 plgstrm(arg1);
19852 _outv = octave_value();
19853 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19854 if (SWIG_IsTmpObj(res1)) {
19855 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19856 } else {
19857 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19858 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19859 }
19860 return _out;
19861 fail:
19862 return octave_value_list();
19863 }
19864 catch(...) {
19865 throw;
19866 }
19867}
19868
19869
19871 char *arg1 = (char *) 0 ;
19872 char local_string1[80] ;
19873 size_t local_string_length1 ;
19874 charMatrix local_charMatrix1 ;
19875 octave_value_list retval1 ;
19876 octave_value_list _out;
19877 octave_value_list *_outp=&_out;
19878 octave_value _outv;
19879
19880 try {
19881 {
19882 arg1 = local_string1;
19883 }
19884 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19885 SWIG_fail;
19886 }
19887 plgver(arg1);
19888 _outv = octave_value();
19889 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19890 {
19891 local_string_length1 = strlen( local_string1 );
19892 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19893 local_charMatrix1.insert( local_string1, 0, 0 );
19894 retval1( 0 ) = octave_value( local_charMatrix1 );
19895 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19896 }
19897 return _out;
19898 fail:
19899 return octave_value_list();
19900 }
19901 catch(...) {
19902 throw;
19903 }
19904}
19905
19906
19908 PLFLT *arg1 = (PLFLT *) 0 ;
19909 PLFLT *arg2 = (PLFLT *) 0 ;
19910 PLFLT *arg3 = (PLFLT *) 0 ;
19911 PLFLT *arg4 = (PLFLT *) 0 ;
19912 PLFLT temp1 ;
19913 int res1 = SWIG_TMPOBJ ;
19914 PLFLT temp2 ;
19915 int res2 = SWIG_TMPOBJ ;
19916 PLFLT temp3 ;
19917 int res3 = SWIG_TMPOBJ ;
19918 PLFLT temp4 ;
19919 int res4 = SWIG_TMPOBJ ;
19920 octave_value_list _out;
19921 octave_value_list *_outp=&_out;
19922 octave_value _outv;
19923
19924 try {
19925 arg1 = &temp1;
19926 arg2 = &temp2;
19927 arg3 = &temp3;
19928 arg4 = &temp4;
19929 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19930 SWIG_fail;
19931 }
19932 plgvpd(arg1,arg2,arg3,arg4);
19933 _outv = octave_value();
19934 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19935 if (SWIG_IsTmpObj(res1)) {
19936 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19937 } else {
19938 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19939 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19940 }
19941 if (SWIG_IsTmpObj(res2)) {
19942 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19943 } else {
19944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19945 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19946 }
19947 if (SWIG_IsTmpObj(res3)) {
19948 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19949 } else {
19950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19951 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19952 }
19953 if (SWIG_IsTmpObj(res4)) {
19954 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19955 } else {
19956 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19957 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19958 }
19959 return _out;
19960 fail:
19961 return octave_value_list();
19962 }
19963 catch(...) {
19964 throw;
19965 }
19966}
19967
19968
19970 PLFLT *arg1 = (PLFLT *) 0 ;
19971 PLFLT *arg2 = (PLFLT *) 0 ;
19972 PLFLT *arg3 = (PLFLT *) 0 ;
19973 PLFLT *arg4 = (PLFLT *) 0 ;
19974 PLFLT temp1 ;
19975 int res1 = SWIG_TMPOBJ ;
19976 PLFLT temp2 ;
19977 int res2 = SWIG_TMPOBJ ;
19978 PLFLT temp3 ;
19979 int res3 = SWIG_TMPOBJ ;
19980 PLFLT temp4 ;
19981 int res4 = SWIG_TMPOBJ ;
19982 octave_value_list _out;
19983 octave_value_list *_outp=&_out;
19984 octave_value _outv;
19985
19986 try {
19987 arg1 = &temp1;
19988 arg2 = &temp2;
19989 arg3 = &temp3;
19990 arg4 = &temp4;
19991 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19992 SWIG_fail;
19993 }
19994 plgvpw(arg1,arg2,arg3,arg4);
19995 _outv = octave_value();
19996 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19997 if (SWIG_IsTmpObj(res1)) {
19998 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19999 } else {
20000 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20001 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20002 }
20003 if (SWIG_IsTmpObj(res2)) {
20004 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20005 } else {
20006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20007 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20008 }
20009 if (SWIG_IsTmpObj(res3)) {
20010 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
20011 } else {
20012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20013 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
20014 }
20015 if (SWIG_IsTmpObj(res4)) {
20016 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20017 } else {
20018 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20019 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20020 }
20021 return _out;
20022 fail:
20023 return octave_value_list();
20024 }
20025 catch(...) {
20026 throw;
20027 }
20028}
20029
20030
20032 PLINT *arg1 = (PLINT *) 0 ;
20033 PLINT *arg2 = (PLINT *) 0 ;
20034 PLINT temp1 ;
20035 int res1 = SWIG_TMPOBJ ;
20036 PLINT temp2 ;
20037 int res2 = SWIG_TMPOBJ ;
20038 octave_value_list _out;
20039 octave_value_list *_outp=&_out;
20040 octave_value _outv;
20041
20042 try {
20043 arg1 = &temp1;
20044 arg2 = &temp2;
20045 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
20046 SWIG_fail;
20047 }
20048 plgxax(arg1,arg2);
20049 _outv = octave_value();
20050 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20051 if (SWIG_IsTmpObj(res1)) {
20052 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20053 } else {
20054 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20055 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20056 }
20057 if (SWIG_IsTmpObj(res2)) {
20058 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20059 } else {
20060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20061 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20062 }
20063 return _out;
20064 fail:
20065 return octave_value_list();
20066 }
20067 catch(...) {
20068 throw;
20069 }
20070}
20071
20072
20074 PLINT *arg1 = (PLINT *) 0 ;
20075 PLINT *arg2 = (PLINT *) 0 ;
20076 PLINT temp1 ;
20077 int res1 = SWIG_TMPOBJ ;
20078 PLINT temp2 ;
20079 int res2 = SWIG_TMPOBJ ;
20080 octave_value_list _out;
20081 octave_value_list *_outp=&_out;
20082 octave_value _outv;
20083
20084 try {
20085 arg1 = &temp1;
20086 arg2 = &temp2;
20087 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20088 SWIG_fail;
20089 }
20090 plgyax(arg1,arg2);
20091 _outv = octave_value();
20092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20093 if (SWIG_IsTmpObj(res1)) {
20094 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20095 } else {
20096 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20097 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20098 }
20099 if (SWIG_IsTmpObj(res2)) {
20100 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20101 } else {
20102 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20103 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20104 }
20105 return _out;
20106 fail:
20107 return octave_value_list();
20108 }
20109 catch(...) {
20110 throw;
20111 }
20112}
20113
20114
20116 PLINT *arg1 = (PLINT *) 0 ;
20117 PLINT *arg2 = (PLINT *) 0 ;
20118 PLINT temp1 ;
20119 int res1 = SWIG_TMPOBJ ;
20120 PLINT temp2 ;
20121 int res2 = SWIG_TMPOBJ ;
20122 octave_value_list _out;
20123 octave_value_list *_outp=&_out;
20124 octave_value _outv;
20125
20126 try {
20127 arg1 = &temp1;
20128 arg2 = &temp2;
20129 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20130 SWIG_fail;
20131 }
20132 plgzax(arg1,arg2);
20133 _outv = octave_value();
20134 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20135 if (SWIG_IsTmpObj(res1)) {
20136 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20137 } else {
20138 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20139 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20140 }
20141 if (SWIG_IsTmpObj(res2)) {
20142 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20143 } else {
20144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20145 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20146 }
20147 return _out;
20148 fail:
20149 return octave_value_list();
20150 }
20151 catch(...) {
20152 throw;
20153 }
20154}
20155
20156
20158 PLINT arg1 ;
20159 PLFLT *arg2 = (PLFLT *) 0 ;
20160 PLFLT arg3 ;
20161 PLFLT arg4 ;
20162 PLINT arg5 ;
20163 PLINT arg6 ;
20164 Matrix temp1 ;
20165 double val3 ;
20166 int ecode3 = 0 ;
20167 double val4 ;
20168 int ecode4 = 0 ;
20169 int val5 ;
20170 int ecode5 = 0 ;
20171 int val6 ;
20172 int ecode6 = 0 ;
20173 octave_value_list _out;
20174 octave_value_list *_outp=&_out;
20175 octave_value _outv;
20176
20177 try {
20178 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20179 SWIG_fail;
20180 }
20181 {
20182 if ( _n_dims( args(0) ) > 1 )
20183 {
20184 error( "argument must be a scalar or vector" ); SWIG_fail;
20185 }
20186 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20187 temp1 = args(0).matrix_value();
20188 arg2 = &temp1( 0, 0 );
20189 }
20190 ecode3 = SWIG_AsVal_double(args(1), &val3);
20191 if (!SWIG_IsOK(ecode3)) {
20192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20193 }
20194 arg3 = static_cast< PLFLT >(val3);
20195 ecode4 = SWIG_AsVal_double(args(2), &val4);
20196 if (!SWIG_IsOK(ecode4)) {
20197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20198 }
20199 arg4 = static_cast< PLFLT >(val4);
20200 ecode5 = SWIG_AsVal_int(args(3), &val5);
20201 if (!SWIG_IsOK(ecode5)) {
20202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20203 }
20204 arg5 = static_cast< PLINT >(val5);
20205 ecode6 = SWIG_AsVal_int(args(4), &val6);
20206 if (!SWIG_IsOK(ecode6)) {
20207 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20208 }
20209 arg6 = static_cast< PLINT >(val6);
20210 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20211 _outv = octave_value();
20212 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20213 {
20214
20215 }
20216 return _out;
20217 fail:
20218 {
20219
20220 }
20221 return octave_value_list();
20222 }
20223 catch(...) {
20224 {
20225
20226 }
20227 throw;
20228 }
20229}
20230
20231
20233 PLFLT arg1 ;
20234 PLFLT arg2 ;
20235 PLFLT arg3 ;
20236 PLFLT *arg4 = (PLFLT *) 0 ;
20237 PLFLT *arg5 = (PLFLT *) 0 ;
20238 PLFLT *arg6 = (PLFLT *) 0 ;
20239 double val1 ;
20240 int ecode1 = 0 ;
20241 double val2 ;
20242 int ecode2 = 0 ;
20243 double val3 ;
20244 int ecode3 = 0 ;
20245 PLFLT temp4 ;
20246 int res4 = SWIG_TMPOBJ ;
20247 PLFLT temp5 ;
20248 int res5 = SWIG_TMPOBJ ;
20249 PLFLT temp6 ;
20250 int res6 = SWIG_TMPOBJ ;
20251 octave_value_list _out;
20252 octave_value_list *_outp=&_out;
20253 octave_value _outv;
20254
20255 try {
20256 arg4 = &temp4;
20257 arg5 = &temp5;
20258 arg6 = &temp6;
20259 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20260 SWIG_fail;
20261 }
20262 ecode1 = SWIG_AsVal_double(args(0), &val1);
20263 if (!SWIG_IsOK(ecode1)) {
20264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20265 }
20266 arg1 = static_cast< PLFLT >(val1);
20267 ecode2 = SWIG_AsVal_double(args(1), &val2);
20268 if (!SWIG_IsOK(ecode2)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20270 }
20271 arg2 = static_cast< PLFLT >(val2);
20272 ecode3 = SWIG_AsVal_double(args(2), &val3);
20273 if (!SWIG_IsOK(ecode3)) {
20274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20275 }
20276 arg3 = static_cast< PLFLT >(val3);
20277 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20278 _outv = octave_value();
20279 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20280 if (SWIG_IsTmpObj(res4)) {
20281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20282 } else {
20283 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20285 }
20286 if (SWIG_IsTmpObj(res5)) {
20287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20288 } else {
20289 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20291 }
20292 if (SWIG_IsTmpObj(res6)) {
20293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20294 } else {
20295 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20296 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20297 }
20298 return _out;
20299 fail:
20300 return octave_value_list();
20301 }
20302 catch(...) {
20303 throw;
20304 }
20305}
20306
20307
20309 octave_value_list _out;
20310 octave_value_list *_outp=&_out;
20311 octave_value _outv;
20312
20313 try {
20314 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20315 SWIG_fail;
20316 }
20317 plinit();
20318 _outv = octave_value();
20319 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20320 return _out;
20321 fail:
20322 return octave_value_list();
20323 }
20324 catch(...) {
20325 throw;
20326 }
20327}
20328
20329
20331 PLFLT arg1 ;
20332 PLFLT arg2 ;
20333 PLFLT arg3 ;
20334 PLFLT arg4 ;
20335 double val1 ;
20336 int ecode1 = 0 ;
20337 double val2 ;
20338 int ecode2 = 0 ;
20339 double val3 ;
20340 int ecode3 = 0 ;
20341 double val4 ;
20342 int ecode4 = 0 ;
20343 octave_value_list _out;
20344 octave_value_list *_outp=&_out;
20345 octave_value _outv;
20346
20347 try {
20348 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20349 SWIG_fail;
20350 }
20351 ecode1 = SWIG_AsVal_double(args(0), &val1);
20352 if (!SWIG_IsOK(ecode1)) {
20353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20354 }
20355 arg1 = static_cast< PLFLT >(val1);
20356 ecode2 = SWIG_AsVal_double(args(1), &val2);
20357 if (!SWIG_IsOK(ecode2)) {
20358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20359 }
20360 arg2 = static_cast< PLFLT >(val2);
20361 ecode3 = SWIG_AsVal_double(args(2), &val3);
20362 if (!SWIG_IsOK(ecode3)) {
20363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20364 }
20365 arg3 = static_cast< PLFLT >(val3);
20366 ecode4 = SWIG_AsVal_double(args(3), &val4);
20367 if (!SWIG_IsOK(ecode4)) {
20368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20369 }
20370 arg4 = static_cast< PLFLT >(val4);
20371 pljoin(arg1,arg2,arg3,arg4);
20372 _outv = octave_value();
20373 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20374 return _out;
20375 fail:
20376 return octave_value_list();
20377 }
20378 catch(...) {
20379 throw;
20380 }
20381}
20382
20383
20385 char *arg1 = (char *) 0 ;
20386 char *arg2 = (char *) 0 ;
20387 char *arg3 = (char *) 0 ;
20388 int res1 ;
20389 char *buf1 = 0 ;
20390 int alloc1 = 0 ;
20391 int res2 ;
20392 char *buf2 = 0 ;
20393 int alloc2 = 0 ;
20394 int res3 ;
20395 char *buf3 = 0 ;
20396 int alloc3 = 0 ;
20397 octave_value_list _out;
20398 octave_value_list *_outp=&_out;
20399 octave_value _outv;
20400
20401 try {
20402 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20403 SWIG_fail;
20404 }
20405 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20406 if (!SWIG_IsOK(res1)) {
20407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20408 }
20409 arg1 = reinterpret_cast< char * >(buf1);
20410 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20411 if (!SWIG_IsOK(res2)) {
20412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20413 }
20414 arg2 = reinterpret_cast< char * >(buf2);
20415 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20416 if (!SWIG_IsOK(res3)) {
20417 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20418 }
20419 arg3 = reinterpret_cast< char * >(buf3);
20420 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20421 _outv = octave_value();
20422 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20423 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20424 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20425 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20426 return _out;
20427 fail:
20428 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20429 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20430 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20431 return octave_value_list();
20432 }
20433 catch(...) {
20434 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20435 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20436 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20437 throw;
20438 }
20439}
20440
20441
20443 PLFLT *arg1 = (PLFLT *) 0 ;
20444 PLFLT *arg2 = (PLFLT *) 0 ;
20445 PLINT arg3 ;
20446 PLINT arg4 ;
20447 PLFLT arg5 ;
20448 PLFLT arg6 ;
20449 PLFLT arg7 ;
20450 PLINT arg8 ;
20451 PLINT arg9 ;
20452 PLINT arg10 ;
20453 PLINT arg11 ;
20454 PLINT arg12 ;
20455 PLINT arg13 ;
20456 PLINT *arg14 = (PLINT *) 0 ;
20457 PLFLT arg15 ;
20458 PLFLT arg16 ;
20459 PLFLT arg17 ;
20460 PLFLT arg18 ;
20461 PLINT *arg19 = (PLINT *) 0 ;
20462 char **arg20 = (char **) 0 ;
20463 PLINT *arg21 = (PLINT *) 0 ;
20464 PLINT *arg22 = (PLINT *) 0 ;
20465 PLFLT *arg23 = (PLFLT *) 0 ;
20466 PLFLT *arg24 = (PLFLT *) 0 ;
20467 PLINT *arg25 = (PLINT *) 0 ;
20468 PLINT *arg26 = (PLINT *) 0 ;
20469 PLFLT *arg27 = (PLFLT *) 0 ;
20470 PLINT *arg28 = (PLINT *) 0 ;
20471 PLFLT *arg29 = (PLFLT *) 0 ;
20472 PLINT *arg30 = (PLINT *) 0 ;
20473 char **arg31 = (char **) 0 ;
20474 PLFLT temp1 ;
20475 int res1 = SWIG_TMPOBJ ;
20476 PLFLT temp2 ;
20477 int res2 = SWIG_TMPOBJ ;
20478 int val3 ;
20479 int ecode3 = 0 ;
20480 int val4 ;
20481 int ecode4 = 0 ;
20482 double val5 ;
20483 int ecode5 = 0 ;
20484 double val6 ;
20485 int ecode6 = 0 ;
20486 double val7 ;
20487 int ecode7 = 0 ;
20488 int val8 ;
20489 int ecode8 = 0 ;
20490 int val9 ;
20491 int ecode9 = 0 ;
20492 int val10 ;
20493 int ecode10 = 0 ;
20494 int val11 ;
20495 int ecode11 = 0 ;
20496 int val12 ;
20497 int ecode12 = 0 ;
20498 Matrix temp13 ;
20499 double val15 ;
20500 int ecode15 = 0 ;
20501 double val16 ;
20502 int ecode16 = 0 ;
20503 double val17 ;
20504 int ecode17 = 0 ;
20505 double val18 ;
20506 int ecode18 = 0 ;
20507 Matrix temp19 ;
20508 Matrix temp21 ;
20509 Matrix temp22 ;
20510 Matrix temp23 ;
20511 Matrix temp24 ;
20512 Matrix temp25 ;
20513 Matrix temp26 ;
20514 Matrix temp27 ;
20515 Matrix temp28 ;
20516 Matrix temp29 ;
20517 Matrix temp30 ;
20518 octave_value_list _out;
20519 octave_value_list *_outp=&_out;
20520 octave_value _outv;
20521
20522 try {
20523 arg1 = &temp1;
20524 arg2 = &temp2;
20525 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20526 SWIG_fail;
20527 }
20528 ecode3 = SWIG_AsVal_int(args(0), &val3);
20529 if (!SWIG_IsOK(ecode3)) {
20530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20531 }
20532 arg3 = static_cast< PLINT >(val3);
20533 ecode4 = SWIG_AsVal_int(args(1), &val4);
20534 if (!SWIG_IsOK(ecode4)) {
20535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20536 }
20537 arg4 = static_cast< PLINT >(val4);
20538 ecode5 = SWIG_AsVal_double(args(2), &val5);
20539 if (!SWIG_IsOK(ecode5)) {
20540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20541 }
20542 arg5 = static_cast< PLFLT >(val5);
20543 ecode6 = SWIG_AsVal_double(args(3), &val6);
20544 if (!SWIG_IsOK(ecode6)) {
20545 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20546 }
20547 arg6 = static_cast< PLFLT >(val6);
20548 ecode7 = SWIG_AsVal_double(args(4), &val7);
20549 if (!SWIG_IsOK(ecode7)) {
20550 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20551 }
20552 arg7 = static_cast< PLFLT >(val7);
20553 ecode8 = SWIG_AsVal_int(args(5), &val8);
20554 if (!SWIG_IsOK(ecode8)) {
20555 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20556 }
20557 arg8 = static_cast< PLINT >(val8);
20558 ecode9 = SWIG_AsVal_int(args(6), &val9);
20559 if (!SWIG_IsOK(ecode9)) {
20560 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20561 }
20562 arg9 = static_cast< PLINT >(val9);
20563 ecode10 = SWIG_AsVal_int(args(7), &val10);
20564 if (!SWIG_IsOK(ecode10)) {
20565 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20566 }
20567 arg10 = static_cast< PLINT >(val10);
20568 ecode11 = SWIG_AsVal_int(args(8), &val11);
20569 if (!SWIG_IsOK(ecode11)) {
20570 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20571 }
20572 arg11 = static_cast< PLINT >(val11);
20573 ecode12 = SWIG_AsVal_int(args(9), &val12);
20574 if (!SWIG_IsOK(ecode12)) {
20575 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20576 }
20577 arg12 = static_cast< PLINT >(val12);
20578 {
20579 if ( _n_dims( args(10) ) > 1 )
20580 {
20581 error( "argument must be a scalar or vector" ); SWIG_fail;
20582 }
20583 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20584 arg14 = new PLINT[Alen];
20585 temp13 = args(10).matrix_value();
20586 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20587 }
20588 ecode15 = SWIG_AsVal_double(args(11), &val15);
20589 if (!SWIG_IsOK(ecode15)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20591 }
20592 arg15 = static_cast< PLFLT >(val15);
20593 ecode16 = SWIG_AsVal_double(args(12), &val16);
20594 if (!SWIG_IsOK(ecode16)) {
20595 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20596 }
20597 arg16 = static_cast< PLFLT >(val16);
20598 ecode17 = SWIG_AsVal_double(args(13), &val17);
20599 if (!SWIG_IsOK(ecode17)) {
20600 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20601 }
20602 arg17 = static_cast< PLFLT >(val17);
20603 ecode18 = SWIG_AsVal_double(args(14), &val18);
20604 if (!SWIG_IsOK(ecode18)) {
20605 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20606 }
20607 arg18 = static_cast< PLFLT >(val18);
20608 {
20609 if ( _n_dims( args(15) ) > 1 )
20610 {
20611 error( "argument must be a scalar or vector" ); SWIG_fail;
20612 }
20613 if ( _dim( args(15), 0 ) != Alen )
20614 {
20615 error( "argument vectors must be same length" ); SWIG_fail;
20616 }
20617 temp19 = args(15).matrix_value();
20618 arg19 = new PLINT[Alen];
20619 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20620 }
20621 {
20622 charMatrix temp_matrix;
20623 Cell temp_cell;
20624 char *tmp_cstring;
20625 std::string str;
20626 size_t max_length = 0, non_blank_length;
20627 int i, ifcell;
20628 if ( _n_dims( args(16) ) > 2 )
20629 {
20630 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20631 }
20632#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20633 if ( !args(16).isempty() )
20634#else
20635 if ( !args(16).is_empty() )
20636#endif
20637 {
20638 if ( _dim( args(16), 0 ) != Alen )
20639 {
20640 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20641 }
20642 arg20 = new char*[Alen];
20643#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20644 ifcell = args(16).iscell();
20645#else
20646 ifcell = args(16).is_cell();
20647#endif
20648 if ( ifcell )
20649 {
20650 temp_cell = args(16).cell_value();
20651 }
20652 else
20653 {
20654 temp_matrix = args(16).char_matrix_value();
20655 // Allow one extra space for null termination.
20656 max_length = _dim( args(16), 1 ) + 1;
20657 }
20658
20659 for ( i = 0; i < Alen; i++ )
20660 {
20661 // Must copy string to "permanent" location because the string
20662 // location corresponding to tmp_cstring gets
20663 // overwritten for each iteration of loop.
20664 if ( ifcell )
20665 {
20666 if ( temp_cell.elem( i ).is_string() )
20667 {
20668 str = temp_cell.elem( i ).string_value();
20669 // leave room for null termination.
20670 max_length = str.size() + 1;
20671 tmp_cstring = (char *) str.c_str();
20672 }
20673 else
20674 {
20675 // Use null string if user attempts to pass a cell array
20676 // with a non-string element (likely an empty element
20677 // since that should be allowed by the PLplot interface
20678 // if that element is going to be unused).
20679 // leave room for null termination.
20680 max_length = 1;
20681 tmp_cstring = (char *) "";
20682 }
20683 }
20684 else
20685 {
20686 str = temp_matrix.row_as_string( i );
20687 tmp_cstring = (char *) str.c_str();
20688 }
20689 arg20[i] = new char[max_length];
20690 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20691 arg20[i][max_length - 1] = '\0';
20692 // All the trailing blank crapola should not be needed for
20693 // string cell arrays.
20694 if ( !ifcell )
20695 {
20696 // remove trailing-blank padding that is used by the
20697 // charMatrix class to insure all strings in a given
20698 // charMatrix instance have the same length.
20699 // This transformation also removes legitimate trailing
20700 // blanks but there is nothing we can do about that
20701 // for the charMatrix class.
20702
20703 // Look for trailing nulls first (just in case, although that
20704 // shouldn't happen if charMatrix implemented as documented)
20705 // before looking for trailing blanks.
20706 non_blank_length = max_length - 2;
20707 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20708 {
20709 non_blank_length--;
20710 }
20711 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20712 {
20713 non_blank_length--;
20714 }
20715 arg20[i][non_blank_length + 1] = '\0';
20716 }
20717 }
20718 }
20719 else
20720 {
20721 arg20 = NULL;
20722 }
20723 }
20724 {
20725 if ( _n_dims( args(17) ) > 1 )
20726 {
20727 error( "argument must be a scalar or vector" ); SWIG_fail;
20728 }
20729#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20730 if ( !args(17).isempty() )
20731#else
20732 if ( !args(17).is_empty() )
20733#endif
20734 {
20735 if ( _dim( args(17), 0 ) != Alen )
20736 {
20737 error( "argument vectors must be same length" ); SWIG_fail;
20738 }
20739 temp21 = args(17).matrix_value();
20740 arg21 = new PLINT[Alen];
20741 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20742 }
20743 else
20744 {
20745 arg21 = NULL;
20746 }
20747 }
20748 {
20749 if ( _n_dims( args(18) ) > 1 )
20750 {
20751 error( "argument must be a scalar or vector" ); SWIG_fail;
20752 }
20753#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20754 if ( !args(18).isempty() )
20755#else
20756 if ( !args(18).is_empty() )
20757#endif
20758 {
20759 if ( _dim( args(18), 0 ) != Alen )
20760 {
20761 error( "argument vectors must be same length" ); SWIG_fail;
20762 }
20763 temp22 = args(18).matrix_value();
20764 arg22 = new PLINT[Alen];
20765 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20766 }
20767 else
20768 {
20769 arg22 = NULL;
20770 }
20771 }
20772 {
20773 if ( _n_dims( args(19) ) > 1 )
20774 {
20775 error( "argument must be a scalar or vector" ); SWIG_fail;
20776 }
20777#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20778 if ( !args(19).isempty() )
20779#else
20780 if ( !args(19).is_empty() )
20781#endif
20782 {
20783 if ( _dim( args(19), 0 ) != Alen )
20784 {
20785 error( "argument vectors must be same length" ); SWIG_fail;
20786 }
20787 temp23 = args(19).matrix_value();
20788 arg23 = &temp23( 0, 0 );
20789 }
20790 else
20791 {
20792 arg23 = NULL;
20793 }
20794 }
20795 {
20796 if ( _n_dims( args(20) ) > 1 )
20797 {
20798 error( "argument must be a scalar or vector" ); SWIG_fail;
20799 }
20800#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20801 if ( !args(20).isempty() )
20802#else
20803 if ( !args(20).is_empty() )
20804#endif
20805 {
20806 if ( _dim( args(20), 0 ) != Alen )
20807 {
20808 error( "argument vectors must be same length" ); SWIG_fail;
20809 }
20810 temp24 = args(20).matrix_value();
20811 arg24 = &temp24( 0, 0 );
20812 }
20813 else
20814 {
20815 arg24 = NULL;
20816 }
20817 }
20818 {
20819 if ( _n_dims( args(21) ) > 1 )
20820 {
20821 error( "argument must be a scalar or vector" ); SWIG_fail;
20822 }
20823#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20824 if ( !args(21).isempty() )
20825#else
20826 if ( !args(21).is_empty() )
20827#endif
20828 {
20829 if ( _dim( args(21), 0 ) != Alen )
20830 {
20831 error( "argument vectors must be same length" ); SWIG_fail;
20832 }
20833 temp25 = args(21).matrix_value();
20834 arg25 = new PLINT[Alen];
20835 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20836 }
20837 else
20838 {
20839 arg25 = NULL;
20840 }
20841 }
20842 {
20843 if ( _n_dims( args(22) ) > 1 )
20844 {
20845 error( "argument must be a scalar or vector" ); SWIG_fail;
20846 }
20847#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20848 if ( !args(22).isempty() )
20849#else
20850 if ( !args(22).is_empty() )
20851#endif
20852 {
20853 if ( _dim( args(22), 0 ) != Alen )
20854 {
20855 error( "argument vectors must be same length" ); SWIG_fail;
20856 }
20857 temp26 = args(22).matrix_value();
20858 arg26 = new PLINT[Alen];
20859 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20860 }
20861 else
20862 {
20863 arg26 = NULL;
20864 }
20865 }
20866 {
20867 if ( _n_dims( args(23) ) > 1 )
20868 {
20869 error( "argument must be a scalar or vector" ); SWIG_fail;
20870 }
20871#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20872 if ( !args(23).isempty() )
20873#else
20874 if ( !args(23).is_empty() )
20875#endif
20876 {
20877 if ( _dim( args(23), 0 ) != Alen )
20878 {
20879 error( "argument vectors must be same length" ); SWIG_fail;
20880 }
20881 temp27 = args(23).matrix_value();
20882 arg27 = &temp27( 0, 0 );
20883 }
20884 else
20885 {
20886 arg27 = NULL;
20887 }
20888 }
20889 {
20890 if ( _n_dims( args(24) ) > 1 )
20891 {
20892 error( "argument must be a scalar or vector" ); SWIG_fail;
20893 }
20894#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20895 if ( !args(24).isempty() )
20896#else
20897 if ( !args(24).is_empty() )
20898#endif
20899 {
20900 if ( _dim( args(24), 0 ) != Alen )
20901 {
20902 error( "argument vectors must be same length" ); SWIG_fail;
20903 }
20904 temp28 = args(24).matrix_value();
20905 arg28 = new PLINT[Alen];
20906 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20907 }
20908 else
20909 {
20910 arg28 = NULL;
20911 }
20912 }
20913 {
20914 if ( _n_dims( args(25) ) > 1 )
20915 {
20916 error( "argument must be a scalar or vector" ); SWIG_fail;
20917 }
20918#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20919 if ( !args(25).isempty() )
20920#else
20921 if ( !args(25).is_empty() )
20922#endif
20923 {
20924 if ( _dim( args(25), 0 ) != Alen )
20925 {
20926 error( "argument vectors must be same length" ); SWIG_fail;
20927 }
20928 temp29 = args(25).matrix_value();
20929 arg29 = &temp29( 0, 0 );
20930 }
20931 else
20932 {
20933 arg29 = NULL;
20934 }
20935 }
20936 {
20937 if ( _n_dims( args(26) ) > 1 )
20938 {
20939 error( "argument must be a scalar or vector" ); SWIG_fail;
20940 }
20941#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20942 if ( !args(26).isempty() )
20943#else
20944 if ( !args(26).is_empty() )
20945#endif
20946 {
20947 if ( _dim( args(26), 0 ) != Alen )
20948 {
20949 error( "argument vectors must be same length" ); SWIG_fail;
20950 }
20951 temp30 = args(26).matrix_value();
20952 arg30 = new PLINT[Alen];
20953 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20954 }
20955 else
20956 {
20957 arg30 = NULL;
20958 }
20959 }
20960 {
20961 charMatrix temp_matrix;
20962 Cell temp_cell;
20963 char *tmp_cstring;
20964 std::string str;
20965 size_t max_length = 0, non_blank_length;
20966 int i, ifcell;
20967 if ( _n_dims( args(27) ) > 2 )
20968 {
20969 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20970 }
20971#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20972 if ( !args(27).isempty() )
20973#else
20974 if ( !args(27).is_empty() )
20975#endif
20976 {
20977 if ( _dim( args(27), 0 ) != Alen )
20978 {
20979 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20980 }
20981 arg31 = new char*[Alen];
20982#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20983 ifcell = args(27).iscell();
20984#else
20985 ifcell = args(27).is_cell();
20986#endif
20987 if ( ifcell )
20988 {
20989 temp_cell = args(27).cell_value();
20990 }
20991 else
20992 {
20993 temp_matrix = args(27).char_matrix_value();
20994 // Allow one extra space for null termination.
20995 max_length = _dim( args(27), 1 ) + 1;
20996 }
20997
20998 for ( i = 0; i < Alen; i++ )
20999 {
21000 // Must copy string to "permanent" location because the string
21001 // location corresponding to tmp_cstring gets
21002 // overwritten for each iteration of loop.
21003 if ( ifcell )
21004 {
21005 if ( temp_cell.elem( i ).is_string() )
21006 {
21007 str = temp_cell.elem( i ).string_value();
21008 // leave room for null termination.
21009 max_length = str.size() + 1;
21010 tmp_cstring = (char *) str.c_str();
21011 }
21012 else
21013 {
21014 // Use null string if user attempts to pass a cell array
21015 // with a non-string element (likely an empty element
21016 // since that should be allowed by the PLplot interface
21017 // if that element is going to be unused).
21018 // leave room for null termination.
21019 max_length = 1;
21020 tmp_cstring = (char *) "";
21021 }
21022 }
21023 else
21024 {
21025 str = temp_matrix.row_as_string( i );
21026 tmp_cstring = (char *) str.c_str();
21027 }
21028 arg31[i] = new char[max_length];
21029 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21030 arg31[i][max_length - 1] = '\0';
21031 // All the trailing blank crapola should not be needed for
21032 // string cell arrays.
21033 if ( !ifcell )
21034 {
21035 // remove trailing-blank padding that is used by the
21036 // charMatrix class to insure all strings in a given
21037 // charMatrix instance have the same length.
21038 // This transformation also removes legitimate trailing
21039 // blanks but there is nothing we can do about that
21040 // for the charMatrix class.
21041
21042 // Look for trailing nulls first (just in case, although that
21043 // shouldn't happen if charMatrix implemented as documented)
21044 // before looking for trailing blanks.
21045 non_blank_length = max_length - 2;
21046 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
21047 {
21048 non_blank_length--;
21049 }
21050 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
21051 {
21052 non_blank_length--;
21053 }
21054 arg31[i][non_blank_length + 1] = '\0';
21055 }
21056 }
21057 }
21058 else
21059 {
21060 arg31 = NULL;
21061 }
21062 }
21063 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);
21064 _outv = octave_value();
21065 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21066 if (SWIG_IsTmpObj(res1)) {
21067 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21068 } else {
21069 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21070 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21071 }
21072 if (SWIG_IsTmpObj(res2)) {
21073 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21074 } else {
21075 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21076 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21077 }
21078 {
21079 delete [] arg14;
21080 }
21081 {
21082 delete [] arg19;
21083 }
21084 {
21085 int i;
21086 if ( arg20 != NULL )
21087 {
21088 for ( i = 0; i < Alen; i++ )
21089 {
21090 delete[] arg20[i];
21091 }
21092 delete[] arg20;
21093 }
21094 }
21095 {
21096 if ( arg21 != NULL )
21097 delete [] arg21;
21098 }
21099 {
21100 if ( arg22 != NULL )
21101 delete [] arg22;
21102 }
21103 {
21104
21105 }
21106 {
21107
21108 }
21109 {
21110 if ( arg25 != NULL )
21111 delete [] arg25;
21112 }
21113 {
21114 if ( arg26 != NULL )
21115 delete [] arg26;
21116 }
21117 {
21118
21119 }
21120 {
21121 if ( arg28 != NULL )
21122 delete [] arg28;
21123 }
21124 {
21125
21126 }
21127 {
21128 if ( arg30 != NULL )
21129 delete [] arg30;
21130 }
21131 {
21132 int i;
21133 if ( arg31 != NULL )
21134 {
21135 for ( i = 0; i < Alen; i++ )
21136 {
21137 delete[] arg31[i];
21138 }
21139 delete[] arg31;
21140 }
21141 }
21142 return _out;
21143 fail:
21144 {
21145 delete [] arg14;
21146 }
21147 {
21148 delete [] arg19;
21149 }
21150 {
21151 int i;
21152 if ( arg20 != NULL )
21153 {
21154 for ( i = 0; i < Alen; i++ )
21155 {
21156 delete[] arg20[i];
21157 }
21158 delete[] arg20;
21159 }
21160 }
21161 {
21162 if ( arg21 != NULL )
21163 delete [] arg21;
21164 }
21165 {
21166 if ( arg22 != NULL )
21167 delete [] arg22;
21168 }
21169 {
21170
21171 }
21172 {
21173
21174 }
21175 {
21176 if ( arg25 != NULL )
21177 delete [] arg25;
21178 }
21179 {
21180 if ( arg26 != NULL )
21181 delete [] arg26;
21182 }
21183 {
21184
21185 }
21186 {
21187 if ( arg28 != NULL )
21188 delete [] arg28;
21189 }
21190 {
21191
21192 }
21193 {
21194 if ( arg30 != NULL )
21195 delete [] arg30;
21196 }
21197 {
21198 int i;
21199 if ( arg31 != NULL )
21200 {
21201 for ( i = 0; i < Alen; i++ )
21202 {
21203 delete[] arg31[i];
21204 }
21205 delete[] arg31;
21206 }
21207 }
21208 return octave_value_list();
21209 }
21210 catch(...) {
21211 {
21212 delete [] arg14;
21213 }
21214 {
21215 delete [] arg19;
21216 }
21217 {
21218 int i;
21219 if ( arg20 != NULL )
21220 {
21221 for ( i = 0; i < Alen; i++ )
21222 {
21223 delete[] arg20[i];
21224 }
21225 delete[] arg20;
21226 }
21227 }
21228 {
21229 if ( arg21 != NULL )
21230 delete [] arg21;
21231 }
21232 {
21233 if ( arg22 != NULL )
21234 delete [] arg22;
21235 }
21236 {
21237
21238 }
21239 {
21240
21241 }
21242 {
21243 if ( arg25 != NULL )
21244 delete [] arg25;
21245 }
21246 {
21247 if ( arg26 != NULL )
21248 delete [] arg26;
21249 }
21250 {
21251
21252 }
21253 {
21254 if ( arg28 != NULL )
21255 delete [] arg28;
21256 }
21257 {
21258
21259 }
21260 {
21261 if ( arg30 != NULL )
21262 delete [] arg30;
21263 }
21264 {
21265 int i;
21266 if ( arg31 != NULL )
21267 {
21268 for ( i = 0; i < Alen; i++ )
21269 {
21270 delete[] arg31[i];
21271 }
21272 delete[] arg31;
21273 }
21274 }
21275 throw;
21276 }
21277}
21278
21279
21281 PLFLT arg1 ;
21282 PLFLT arg2 ;
21283 PLFLT arg3 ;
21284 double val1 ;
21285 int ecode1 = 0 ;
21286 double val2 ;
21287 int ecode2 = 0 ;
21288 double val3 ;
21289 int ecode3 = 0 ;
21290 octave_value_list _out;
21291 octave_value_list *_outp=&_out;
21292 octave_value _outv;
21293
21294 try {
21295 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21296 SWIG_fail;
21297 }
21298 ecode1 = SWIG_AsVal_double(args(0), &val1);
21299 if (!SWIG_IsOK(ecode1)) {
21300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21301 }
21302 arg1 = static_cast< PLFLT >(val1);
21303 ecode2 = SWIG_AsVal_double(args(1), &val2);
21304 if (!SWIG_IsOK(ecode2)) {
21305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21306 }
21307 arg2 = static_cast< PLFLT >(val2);
21308 ecode3 = SWIG_AsVal_double(args(2), &val3);
21309 if (!SWIG_IsOK(ecode3)) {
21310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21311 }
21312 arg3 = static_cast< PLFLT >(val3);
21313 pllightsource(arg1,arg2,arg3);
21314 _outv = octave_value();
21315 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21316 return _out;
21317 fail:
21318 return octave_value_list();
21319 }
21320 catch(...) {
21321 throw;
21322 }
21323}
21324
21325
21327 PLINT arg1 ;
21328 PLFLT *arg2 = (PLFLT *) 0 ;
21329 PLFLT *arg3 = (PLFLT *) 0 ;
21330 Matrix temp1 ;
21331 Matrix temp3 ;
21332 octave_value_list _out;
21333 octave_value_list *_outp=&_out;
21334 octave_value _outv;
21335
21336 try {
21337 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21338 SWIG_fail;
21339 }
21340 {
21341 if ( _n_dims( args(0) ) > 1 )
21342 {
21343 error( "argument must be a scalar or vector" ); SWIG_fail;
21344 }
21345 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21346 temp1 = args(0).matrix_value();
21347 arg2 = &temp1( 0, 0 );
21348 }
21349 {
21350 if ( _n_dims( args(1) ) > 1 )
21351 {
21352 error( "argument must be a scalar or vector" ); SWIG_fail;
21353 }
21354 if ( _dim( args(1), 0 ) != Alen )
21355 {
21356 error( "argument vectors must be same length" ); SWIG_fail;
21357 }
21358 temp3 = args(1).matrix_value();
21359 arg3 = &temp3( 0, 0 );
21360 }
21361 plline(arg1,(double const *)arg2,(double const *)arg3);
21362 _outv = octave_value();
21363 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21364 {
21365
21366 }
21367 {
21368
21369 }
21370 return _out;
21371 fail:
21372 {
21373
21374 }
21375 {
21376
21377 }
21378 return octave_value_list();
21379 }
21380 catch(...) {
21381 {
21382
21383 }
21384 {
21385
21386 }
21387 throw;
21388 }
21389}
21390
21391
21393 PLINT arg1 ;
21394 PLFLT *arg2 = (PLFLT *) 0 ;
21395 PLFLT *arg3 = (PLFLT *) 0 ;
21396 PLFLT *arg4 = (PLFLT *) 0 ;
21397 Matrix temp1 ;
21398 Matrix temp3 ;
21399 Matrix temp4 ;
21400 octave_value_list _out;
21401 octave_value_list *_outp=&_out;
21402 octave_value _outv;
21403
21404 try {
21405 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21406 SWIG_fail;
21407 }
21408 {
21409 if ( _n_dims( args(0) ) > 1 )
21410 {
21411 error( "argument must be a scalar or vector" ); SWIG_fail;
21412 }
21413 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21414 temp1 = args(0).matrix_value();
21415 arg2 = &temp1( 0, 0 );
21416 }
21417 {
21418 if ( _n_dims( args(1) ) > 1 )
21419 {
21420 error( "argument must be a scalar or vector" ); SWIG_fail;
21421 }
21422 if ( _dim( args(1), 0 ) != Alen )
21423 {
21424 error( "argument vectors must be same length" ); SWIG_fail;
21425 }
21426 temp3 = args(1).matrix_value();
21427 arg3 = &temp3( 0, 0 );
21428 }
21429 {
21430 if ( _n_dims( args(2) ) > 1 )
21431 {
21432 error( "argument must be a scalar or vector" ); SWIG_fail;
21433 }
21434 if ( _dim( args(2), 0 ) != Alen )
21435 {
21436 error( "argument vectors must be same length" ); SWIG_fail;
21437 }
21438 temp4 = args(2).matrix_value();
21439 arg4 = &temp4( 0, 0 );
21440 }
21441 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21442 _outv = octave_value();
21443 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21444 {
21445
21446 }
21447 {
21448
21449 }
21450 {
21451
21452 }
21453 return _out;
21454 fail:
21455 {
21456
21457 }
21458 {
21459
21460 }
21461 {
21462
21463 }
21464 return octave_value_list();
21465 }
21466 catch(...) {
21467 {
21468
21469 }
21470 {
21471
21472 }
21473 {
21474
21475 }
21476 throw;
21477 }
21478}
21479
21480
21482 PLINT arg1 ;
21483 int val1 ;
21484 int ecode1 = 0 ;
21485 octave_value_list _out;
21486 octave_value_list *_outp=&_out;
21487 octave_value _outv;
21488
21489 try {
21490 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21491 SWIG_fail;
21492 }
21493 ecode1 = SWIG_AsVal_int(args(0), &val1);
21494 if (!SWIG_IsOK(ecode1)) {
21495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21496 }
21497 arg1 = static_cast< PLINT >(val1);
21498 pllsty(arg1);
21499 _outv = octave_value();
21500 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21501 return _out;
21502 fail:
21503 return octave_value_list();
21504 }
21505 catch(...) {
21506 throw;
21507 }
21508}
21509
21510
21512 PLINT *arg1 = (PLINT *) 0 ;
21513 PLINT temp1 ;
21514 int res1 = SWIG_TMPOBJ ;
21515 octave_value_list _out;
21516 octave_value_list *_outp=&_out;
21517 octave_value _outv;
21518
21519 try {
21520 arg1 = &temp1;
21521 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21522 SWIG_fail;
21523 }
21524 plmkstrm(arg1);
21525 _outv = octave_value();
21526 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21527 if (SWIG_IsTmpObj(res1)) {
21528 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21529 } else {
21530 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21531 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21532 }
21533 return _out;
21534 fail:
21535 return octave_value_list();
21536 }
21537 catch(...) {
21538 throw;
21539 }
21540}
21541
21542
21544 char *arg1 = (char *) 0 ;
21545 PLFLT arg2 ;
21546 PLFLT arg3 ;
21547 PLFLT arg4 ;
21548 char *arg5 = (char *) 0 ;
21549 int res1 ;
21550 char *buf1 = 0 ;
21551 int alloc1 = 0 ;
21552 double val2 ;
21553 int ecode2 = 0 ;
21554 double val3 ;
21555 int ecode3 = 0 ;
21556 double val4 ;
21557 int ecode4 = 0 ;
21558 int res5 ;
21559 char *buf5 = 0 ;
21560 int alloc5 = 0 ;
21561 octave_value_list _out;
21562 octave_value_list *_outp=&_out;
21563 octave_value _outv;
21564
21565 try {
21566 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21567 SWIG_fail;
21568 }
21569 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21572 }
21573 arg1 = reinterpret_cast< char * >(buf1);
21574 ecode2 = SWIG_AsVal_double(args(1), &val2);
21575 if (!SWIG_IsOK(ecode2)) {
21576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21577 }
21578 arg2 = static_cast< PLFLT >(val2);
21579 ecode3 = SWIG_AsVal_double(args(2), &val3);
21580 if (!SWIG_IsOK(ecode3)) {
21581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21582 }
21583 arg3 = static_cast< PLFLT >(val3);
21584 ecode4 = SWIG_AsVal_double(args(3), &val4);
21585 if (!SWIG_IsOK(ecode4)) {
21586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21587 }
21588 arg4 = static_cast< PLFLT >(val4);
21589 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21590 if (!SWIG_IsOK(res5)) {
21591 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21592 }
21593 arg5 = reinterpret_cast< char * >(buf5);
21594 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21595 _outv = octave_value();
21596 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21597 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21598 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21599 return _out;
21600 fail:
21601 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21602 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21603 return octave_value_list();
21604 }
21605 catch(...) {
21606 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21607 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21608 throw;
21609 }
21610}
21611
21612
21614 char *arg1 = (char *) 0 ;
21615 PLFLT arg2 ;
21616 PLFLT arg3 ;
21617 PLFLT arg4 ;
21618 char *arg5 = (char *) 0 ;
21619 int res1 ;
21620 char *buf1 = 0 ;
21621 int alloc1 = 0 ;
21622 double val2 ;
21623 int ecode2 = 0 ;
21624 double val3 ;
21625 int ecode3 = 0 ;
21626 double val4 ;
21627 int ecode4 = 0 ;
21628 int res5 ;
21629 char *buf5 = 0 ;
21630 int alloc5 = 0 ;
21631 octave_value_list _out;
21632 octave_value_list *_outp=&_out;
21633 octave_value _outv;
21634
21635 try {
21636 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21637 SWIG_fail;
21638 }
21639 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21640 if (!SWIG_IsOK(res1)) {
21641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21642 }
21643 arg1 = reinterpret_cast< char * >(buf1);
21644 ecode2 = SWIG_AsVal_double(args(1), &val2);
21645 if (!SWIG_IsOK(ecode2)) {
21646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21647 }
21648 arg2 = static_cast< PLFLT >(val2);
21649 ecode3 = SWIG_AsVal_double(args(2), &val3);
21650 if (!SWIG_IsOK(ecode3)) {
21651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21652 }
21653 arg3 = static_cast< PLFLT >(val3);
21654 ecode4 = SWIG_AsVal_double(args(3), &val4);
21655 if (!SWIG_IsOK(ecode4)) {
21656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21657 }
21658 arg4 = static_cast< PLFLT >(val4);
21659 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21660 if (!SWIG_IsOK(res5)) {
21661 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21662 }
21663 arg5 = reinterpret_cast< char * >(buf5);
21664 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21665 _outv = octave_value();
21666 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21667 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21668 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21669 return _out;
21670 fail:
21671 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21672 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21673 return octave_value_list();
21674 }
21675 catch(...) {
21676 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21677 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21678 throw;
21679 }
21680}
21681
21682
21684 int *arg1 = (int *) 0 ;
21685 char **arg2 = (char **) 0 ;
21686 PLINT arg3 ;
21687 void *argp1 = 0 ;
21688 int res1 = 0 ;
21689 void *argp2 = 0 ;
21690 int res2 = 0 ;
21691 int val3 ;
21692 int ecode3 = 0 ;
21693 octave_value_list _out;
21694 octave_value_list *_outp=&_out;
21695 octave_value _outv;
21696 PLINT result;
21697
21698 try {
21699 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21700 SWIG_fail;
21701 }
21702 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21703 if (!SWIG_IsOK(res1)) {
21704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21705 }
21706 arg1 = reinterpret_cast< int * >(argp1);
21707 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21708 if (!SWIG_IsOK(res2)) {
21709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21710 }
21711 arg2 = reinterpret_cast< char ** >(argp2);
21712 ecode3 = SWIG_AsVal_int(args(2), &val3);
21713 if (!SWIG_IsOK(ecode3)) {
21714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21715 }
21716 arg3 = static_cast< PLINT >(val3);
21717 result = (PLINT)plparseopts(arg1,arg2,arg3);
21718 _outv = SWIG_From_int(static_cast< int >(result));
21719 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21720 return _out;
21721 fail:
21722 return octave_value_list();
21723 }
21724 catch(...) {
21725 throw;
21726 }
21727}
21728
21729
21731 PLINT arg1 ;
21732 PLINT *arg2 = (PLINT *) 0 ;
21733 PLINT *arg3 = (PLINT *) 0 ;
21734 Matrix temp1 ;
21735 Matrix temp3 ;
21736 octave_value_list _out;
21737 octave_value_list *_outp=&_out;
21738 octave_value _outv;
21739
21740 try {
21741 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21742 SWIG_fail;
21743 }
21744 {
21745 if ( _n_dims( args(0) ) > 1 )
21746 {
21747 error( "argument must be a scalar or vector" ); SWIG_fail;
21748 }
21749 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21750 arg2 = new PLINT[Alen];
21751 temp1 = args(0).matrix_value();
21752 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21753 }
21754 {
21755 if ( _n_dims( args(1) ) > 1 )
21756 {
21757 error( "argument must be a scalar or vector" ); SWIG_fail;
21758 }
21759 if ( _dim( args(1), 0 ) != Alen )
21760 {
21761 error( "argument vectors must be same length" ); SWIG_fail;
21762 }
21763 temp3 = args(1).matrix_value();
21764 arg3 = new PLINT[Alen];
21765 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21766 }
21767 plpat(arg1,(int const *)arg2,(int const *)arg3);
21768 _outv = octave_value();
21769 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21770 {
21771 delete [] arg2;
21772 }
21773 {
21774 delete [] arg3;
21775 }
21776 return _out;
21777 fail:
21778 {
21779 delete [] arg2;
21780 }
21781 {
21782 delete [] arg3;
21783 }
21784 return octave_value_list();
21785 }
21786 catch(...) {
21787 {
21788 delete [] arg2;
21789 }
21790 {
21791 delete [] arg3;
21792 }
21793 throw;
21794 }
21795}
21796
21797
21799 PLINT arg1 ;
21800 PLFLT arg2 ;
21801 PLFLT arg3 ;
21802 PLFLT arg4 ;
21803 PLFLT arg5 ;
21804 int val1 ;
21805 int ecode1 = 0 ;
21806 double val2 ;
21807 int ecode2 = 0 ;
21808 double val3 ;
21809 int ecode3 = 0 ;
21810 double val4 ;
21811 int ecode4 = 0 ;
21812 double val5 ;
21813 int ecode5 = 0 ;
21814 octave_value_list _out;
21815 octave_value_list *_outp=&_out;
21816 octave_value _outv;
21817
21818 try {
21819 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21820 SWIG_fail;
21821 }
21822 ecode1 = SWIG_AsVal_int(args(0), &val1);
21823 if (!SWIG_IsOK(ecode1)) {
21824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21825 }
21826 arg1 = static_cast< PLINT >(val1);
21827 ecode2 = SWIG_AsVal_double(args(1), &val2);
21828 if (!SWIG_IsOK(ecode2)) {
21829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21830 }
21831 arg2 = static_cast< PLFLT >(val2);
21832 ecode3 = SWIG_AsVal_double(args(2), &val3);
21833 if (!SWIG_IsOK(ecode3)) {
21834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21835 }
21836 arg3 = static_cast< PLFLT >(val3);
21837 ecode4 = SWIG_AsVal_double(args(3), &val4);
21838 if (!SWIG_IsOK(ecode4)) {
21839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21840 }
21841 arg4 = static_cast< PLFLT >(val4);
21842 ecode5 = SWIG_AsVal_double(args(4), &val5);
21843 if (!SWIG_IsOK(ecode5)) {
21844 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21845 }
21846 arg5 = static_cast< PLFLT >(val5);
21847 plpath(arg1,arg2,arg3,arg4,arg5);
21848 _outv = octave_value();
21849 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21850 return _out;
21851 fail:
21852 return octave_value_list();
21853 }
21854 catch(...) {
21855 throw;
21856 }
21857}
21858
21859
21861 PLINT arg1 ;
21862 PLFLT *arg2 = (PLFLT *) 0 ;
21863 PLFLT *arg3 = (PLFLT *) 0 ;
21864 PLINT arg4 ;
21865 Matrix temp1 ;
21866 Matrix temp3 ;
21867 int val4 ;
21868 int ecode4 = 0 ;
21869 octave_value_list _out;
21870 octave_value_list *_outp=&_out;
21871 octave_value _outv;
21872
21873 try {
21874 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21875 SWIG_fail;
21876 }
21877 {
21878 if ( _n_dims( args(0) ) > 1 )
21879 {
21880 error( "argument must be a scalar or vector" ); SWIG_fail;
21881 }
21882 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21883 temp1 = args(0).matrix_value();
21884 arg2 = &temp1( 0, 0 );
21885 }
21886 {
21887 if ( _n_dims( args(1) ) > 1 )
21888 {
21889 error( "argument must be a scalar or vector" ); SWIG_fail;
21890 }
21891 if ( _dim( args(1), 0 ) != Alen )
21892 {
21893 error( "argument vectors must be same length" ); SWIG_fail;
21894 }
21895 temp3 = args(1).matrix_value();
21896 arg3 = &temp3( 0, 0 );
21897 }
21898 ecode4 = SWIG_AsVal_int(args(2), &val4);
21899 if (!SWIG_IsOK(ecode4)) {
21900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21901 }
21902 arg4 = static_cast< PLINT >(val4);
21903 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21904 _outv = octave_value();
21905 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21906 {
21907
21908 }
21909 {
21910
21911 }
21912 return _out;
21913 fail:
21914 {
21915
21916 }
21917 {
21918
21919 }
21920 return octave_value_list();
21921 }
21922 catch(...) {
21923 {
21924
21925 }
21926 {
21927
21928 }
21929 throw;
21930 }
21931}
21932
21933
21935 PLINT arg1 ;
21936 PLFLT *arg2 = (PLFLT *) 0 ;
21937 PLFLT *arg3 = (PLFLT *) 0 ;
21938 PLFLT *arg4 = (PLFLT *) 0 ;
21939 PLINT arg5 ;
21940 Matrix temp1 ;
21941 Matrix temp3 ;
21942 Matrix temp4 ;
21943 int val5 ;
21944 int ecode5 = 0 ;
21945 octave_value_list _out;
21946 octave_value_list *_outp=&_out;
21947 octave_value _outv;
21948
21949 try {
21950 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21951 SWIG_fail;
21952 }
21953 {
21954 if ( _n_dims( args(0) ) > 1 )
21955 {
21956 error( "argument must be a scalar or vector" ); SWIG_fail;
21957 }
21958 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21959 temp1 = args(0).matrix_value();
21960 arg2 = &temp1( 0, 0 );
21961 }
21962 {
21963 if ( _n_dims( args(1) ) > 1 )
21964 {
21965 error( "argument must be a scalar or vector" ); SWIG_fail;
21966 }
21967 if ( _dim( args(1), 0 ) != Alen )
21968 {
21969 error( "argument vectors must be same length" ); SWIG_fail;
21970 }
21971 temp3 = args(1).matrix_value();
21972 arg3 = &temp3( 0, 0 );
21973 }
21974 {
21975 if ( _n_dims( args(2) ) > 1 )
21976 {
21977 error( "argument must be a scalar or vector" ); SWIG_fail;
21978 }
21979 if ( _dim( args(2), 0 ) != Alen )
21980 {
21981 error( "argument vectors must be same length" ); SWIG_fail;
21982 }
21983 temp4 = args(2).matrix_value();
21984 arg4 = &temp4( 0, 0 );
21985 }
21986 ecode5 = SWIG_AsVal_int(args(3), &val5);
21987 if (!SWIG_IsOK(ecode5)) {
21988 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21989 }
21990 arg5 = static_cast< PLINT >(val5);
21991 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21992 _outv = octave_value();
21993 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21994 {
21995
21996 }
21997 {
21998
21999 }
22000 {
22001
22002 }
22003 return _out;
22004 fail:
22005 {
22006
22007 }
22008 {
22009
22010 }
22011 {
22012
22013 }
22014 return octave_value_list();
22015 }
22016 catch(...) {
22017 {
22018
22019 }
22020 {
22021
22022 }
22023 {
22024
22025 }
22026 throw;
22027 }
22028}
22029
22030
22032 PLINT arg1 ;
22033 PLFLT *arg2 = (PLFLT *) 0 ;
22034 PLFLT *arg3 = (PLFLT *) 0 ;
22035 PLFLT *arg4 = (PLFLT *) 0 ;
22036 PLBOOL *arg5 = (PLBOOL *) 0 ;
22037 PLBOOL arg6 ;
22038 Matrix temp1 ;
22039 Matrix temp3 ;
22040 Matrix temp4 ;
22041 Matrix temp5 ;
22042 int val6 ;
22043 int ecode6 = 0 ;
22044 octave_value_list _out;
22045 octave_value_list *_outp=&_out;
22046 octave_value _outv;
22047
22048 try {
22049 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
22050 SWIG_fail;
22051 }
22052 {
22053 if ( _n_dims( args(0) ) > 1 )
22054 {
22055 error( "argument must be a scalar or vector" ); SWIG_fail;
22056 }
22057 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22058 temp1 = args(0).matrix_value();
22059 arg2 = &temp1( 0, 0 );
22060 }
22061 {
22062 if ( _n_dims( args(1) ) > 1 )
22063 {
22064 error( "argument must be a scalar or vector" ); SWIG_fail;
22065 }
22066 if ( _dim( args(1), 0 ) != Alen )
22067 {
22068 error( "argument vectors must be same length" ); SWIG_fail;
22069 }
22070 temp3 = args(1).matrix_value();
22071 arg3 = &temp3( 0, 0 );
22072 }
22073 {
22074 if ( _n_dims( args(2) ) > 1 )
22075 {
22076 error( "argument must be a scalar or vector" ); SWIG_fail;
22077 }
22078 if ( _dim( args(2), 0 ) != Alen )
22079 {
22080 error( "argument vectors must be same length" ); SWIG_fail;
22081 }
22082 temp4 = args(2).matrix_value();
22083 arg4 = &temp4( 0, 0 );
22084 }
22085 {
22086 if ( _n_dims( args(3) ) > 1 )
22087 {
22088 error( "argument must be a scalar or vector" ); SWIG_fail;
22089 }
22090 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22091 {
22092 error( "argument vector must be same length or one less" ); SWIG_fail;
22093 }
22094 temp5 = args(3).matrix_value();
22095 arg5 = new PLINT[Alen];
22096 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22097 }
22098 ecode6 = SWIG_AsVal_int(args(4), &val6);
22099 if (!SWIG_IsOK(ecode6)) {
22100 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22101 }
22102 arg6 = static_cast< PLBOOL >(val6);
22103 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22104 _outv = octave_value();
22105 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22106 {
22107
22108 }
22109 {
22110
22111 }
22112 {
22113
22114 }
22115 {
22116 delete [] arg5;
22117 }
22118 return _out;
22119 fail:
22120 {
22121
22122 }
22123 {
22124
22125 }
22126 {
22127
22128 }
22129 {
22130 delete [] arg5;
22131 }
22132 return octave_value_list();
22133 }
22134 catch(...) {
22135 {
22136
22137 }
22138 {
22139
22140 }
22141 {
22142
22143 }
22144 {
22145 delete [] arg5;
22146 }
22147 throw;
22148 }
22149}
22150
22151
22153 PLINT arg1 ;
22154 PLINT arg2 ;
22155 int val1 ;
22156 int ecode1 = 0 ;
22157 int val2 ;
22158 int ecode2 = 0 ;
22159 octave_value_list _out;
22160 octave_value_list *_outp=&_out;
22161 octave_value _outv;
22162
22163 try {
22164 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22165 SWIG_fail;
22166 }
22167 ecode1 = SWIG_AsVal_int(args(0), &val1);
22168 if (!SWIG_IsOK(ecode1)) {
22169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22170 }
22171 arg1 = static_cast< PLINT >(val1);
22172 ecode2 = SWIG_AsVal_int(args(1), &val2);
22173 if (!SWIG_IsOK(ecode2)) {
22174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22175 }
22176 arg2 = static_cast< PLINT >(val2);
22177 plprec(arg1,arg2);
22178 _outv = octave_value();
22179 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22180 return _out;
22181 fail:
22182 return octave_value_list();
22183 }
22184 catch(...) {
22185 throw;
22186 }
22187}
22188
22189
22191 PLINT arg1 ;
22192 int val1 ;
22193 int ecode1 = 0 ;
22194 octave_value_list _out;
22195 octave_value_list *_outp=&_out;
22196 octave_value _outv;
22197
22198 try {
22199 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22200 SWIG_fail;
22201 }
22202 ecode1 = SWIG_AsVal_int(args(0), &val1);
22203 if (!SWIG_IsOK(ecode1)) {
22204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22205 }
22206 arg1 = static_cast< PLINT >(val1);
22207 plpsty(arg1);
22208 _outv = octave_value();
22209 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22210 return _out;
22211 fail:
22212 return octave_value_list();
22213 }
22214 catch(...) {
22215 throw;
22216 }
22217}
22218
22219
22221 PLFLT arg1 ;
22222 PLFLT arg2 ;
22223 PLFLT arg3 ;
22224 PLFLT arg4 ;
22225 PLFLT arg5 ;
22226 char *arg6 = (char *) 0 ;
22227 double val1 ;
22228 int ecode1 = 0 ;
22229 double val2 ;
22230 int ecode2 = 0 ;
22231 double val3 ;
22232 int ecode3 = 0 ;
22233 double val4 ;
22234 int ecode4 = 0 ;
22235 double val5 ;
22236 int ecode5 = 0 ;
22237 int res6 ;
22238 char *buf6 = 0 ;
22239 int alloc6 = 0 ;
22240 octave_value_list _out;
22241 octave_value_list *_outp=&_out;
22242 octave_value _outv;
22243
22244 try {
22245 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22246 SWIG_fail;
22247 }
22248 ecode1 = SWIG_AsVal_double(args(0), &val1);
22249 if (!SWIG_IsOK(ecode1)) {
22250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22251 }
22252 arg1 = static_cast< PLFLT >(val1);
22253 ecode2 = SWIG_AsVal_double(args(1), &val2);
22254 if (!SWIG_IsOK(ecode2)) {
22255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22256 }
22257 arg2 = static_cast< PLFLT >(val2);
22258 ecode3 = SWIG_AsVal_double(args(2), &val3);
22259 if (!SWIG_IsOK(ecode3)) {
22260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22261 }
22262 arg3 = static_cast< PLFLT >(val3);
22263 ecode4 = SWIG_AsVal_double(args(3), &val4);
22264 if (!SWIG_IsOK(ecode4)) {
22265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22266 }
22267 arg4 = static_cast< PLFLT >(val4);
22268 ecode5 = SWIG_AsVal_double(args(4), &val5);
22269 if (!SWIG_IsOK(ecode5)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22271 }
22272 arg5 = static_cast< PLFLT >(val5);
22273 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22274 if (!SWIG_IsOK(res6)) {
22275 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22276 }
22277 arg6 = reinterpret_cast< char * >(buf6);
22278 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22279 _outv = octave_value();
22280 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22281 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22282 return _out;
22283 fail:
22284 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22285 return octave_value_list();
22286 }
22287 catch(...) {
22288 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22289 throw;
22290 }
22291}
22292
22293
22295 PLFLT arg1 ;
22296 PLFLT arg2 ;
22297 PLFLT arg3 ;
22298 PLFLT arg4 ;
22299 PLFLT arg5 ;
22300 PLFLT arg6 ;
22301 PLFLT arg7 ;
22302 PLFLT arg8 ;
22303 PLFLT arg9 ;
22304 PLFLT arg10 ;
22305 char *arg11 = (char *) 0 ;
22306 double val1 ;
22307 int ecode1 = 0 ;
22308 double val2 ;
22309 int ecode2 = 0 ;
22310 double val3 ;
22311 int ecode3 = 0 ;
22312 double val4 ;
22313 int ecode4 = 0 ;
22314 double val5 ;
22315 int ecode5 = 0 ;
22316 double val6 ;
22317 int ecode6 = 0 ;
22318 double val7 ;
22319 int ecode7 = 0 ;
22320 double val8 ;
22321 int ecode8 = 0 ;
22322 double val9 ;
22323 int ecode9 = 0 ;
22324 double val10 ;
22325 int ecode10 = 0 ;
22326 int res11 ;
22327 char *buf11 = 0 ;
22328 int alloc11 = 0 ;
22329 octave_value_list _out;
22330 octave_value_list *_outp=&_out;
22331 octave_value _outv;
22332
22333 try {
22334 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22335 SWIG_fail;
22336 }
22337 ecode1 = SWIG_AsVal_double(args(0), &val1);
22338 if (!SWIG_IsOK(ecode1)) {
22339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22340 }
22341 arg1 = static_cast< PLFLT >(val1);
22342 ecode2 = SWIG_AsVal_double(args(1), &val2);
22343 if (!SWIG_IsOK(ecode2)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22345 }
22346 arg2 = static_cast< PLFLT >(val2);
22347 ecode3 = SWIG_AsVal_double(args(2), &val3);
22348 if (!SWIG_IsOK(ecode3)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22350 }
22351 arg3 = static_cast< PLFLT >(val3);
22352 ecode4 = SWIG_AsVal_double(args(3), &val4);
22353 if (!SWIG_IsOK(ecode4)) {
22354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22355 }
22356 arg4 = static_cast< PLFLT >(val4);
22357 ecode5 = SWIG_AsVal_double(args(4), &val5);
22358 if (!SWIG_IsOK(ecode5)) {
22359 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22360 }
22361 arg5 = static_cast< PLFLT >(val5);
22362 ecode6 = SWIG_AsVal_double(args(5), &val6);
22363 if (!SWIG_IsOK(ecode6)) {
22364 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22365 }
22366 arg6 = static_cast< PLFLT >(val6);
22367 ecode7 = SWIG_AsVal_double(args(6), &val7);
22368 if (!SWIG_IsOK(ecode7)) {
22369 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22370 }
22371 arg7 = static_cast< PLFLT >(val7);
22372 ecode8 = SWIG_AsVal_double(args(7), &val8);
22373 if (!SWIG_IsOK(ecode8)) {
22374 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22375 }
22376 arg8 = static_cast< PLFLT >(val8);
22377 ecode9 = SWIG_AsVal_double(args(8), &val9);
22378 if (!SWIG_IsOK(ecode9)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22380 }
22381 arg9 = static_cast< PLFLT >(val9);
22382 ecode10 = SWIG_AsVal_double(args(9), &val10);
22383 if (!SWIG_IsOK(ecode10)) {
22384 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22385 }
22386 arg10 = static_cast< PLFLT >(val10);
22387 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22388 if (!SWIG_IsOK(res11)) {
22389 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22390 }
22391 arg11 = reinterpret_cast< char * >(buf11);
22392 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22393 _outv = octave_value();
22394 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22395 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22396 return _out;
22397 fail:
22398 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22399 return octave_value_list();
22400 }
22401 catch(...) {
22402 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22403 throw;
22404 }
22405}
22406
22407
22409 octave_value_list _out;
22410 octave_value_list *_outp=&_out;
22411 octave_value _outv;
22412 PLFLT result;
22413
22414 try {
22415 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22416 SWIG_fail;
22417 }
22418 result = (PLFLT)plrandd();
22419 _outv = SWIG_From_double(static_cast< double >(result));
22420 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22421 return _out;
22422 fail:
22423 return octave_value_list();
22424 }
22425 catch(...) {
22426 throw;
22427 }
22428}
22429
22430
22432 octave_value_list _out;
22433 octave_value_list *_outp=&_out;
22434 octave_value _outv;
22435
22436 try {
22437 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22438 SWIG_fail;
22439 }
22440 plreplot();
22441 _outv = octave_value();
22442 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22443 return _out;
22444 fail:
22445 return octave_value_list();
22446 }
22447 catch(...) {
22448 throw;
22449 }
22450}
22451
22452
22454 PLFLT arg1 ;
22455 PLFLT arg2 ;
22456 PLFLT arg3 ;
22457 PLFLT *arg4 = (PLFLT *) 0 ;
22458 PLFLT *arg5 = (PLFLT *) 0 ;
22459 PLFLT *arg6 = (PLFLT *) 0 ;
22460 double val1 ;
22461 int ecode1 = 0 ;
22462 double val2 ;
22463 int ecode2 = 0 ;
22464 double val3 ;
22465 int ecode3 = 0 ;
22466 PLFLT temp4 ;
22467 int res4 = SWIG_TMPOBJ ;
22468 PLFLT temp5 ;
22469 int res5 = SWIG_TMPOBJ ;
22470 PLFLT temp6 ;
22471 int res6 = SWIG_TMPOBJ ;
22472 octave_value_list _out;
22473 octave_value_list *_outp=&_out;
22474 octave_value _outv;
22475
22476 try {
22477 arg4 = &temp4;
22478 arg5 = &temp5;
22479 arg6 = &temp6;
22480 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22481 SWIG_fail;
22482 }
22483 ecode1 = SWIG_AsVal_double(args(0), &val1);
22484 if (!SWIG_IsOK(ecode1)) {
22485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22486 }
22487 arg1 = static_cast< PLFLT >(val1);
22488 ecode2 = SWIG_AsVal_double(args(1), &val2);
22489 if (!SWIG_IsOK(ecode2)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22491 }
22492 arg2 = static_cast< PLFLT >(val2);
22493 ecode3 = SWIG_AsVal_double(args(2), &val3);
22494 if (!SWIG_IsOK(ecode3)) {
22495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22496 }
22497 arg3 = static_cast< PLFLT >(val3);
22498 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22499 _outv = octave_value();
22500 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22501 if (SWIG_IsTmpObj(res4)) {
22502 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22503 } else {
22504 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22505 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22506 }
22507 if (SWIG_IsTmpObj(res5)) {
22508 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22509 } else {
22510 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22511 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22512 }
22513 if (SWIG_IsTmpObj(res6)) {
22514 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22515 } else {
22516 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22517 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22518 }
22519 return _out;
22520 fail:
22521 return octave_value_list();
22522 }
22523 catch(...) {
22524 throw;
22525 }
22526}
22527
22528
22530 PLFLT arg1 ;
22531 PLFLT arg2 ;
22532 double val1 ;
22533 int ecode1 = 0 ;
22534 double val2 ;
22535 int ecode2 = 0 ;
22536 octave_value_list _out;
22537 octave_value_list *_outp=&_out;
22538 octave_value _outv;
22539
22540 try {
22541 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22542 SWIG_fail;
22543 }
22544 ecode1 = SWIG_AsVal_double(args(0), &val1);
22545 if (!SWIG_IsOK(ecode1)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22547 }
22548 arg1 = static_cast< PLFLT >(val1);
22549 ecode2 = SWIG_AsVal_double(args(1), &val2);
22550 if (!SWIG_IsOK(ecode2)) {
22551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22552 }
22553 arg2 = static_cast< PLFLT >(val2);
22554 plschr(arg1,arg2);
22555 _outv = octave_value();
22556 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22557 return _out;
22558 fail:
22559 return octave_value_list();
22560 }
22561 catch(...) {
22562 throw;
22563 }
22564}
22565
22566
22568 PLINT *arg1 = (PLINT *) 0 ;
22569 PLINT *arg2 = (PLINT *) 0 ;
22570 PLINT *arg3 = (PLINT *) 0 ;
22571 PLINT arg4 ;
22572 Matrix temp1 ;
22573 Matrix temp2 ;
22574 Matrix temp3 ;
22575 octave_value_list _out;
22576 octave_value_list *_outp=&_out;
22577 octave_value _outv;
22578
22579 try {
22580 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22581 SWIG_fail;
22582 }
22583 {
22584 if ( _n_dims( args(0) ) > 1 )
22585 {
22586 error( "argument must be a scalar or vector" ); SWIG_fail;
22587 }
22588 Alen = (PLINT) ( _dim( args(0), 0 ) );
22589 temp1 = args(0).matrix_value();
22590 arg1 = new PLINT[Alen];
22591 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22592 }
22593 {
22594 if ( _n_dims( args(1) ) > 1 )
22595 {
22596 error( "argument must be a scalar or vector" ); SWIG_fail;
22597 }
22598 if ( _dim( args(1), 0 ) != Alen )
22599 {
22600 error( "argument vectors must be same length" ); SWIG_fail;
22601 }
22602 temp2 = args(1).matrix_value();
22603 arg2 = new PLINT[Alen];
22604 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22605 }
22606 {
22607 if ( _n_dims( args(2) ) > 1 )
22608 {
22609 error( "argument must be a scalar or vector" ); SWIG_fail;
22610 }
22611 if ( _dim( args(2), 0 ) != Alen )
22612 {
22613 error( "argument vectors must be same length" ); SWIG_fail;
22614 }
22615 temp3 = args(2).matrix_value();
22616 arg3 = new PLINT[Alen];
22617 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22618 arg4 = Alen;
22619 }
22620 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22621 _outv = octave_value();
22622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22623 {
22624 delete [] arg1;
22625 }
22626 {
22627 delete [] arg2;
22628 }
22629 {
22630 delete [] arg3;
22631 }
22632 return _out;
22633 fail:
22634 {
22635 delete [] arg1;
22636 }
22637 {
22638 delete [] arg2;
22639 }
22640 {
22641 delete [] arg3;
22642 }
22643 return octave_value_list();
22644 }
22645 catch(...) {
22646 {
22647 delete [] arg1;
22648 }
22649 {
22650 delete [] arg2;
22651 }
22652 {
22653 delete [] arg3;
22654 }
22655 throw;
22656 }
22657}
22658
22659
22661 PLINT *arg1 = (PLINT *) 0 ;
22662 PLINT *arg2 = (PLINT *) 0 ;
22663 PLINT *arg3 = (PLINT *) 0 ;
22664 PLFLT *arg4 = (PLFLT *) 0 ;
22665 PLINT arg5 ;
22666 Matrix temp1 ;
22667 Matrix temp2 ;
22668 Matrix temp3 ;
22669 Matrix temp4 ;
22670 octave_value_list _out;
22671 octave_value_list *_outp=&_out;
22672 octave_value _outv;
22673
22674 try {
22675 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22676 SWIG_fail;
22677 }
22678 {
22679 if ( _n_dims( args(0) ) > 1 )
22680 {
22681 error( "argument must be a scalar or vector" ); SWIG_fail;
22682 }
22683 Alen = (PLINT) ( _dim( args(0), 0 ) );
22684 temp1 = args(0).matrix_value();
22685 arg1 = new PLINT[Alen];
22686 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22687 }
22688 {
22689 if ( _n_dims( args(1) ) > 1 )
22690 {
22691 error( "argument must be a scalar or vector" ); SWIG_fail;
22692 }
22693 if ( _dim( args(1), 0 ) != Alen )
22694 {
22695 error( "argument vectors must be same length" ); SWIG_fail;
22696 }
22697 temp2 = args(1).matrix_value();
22698 arg2 = new PLINT[Alen];
22699 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22700 }
22701 {
22702 if ( _n_dims( args(2) ) > 1 )
22703 {
22704 error( "argument must be a scalar or vector" ); SWIG_fail;
22705 }
22706 if ( _dim( args(2), 0 ) != Alen )
22707 {
22708 error( "argument vectors must be same length" ); SWIG_fail;
22709 }
22710 temp3 = args(2).matrix_value();
22711 arg3 = new PLINT[Alen];
22712 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22713 }
22714 {
22715 if ( _n_dims( args(3) ) > 1 )
22716 {
22717 error( "argument must be a scalar or vector" ); SWIG_fail;
22718 }
22719 if ( _dim( args(3), 0 ) != Alen )
22720 {
22721 error( "argument vectors must be same length" ); SWIG_fail;
22722 }
22723 temp4 = args(3).matrix_value();
22724 arg4 = &temp4( 0, 0 );
22725 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22726 }
22727 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22728 _outv = octave_value();
22729 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22730 {
22731 delete [] arg1;
22732 }
22733 {
22734 delete [] arg2;
22735 }
22736 {
22737 delete [] arg3;
22738 }
22739 {
22740
22741 }
22742 return _out;
22743 fail:
22744 {
22745 delete [] arg1;
22746 }
22747 {
22748 delete [] arg2;
22749 }
22750 {
22751 delete [] arg3;
22752 }
22753 {
22754
22755 }
22756 return octave_value_list();
22757 }
22758 catch(...) {
22759 {
22760 delete [] arg1;
22761 }
22762 {
22763 delete [] arg2;
22764 }
22765 {
22766 delete [] arg3;
22767 }
22768 {
22769
22770 }
22771 throw;
22772 }
22773}
22774
22775
22777 PLINT arg1 ;
22778 int val1 ;
22779 int ecode1 = 0 ;
22780 octave_value_list _out;
22781 octave_value_list *_outp=&_out;
22782 octave_value _outv;
22783
22784 try {
22785 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22786 SWIG_fail;
22787 }
22788 ecode1 = SWIG_AsVal_int(args(0), &val1);
22789 if (!SWIG_IsOK(ecode1)) {
22790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22791 }
22792 arg1 = static_cast< PLINT >(val1);
22793 plscmap0n(arg1);
22794 _outv = octave_value();
22795 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22796 return _out;
22797 fail:
22798 return octave_value_list();
22799 }
22800 catch(...) {
22801 throw;
22802 }
22803}
22804
22805
22807 PLINT *arg1 = (PLINT *) 0 ;
22808 PLINT *arg2 = (PLINT *) 0 ;
22809 PLINT *arg3 = (PLINT *) 0 ;
22810 PLINT arg4 ;
22811 Matrix temp1 ;
22812 Matrix temp2 ;
22813 Matrix temp3 ;
22814 octave_value_list _out;
22815 octave_value_list *_outp=&_out;
22816 octave_value _outv;
22817
22818 try {
22819 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22820 SWIG_fail;
22821 }
22822 {
22823 if ( _n_dims( args(0) ) > 1 )
22824 {
22825 error( "argument must be a scalar or vector" ); SWIG_fail;
22826 }
22827 Alen = (PLINT) ( _dim( args(0), 0 ) );
22828 temp1 = args(0).matrix_value();
22829 arg1 = new PLINT[Alen];
22830 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22831 }
22832 {
22833 if ( _n_dims( args(1) ) > 1 )
22834 {
22835 error( "argument must be a scalar or vector" ); SWIG_fail;
22836 }
22837 if ( _dim( args(1), 0 ) != Alen )
22838 {
22839 error( "argument vectors must be same length" ); SWIG_fail;
22840 }
22841 temp2 = args(1).matrix_value();
22842 arg2 = new PLINT[Alen];
22843 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22844 }
22845 {
22846 if ( _n_dims( args(2) ) > 1 )
22847 {
22848 error( "argument must be a scalar or vector" ); SWIG_fail;
22849 }
22850 if ( _dim( args(2), 0 ) != Alen )
22851 {
22852 error( "argument vectors must be same length" ); SWIG_fail;
22853 }
22854 temp3 = args(2).matrix_value();
22855 arg3 = new PLINT[Alen];
22856 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22857 arg4 = Alen;
22858 }
22859 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22860 _outv = octave_value();
22861 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22862 {
22863 delete [] arg1;
22864 }
22865 {
22866 delete [] arg2;
22867 }
22868 {
22869 delete [] arg3;
22870 }
22871 return _out;
22872 fail:
22873 {
22874 delete [] arg1;
22875 }
22876 {
22877 delete [] arg2;
22878 }
22879 {
22880 delete [] arg3;
22881 }
22882 return octave_value_list();
22883 }
22884 catch(...) {
22885 {
22886 delete [] arg1;
22887 }
22888 {
22889 delete [] arg2;
22890 }
22891 {
22892 delete [] arg3;
22893 }
22894 throw;
22895 }
22896}
22897
22898
22900 PLINT *arg1 = (PLINT *) 0 ;
22901 PLINT *arg2 = (PLINT *) 0 ;
22902 PLINT *arg3 = (PLINT *) 0 ;
22903 PLFLT *arg4 = (PLFLT *) 0 ;
22904 PLINT arg5 ;
22905 Matrix temp1 ;
22906 Matrix temp2 ;
22907 Matrix temp3 ;
22908 Matrix temp4 ;
22909 octave_value_list _out;
22910 octave_value_list *_outp=&_out;
22911 octave_value _outv;
22912
22913 try {
22914 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22915 SWIG_fail;
22916 }
22917 {
22918 if ( _n_dims( args(0) ) > 1 )
22919 {
22920 error( "argument must be a scalar or vector" ); SWIG_fail;
22921 }
22922 Alen = (PLINT) ( _dim( args(0), 0 ) );
22923 temp1 = args(0).matrix_value();
22924 arg1 = new PLINT[Alen];
22925 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22926 }
22927 {
22928 if ( _n_dims( args(1) ) > 1 )
22929 {
22930 error( "argument must be a scalar or vector" ); SWIG_fail;
22931 }
22932 if ( _dim( args(1), 0 ) != Alen )
22933 {
22934 error( "argument vectors must be same length" ); SWIG_fail;
22935 }
22936 temp2 = args(1).matrix_value();
22937 arg2 = new PLINT[Alen];
22938 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22939 }
22940 {
22941 if ( _n_dims( args(2) ) > 1 )
22942 {
22943 error( "argument must be a scalar or vector" ); SWIG_fail;
22944 }
22945 if ( _dim( args(2), 0 ) != Alen )
22946 {
22947 error( "argument vectors must be same length" ); SWIG_fail;
22948 }
22949 temp3 = args(2).matrix_value();
22950 arg3 = new PLINT[Alen];
22951 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22952 }
22953 {
22954 if ( _n_dims( args(3) ) > 1 )
22955 {
22956 error( "argument must be a scalar or vector" ); SWIG_fail;
22957 }
22958 if ( _dim( args(3), 0 ) != Alen )
22959 {
22960 error( "argument vectors must be same length" ); SWIG_fail;
22961 }
22962 temp4 = args(3).matrix_value();
22963 arg4 = &temp4( 0, 0 );
22964 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22965 }
22966 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22967 _outv = octave_value();
22968 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22969 {
22970 delete [] arg1;
22971 }
22972 {
22973 delete [] arg2;
22974 }
22975 {
22976 delete [] arg3;
22977 }
22978 {
22979
22980 }
22981 return _out;
22982 fail:
22983 {
22984 delete [] arg1;
22985 }
22986 {
22987 delete [] arg2;
22988 }
22989 {
22990 delete [] arg3;
22991 }
22992 {
22993
22994 }
22995 return octave_value_list();
22996 }
22997 catch(...) {
22998 {
22999 delete [] arg1;
23000 }
23001 {
23002 delete [] arg2;
23003 }
23004 {
23005 delete [] arg3;
23006 }
23007 {
23008
23009 }
23010 throw;
23011 }
23012}
23013
23014
23016 PLBOOL arg1 ;
23017 PLINT arg2 ;
23018 PLFLT *arg3 = (PLFLT *) 0 ;
23019 PLFLT *arg4 = (PLFLT *) 0 ;
23020 PLFLT *arg5 = (PLFLT *) 0 ;
23021 PLFLT *arg6 = (PLFLT *) 0 ;
23022 PLBOOL *arg7 = (PLBOOL *) 0 ;
23023 int val1 ;
23024 int ecode1 = 0 ;
23025 Matrix temp2 ;
23026 Matrix temp4 ;
23027 Matrix temp5 ;
23028 Matrix temp6 ;
23029 Matrix temp7 ;
23030 octave_value_list _out;
23031 octave_value_list *_outp=&_out;
23032 octave_value _outv;
23033
23034 try {
23035 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
23036 SWIG_fail;
23037 }
23038 ecode1 = SWIG_AsVal_int(args(0), &val1);
23039 if (!SWIG_IsOK(ecode1)) {
23040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
23041 }
23042 arg1 = static_cast< PLBOOL >(val1);
23043 {
23044 if ( _n_dims( args(1) ) > 1 )
23045 {
23046 error( "argument must be a scalar or vector" ); SWIG_fail;
23047 }
23048 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23049 temp2 = args(1).matrix_value();
23050 arg3 = &temp2( 0, 0 );
23051 }
23052 {
23053 if ( _n_dims( args(2) ) > 1 )
23054 {
23055 error( "argument must be a scalar or vector" ); SWIG_fail;
23056 }
23057 if ( _dim( args(2), 0 ) != Alen )
23058 {
23059 error( "argument vectors must be same length" ); SWIG_fail;
23060 }
23061 temp4 = args(2).matrix_value();
23062 arg4 = &temp4( 0, 0 );
23063 }
23064 {
23065 if ( _n_dims( args(3) ) > 1 )
23066 {
23067 error( "argument must be a scalar or vector" ); SWIG_fail;
23068 }
23069 if ( _dim( args(3), 0 ) != Alen )
23070 {
23071 error( "argument vectors must be same length" ); SWIG_fail;
23072 }
23073 temp5 = args(3).matrix_value();
23074 arg5 = &temp5( 0, 0 );
23075 }
23076 {
23077 if ( _n_dims( args(4) ) > 1 )
23078 {
23079 error( "argument must be a scalar or vector" ); SWIG_fail;
23080 }
23081 if ( _dim( args(4), 0 ) != Alen )
23082 {
23083 error( "argument vectors must be same length" ); SWIG_fail;
23084 }
23085 temp6 = args(4).matrix_value();
23086 arg6 = &temp6( 0, 0 );
23087 }
23088 {
23089 if ( _n_dims( args(5) ) > 1 )
23090 {
23091 error( "argument must be a scalar or vector" ); SWIG_fail;
23092 }
23093 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23094 {
23095 error( "argument vector must be same length or one less" ); SWIG_fail;
23096 }
23097 temp7 = args(5).matrix_value();
23098 arg7 = new PLINT[Alen];
23099 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23100 }
23101 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23102 _outv = octave_value();
23103 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23104 {
23105
23106 }
23107 {
23108
23109 }
23110 {
23111
23112 }
23113 {
23114
23115 }
23116 {
23117 delete [] arg7;
23118 }
23119 return _out;
23120 fail:
23121 {
23122
23123 }
23124 {
23125
23126 }
23127 {
23128
23129 }
23130 {
23131
23132 }
23133 {
23134 delete [] arg7;
23135 }
23136 return octave_value_list();
23137 }
23138 catch(...) {
23139 {
23140
23141 }
23142 {
23143
23144 }
23145 {
23146
23147 }
23148 {
23149
23150 }
23151 {
23152 delete [] arg7;
23153 }
23154 throw;
23155 }
23156}
23157
23158
23160 PLBOOL arg1 ;
23161 PLINT arg2 ;
23162 PLFLT *arg3 = (PLFLT *) 0 ;
23163 PLFLT *arg4 = (PLFLT *) 0 ;
23164 PLFLT *arg5 = (PLFLT *) 0 ;
23165 PLFLT *arg6 = (PLFLT *) 0 ;
23166 PLFLT *arg7 = (PLFLT *) 0 ;
23167 PLBOOL *arg8 = (PLBOOL *) 0 ;
23168 int val1 ;
23169 int ecode1 = 0 ;
23170 Matrix temp2 ;
23171 Matrix temp4 ;
23172 Matrix temp5 ;
23173 Matrix temp6 ;
23174 Matrix temp7 ;
23175 Matrix temp8 ;
23176 octave_value_list _out;
23177 octave_value_list *_outp=&_out;
23178 octave_value _outv;
23179
23180 try {
23181 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23182 SWIG_fail;
23183 }
23184 ecode1 = SWIG_AsVal_int(args(0), &val1);
23185 if (!SWIG_IsOK(ecode1)) {
23186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23187 }
23188 arg1 = static_cast< PLBOOL >(val1);
23189 {
23190 if ( _n_dims( args(1) ) > 1 )
23191 {
23192 error( "argument must be a scalar or vector" ); SWIG_fail;
23193 }
23194 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23195 temp2 = args(1).matrix_value();
23196 arg3 = &temp2( 0, 0 );
23197 }
23198 {
23199 if ( _n_dims( args(2) ) > 1 )
23200 {
23201 error( "argument must be a scalar or vector" ); SWIG_fail;
23202 }
23203 if ( _dim( args(2), 0 ) != Alen )
23204 {
23205 error( "argument vectors must be same length" ); SWIG_fail;
23206 }
23207 temp4 = args(2).matrix_value();
23208 arg4 = &temp4( 0, 0 );
23209 }
23210 {
23211 if ( _n_dims( args(3) ) > 1 )
23212 {
23213 error( "argument must be a scalar or vector" ); SWIG_fail;
23214 }
23215 if ( _dim( args(3), 0 ) != Alen )
23216 {
23217 error( "argument vectors must be same length" ); SWIG_fail;
23218 }
23219 temp5 = args(3).matrix_value();
23220 arg5 = &temp5( 0, 0 );
23221 }
23222 {
23223 if ( _n_dims( args(4) ) > 1 )
23224 {
23225 error( "argument must be a scalar or vector" ); SWIG_fail;
23226 }
23227 if ( _dim( args(4), 0 ) != Alen )
23228 {
23229 error( "argument vectors must be same length" ); SWIG_fail;
23230 }
23231 temp6 = args(4).matrix_value();
23232 arg6 = &temp6( 0, 0 );
23233 }
23234 {
23235 if ( _n_dims( args(5) ) > 1 )
23236 {
23237 error( "argument must be a scalar or vector" ); SWIG_fail;
23238 }
23239 if ( _dim( args(5), 0 ) != Alen )
23240 {
23241 error( "argument vectors must be same length" ); SWIG_fail;
23242 }
23243 temp7 = args(5).matrix_value();
23244 arg7 = &temp7( 0, 0 );
23245 }
23246 {
23247 if ( _n_dims( args(6) ) > 1 )
23248 {
23249 error( "argument must be a scalar or vector" ); SWIG_fail;
23250 }
23251 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23252 {
23253 error( "argument vector must be same length or one less" ); SWIG_fail;
23254 }
23255 temp8 = args(6).matrix_value();
23256 arg8 = new PLINT[Alen];
23257 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23258 }
23259 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23260 _outv = octave_value();
23261 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23262 {
23263
23264 }
23265 {
23266
23267 }
23268 {
23269
23270 }
23271 {
23272
23273 }
23274 {
23275
23276 }
23277 {
23278 delete [] arg8;
23279 }
23280 return _out;
23281 fail:
23282 {
23283
23284 }
23285 {
23286
23287 }
23288 {
23289
23290 }
23291 {
23292
23293 }
23294 {
23295
23296 }
23297 {
23298 delete [] arg8;
23299 }
23300 return octave_value_list();
23301 }
23302 catch(...) {
23303 {
23304
23305 }
23306 {
23307
23308 }
23309 {
23310
23311 }
23312 {
23313
23314 }
23315 {
23316
23317 }
23318 {
23319 delete [] arg8;
23320 }
23321 throw;
23322 }
23323}
23324
23325
23327 PLINT arg1 ;
23328 int val1 ;
23329 int ecode1 = 0 ;
23330 octave_value_list _out;
23331 octave_value_list *_outp=&_out;
23332 octave_value _outv;
23333
23334 try {
23335 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23336 SWIG_fail;
23337 }
23338 ecode1 = SWIG_AsVal_int(args(0), &val1);
23339 if (!SWIG_IsOK(ecode1)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23341 }
23342 arg1 = static_cast< PLINT >(val1);
23343 plscmap1n(arg1);
23344 _outv = octave_value();
23345 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23346 return _out;
23347 fail:
23348 return octave_value_list();
23349 }
23350 catch(...) {
23351 throw;
23352 }
23353}
23354
23355
23357 PLFLT arg1 ;
23358 PLFLT arg2 ;
23359 double val1 ;
23360 int ecode1 = 0 ;
23361 double val2 ;
23362 int ecode2 = 0 ;
23363 octave_value_list _out;
23364 octave_value_list *_outp=&_out;
23365 octave_value _outv;
23366
23367 try {
23368 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23369 SWIG_fail;
23370 }
23371 ecode1 = SWIG_AsVal_double(args(0), &val1);
23372 if (!SWIG_IsOK(ecode1)) {
23373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23374 }
23375 arg1 = static_cast< PLFLT >(val1);
23376 ecode2 = SWIG_AsVal_double(args(1), &val2);
23377 if (!SWIG_IsOK(ecode2)) {
23378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23379 }
23380 arg2 = static_cast< PLFLT >(val2);
23381 plscmap1_range(arg1,arg2);
23382 _outv = octave_value();
23383 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23384 return _out;
23385 fail:
23386 return octave_value_list();
23387 }
23388 catch(...) {
23389 throw;
23390 }
23391}
23392
23393
23395 PLFLT *arg1 = (PLFLT *) 0 ;
23396 PLFLT *arg2 = (PLFLT *) 0 ;
23397 PLFLT temp1 ;
23398 int res1 = SWIG_TMPOBJ ;
23399 PLFLT temp2 ;
23400 int res2 = SWIG_TMPOBJ ;
23401 octave_value_list _out;
23402 octave_value_list *_outp=&_out;
23403 octave_value _outv;
23404
23405 try {
23406 arg1 = &temp1;
23407 arg2 = &temp2;
23408 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23409 SWIG_fail;
23410 }
23411 plgcmap1_range(arg1,arg2);
23412 _outv = octave_value();
23413 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23414 if (SWIG_IsTmpObj(res1)) {
23415 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23416 } else {
23417 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23418 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23419 }
23420 if (SWIG_IsTmpObj(res2)) {
23421 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23422 } else {
23423 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23424 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23425 }
23426 return _out;
23427 fail:
23428 return octave_value_list();
23429 }
23430 catch(...) {
23431 throw;
23432 }
23433}
23434
23435
23437 PLINT arg1 ;
23438 PLINT arg2 ;
23439 PLINT arg3 ;
23440 PLINT arg4 ;
23441 int val1 ;
23442 int ecode1 = 0 ;
23443 int val2 ;
23444 int ecode2 = 0 ;
23445 int val3 ;
23446 int ecode3 = 0 ;
23447 int val4 ;
23448 int ecode4 = 0 ;
23449 octave_value_list _out;
23450 octave_value_list *_outp=&_out;
23451 octave_value _outv;
23452
23453 try {
23454 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23455 SWIG_fail;
23456 }
23457 ecode1 = SWIG_AsVal_int(args(0), &val1);
23458 if (!SWIG_IsOK(ecode1)) {
23459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23460 }
23461 arg1 = static_cast< PLINT >(val1);
23462 ecode2 = SWIG_AsVal_int(args(1), &val2);
23463 if (!SWIG_IsOK(ecode2)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23465 }
23466 arg2 = static_cast< PLINT >(val2);
23467 ecode3 = SWIG_AsVal_int(args(2), &val3);
23468 if (!SWIG_IsOK(ecode3)) {
23469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23470 }
23471 arg3 = static_cast< PLINT >(val3);
23472 ecode4 = SWIG_AsVal_int(args(3), &val4);
23473 if (!SWIG_IsOK(ecode4)) {
23474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23475 }
23476 arg4 = static_cast< PLINT >(val4);
23477 plscol0(arg1,arg2,arg3,arg4);
23478 _outv = octave_value();
23479 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23480 return _out;
23481 fail:
23482 return octave_value_list();
23483 }
23484 catch(...) {
23485 throw;
23486 }
23487}
23488
23489
23491 PLINT arg1 ;
23492 PLINT arg2 ;
23493 PLINT arg3 ;
23494 PLINT arg4 ;
23495 PLFLT arg5 ;
23496 int val1 ;
23497 int ecode1 = 0 ;
23498 int val2 ;
23499 int ecode2 = 0 ;
23500 int val3 ;
23501 int ecode3 = 0 ;
23502 int val4 ;
23503 int ecode4 = 0 ;
23504 double val5 ;
23505 int ecode5 = 0 ;
23506 octave_value_list _out;
23507 octave_value_list *_outp=&_out;
23508 octave_value _outv;
23509
23510 try {
23511 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23512 SWIG_fail;
23513 }
23514 ecode1 = SWIG_AsVal_int(args(0), &val1);
23515 if (!SWIG_IsOK(ecode1)) {
23516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23517 }
23518 arg1 = static_cast< PLINT >(val1);
23519 ecode2 = SWIG_AsVal_int(args(1), &val2);
23520 if (!SWIG_IsOK(ecode2)) {
23521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23522 }
23523 arg2 = static_cast< PLINT >(val2);
23524 ecode3 = SWIG_AsVal_int(args(2), &val3);
23525 if (!SWIG_IsOK(ecode3)) {
23526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23527 }
23528 arg3 = static_cast< PLINT >(val3);
23529 ecode4 = SWIG_AsVal_int(args(3), &val4);
23530 if (!SWIG_IsOK(ecode4)) {
23531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23532 }
23533 arg4 = static_cast< PLINT >(val4);
23534 ecode5 = SWIG_AsVal_double(args(4), &val5);
23535 if (!SWIG_IsOK(ecode5)) {
23536 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23537 }
23538 arg5 = static_cast< PLFLT >(val5);
23539 plscol0a(arg1,arg2,arg3,arg4,arg5);
23540 _outv = octave_value();
23541 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23542 return _out;
23543 fail:
23544 return octave_value_list();
23545 }
23546 catch(...) {
23547 throw;
23548 }
23549}
23550
23551
23553 PLINT arg1 ;
23554 PLINT arg2 ;
23555 PLINT arg3 ;
23556 int val1 ;
23557 int ecode1 = 0 ;
23558 int val2 ;
23559 int ecode2 = 0 ;
23560 int val3 ;
23561 int ecode3 = 0 ;
23562 octave_value_list _out;
23563 octave_value_list *_outp=&_out;
23564 octave_value _outv;
23565
23566 try {
23567 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23568 SWIG_fail;
23569 }
23570 ecode1 = SWIG_AsVal_int(args(0), &val1);
23571 if (!SWIG_IsOK(ecode1)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23573 }
23574 arg1 = static_cast< PLINT >(val1);
23575 ecode2 = SWIG_AsVal_int(args(1), &val2);
23576 if (!SWIG_IsOK(ecode2)) {
23577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23578 }
23579 arg2 = static_cast< PLINT >(val2);
23580 ecode3 = SWIG_AsVal_int(args(2), &val3);
23581 if (!SWIG_IsOK(ecode3)) {
23582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23583 }
23584 arg3 = static_cast< PLINT >(val3);
23585 plscolbg(arg1,arg2,arg3);
23586 _outv = octave_value();
23587 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23588 return _out;
23589 fail:
23590 return octave_value_list();
23591 }
23592 catch(...) {
23593 throw;
23594 }
23595}
23596
23597
23599 PLINT arg1 ;
23600 PLINT arg2 ;
23601 PLINT arg3 ;
23602 PLFLT arg4 ;
23603 int val1 ;
23604 int ecode1 = 0 ;
23605 int val2 ;
23606 int ecode2 = 0 ;
23607 int val3 ;
23608 int ecode3 = 0 ;
23609 double val4 ;
23610 int ecode4 = 0 ;
23611 octave_value_list _out;
23612 octave_value_list *_outp=&_out;
23613 octave_value _outv;
23614
23615 try {
23616 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23617 SWIG_fail;
23618 }
23619 ecode1 = SWIG_AsVal_int(args(0), &val1);
23620 if (!SWIG_IsOK(ecode1)) {
23621 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23622 }
23623 arg1 = static_cast< PLINT >(val1);
23624 ecode2 = SWIG_AsVal_int(args(1), &val2);
23625 if (!SWIG_IsOK(ecode2)) {
23626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23627 }
23628 arg2 = static_cast< PLINT >(val2);
23629 ecode3 = SWIG_AsVal_int(args(2), &val3);
23630 if (!SWIG_IsOK(ecode3)) {
23631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23632 }
23633 arg3 = static_cast< PLINT >(val3);
23634 ecode4 = SWIG_AsVal_double(args(3), &val4);
23635 if (!SWIG_IsOK(ecode4)) {
23636 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23637 }
23638 arg4 = static_cast< PLFLT >(val4);
23639 plscolbga(arg1,arg2,arg3,arg4);
23640 _outv = octave_value();
23641 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23642 return _out;
23643 fail:
23644 return octave_value_list();
23645 }
23646 catch(...) {
23647 throw;
23648 }
23649}
23650
23651
23653 PLINT arg1 ;
23654 int val1 ;
23655 int ecode1 = 0 ;
23656 octave_value_list _out;
23657 octave_value_list *_outp=&_out;
23658 octave_value _outv;
23659
23660 try {
23661 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23662 SWIG_fail;
23663 }
23664 ecode1 = SWIG_AsVal_int(args(0), &val1);
23665 if (!SWIG_IsOK(ecode1)) {
23666 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23667 }
23668 arg1 = static_cast< PLINT >(val1);
23669 plscolor(arg1);
23670 _outv = octave_value();
23671 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23672 return _out;
23673 fail:
23674 return octave_value_list();
23675 }
23676 catch(...) {
23677 throw;
23678 }
23679}
23680
23681
23683 PLINT arg1 ;
23684 int val1 ;
23685 int ecode1 = 0 ;
23686 octave_value_list _out;
23687 octave_value_list *_outp=&_out;
23688 octave_value _outv;
23689
23690 try {
23691 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23692 SWIG_fail;
23693 }
23694 ecode1 = SWIG_AsVal_int(args(0), &val1);
23695 if (!SWIG_IsOK(ecode1)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23697 }
23698 arg1 = static_cast< PLINT >(val1);
23699 plscompression(arg1);
23700 _outv = octave_value();
23701 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23702 return _out;
23703 fail:
23704 return octave_value_list();
23705 }
23706 catch(...) {
23707 throw;
23708 }
23709}
23710
23711
23713 char *arg1 = (char *) 0 ;
23714 int res1 ;
23715 char *buf1 = 0 ;
23716 int alloc1 = 0 ;
23717 octave_value_list _out;
23718 octave_value_list *_outp=&_out;
23719 octave_value _outv;
23720
23721 try {
23722 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23723 SWIG_fail;
23724 }
23725 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23726 if (!SWIG_IsOK(res1)) {
23727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23728 }
23729 arg1 = reinterpret_cast< char * >(buf1);
23730 plsdev((char const *)arg1);
23731 _outv = octave_value();
23732 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23733 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23734 return _out;
23735 fail:
23736 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23737 return octave_value_list();
23738 }
23739 catch(...) {
23740 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23741 throw;
23742 }
23743}
23744
23745
23747 PLFLT arg1 ;
23748 PLFLT arg2 ;
23749 PLFLT arg3 ;
23750 PLFLT arg4 ;
23751 double val1 ;
23752 int ecode1 = 0 ;
23753 double val2 ;
23754 int ecode2 = 0 ;
23755 double val3 ;
23756 int ecode3 = 0 ;
23757 double val4 ;
23758 int ecode4 = 0 ;
23759 octave_value_list _out;
23760 octave_value_list *_outp=&_out;
23761 octave_value _outv;
23762
23763 try {
23764 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23765 SWIG_fail;
23766 }
23767 ecode1 = SWIG_AsVal_double(args(0), &val1);
23768 if (!SWIG_IsOK(ecode1)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23770 }
23771 arg1 = static_cast< PLFLT >(val1);
23772 ecode2 = SWIG_AsVal_double(args(1), &val2);
23773 if (!SWIG_IsOK(ecode2)) {
23774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23775 }
23776 arg2 = static_cast< PLFLT >(val2);
23777 ecode3 = SWIG_AsVal_double(args(2), &val3);
23778 if (!SWIG_IsOK(ecode3)) {
23779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23780 }
23781 arg3 = static_cast< PLFLT >(val3);
23782 ecode4 = SWIG_AsVal_double(args(3), &val4);
23783 if (!SWIG_IsOK(ecode4)) {
23784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23785 }
23786 arg4 = static_cast< PLFLT >(val4);
23787 plsdidev(arg1,arg2,arg3,arg4);
23788 _outv = octave_value();
23789 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23790 return _out;
23791 fail:
23792 return octave_value_list();
23793 }
23794 catch(...) {
23795 throw;
23796 }
23797}
23798
23799
23801 PLINT arg1 ;
23802 PLINT arg2 ;
23803 PLINT arg3 ;
23804 PLINT arg4 ;
23805 PLFLT arg5 ;
23806 PLFLT arg6 ;
23807 int val1 ;
23808 int ecode1 = 0 ;
23809 int val2 ;
23810 int ecode2 = 0 ;
23811 int val3 ;
23812 int ecode3 = 0 ;
23813 int val4 ;
23814 int ecode4 = 0 ;
23815 double val5 ;
23816 int ecode5 = 0 ;
23817 double val6 ;
23818 int ecode6 = 0 ;
23819 octave_value_list _out;
23820 octave_value_list *_outp=&_out;
23821 octave_value _outv;
23822
23823 try {
23824 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23825 SWIG_fail;
23826 }
23827 ecode1 = SWIG_AsVal_int(args(0), &val1);
23828 if (!SWIG_IsOK(ecode1)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23830 }
23831 arg1 = static_cast< PLINT >(val1);
23832 ecode2 = SWIG_AsVal_int(args(1), &val2);
23833 if (!SWIG_IsOK(ecode2)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23835 }
23836 arg2 = static_cast< PLINT >(val2);
23837 ecode3 = SWIG_AsVal_int(args(2), &val3);
23838 if (!SWIG_IsOK(ecode3)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23840 }
23841 arg3 = static_cast< PLINT >(val3);
23842 ecode4 = SWIG_AsVal_int(args(3), &val4);
23843 if (!SWIG_IsOK(ecode4)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23845 }
23846 arg4 = static_cast< PLINT >(val4);
23847 ecode5 = SWIG_AsVal_double(args(4), &val5);
23848 if (!SWIG_IsOK(ecode5)) {
23849 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23850 }
23851 arg5 = static_cast< PLFLT >(val5);
23852 ecode6 = SWIG_AsVal_double(args(5), &val6);
23853 if (!SWIG_IsOK(ecode6)) {
23854 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23855 }
23856 arg6 = static_cast< PLFLT >(val6);
23857 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23858 _outv = octave_value();
23859 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23860 return _out;
23861 fail:
23862 return octave_value_list();
23863 }
23864 catch(...) {
23865 throw;
23866 }
23867}
23868
23869
23871 PLFLT arg1 ;
23872 double val1 ;
23873 int ecode1 = 0 ;
23874 octave_value_list _out;
23875 octave_value_list *_outp=&_out;
23876 octave_value _outv;
23877
23878 try {
23879 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23880 SWIG_fail;
23881 }
23882 ecode1 = SWIG_AsVal_double(args(0), &val1);
23883 if (!SWIG_IsOK(ecode1)) {
23884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23885 }
23886 arg1 = static_cast< PLFLT >(val1);
23887 plsdiori(arg1);
23888 _outv = octave_value();
23889 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23890 return _out;
23891 fail:
23892 return octave_value_list();
23893 }
23894 catch(...) {
23895 throw;
23896 }
23897}
23898
23899
23901 PLFLT arg1 ;
23902 PLFLT arg2 ;
23903 PLFLT arg3 ;
23904 PLFLT arg4 ;
23905 double val1 ;
23906 int ecode1 = 0 ;
23907 double val2 ;
23908 int ecode2 = 0 ;
23909 double val3 ;
23910 int ecode3 = 0 ;
23911 double val4 ;
23912 int ecode4 = 0 ;
23913 octave_value_list _out;
23914 octave_value_list *_outp=&_out;
23915 octave_value _outv;
23916
23917 try {
23918 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23919 SWIG_fail;
23920 }
23921 ecode1 = SWIG_AsVal_double(args(0), &val1);
23922 if (!SWIG_IsOK(ecode1)) {
23923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23924 }
23925 arg1 = static_cast< PLFLT >(val1);
23926 ecode2 = SWIG_AsVal_double(args(1), &val2);
23927 if (!SWIG_IsOK(ecode2)) {
23928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23929 }
23930 arg2 = static_cast< PLFLT >(val2);
23931 ecode3 = SWIG_AsVal_double(args(2), &val3);
23932 if (!SWIG_IsOK(ecode3)) {
23933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23934 }
23935 arg3 = static_cast< PLFLT >(val3);
23936 ecode4 = SWIG_AsVal_double(args(3), &val4);
23937 if (!SWIG_IsOK(ecode4)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23939 }
23940 arg4 = static_cast< PLFLT >(val4);
23941 plsdiplt(arg1,arg2,arg3,arg4);
23942 _outv = octave_value();
23943 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23944 return _out;
23945 fail:
23946 return octave_value_list();
23947 }
23948 catch(...) {
23949 throw;
23950 }
23951}
23952
23953
23955 PLFLT arg1 ;
23956 PLFLT arg2 ;
23957 PLFLT arg3 ;
23958 PLFLT arg4 ;
23959 double val1 ;
23960 int ecode1 = 0 ;
23961 double val2 ;
23962 int ecode2 = 0 ;
23963 double val3 ;
23964 int ecode3 = 0 ;
23965 double val4 ;
23966 int ecode4 = 0 ;
23967 octave_value_list _out;
23968 octave_value_list *_outp=&_out;
23969 octave_value _outv;
23970
23971 try {
23972 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23973 SWIG_fail;
23974 }
23975 ecode1 = SWIG_AsVal_double(args(0), &val1);
23976 if (!SWIG_IsOK(ecode1)) {
23977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23978 }
23979 arg1 = static_cast< PLFLT >(val1);
23980 ecode2 = SWIG_AsVal_double(args(1), &val2);
23981 if (!SWIG_IsOK(ecode2)) {
23982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23983 }
23984 arg2 = static_cast< PLFLT >(val2);
23985 ecode3 = SWIG_AsVal_double(args(2), &val3);
23986 if (!SWIG_IsOK(ecode3)) {
23987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23988 }
23989 arg3 = static_cast< PLFLT >(val3);
23990 ecode4 = SWIG_AsVal_double(args(3), &val4);
23991 if (!SWIG_IsOK(ecode4)) {
23992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23993 }
23994 arg4 = static_cast< PLFLT >(val4);
23995 plsdiplz(arg1,arg2,arg3,arg4);
23996 _outv = octave_value();
23997 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23998 return _out;
23999 fail:
24000 return octave_value_list();
24001 }
24002 catch(...) {
24003 throw;
24004 }
24005}
24006
24007
24009 unsigned int arg1 ;
24010 unsigned int val1 ;
24011 int ecode1 = 0 ;
24012 octave_value_list _out;
24013 octave_value_list *_outp=&_out;
24014 octave_value _outv;
24015
24016 try {
24017 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
24018 SWIG_fail;
24019 }
24020 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24021 if (!SWIG_IsOK(ecode1)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
24023 }
24024 arg1 = static_cast< unsigned int >(val1);
24025 plseed(arg1);
24026 _outv = octave_value();
24027 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24028 return _out;
24029 fail:
24030 return octave_value_list();
24031 }
24032 catch(...) {
24033 throw;
24034 }
24035}
24036
24037
24039 char arg1 ;
24040 char val1 ;
24041 int ecode1 = 0 ;
24042 octave_value_list _out;
24043 octave_value_list *_outp=&_out;
24044 octave_value _outv;
24045
24046 try {
24047 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
24048 SWIG_fail;
24049 }
24050 ecode1 = SWIG_AsVal_char(args(0), &val1);
24051 if (!SWIG_IsOK(ecode1)) {
24052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
24053 }
24054 arg1 = static_cast< char >(val1);
24055 plsesc(arg1);
24056 _outv = octave_value();
24057 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24058 return _out;
24059 fail:
24060 return octave_value_list();
24061 }
24062 catch(...) {
24063 throw;
24064 }
24065}
24066
24067
24068SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
24069 char *arg1 = (char *) 0 ;
24070 char *arg2 = (char *) 0 ;
24071 int res1 ;
24072 char *buf1 = 0 ;
24073 int alloc1 = 0 ;
24074 int res2 ;
24075 char *buf2 = 0 ;
24076 int alloc2 = 0 ;
24077 octave_value_list _out;
24078 octave_value_list *_outp=&_out;
24079 octave_value _outv;
24080 PLINT result;
24081
24082 try {
24083 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24084 SWIG_fail;
24085 }
24086 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24087 if (!SWIG_IsOK(res1)) {
24088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24089 }
24090 arg1 = reinterpret_cast< char * >(buf1);
24091 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24092 if (!SWIG_IsOK(res2)) {
24093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24094 }
24095 arg2 = reinterpret_cast< char * >(buf2);
24096 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24097 _outv = SWIG_From_int(static_cast< int >(result));
24098 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24099 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24100 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24101 return _out;
24102 fail:
24103 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24104 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24105 return octave_value_list();
24106 }
24107 catch(...) {
24108 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24109 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24110 throw;
24111 }
24112}
24113
24114
24116 PLINT arg1 ;
24117 PLINT arg2 ;
24118 PLINT arg3 ;
24119 int val1 ;
24120 int ecode1 = 0 ;
24121 int val2 ;
24122 int ecode2 = 0 ;
24123 int val3 ;
24124 int ecode3 = 0 ;
24125 octave_value_list _out;
24126 octave_value_list *_outp=&_out;
24127 octave_value _outv;
24128
24129 try {
24130 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24131 SWIG_fail;
24132 }
24133 ecode1 = SWIG_AsVal_int(args(0), &val1);
24134 if (!SWIG_IsOK(ecode1)) {
24135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24136 }
24137 arg1 = static_cast< PLINT >(val1);
24138 ecode2 = SWIG_AsVal_int(args(1), &val2);
24139 if (!SWIG_IsOK(ecode2)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24141 }
24142 arg2 = static_cast< PLINT >(val2);
24143 ecode3 = SWIG_AsVal_int(args(2), &val3);
24144 if (!SWIG_IsOK(ecode3)) {
24145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24146 }
24147 arg3 = static_cast< PLINT >(val3);
24148 plsfam(arg1,arg2,arg3);
24149 _outv = octave_value();
24150 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24151 return _out;
24152 fail:
24153 return octave_value_list();
24154 }
24155 catch(...) {
24156 throw;
24157 }
24158}
24159
24160
24162 PLUNICODE arg1 ;
24163 unsigned int val1 ;
24164 int ecode1 = 0 ;
24165 octave_value_list _out;
24166 octave_value_list *_outp=&_out;
24167 octave_value _outv;
24168
24169 try {
24170 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24171 SWIG_fail;
24172 }
24173 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24174 if (!SWIG_IsOK(ecode1)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24176 }
24177 arg1 = static_cast< PLUNICODE >(val1);
24178 plsfci(arg1);
24179 _outv = octave_value();
24180 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24181 return _out;
24182 fail:
24183 return octave_value_list();
24184 }
24185 catch(...) {
24186 throw;
24187 }
24188}
24189
24190
24192 char *arg1 = (char *) 0 ;
24193 int res1 ;
24194 char *buf1 = 0 ;
24195 int alloc1 = 0 ;
24196 octave_value_list _out;
24197 octave_value_list *_outp=&_out;
24198 octave_value _outv;
24199
24200 try {
24201 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24202 SWIG_fail;
24203 }
24204 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24205 if (!SWIG_IsOK(res1)) {
24206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24207 }
24208 arg1 = reinterpret_cast< char * >(buf1);
24209 plsfnam((char const *)arg1);
24210 _outv = octave_value();
24211 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24212 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24213 return _out;
24214 fail:
24215 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24216 return octave_value_list();
24217 }
24218 catch(...) {
24219 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24220 throw;
24221 }
24222}
24223
24224
24226 PLINT arg1 ;
24227 PLINT arg2 ;
24228 PLINT arg3 ;
24229 int val1 ;
24230 int ecode1 = 0 ;
24231 int val2 ;
24232 int ecode2 = 0 ;
24233 int val3 ;
24234 int ecode3 = 0 ;
24235 octave_value_list _out;
24236 octave_value_list *_outp=&_out;
24237 octave_value _outv;
24238
24239 try {
24240 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24241 SWIG_fail;
24242 }
24243 ecode1 = SWIG_AsVal_int(args(0), &val1);
24244 if (!SWIG_IsOK(ecode1)) {
24245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24246 }
24247 arg1 = static_cast< PLINT >(val1);
24248 ecode2 = SWIG_AsVal_int(args(1), &val2);
24249 if (!SWIG_IsOK(ecode2)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24251 }
24252 arg2 = static_cast< PLINT >(val2);
24253 ecode3 = SWIG_AsVal_int(args(2), &val3);
24254 if (!SWIG_IsOK(ecode3)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24256 }
24257 arg3 = static_cast< PLINT >(val3);
24258 plsfont(arg1,arg2,arg3);
24259 _outv = octave_value();
24260 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24261 return _out;
24262 fail:
24263 return octave_value_list();
24264 }
24265 catch(...) {
24266 throw;
24267 }
24268}
24269
24270
24272 label_func arg1 = (label_func) 0 ;
24273 PLPointer arg2 = (PLPointer) 0 ;
24274 int res2 ;
24275 octave_value_list _out;
24276 octave_value_list *_outp=&_out;
24277 octave_value _outv;
24278
24279 try {
24280 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24281 SWIG_fail;
24282 }
24283 {
24284 octave_value obj = args(0);
24285#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24286 if ( !obj.isempty() )
24287#else
24288 if ( !obj.is_empty() )
24289#endif
24290 {
24291 if ( obj.is_function_handle() || obj.is_inline_function() )
24292 {
24293 fcnLabelFunc = obj.function_value();
24294 }
24295 else if ( obj.is_string() )
24296 {
24297 nameLabelFunc = obj.string_value();
24298 fcnLabelFunc = NULL;
24299 }
24300 arg1 = labelfunc_octave;
24301 }
24302 else
24303 {
24304 arg1 = NULL;
24305 }
24306 }
24307 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24308 if (!SWIG_IsOK(res2)) {
24309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24310 }
24311 plslabelfunc(arg1,arg2);
24312 _outv = octave_value();
24313 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24314 return _out;
24315 fail:
24316 return octave_value_list();
24317 }
24318 catch(...) {
24319 throw;
24320 }
24321}
24322
24323
24325 PLFLT arg1 ;
24326 PLFLT arg2 ;
24327 double val1 ;
24328 int ecode1 = 0 ;
24329 double val2 ;
24330 int ecode2 = 0 ;
24331 octave_value_list _out;
24332 octave_value_list *_outp=&_out;
24333 octave_value _outv;
24334
24335 try {
24336 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24337 SWIG_fail;
24338 }
24339 ecode1 = SWIG_AsVal_double(args(0), &val1);
24340 if (!SWIG_IsOK(ecode1)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24342 }
24343 arg1 = static_cast< PLFLT >(val1);
24344 ecode2 = SWIG_AsVal_double(args(1), &val2);
24345 if (!SWIG_IsOK(ecode2)) {
24346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24347 }
24348 arg2 = static_cast< PLFLT >(val2);
24349 plsmaj(arg1,arg2);
24350 _outv = octave_value();
24351 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24352 return _out;
24353 fail:
24354 return octave_value_list();
24355 }
24356 catch(...) {
24357 throw;
24358 }
24359}
24360
24361
24363 PLFLT arg1 ;
24364 PLFLT arg2 ;
24365 double val1 ;
24366 int ecode1 = 0 ;
24367 double val2 ;
24368 int ecode2 = 0 ;
24369 octave_value_list _out;
24370 octave_value_list *_outp=&_out;
24371 octave_value _outv;
24372
24373 try {
24374 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24375 SWIG_fail;
24376 }
24377 ecode1 = SWIG_AsVal_double(args(0), &val1);
24378 if (!SWIG_IsOK(ecode1)) {
24379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24380 }
24381 arg1 = static_cast< PLFLT >(val1);
24382 ecode2 = SWIG_AsVal_double(args(1), &val2);
24383 if (!SWIG_IsOK(ecode2)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24385 }
24386 arg2 = static_cast< PLFLT >(val2);
24387 plsmin(arg1,arg2);
24388 _outv = octave_value();
24389 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24390 return _out;
24391 fail:
24392 return octave_value_list();
24393 }
24394 catch(...) {
24395 throw;
24396 }
24397}
24398
24399
24401 PLINT arg1 ;
24402 int val1 ;
24403 int ecode1 = 0 ;
24404 octave_value_list _out;
24405 octave_value_list *_outp=&_out;
24406 octave_value _outv;
24407
24408 try {
24409 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24410 SWIG_fail;
24411 }
24412 ecode1 = SWIG_AsVal_int(args(0), &val1);
24413 if (!SWIG_IsOK(ecode1)) {
24414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24415 }
24416 arg1 = static_cast< PLINT >(val1);
24417 plsori(arg1);
24418 _outv = octave_value();
24419 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24420 return _out;
24421 fail:
24422 return octave_value_list();
24423 }
24424 catch(...) {
24425 throw;
24426 }
24427}
24428
24429
24431 PLFLT arg1 ;
24432 PLFLT arg2 ;
24433 PLINT arg3 ;
24434 PLINT arg4 ;
24435 PLINT arg5 ;
24436 PLINT arg6 ;
24437 double val1 ;
24438 int ecode1 = 0 ;
24439 double val2 ;
24440 int ecode2 = 0 ;
24441 int val3 ;
24442 int ecode3 = 0 ;
24443 int val4 ;
24444 int ecode4 = 0 ;
24445 int val5 ;
24446 int ecode5 = 0 ;
24447 int val6 ;
24448 int ecode6 = 0 ;
24449 octave_value_list _out;
24450 octave_value_list *_outp=&_out;
24451 octave_value _outv;
24452
24453 try {
24454 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24455 SWIG_fail;
24456 }
24457 ecode1 = SWIG_AsVal_double(args(0), &val1);
24458 if (!SWIG_IsOK(ecode1)) {
24459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24460 }
24461 arg1 = static_cast< PLFLT >(val1);
24462 ecode2 = SWIG_AsVal_double(args(1), &val2);
24463 if (!SWIG_IsOK(ecode2)) {
24464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24465 }
24466 arg2 = static_cast< PLFLT >(val2);
24467 ecode3 = SWIG_AsVal_int(args(2), &val3);
24468 if (!SWIG_IsOK(ecode3)) {
24469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24470 }
24471 arg3 = static_cast< PLINT >(val3);
24472 ecode4 = SWIG_AsVal_int(args(3), &val4);
24473 if (!SWIG_IsOK(ecode4)) {
24474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24475 }
24476 arg4 = static_cast< PLINT >(val4);
24477 ecode5 = SWIG_AsVal_int(args(4), &val5);
24478 if (!SWIG_IsOK(ecode5)) {
24479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24480 }
24481 arg5 = static_cast< PLINT >(val5);
24482 ecode6 = SWIG_AsVal_int(args(5), &val6);
24483 if (!SWIG_IsOK(ecode6)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24485 }
24486 arg6 = static_cast< PLINT >(val6);
24487 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24488 _outv = octave_value();
24489 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24490 return _out;
24491 fail:
24492 return octave_value_list();
24493 }
24494 catch(...) {
24495 throw;
24496 }
24497}
24498
24499
24501 char *arg1 = (char *) 0 ;
24502 int res1 ;
24503 char *buf1 = 0 ;
24504 int alloc1 = 0 ;
24505 octave_value_list _out;
24506 octave_value_list *_outp=&_out;
24507 octave_value _outv;
24508
24509 try {
24510 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24511 SWIG_fail;
24512 }
24513 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24516 }
24517 arg1 = reinterpret_cast< char * >(buf1);
24518 plspal0((char const *)arg1);
24519 _outv = octave_value();
24520 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24521 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24522 return _out;
24523 fail:
24524 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24525 return octave_value_list();
24526 }
24527 catch(...) {
24528 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24529 throw;
24530 }
24531}
24532
24533
24535 char *arg1 = (char *) 0 ;
24536 PLBOOL arg2 ;
24537 int res1 ;
24538 char *buf1 = 0 ;
24539 int alloc1 = 0 ;
24540 int 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("plspal1",args.length(),2,2,0)) {
24548 SWIG_fail;
24549 }
24550 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24551 if (!SWIG_IsOK(res1)) {
24552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24553 }
24554 arg1 = reinterpret_cast< char * >(buf1);
24555 ecode2 = SWIG_AsVal_int(args(1), &val2);
24556 if (!SWIG_IsOK(ecode2)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24558 }
24559 arg2 = static_cast< PLBOOL >(val2);
24560 plspal1((char const *)arg1,arg2);
24561 _outv = octave_value();
24562 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24563 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24564 return _out;
24565 fail:
24566 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24567 return octave_value_list();
24568 }
24569 catch(...) {
24570 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24571 throw;
24572 }
24573}
24574
24575
24577 PLBOOL arg1 ;
24578 int val1 ;
24579 int ecode1 = 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("plspause",args.length(),1,1,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 '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24591 }
24592 arg1 = static_cast< PLBOOL >(val1);
24593 plspause(arg1);
24594 _outv = octave_value();
24595 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24596 return _out;
24597 fail:
24598 return octave_value_list();
24599 }
24600 catch(...) {
24601 throw;
24602 }
24603}
24604
24605
24606SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24607 PLINT arg1 ;
24608 int val1 ;
24609 int ecode1 = 0 ;
24610 octave_value_list _out;
24611 octave_value_list *_outp=&_out;
24612 octave_value _outv;
24613
24614 try {
24615 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24616 SWIG_fail;
24617 }
24618 ecode1 = SWIG_AsVal_int(args(0), &val1);
24619 if (!SWIG_IsOK(ecode1)) {
24620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24621 }
24622 arg1 = static_cast< PLINT >(val1);
24623 plsstrm(arg1);
24624 _outv = octave_value();
24625 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24626 return _out;
24627 fail:
24628 return octave_value_list();
24629 }
24630 catch(...) {
24631 throw;
24632 }
24633}
24634
24635
24637 PLINT arg1 ;
24638 PLINT arg2 ;
24639 int val1 ;
24640 int ecode1 = 0 ;
24641 int val2 ;
24642 int ecode2 = 0 ;
24643 octave_value_list _out;
24644 octave_value_list *_outp=&_out;
24645 octave_value _outv;
24646
24647 try {
24648 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24649 SWIG_fail;
24650 }
24651 ecode1 = SWIG_AsVal_int(args(0), &val1);
24652 if (!SWIG_IsOK(ecode1)) {
24653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24654 }
24655 arg1 = static_cast< PLINT >(val1);
24656 ecode2 = SWIG_AsVal_int(args(1), &val2);
24657 if (!SWIG_IsOK(ecode2)) {
24658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24659 }
24660 arg2 = static_cast< PLINT >(val2);
24661 plssub(arg1,arg2);
24662 _outv = octave_value();
24663 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24664 return _out;
24665 fail:
24666 return octave_value_list();
24667 }
24668 catch(...) {
24669 throw;
24670 }
24671}
24672
24673
24675 PLFLT arg1 ;
24676 PLFLT arg2 ;
24677 double val1 ;
24678 int ecode1 = 0 ;
24679 double val2 ;
24680 int ecode2 = 0 ;
24681 octave_value_list _out;
24682 octave_value_list *_outp=&_out;
24683 octave_value _outv;
24684
24685 try {
24686 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24687 SWIG_fail;
24688 }
24689 ecode1 = SWIG_AsVal_double(args(0), &val1);
24690 if (!SWIG_IsOK(ecode1)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24692 }
24693 arg1 = static_cast< PLFLT >(val1);
24694 ecode2 = SWIG_AsVal_double(args(1), &val2);
24695 if (!SWIG_IsOK(ecode2)) {
24696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24697 }
24698 arg2 = static_cast< PLFLT >(val2);
24699 plssym(arg1,arg2);
24700 _outv = octave_value();
24701 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24702 return _out;
24703 fail:
24704 return octave_value_list();
24705 }
24706 catch(...) {
24707 throw;
24708 }
24709}
24710
24711
24713 PLINT arg1 ;
24714 PLINT arg2 ;
24715 int val1 ;
24716 int ecode1 = 0 ;
24717 int val2 ;
24718 int ecode2 = 0 ;
24719 octave_value_list _out;
24720 octave_value_list *_outp=&_out;
24721 octave_value _outv;
24722
24723 try {
24724 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24725 SWIG_fail;
24726 }
24727 ecode1 = SWIG_AsVal_int(args(0), &val1);
24728 if (!SWIG_IsOK(ecode1)) {
24729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24730 }
24731 arg1 = static_cast< PLINT >(val1);
24732 ecode2 = SWIG_AsVal_int(args(1), &val2);
24733 if (!SWIG_IsOK(ecode2)) {
24734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24735 }
24736 arg2 = static_cast< PLINT >(val2);
24737 plstar(arg1,arg2);
24738 _outv = octave_value();
24739 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24740 return _out;
24741 fail:
24742 return octave_value_list();
24743 }
24744 catch(...) {
24745 throw;
24746 }
24747}
24748
24749
24751 char *arg1 = (char *) 0 ;
24752 PLINT arg2 ;
24753 PLINT arg3 ;
24754 int res1 ;
24755 char *buf1 = 0 ;
24756 int alloc1 = 0 ;
24757 int val2 ;
24758 int ecode2 = 0 ;
24759 int val3 ;
24760 int ecode3 = 0 ;
24761 octave_value_list _out;
24762 octave_value_list *_outp=&_out;
24763 octave_value _outv;
24764
24765 try {
24766 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24767 SWIG_fail;
24768 }
24769 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24770 if (!SWIG_IsOK(res1)) {
24771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24772 }
24773 arg1 = reinterpret_cast< char * >(buf1);
24774 ecode2 = SWIG_AsVal_int(args(1), &val2);
24775 if (!SWIG_IsOK(ecode2)) {
24776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24777 }
24778 arg2 = static_cast< PLINT >(val2);
24779 ecode3 = SWIG_AsVal_int(args(2), &val3);
24780 if (!SWIG_IsOK(ecode3)) {
24781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24782 }
24783 arg3 = static_cast< PLINT >(val3);
24784 plstart((char const *)arg1,arg2,arg3);
24785 _outv = octave_value();
24786 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24787 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24788 return _out;
24789 fail:
24790 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24791 return octave_value_list();
24792 }
24793 catch(...) {
24794 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24795 throw;
24796 }
24797}
24798
24799
24801 ct_func arg1 = (ct_func) 0 ;
24802 PLPointer arg2 = (PLPointer) 0 ;
24803 int res2 ;
24804 octave_value_list _out;
24805 octave_value_list *_outp=&_out;
24806 octave_value _outv;
24807
24808 try {
24809 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24810 SWIG_fail;
24811 }
24812 {
24813 octave_value obj = args(0);
24814#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24815 if ( !obj.isempty() )
24816#else
24817 if ( !obj.is_empty() )
24818#endif
24819 {
24820 if ( obj.is_function_handle() || obj.is_inline_function() )
24821 {
24822 fcnCoordTrans = obj.function_value();
24823 }
24824 else if ( obj.is_string() )
24825 {
24826 nameCoordTrans = obj.string_value();
24827 fcnCoordTrans = NULL;
24828 }
24829 arg1 = ct_octave;
24830 }
24831 else
24832 {
24833 arg1 = NULL;
24834 }
24835 }
24836 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24837 if (!SWIG_IsOK(res2)) {
24838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24839 }
24840 plstransform(arg1,arg2);
24841 _outv = octave_value();
24842 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24843 return _out;
24844 fail:
24845 return octave_value_list();
24846 }
24847 catch(...) {
24848 throw;
24849 }
24850}
24851
24852
24854 PLINT arg1 ;
24855 PLFLT *arg2 = (PLFLT *) 0 ;
24856 PLFLT *arg3 = (PLFLT *) 0 ;
24857 char *arg4 = (char *) 0 ;
24858 Matrix temp1 ;
24859 Matrix temp3 ;
24860 int res4 ;
24861 char *buf4 = 0 ;
24862 int alloc4 = 0 ;
24863 octave_value_list _out;
24864 octave_value_list *_outp=&_out;
24865 octave_value _outv;
24866
24867 try {
24868 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24869 SWIG_fail;
24870 }
24871 {
24872 if ( _n_dims( args(0) ) > 1 )
24873 {
24874 error( "argument must be a scalar or vector" ); SWIG_fail;
24875 }
24876 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24877 temp1 = args(0).matrix_value();
24878 arg2 = &temp1( 0, 0 );
24879 }
24880 {
24881 if ( _n_dims( args(1) ) > 1 )
24882 {
24883 error( "argument must be a scalar or vector" ); SWIG_fail;
24884 }
24885 if ( _dim( args(1), 0 ) != Alen )
24886 {
24887 error( "argument vectors must be same length" ); SWIG_fail;
24888 }
24889 temp3 = args(1).matrix_value();
24890 arg3 = &temp3( 0, 0 );
24891 }
24892 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24893 if (!SWIG_IsOK(res4)) {
24894 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24895 }
24896 arg4 = reinterpret_cast< char * >(buf4);
24897 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24898 _outv = octave_value();
24899 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24900 {
24901
24902 }
24903 {
24904
24905 }
24906 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24907 return _out;
24908 fail:
24909 {
24910
24911 }
24912 {
24913
24914 }
24915 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24916 return octave_value_list();
24917 }
24918 catch(...) {
24919 {
24920
24921 }
24922 {
24923
24924 }
24925 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24926 throw;
24927 }
24928}
24929
24930
24932 PLINT arg1 ;
24933 PLFLT *arg2 = (PLFLT *) 0 ;
24934 PLFLT *arg3 = (PLFLT *) 0 ;
24935 PLFLT *arg4 = (PLFLT *) 0 ;
24936 char *arg5 = (char *) 0 ;
24937 Matrix temp1 ;
24938 Matrix temp3 ;
24939 Matrix temp4 ;
24940 int res5 ;
24941 char *buf5 = 0 ;
24942 int alloc5 = 0 ;
24943 octave_value_list _out;
24944 octave_value_list *_outp=&_out;
24945 octave_value _outv;
24946
24947 try {
24948 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24949 SWIG_fail;
24950 }
24951 {
24952 if ( _n_dims( args(0) ) > 1 )
24953 {
24954 error( "argument must be a scalar or vector" ); SWIG_fail;
24955 }
24956 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24957 temp1 = args(0).matrix_value();
24958 arg2 = &temp1( 0, 0 );
24959 }
24960 {
24961 if ( _n_dims( args(1) ) > 1 )
24962 {
24963 error( "argument must be a scalar or vector" ); SWIG_fail;
24964 }
24965 if ( _dim( args(1), 0 ) != Alen )
24966 {
24967 error( "argument vectors must be same length" ); SWIG_fail;
24968 }
24969 temp3 = args(1).matrix_value();
24970 arg3 = &temp3( 0, 0 );
24971 }
24972 {
24973 if ( _n_dims( args(2) ) > 1 )
24974 {
24975 error( "argument must be a scalar or vector" ); SWIG_fail;
24976 }
24977 if ( _dim( args(2), 0 ) != Alen )
24978 {
24979 error( "argument vectors must be same length" ); SWIG_fail;
24980 }
24981 temp4 = args(2).matrix_value();
24982 arg4 = &temp4( 0, 0 );
24983 }
24984 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24985 if (!SWIG_IsOK(res5)) {
24986 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24987 }
24988 arg5 = reinterpret_cast< char * >(buf5);
24989 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24990 _outv = octave_value();
24991 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24992 {
24993
24994 }
24995 {
24996
24997 }
24998 {
24999
25000 }
25001 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25002 return _out;
25003 fail:
25004 {
25005
25006 }
25007 {
25008
25009 }
25010 {
25011
25012 }
25013 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25014 return octave_value_list();
25015 }
25016 catch(...) {
25017 {
25018
25019 }
25020 {
25021
25022 }
25023 {
25024
25025 }
25026 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25027 throw;
25028 }
25029}
25030
25031
25033 PLINT arg1 ;
25034 PLINT arg2 ;
25035 PLFLT arg3 ;
25036 PLFLT arg4 ;
25037 int val1 ;
25038 int ecode1 = 0 ;
25039 int val2 ;
25040 int ecode2 = 0 ;
25041 double val3 ;
25042 int ecode3 = 0 ;
25043 double val4 ;
25044 int ecode4 = 0 ;
25045 octave_value_list _out;
25046 octave_value_list *_outp=&_out;
25047 octave_value _outv;
25048
25049 try {
25050 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
25051 SWIG_fail;
25052 }
25053 ecode1 = SWIG_AsVal_int(args(0), &val1);
25054 if (!SWIG_IsOK(ecode1)) {
25055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
25056 }
25057 arg1 = static_cast< PLINT >(val1);
25058 ecode2 = SWIG_AsVal_int(args(1), &val2);
25059 if (!SWIG_IsOK(ecode2)) {
25060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
25061 }
25062 arg2 = static_cast< PLINT >(val2);
25063 ecode3 = SWIG_AsVal_double(args(2), &val3);
25064 if (!SWIG_IsOK(ecode3)) {
25065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
25066 }
25067 arg3 = static_cast< PLFLT >(val3);
25068 ecode4 = SWIG_AsVal_double(args(3), &val4);
25069 if (!SWIG_IsOK(ecode4)) {
25070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
25071 }
25072 arg4 = static_cast< PLFLT >(val4);
25073 plstripa(arg1,arg2,arg3,arg4);
25074 _outv = octave_value();
25075 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25076 return _out;
25077 fail:
25078 return octave_value_list();
25079 }
25080 catch(...) {
25081 throw;
25082 }
25083}
25084
25085
25087 PLINT arg1 ;
25088 int val1 ;
25089 int ecode1 = 0 ;
25090 octave_value_list _out;
25091 octave_value_list *_outp=&_out;
25092 octave_value _outv;
25093
25094 try {
25095 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25096 SWIG_fail;
25097 }
25098 ecode1 = SWIG_AsVal_int(args(0), &val1);
25099 if (!SWIG_IsOK(ecode1)) {
25100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25101 }
25102 arg1 = static_cast< PLINT >(val1);
25103 plstripd(arg1);
25104 _outv = octave_value();
25105 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25106 return _out;
25107 fail:
25108 return octave_value_list();
25109 }
25110 catch(...) {
25111 throw;
25112 }
25113}
25114
25115
25117 PLINT arg1 ;
25118 PLINT *arg2 = (PLINT *) 0 ;
25119 PLINT *arg3 = (PLINT *) 0 ;
25120 Matrix temp1 ;
25121 Matrix temp3 ;
25122 octave_value_list _out;
25123 octave_value_list *_outp=&_out;
25124 octave_value _outv;
25125
25126 try {
25127 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25128 SWIG_fail;
25129 }
25130 {
25131 if ( _n_dims( args(0) ) > 1 )
25132 {
25133 error( "argument must be a scalar or vector" ); SWIG_fail;
25134 }
25135 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25136 arg2 = new PLINT[Alen];
25137 temp1 = args(0).matrix_value();
25138 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25139 }
25140 {
25141 if ( _n_dims( args(1) ) > 1 )
25142 {
25143 error( "argument must be a scalar or vector" ); SWIG_fail;
25144 }
25145 if ( _dim( args(1), 0 ) != Alen )
25146 {
25147 error( "argument vectors must be same length" ); SWIG_fail;
25148 }
25149 temp3 = args(1).matrix_value();
25150 arg3 = new PLINT[Alen];
25151 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25152 }
25153 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25154 _outv = octave_value();
25155 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25156 {
25157 delete [] arg2;
25158 }
25159 {
25160 delete [] arg3;
25161 }
25162 return _out;
25163 fail:
25164 {
25165 delete [] arg2;
25166 }
25167 {
25168 delete [] arg3;
25169 }
25170 return octave_value_list();
25171 }
25172 catch(...) {
25173 {
25174 delete [] arg2;
25175 }
25176 {
25177 delete [] arg3;
25178 }
25179 throw;
25180 }
25181}
25182
25183
25185 PLFLT *arg1 = (PLFLT *) 0 ;
25186 PLFLT *arg2 = (PLFLT *) 0 ;
25187 PLINT arg3 ;
25188 PLBOOL arg4 ;
25189 Matrix temp1 ;
25190 Matrix temp2 ;
25191 int val4 ;
25192 int ecode4 = 0 ;
25193 octave_value_list _out;
25194 octave_value_list *_outp=&_out;
25195 octave_value _outv;
25196
25197 try {
25198 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25199 SWIG_fail;
25200 }
25201 {
25202 if ( _n_dims( args(0) ) > 1 )
25203 {
25204 error( "argument must be a scalar or vector" ); SWIG_fail;
25205 }
25206#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25207 if ( !args(0).isempty() )
25208#else
25209 if ( !args(0).is_empty() )
25210#endif
25211 {
25212 Alen = (PLINT) ( _dim( args(0), 0 ) );
25213 temp1 = args(0).matrix_value();
25214 arg1 = &temp1( 0, 0 );
25215 }
25216 else
25217 {
25218 arg1 = NULL;
25219 Alen = 0;
25220 }
25221 }
25222 {
25223 if ( _n_dims( args(1) ) > 1 )
25224 {
25225 error( "argument must be a scalar or vector" ); SWIG_fail;
25226 }
25227#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25228 if ( !args(1).isempty() )
25229#else
25230 if ( !args(1).is_empty() )
25231#endif
25232 {
25233 if ( _dim( args(1), 0 ) != Alen )
25234 {
25235 error( "argument vectors must be same length" ); SWIG_fail;
25236 }
25237 temp2 = args(1).matrix_value();
25238 arg2 = &temp2( 0, 0 );
25239 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25240 }
25241 else
25242 {
25243 arg2 = NULL;
25244 arg3 = 0;
25245 }
25246 }
25247 ecode4 = SWIG_AsVal_int(args(2), &val4);
25248 if (!SWIG_IsOK(ecode4)) {
25249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25250 }
25251 arg4 = static_cast< PLBOOL >(val4);
25252 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25253 _outv = octave_value();
25254 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25255 {
25256
25257 }
25258 {
25259
25260 }
25261 return _out;
25262 fail:
25263 {
25264
25265 }
25266 {
25267
25268 }
25269 return octave_value_list();
25270 }
25271 catch(...) {
25272 {
25273
25274 }
25275 {
25276
25277 }
25278 throw;
25279 }
25280}
25281
25282
25284 PLFLT arg1 ;
25285 PLFLT arg2 ;
25286 PLFLT arg3 ;
25287 PLFLT arg4 ;
25288 double val1 ;
25289 int ecode1 = 0 ;
25290 double val2 ;
25291 int ecode2 = 0 ;
25292 double val3 ;
25293 int ecode3 = 0 ;
25294 double val4 ;
25295 int ecode4 = 0 ;
25296 octave_value_list _out;
25297 octave_value_list *_outp=&_out;
25298 octave_value _outv;
25299
25300 try {
25301 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25302 SWIG_fail;
25303 }
25304 ecode1 = SWIG_AsVal_double(args(0), &val1);
25305 if (!SWIG_IsOK(ecode1)) {
25306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25307 }
25308 arg1 = static_cast< PLFLT >(val1);
25309 ecode2 = SWIG_AsVal_double(args(1), &val2);
25310 if (!SWIG_IsOK(ecode2)) {
25311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25312 }
25313 arg2 = static_cast< PLFLT >(val2);
25314 ecode3 = SWIG_AsVal_double(args(2), &val3);
25315 if (!SWIG_IsOK(ecode3)) {
25316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25317 }
25318 arg3 = static_cast< PLFLT >(val3);
25319 ecode4 = SWIG_AsVal_double(args(3), &val4);
25320 if (!SWIG_IsOK(ecode4)) {
25321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25322 }
25323 arg4 = static_cast< PLFLT >(val4);
25324 plsvpa(arg1,arg2,arg3,arg4);
25325 _outv = octave_value();
25326 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25327 return _out;
25328 fail:
25329 return octave_value_list();
25330 }
25331 catch(...) {
25332 throw;
25333 }
25334}
25335
25336
25338 PLINT arg1 ;
25339 PLINT arg2 ;
25340 int val1 ;
25341 int ecode1 = 0 ;
25342 int val2 ;
25343 int ecode2 = 0 ;
25344 octave_value_list _out;
25345 octave_value_list *_outp=&_out;
25346 octave_value _outv;
25347
25348 try {
25349 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25350 SWIG_fail;
25351 }
25352 ecode1 = SWIG_AsVal_int(args(0), &val1);
25353 if (!SWIG_IsOK(ecode1)) {
25354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25355 }
25356 arg1 = static_cast< PLINT >(val1);
25357 ecode2 = SWIG_AsVal_int(args(1), &val2);
25358 if (!SWIG_IsOK(ecode2)) {
25359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25360 }
25361 arg2 = static_cast< PLINT >(val2);
25362 plsxax(arg1,arg2);
25363 _outv = octave_value();
25364 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25365 return _out;
25366 fail:
25367 return octave_value_list();
25368 }
25369 catch(...) {
25370 throw;
25371 }
25372}
25373
25374
25376 PLINT arg1 ;
25377 PLINT arg2 ;
25378 int val1 ;
25379 int ecode1 = 0 ;
25380 int val2 ;
25381 int ecode2 = 0 ;
25382 octave_value_list _out;
25383 octave_value_list *_outp=&_out;
25384 octave_value _outv;
25385
25386 try {
25387 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25388 SWIG_fail;
25389 }
25390 ecode1 = SWIG_AsVal_int(args(0), &val1);
25391 if (!SWIG_IsOK(ecode1)) {
25392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25393 }
25394 arg1 = static_cast< PLINT >(val1);
25395 ecode2 = SWIG_AsVal_int(args(1), &val2);
25396 if (!SWIG_IsOK(ecode2)) {
25397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25398 }
25399 arg2 = static_cast< PLINT >(val2);
25400 plsyax(arg1,arg2);
25401 _outv = octave_value();
25402 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25403 return _out;
25404 fail:
25405 return octave_value_list();
25406 }
25407 catch(...) {
25408 throw;
25409 }
25410}
25411
25412
25414 PLINT arg1 ;
25415 PLFLT *arg2 = (PLFLT *) 0 ;
25416 PLFLT *arg3 = (PLFLT *) 0 ;
25417 PLINT arg4 ;
25418 Matrix temp1 ;
25419 Matrix temp3 ;
25420 int val4 ;
25421 int ecode4 = 0 ;
25422 octave_value_list _out;
25423 octave_value_list *_outp=&_out;
25424 octave_value _outv;
25425
25426 try {
25427 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25428 SWIG_fail;
25429 }
25430 {
25431 if ( _n_dims( args(0) ) > 1 )
25432 {
25433 error( "argument must be a scalar or vector" ); SWIG_fail;
25434 }
25435 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25436 temp1 = args(0).matrix_value();
25437 arg2 = &temp1( 0, 0 );
25438 }
25439 {
25440 if ( _n_dims( args(1) ) > 1 )
25441 {
25442 error( "argument must be a scalar or vector" ); SWIG_fail;
25443 }
25444 if ( _dim( args(1), 0 ) != Alen )
25445 {
25446 error( "argument vectors must be same length" ); SWIG_fail;
25447 }
25448 temp3 = args(1).matrix_value();
25449 arg3 = &temp3( 0, 0 );
25450 }
25451 ecode4 = SWIG_AsVal_int(args(2), &val4);
25452 if (!SWIG_IsOK(ecode4)) {
25453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25454 }
25455 arg4 = static_cast< PLINT >(val4);
25456 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25457 _outv = octave_value();
25458 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25459 {
25460
25461 }
25462 {
25463
25464 }
25465 return _out;
25466 fail:
25467 {
25468
25469 }
25470 {
25471
25472 }
25473 return octave_value_list();
25474 }
25475 catch(...) {
25476 {
25477
25478 }
25479 {
25480
25481 }
25482 throw;
25483 }
25484}
25485
25486
25488 PLINT arg1 ;
25489 PLINT arg2 ;
25490 int val1 ;
25491 int ecode1 = 0 ;
25492 int val2 ;
25493 int ecode2 = 0 ;
25494 octave_value_list _out;
25495 octave_value_list *_outp=&_out;
25496 octave_value _outv;
25497
25498 try {
25499 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25500 SWIG_fail;
25501 }
25502 ecode1 = SWIG_AsVal_int(args(0), &val1);
25503 if (!SWIG_IsOK(ecode1)) {
25504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25505 }
25506 arg1 = static_cast< PLINT >(val1);
25507 ecode2 = SWIG_AsVal_int(args(1), &val2);
25508 if (!SWIG_IsOK(ecode2)) {
25509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25510 }
25511 arg2 = static_cast< PLINT >(val2);
25512 plszax(arg1,arg2);
25513 _outv = octave_value();
25514 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25515 return _out;
25516 fail:
25517 return octave_value_list();
25518 }
25519 catch(...) {
25520 throw;
25521 }
25522}
25523
25524
25526 octave_value_list _out;
25527 octave_value_list *_outp=&_out;
25528 octave_value _outv;
25529
25530 try {
25531 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25532 SWIG_fail;
25533 }
25534 pltext();
25535 _outv = octave_value();
25536 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25537 return _out;
25538 fail:
25539 return octave_value_list();
25540 }
25541 catch(...) {
25542 throw;
25543 }
25544}
25545
25546
25548 char *arg1 = (char *) 0 ;
25549 int res1 ;
25550 char *buf1 = 0 ;
25551 int alloc1 = 0 ;
25552 octave_value_list _out;
25553 octave_value_list *_outp=&_out;
25554 octave_value _outv;
25555
25556 try {
25557 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25558 SWIG_fail;
25559 }
25560 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25563 }
25564 arg1 = reinterpret_cast< char * >(buf1);
25565 pltimefmt((char const *)arg1);
25566 _outv = octave_value();
25567 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25568 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25569 return _out;
25570 fail:
25571 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25572 return octave_value_list();
25573 }
25574 catch(...) {
25575 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25576 throw;
25577 }
25578}
25579
25580
25582 PLFLT arg1 ;
25583 double val1 ;
25584 int ecode1 = 0 ;
25585 octave_value_list _out;
25586 octave_value_list *_outp=&_out;
25587 octave_value _outv;
25588
25589 try {
25590 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25591 SWIG_fail;
25592 }
25593 ecode1 = SWIG_AsVal_double(args(0), &val1);
25594 if (!SWIG_IsOK(ecode1)) {
25595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25596 }
25597 arg1 = static_cast< PLFLT >(val1);
25598 plvasp(arg1);
25599 _outv = octave_value();
25600 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25601 return _out;
25602 fail:
25603 return octave_value_list();
25604 }
25605 catch(...) {
25606 throw;
25607 }
25608}
25609
25610
25612 PLFLT arg1 ;
25613 PLFLT arg2 ;
25614 PLFLT arg3 ;
25615 PLFLT arg4 ;
25616 PLFLT arg5 ;
25617 double val1 ;
25618 int ecode1 = 0 ;
25619 double val2 ;
25620 int ecode2 = 0 ;
25621 double val3 ;
25622 int ecode3 = 0 ;
25623 double val4 ;
25624 int ecode4 = 0 ;
25625 double val5 ;
25626 int ecode5 = 0 ;
25627 octave_value_list _out;
25628 octave_value_list *_outp=&_out;
25629 octave_value _outv;
25630
25631 try {
25632 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25633 SWIG_fail;
25634 }
25635 ecode1 = SWIG_AsVal_double(args(0), &val1);
25636 if (!SWIG_IsOK(ecode1)) {
25637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25638 }
25639 arg1 = static_cast< PLFLT >(val1);
25640 ecode2 = SWIG_AsVal_double(args(1), &val2);
25641 if (!SWIG_IsOK(ecode2)) {
25642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25643 }
25644 arg2 = static_cast< PLFLT >(val2);
25645 ecode3 = SWIG_AsVal_double(args(2), &val3);
25646 if (!SWIG_IsOK(ecode3)) {
25647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25648 }
25649 arg3 = static_cast< PLFLT >(val3);
25650 ecode4 = SWIG_AsVal_double(args(3), &val4);
25651 if (!SWIG_IsOK(ecode4)) {
25652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25653 }
25654 arg4 = static_cast< PLFLT >(val4);
25655 ecode5 = SWIG_AsVal_double(args(4), &val5);
25656 if (!SWIG_IsOK(ecode5)) {
25657 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25658 }
25659 arg5 = static_cast< PLFLT >(val5);
25660 plvpas(arg1,arg2,arg3,arg4,arg5);
25661 _outv = octave_value();
25662 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25663 return _out;
25664 fail:
25665 return octave_value_list();
25666 }
25667 catch(...) {
25668 throw;
25669 }
25670}
25671
25672
25674 PLFLT arg1 ;
25675 PLFLT arg2 ;
25676 PLFLT arg3 ;
25677 PLFLT arg4 ;
25678 double val1 ;
25679 int ecode1 = 0 ;
25680 double val2 ;
25681 int ecode2 = 0 ;
25682 double val3 ;
25683 int ecode3 = 0 ;
25684 double val4 ;
25685 int ecode4 = 0 ;
25686 octave_value_list _out;
25687 octave_value_list *_outp=&_out;
25688 octave_value _outv;
25689
25690 try {
25691 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25692 SWIG_fail;
25693 }
25694 ecode1 = SWIG_AsVal_double(args(0), &val1);
25695 if (!SWIG_IsOK(ecode1)) {
25696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25697 }
25698 arg1 = static_cast< PLFLT >(val1);
25699 ecode2 = SWIG_AsVal_double(args(1), &val2);
25700 if (!SWIG_IsOK(ecode2)) {
25701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25702 }
25703 arg2 = static_cast< PLFLT >(val2);
25704 ecode3 = SWIG_AsVal_double(args(2), &val3);
25705 if (!SWIG_IsOK(ecode3)) {
25706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25707 }
25708 arg3 = static_cast< PLFLT >(val3);
25709 ecode4 = SWIG_AsVal_double(args(3), &val4);
25710 if (!SWIG_IsOK(ecode4)) {
25711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25712 }
25713 arg4 = static_cast< PLFLT >(val4);
25714 plvpor(arg1,arg2,arg3,arg4);
25715 _outv = octave_value();
25716 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25717 return _out;
25718 fail:
25719 return octave_value_list();
25720 }
25721 catch(...) {
25722 throw;
25723 }
25724}
25725
25726
25728 octave_value_list _out;
25729 octave_value_list *_outp=&_out;
25730 octave_value _outv;
25731
25732 try {
25733 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25734 SWIG_fail;
25735 }
25736 plvsta();
25737 _outv = octave_value();
25738 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25739 return _out;
25740 fail:
25741 return octave_value_list();
25742 }
25743 catch(...) {
25744 throw;
25745 }
25746}
25747
25748
25750 PLFLT arg1 ;
25751 PLFLT arg2 ;
25752 PLFLT arg3 ;
25753 PLFLT arg4 ;
25754 PLFLT arg5 ;
25755 PLFLT arg6 ;
25756 PLFLT arg7 ;
25757 PLFLT arg8 ;
25758 PLFLT arg9 ;
25759 PLFLT arg10 ;
25760 PLFLT arg11 ;
25761 double val1 ;
25762 int ecode1 = 0 ;
25763 double val2 ;
25764 int ecode2 = 0 ;
25765 double val3 ;
25766 int ecode3 = 0 ;
25767 double val4 ;
25768 int ecode4 = 0 ;
25769 double val5 ;
25770 int ecode5 = 0 ;
25771 double val6 ;
25772 int ecode6 = 0 ;
25773 double val7 ;
25774 int ecode7 = 0 ;
25775 double val8 ;
25776 int ecode8 = 0 ;
25777 double val9 ;
25778 int ecode9 = 0 ;
25779 double val10 ;
25780 int ecode10 = 0 ;
25781 double val11 ;
25782 int ecode11 = 0 ;
25783 octave_value_list _out;
25784 octave_value_list *_outp=&_out;
25785 octave_value _outv;
25786
25787 try {
25788 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25789 SWIG_fail;
25790 }
25791 ecode1 = SWIG_AsVal_double(args(0), &val1);
25792 if (!SWIG_IsOK(ecode1)) {
25793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25794 }
25795 arg1 = static_cast< PLFLT >(val1);
25796 ecode2 = SWIG_AsVal_double(args(1), &val2);
25797 if (!SWIG_IsOK(ecode2)) {
25798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25799 }
25800 arg2 = static_cast< PLFLT >(val2);
25801 ecode3 = SWIG_AsVal_double(args(2), &val3);
25802 if (!SWIG_IsOK(ecode3)) {
25803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25804 }
25805 arg3 = static_cast< PLFLT >(val3);
25806 ecode4 = SWIG_AsVal_double(args(3), &val4);
25807 if (!SWIG_IsOK(ecode4)) {
25808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25809 }
25810 arg4 = static_cast< PLFLT >(val4);
25811 ecode5 = SWIG_AsVal_double(args(4), &val5);
25812 if (!SWIG_IsOK(ecode5)) {
25813 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25814 }
25815 arg5 = static_cast< PLFLT >(val5);
25816 ecode6 = SWIG_AsVal_double(args(5), &val6);
25817 if (!SWIG_IsOK(ecode6)) {
25818 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25819 }
25820 arg6 = static_cast< PLFLT >(val6);
25821 ecode7 = SWIG_AsVal_double(args(6), &val7);
25822 if (!SWIG_IsOK(ecode7)) {
25823 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25824 }
25825 arg7 = static_cast< PLFLT >(val7);
25826 ecode8 = SWIG_AsVal_double(args(7), &val8);
25827 if (!SWIG_IsOK(ecode8)) {
25828 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25829 }
25830 arg8 = static_cast< PLFLT >(val8);
25831 ecode9 = SWIG_AsVal_double(args(8), &val9);
25832 if (!SWIG_IsOK(ecode9)) {
25833 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25834 }
25835 arg9 = static_cast< PLFLT >(val9);
25836 ecode10 = SWIG_AsVal_double(args(9), &val10);
25837 if (!SWIG_IsOK(ecode10)) {
25838 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25839 }
25840 arg10 = static_cast< PLFLT >(val10);
25841 ecode11 = SWIG_AsVal_double(args(10), &val11);
25842 if (!SWIG_IsOK(ecode11)) {
25843 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25844 }
25845 arg11 = static_cast< PLFLT >(val11);
25846 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25847 _outv = octave_value();
25848 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25849 return _out;
25850 fail:
25851 return octave_value_list();
25852 }
25853 catch(...) {
25854 throw;
25855 }
25856}
25857
25858
25860 PLFLT arg1 ;
25861 double val1 ;
25862 int ecode1 = 0 ;
25863 octave_value_list _out;
25864 octave_value_list *_outp=&_out;
25865 octave_value _outv;
25866
25867 try {
25868 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25869 SWIG_fail;
25870 }
25871 ecode1 = SWIG_AsVal_double(args(0), &val1);
25872 if (!SWIG_IsOK(ecode1)) {
25873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25874 }
25875 arg1 = static_cast< PLFLT >(val1);
25876 plwidth(arg1);
25877 _outv = octave_value();
25878 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25879 return _out;
25880 fail:
25881 return octave_value_list();
25882 }
25883 catch(...) {
25884 throw;
25885 }
25886}
25887
25888
25890 PLFLT arg1 ;
25891 PLFLT arg2 ;
25892 PLFLT arg3 ;
25893 PLFLT arg4 ;
25894 double val1 ;
25895 int ecode1 = 0 ;
25896 double val2 ;
25897 int ecode2 = 0 ;
25898 double val3 ;
25899 int ecode3 = 0 ;
25900 double val4 ;
25901 int ecode4 = 0 ;
25902 octave_value_list _out;
25903 octave_value_list *_outp=&_out;
25904 octave_value _outv;
25905
25906 try {
25907 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25908 SWIG_fail;
25909 }
25910 ecode1 = SWIG_AsVal_double(args(0), &val1);
25911 if (!SWIG_IsOK(ecode1)) {
25912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25913 }
25914 arg1 = static_cast< PLFLT >(val1);
25915 ecode2 = SWIG_AsVal_double(args(1), &val2);
25916 if (!SWIG_IsOK(ecode2)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25918 }
25919 arg2 = static_cast< PLFLT >(val2);
25920 ecode3 = SWIG_AsVal_double(args(2), &val3);
25921 if (!SWIG_IsOK(ecode3)) {
25922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25923 }
25924 arg3 = static_cast< PLFLT >(val3);
25925 ecode4 = SWIG_AsVal_double(args(3), &val4);
25926 if (!SWIG_IsOK(ecode4)) {
25927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25928 }
25929 arg4 = static_cast< PLFLT >(val4);
25930 plwind(arg1,arg2,arg3,arg4);
25931 _outv = octave_value();
25932 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25933 return _out;
25934 fail:
25935 return octave_value_list();
25936 }
25937 catch(...) {
25938 throw;
25939 }
25940}
25941
25942
25944 PLBOOL arg1 ;
25945 PLBOOL *arg2 = (PLBOOL *) 0 ;
25946 int val1 ;
25947 int ecode1 = 0 ;
25948 PLBOOL temp2 ;
25949 int res2 = SWIG_TMPOBJ ;
25950 octave_value_list _out;
25951 octave_value_list *_outp=&_out;
25952 octave_value _outv;
25953
25954 try {
25955 arg2 = &temp2;
25956 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25957 SWIG_fail;
25958 }
25959 ecode1 = SWIG_AsVal_int(args(0), &val1);
25960 if (!SWIG_IsOK(ecode1)) {
25961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25962 }
25963 arg1 = static_cast< PLBOOL >(val1);
25964 plxormod(arg1,arg2);
25965 _outv = octave_value();
25966 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25967 if (SWIG_IsTmpObj(res2)) {
25968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25969 } else {
25970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25971 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25972 }
25973 return _out;
25974 fail:
25975 return octave_value_list();
25976 }
25977 catch(...) {
25978 throw;
25979 }
25980}
25981
25982
25984 mapform_func arg1 = (mapform_func) 0 ;
25985 char *arg2 = (char *) 0 ;
25986 PLFLT arg3 ;
25987 PLFLT arg4 ;
25988 PLFLT arg5 ;
25989 PLFLT arg6 ;
25990 int res2 ;
25991 char *buf2 = 0 ;
25992 int alloc2 = 0 ;
25993 double val3 ;
25994 int ecode3 = 0 ;
25995 double val4 ;
25996 int ecode4 = 0 ;
25997 double val5 ;
25998 int ecode5 = 0 ;
25999 double val6 ;
26000 int ecode6 = 0 ;
26001 octave_value_list _out;
26002 octave_value_list *_outp=&_out;
26003 octave_value _outv;
26004
26005 try {
26006 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
26007 SWIG_fail;
26008 }
26009 {
26010 octave_value obj = args(0);
26011#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26012 if ( !obj.isempty() )
26013#else
26014 if ( !obj.is_empty() )
26015#endif
26016 {
26017 if ( obj.is_function_handle() || obj.is_inline_function() )
26018 {
26019 fcnMapForm = obj.function_value();
26020 }
26021 else if ( obj.is_string() )
26022 {
26023 nameMapForm = obj.string_value();
26024 fcnMapForm = NULL;
26025 }
26026 arg1 = mapform_octave;
26027 }
26028 else
26029 {
26030 arg1 = NULL;
26031 }
26032 }
26033 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26034 if (!SWIG_IsOK(res2)) {
26035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
26036 }
26037 arg2 = reinterpret_cast< char * >(buf2);
26038 ecode3 = SWIG_AsVal_double(args(2), &val3);
26039 if (!SWIG_IsOK(ecode3)) {
26040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
26041 }
26042 arg3 = static_cast< PLFLT >(val3);
26043 ecode4 = SWIG_AsVal_double(args(3), &val4);
26044 if (!SWIG_IsOK(ecode4)) {
26045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
26046 }
26047 arg4 = static_cast< PLFLT >(val4);
26048 ecode5 = SWIG_AsVal_double(args(4), &val5);
26049 if (!SWIG_IsOK(ecode5)) {
26050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
26051 }
26052 arg5 = static_cast< PLFLT >(val5);
26053 ecode6 = SWIG_AsVal_double(args(5), &val6);
26054 if (!SWIG_IsOK(ecode6)) {
26055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
26056 }
26057 arg6 = static_cast< PLFLT >(val6);
26058 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
26059 _outv = octave_value();
26060 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26061 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26062 return _out;
26063 fail:
26064 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26065 return octave_value_list();
26066 }
26067 catch(...) {
26068 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26069 throw;
26070 }
26071}
26072
26073
26075 mapform_func arg1 = (mapform_func) 0 ;
26076 char *arg2 = (char *) 0 ;
26077 PLFLT arg3 ;
26078 PLFLT arg4 ;
26079 PLFLT arg5 ;
26080 PLFLT arg6 ;
26081 PLINT *arg7 = (PLINT *) 0 ;
26082 PLINT arg8 ;
26083 int res2 ;
26084 char *buf2 = 0 ;
26085 int alloc2 = 0 ;
26086 double val3 ;
26087 int ecode3 = 0 ;
26088 double val4 ;
26089 int ecode4 = 0 ;
26090 double val5 ;
26091 int ecode5 = 0 ;
26092 double val6 ;
26093 int ecode6 = 0 ;
26094 Matrix temp7 ;
26095 octave_value_list _out;
26096 octave_value_list *_outp=&_out;
26097 octave_value _outv;
26098
26099 try {
26100 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26101 SWIG_fail;
26102 }
26103 {
26104 octave_value obj = args(0);
26105#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26106 if ( !obj.isempty() )
26107#else
26108 if ( !obj.is_empty() )
26109#endif
26110 {
26111 if ( obj.is_function_handle() || obj.is_inline_function() )
26112 {
26113 fcnMapForm = obj.function_value();
26114 }
26115 else if ( obj.is_string() )
26116 {
26117 nameMapForm = obj.string_value();
26118 fcnMapForm = NULL;
26119 }
26120 arg1 = mapform_octave;
26121 }
26122 else
26123 {
26124 arg1 = NULL;
26125 }
26126 }
26127 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26128 if (!SWIG_IsOK(res2)) {
26129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26130 }
26131 arg2 = reinterpret_cast< char * >(buf2);
26132 ecode3 = SWIG_AsVal_double(args(2), &val3);
26133 if (!SWIG_IsOK(ecode3)) {
26134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26135 }
26136 arg3 = static_cast< PLFLT >(val3);
26137 ecode4 = SWIG_AsVal_double(args(3), &val4);
26138 if (!SWIG_IsOK(ecode4)) {
26139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26140 }
26141 arg4 = static_cast< PLFLT >(val4);
26142 ecode5 = SWIG_AsVal_double(args(4), &val5);
26143 if (!SWIG_IsOK(ecode5)) {
26144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26145 }
26146 arg5 = static_cast< PLFLT >(val5);
26147 ecode6 = SWIG_AsVal_double(args(5), &val6);
26148 if (!SWIG_IsOK(ecode6)) {
26149 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26150 }
26151 arg6 = static_cast< PLFLT >(val6);
26152 {
26153 if ( _n_dims( args(6) ) > 1 )
26154 {
26155 error( "argument must be a scalar or vector" ); SWIG_fail;
26156 }
26157#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26158 if ( !args(6).isempty() )
26159#else
26160 if ( !args(6).is_empty() )
26161#endif
26162 {
26163 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26164 temp7 = args(6).matrix_value();
26165 arg7 = new PLINT[arg8];
26166 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26167 }
26168 else
26169 {
26170 arg7 = NULL;
26171 arg8 = 0;
26172 }
26173 }
26174 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26175 _outv = octave_value();
26176 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26177 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26178 {
26179 delete [] arg7;
26180 }
26181 return _out;
26182 fail:
26183 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26184 {
26185 delete [] arg7;
26186 }
26187 return octave_value_list();
26188 }
26189 catch(...) {
26190 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26191 {
26192 delete [] arg7;
26193 }
26194 throw;
26195 }
26196}
26197
26198
26200 mapform_func arg1 = (mapform_func) 0 ;
26201 char *arg2 = (char *) 0 ;
26202 char *arg3 = (char *) 0 ;
26203 PLFLT arg4 ;
26204 PLFLT arg5 ;
26205 PLFLT arg6 ;
26206 PLFLT arg7 ;
26207 PLINT *arg8 = (PLINT *) 0 ;
26208 PLINT arg9 ;
26209 int res2 ;
26210 char *buf2 = 0 ;
26211 int alloc2 = 0 ;
26212 int res3 ;
26213 char *buf3 = 0 ;
26214 int alloc3 = 0 ;
26215 double val4 ;
26216 int ecode4 = 0 ;
26217 double val5 ;
26218 int ecode5 = 0 ;
26219 double val6 ;
26220 int ecode6 = 0 ;
26221 double val7 ;
26222 int ecode7 = 0 ;
26223 Matrix temp8 ;
26224 octave_value_list _out;
26225 octave_value_list *_outp=&_out;
26226 octave_value _outv;
26227
26228 try {
26229 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26230 SWIG_fail;
26231 }
26232 {
26233 octave_value obj = args(0);
26234#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26235 if ( !obj.isempty() )
26236#else
26237 if ( !obj.is_empty() )
26238#endif
26239 {
26240 if ( obj.is_function_handle() || obj.is_inline_function() )
26241 {
26242 fcnMapForm = obj.function_value();
26243 }
26244 else if ( obj.is_string() )
26245 {
26246 nameMapForm = obj.string_value();
26247 fcnMapForm = NULL;
26248 }
26249 arg1 = mapform_octave;
26250 }
26251 else
26252 {
26253 arg1 = NULL;
26254 }
26255 }
26256 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26257 if (!SWIG_IsOK(res2)) {
26258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26259 }
26260 arg2 = reinterpret_cast< char * >(buf2);
26261 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26262 if (!SWIG_IsOK(res3)) {
26263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26264 }
26265 arg3 = reinterpret_cast< char * >(buf3);
26266 ecode4 = SWIG_AsVal_double(args(3), &val4);
26267 if (!SWIG_IsOK(ecode4)) {
26268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26269 }
26270 arg4 = static_cast< PLFLT >(val4);
26271 ecode5 = SWIG_AsVal_double(args(4), &val5);
26272 if (!SWIG_IsOK(ecode5)) {
26273 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26274 }
26275 arg5 = static_cast< PLFLT >(val5);
26276 ecode6 = SWIG_AsVal_double(args(5), &val6);
26277 if (!SWIG_IsOK(ecode6)) {
26278 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26279 }
26280 arg6 = static_cast< PLFLT >(val6);
26281 ecode7 = SWIG_AsVal_double(args(6), &val7);
26282 if (!SWIG_IsOK(ecode7)) {
26283 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26284 }
26285 arg7 = static_cast< PLFLT >(val7);
26286 {
26287 if ( _n_dims( args(7) ) > 1 )
26288 {
26289 error( "argument must be a scalar or vector" ); SWIG_fail;
26290 }
26291#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26292 if ( !args(7).isempty() )
26293#else
26294 if ( !args(7).is_empty() )
26295#endif
26296 {
26297 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26298 temp8 = args(7).matrix_value();
26299 arg8 = new PLINT[arg9];
26300 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26301 }
26302 else
26303 {
26304 arg8 = NULL;
26305 arg9 = 0;
26306 }
26307 }
26308 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26309 _outv = octave_value();
26310 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26311 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26312 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26313 {
26314 delete [] arg8;
26315 }
26316 return _out;
26317 fail:
26318 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26319 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26320 {
26321 delete [] arg8;
26322 }
26323 return octave_value_list();
26324 }
26325 catch(...) {
26326 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26327 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26328 {
26329 delete [] arg8;
26330 }
26331 throw;
26332 }
26333}
26334
26335
26337 mapform_func arg1 = (mapform_func) 0 ;
26338 char *arg2 = (char *) 0 ;
26339 PLFLT arg3 ;
26340 PLFLT arg4 ;
26341 PLFLT arg5 ;
26342 char *arg6 = (char *) 0 ;
26343 PLFLT arg7 ;
26344 PLFLT arg8 ;
26345 PLFLT arg9 ;
26346 PLFLT arg10 ;
26347 PLINT arg11 ;
26348 int res2 ;
26349 char *buf2 = 0 ;
26350 int alloc2 = 0 ;
26351 double val3 ;
26352 int ecode3 = 0 ;
26353 double val4 ;
26354 int ecode4 = 0 ;
26355 double val5 ;
26356 int ecode5 = 0 ;
26357 int res6 ;
26358 char *buf6 = 0 ;
26359 int alloc6 = 0 ;
26360 double val7 ;
26361 int ecode7 = 0 ;
26362 double val8 ;
26363 int ecode8 = 0 ;
26364 double val9 ;
26365 int ecode9 = 0 ;
26366 double val10 ;
26367 int ecode10 = 0 ;
26368 int val11 ;
26369 int ecode11 = 0 ;
26370 octave_value_list _out;
26371 octave_value_list *_outp=&_out;
26372 octave_value _outv;
26373
26374 try {
26375 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26376 SWIG_fail;
26377 }
26378 {
26379 octave_value obj = args(0);
26380#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26381 if ( !obj.isempty() )
26382#else
26383 if ( !obj.is_empty() )
26384#endif
26385 {
26386 if ( obj.is_function_handle() || obj.is_inline_function() )
26387 {
26388 fcnMapForm = obj.function_value();
26389 }
26390 else if ( obj.is_string() )
26391 {
26392 nameMapForm = obj.string_value();
26393 fcnMapForm = NULL;
26394 }
26395 arg1 = mapform_octave;
26396 }
26397 else
26398 {
26399 arg1 = NULL;
26400 }
26401 }
26402 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26403 if (!SWIG_IsOK(res2)) {
26404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26405 }
26406 arg2 = reinterpret_cast< char * >(buf2);
26407 ecode3 = SWIG_AsVal_double(args(2), &val3);
26408 if (!SWIG_IsOK(ecode3)) {
26409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26410 }
26411 arg3 = static_cast< PLFLT >(val3);
26412 ecode4 = SWIG_AsVal_double(args(3), &val4);
26413 if (!SWIG_IsOK(ecode4)) {
26414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26415 }
26416 arg4 = static_cast< PLFLT >(val4);
26417 ecode5 = SWIG_AsVal_double(args(4), &val5);
26418 if (!SWIG_IsOK(ecode5)) {
26419 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26420 }
26421 arg5 = static_cast< PLFLT >(val5);
26422 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26423 if (!SWIG_IsOK(res6)) {
26424 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26425 }
26426 arg6 = reinterpret_cast< char * >(buf6);
26427 ecode7 = SWIG_AsVal_double(args(6), &val7);
26428 if (!SWIG_IsOK(ecode7)) {
26429 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26430 }
26431 arg7 = static_cast< PLFLT >(val7);
26432 ecode8 = SWIG_AsVal_double(args(7), &val8);
26433 if (!SWIG_IsOK(ecode8)) {
26434 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26435 }
26436 arg8 = static_cast< PLFLT >(val8);
26437 ecode9 = SWIG_AsVal_double(args(8), &val9);
26438 if (!SWIG_IsOK(ecode9)) {
26439 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26440 }
26441 arg9 = static_cast< PLFLT >(val9);
26442 ecode10 = SWIG_AsVal_double(args(9), &val10);
26443 if (!SWIG_IsOK(ecode10)) {
26444 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26445 }
26446 arg10 = static_cast< PLFLT >(val10);
26447 ecode11 = SWIG_AsVal_int(args(10), &val11);
26448 if (!SWIG_IsOK(ecode11)) {
26449 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26450 }
26451 arg11 = static_cast< PLINT >(val11);
26452 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26453 _outv = octave_value();
26454 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26455 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26456 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26457 return _out;
26458 fail:
26459 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26460 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26461 return octave_value_list();
26462 }
26463 catch(...) {
26464 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26465 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26466 throw;
26467 }
26468}
26469
26470
26472 mapform_func arg1 = (mapform_func) 0 ;
26473 char *arg2 = (char *) 0 ;
26474 PLFLT arg3 ;
26475 PLFLT arg4 ;
26476 PLFLT arg5 ;
26477 PLFLT arg6 ;
26478 PLINT *arg7 = (PLINT *) 0 ;
26479 PLINT arg8 ;
26480 int res2 ;
26481 char *buf2 = 0 ;
26482 int alloc2 = 0 ;
26483 double val3 ;
26484 int ecode3 = 0 ;
26485 double val4 ;
26486 int ecode4 = 0 ;
26487 double val5 ;
26488 int ecode5 = 0 ;
26489 double val6 ;
26490 int ecode6 = 0 ;
26491 Matrix temp7 ;
26492 octave_value_list _out;
26493 octave_value_list *_outp=&_out;
26494 octave_value _outv;
26495
26496 try {
26497 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26498 SWIG_fail;
26499 }
26500 {
26501 octave_value obj = args(0);
26502#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26503 if ( !obj.isempty() )
26504#else
26505 if ( !obj.is_empty() )
26506#endif
26507 {
26508 if ( obj.is_function_handle() || obj.is_inline_function() )
26509 {
26510 fcnMapForm = obj.function_value();
26511 }
26512 else if ( obj.is_string() )
26513 {
26514 nameMapForm = obj.string_value();
26515 fcnMapForm = NULL;
26516 }
26517 arg1 = mapform_octave;
26518 }
26519 else
26520 {
26521 arg1 = NULL;
26522 }
26523 }
26524 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26525 if (!SWIG_IsOK(res2)) {
26526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26527 }
26528 arg2 = reinterpret_cast< char * >(buf2);
26529 ecode3 = SWIG_AsVal_double(args(2), &val3);
26530 if (!SWIG_IsOK(ecode3)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26532 }
26533 arg3 = static_cast< PLFLT >(val3);
26534 ecode4 = SWIG_AsVal_double(args(3), &val4);
26535 if (!SWIG_IsOK(ecode4)) {
26536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26537 }
26538 arg4 = static_cast< PLFLT >(val4);
26539 ecode5 = SWIG_AsVal_double(args(4), &val5);
26540 if (!SWIG_IsOK(ecode5)) {
26541 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26542 }
26543 arg5 = static_cast< PLFLT >(val5);
26544 ecode6 = SWIG_AsVal_double(args(5), &val6);
26545 if (!SWIG_IsOK(ecode6)) {
26546 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26547 }
26548 arg6 = static_cast< PLFLT >(val6);
26549 {
26550 if ( _n_dims( args(6) ) > 1 )
26551 {
26552 error( "argument must be a scalar or vector" ); SWIG_fail;
26553 }
26554#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26555 if ( !args(6).isempty() )
26556#else
26557 if ( !args(6).is_empty() )
26558#endif
26559 {
26560 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26561 temp7 = args(6).matrix_value();
26562 arg7 = new PLINT[arg8];
26563 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26564 }
26565 else
26566 {
26567 arg7 = NULL;
26568 arg8 = 0;
26569 }
26570 }
26571 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26572 _outv = octave_value();
26573 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26574 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26575 {
26576 delete [] arg7;
26577 }
26578 return _out;
26579 fail:
26580 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26581 {
26582 delete [] arg7;
26583 }
26584 return octave_value_list();
26585 }
26586 catch(...) {
26587 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26588 {
26589 delete [] arg7;
26590 }
26591 throw;
26592 }
26593}
26594
26595
26597 mapform_func arg1 = (mapform_func) 0 ;
26598 PLFLT arg2 ;
26599 PLFLT arg3 ;
26600 PLFLT arg4 ;
26601 PLFLT arg5 ;
26602 PLFLT arg6 ;
26603 PLFLT arg7 ;
26604 double val2 ;
26605 int ecode2 = 0 ;
26606 double val3 ;
26607 int ecode3 = 0 ;
26608 double val4 ;
26609 int ecode4 = 0 ;
26610 double val5 ;
26611 int ecode5 = 0 ;
26612 double val6 ;
26613 int ecode6 = 0 ;
26614 double val7 ;
26615 int ecode7 = 0 ;
26616 octave_value_list _out;
26617 octave_value_list *_outp=&_out;
26618 octave_value _outv;
26619
26620 try {
26621 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26622 SWIG_fail;
26623 }
26624 {
26625 octave_value obj = args(0);
26626#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26627 if ( !obj.isempty() )
26628#else
26629 if ( !obj.is_empty() )
26630#endif
26631 {
26632 if ( obj.is_function_handle() || obj.is_inline_function() )
26633 {
26634 fcnMapForm = obj.function_value();
26635 }
26636 else if ( obj.is_string() )
26637 {
26638 nameMapForm = obj.string_value();
26639 fcnMapForm = NULL;
26640 }
26641 arg1 = mapform_octave;
26642 }
26643 else
26644 {
26645 arg1 = NULL;
26646 }
26647 }
26648 ecode2 = SWIG_AsVal_double(args(1), &val2);
26649 if (!SWIG_IsOK(ecode2)) {
26650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26651 }
26652 arg2 = static_cast< PLFLT >(val2);
26653 ecode3 = SWIG_AsVal_double(args(2), &val3);
26654 if (!SWIG_IsOK(ecode3)) {
26655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26656 }
26657 arg3 = static_cast< PLFLT >(val3);
26658 ecode4 = SWIG_AsVal_double(args(3), &val4);
26659 if (!SWIG_IsOK(ecode4)) {
26660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26661 }
26662 arg4 = static_cast< PLFLT >(val4);
26663 ecode5 = SWIG_AsVal_double(args(4), &val5);
26664 if (!SWIG_IsOK(ecode5)) {
26665 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26666 }
26667 arg5 = static_cast< PLFLT >(val5);
26668 ecode6 = SWIG_AsVal_double(args(5), &val6);
26669 if (!SWIG_IsOK(ecode6)) {
26670 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26671 }
26672 arg6 = static_cast< PLFLT >(val6);
26673 ecode7 = SWIG_AsVal_double(args(6), &val7);
26674 if (!SWIG_IsOK(ecode7)) {
26675 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26676 }
26677 arg7 = static_cast< PLFLT >(val7);
26678 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26679 _outv = octave_value();
26680 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26681 return _out;
26682 fail:
26683 return octave_value_list();
26684 }
26685 catch(...) {
26686 throw;
26687 }
26688}
26689
26690
26692 octave_value_list _out;
26693 octave_value_list *_outp=&_out;
26694 octave_value _outv;
26695
26696 try {
26697 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26698 SWIG_fail;
26699 }
26700 plClearOpts();
26701 _outv = octave_value();
26702 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26703 return _out;
26704 fail:
26705 return octave_value_list();
26706 }
26707 catch(...) {
26708 throw;
26709 }
26710}
26711
26712
26714 octave_value_list _out;
26715 octave_value_list *_outp=&_out;
26716 octave_value _outv;
26717
26718 try {
26719 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26720 SWIG_fail;
26721 }
26722 plResetOpts();
26723 _outv = octave_value();
26724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26725 return _out;
26726 fail:
26727 return octave_value_list();
26728 }
26729 catch(...) {
26730 throw;
26731 }
26732}
26733
26734
26736 char *arg1 = (char *) 0 ;
26737 char *arg2 = (char *) 0 ;
26738 int res1 ;
26739 char *buf1 = 0 ;
26740 int alloc1 = 0 ;
26741 int res2 ;
26742 char *buf2 = 0 ;
26743 int alloc2 = 0 ;
26744 octave_value_list _out;
26745 octave_value_list *_outp=&_out;
26746 octave_value _outv;
26747
26748 try {
26749 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26750 SWIG_fail;
26751 }
26752 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26753 if (!SWIG_IsOK(res1)) {
26754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26755 }
26756 arg1 = reinterpret_cast< char * >(buf1);
26757 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26758 if (!SWIG_IsOK(res2)) {
26759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26760 }
26761 arg2 = reinterpret_cast< char * >(buf2);
26762 plSetUsage((char const *)arg1,(char const *)arg2);
26763 _outv = octave_value();
26764 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26765 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26766 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26767 return _out;
26768 fail:
26769 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26770 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26771 return octave_value_list();
26772 }
26773 catch(...) {
26774 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26775 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26776 throw;
26777 }
26778}
26779
26780
26782 octave_value_list _out;
26783 octave_value_list *_outp=&_out;
26784 octave_value _outv;
26785
26786 try {
26787 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26788 SWIG_fail;
26789 }
26790 plOptUsage();
26791 _outv = octave_value();
26792 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26793 return _out;
26794 fail:
26795 return octave_value_list();
26796 }
26797 catch(...) {
26798 throw;
26799 }
26800}
26801
26802
26803
26804static const struct swig_octave_member swig_globals[] = {
26805{"testppchar",_wrap_testppchar,0,0,2,0},
26806{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26807{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26808{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26809{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26810{"plcont0",_wrap_plcont0,0,0,2,0},
26811{"plcont1",_wrap_plcont1,0,0,2,0},
26812{"plcont2",_wrap_plcont2,0,0,2,0},
26813{"plcont2p",_wrap_plcont2p,0,0,2,0},
26814{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26815{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26816{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26817{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26818{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26819{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26820{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26821{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26822{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26823{"plshade1",_wrap_plshade1,0,0,2,0},
26824{"plshade2",_wrap_plshade2,0,0,2,0},
26825{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26826{"plshadesx",_wrap_plshadesx,0,0,2,0},
26827{"plshades1",_wrap_plshades1,0,0,2,0},
26828{"plshades2",_wrap_plshades2,0,0,2,0},
26829{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26830{"plvect1",_wrap_plvect1,0,0,2,0},
26831{"plvect2",_wrap_plvect2,0,0,2,0},
26832{"pplimage",_wrap_pplimage,0,0,2,0},
26833{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26834{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26835{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26836{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26837{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26838{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26839{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26840{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26841{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26842{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26843{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26844{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26845{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26846{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26847{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26848{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26849{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26850{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26851{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26852{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26853{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26854{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26855{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26856{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26857{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26858{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26859{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26860{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26861{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26862{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26863{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26866{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26867{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26868{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26869{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26870{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26871{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26872{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26873{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26874{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26875{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26876{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26877{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26878{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26879{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26880{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26881{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26882{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26883{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26884{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26885{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26886{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26887{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26888{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26889{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26890{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26891{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26892{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26893{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26894{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26895{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26896{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26897{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26898{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26899{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26900{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26901{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26902{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26903{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26904{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26905{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26906{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26907{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26908{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26909{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26910{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26911{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26912{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26913{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26914{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26915{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26916{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26917{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26918{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26919{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26920{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26921{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26922{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26923{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26924{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26925{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26926{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26927{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26928{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26929{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26930{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26931{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26932{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26933{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26934{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26935{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26936{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26937{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26938{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26939{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26940{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26941{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26942{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26943{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26944{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26945{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26946{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26947{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26948{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26949{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26950{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26951{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26952{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26953{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26954{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26955{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26956{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26957{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26958{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26959{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26960{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26961{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26962{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26963{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26964{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26965{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26966{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26967{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26968{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26969{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26970{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26971{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26972{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26973{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26974{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26975{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26976{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26977{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26978{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26979{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26980{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26981{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26982{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26983{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26984{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26985{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26986{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26987{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26988{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26989{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26990{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26991{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26992{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26993{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26994{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26995{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26996{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26997{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26998{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26999{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
27000{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
27001{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
27002{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
27003{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
27004{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
27005{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
27006{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
27007{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
27008{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
27009{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
27010{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
27011{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
27012{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
27013{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
27014{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
27015{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
27016{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
27017{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
27018{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
27019{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
27020{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
27021{0,0,0,0,0,0}
27022};
27023
27024/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
27025
27026static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
27027static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
27028static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
27029static 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};
27030static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "label_func|void (*)(int,double,char *,int,void *)", 0, 0, (void*)0, 0};
27031static 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};
27032static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
27033static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
27034static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
27035
27047
27048static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
27049static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
27050static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
27054static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
27055static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
27056static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
27057
27069
27070
27071/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
27072
27073/* -----------------------------------------------------------------------------
27074 * Type initialization:
27075 * This problem is tough by the requirement that no dynamic
27076 * memory is used. Also, since swig_type_info structures store pointers to
27077 * swig_cast_info structures and swig_cast_info structures store pointers back
27078 * to swig_type_info structures, we need some lookup code at initialization.
27079 * The idea is that swig generates all the structures that are needed.
27080 * The runtime then collects these partially filled structures.
27081 * The SWIG_InitializeModule function takes these initial arrays out of
27082 * swig_module, and does all the lookup, filling in the swig_module.types
27083 * array with the correct data and linking the correct swig_cast_info
27084 * structures together.
27085 *
27086 * The generated swig_type_info structures are assigned statically to an initial
27087 * array. We just loop through that array, and handle each type individually.
27088 * First we lookup if this type has been already loaded, and if so, use the
27089 * loaded structure instead of the generated one. Then we have to fill in the
27090 * cast linked list. The cast data is initially stored in something like a
27091 * two-dimensional array. Each row corresponds to a type (there are the same
27092 * number of rows as there are in the swig_type_initial array). Each entry in
27093 * a column is one of the swig_cast_info structures for that type.
27094 * The cast_initial array is actually an array of arrays, because each row has
27095 * a variable number of columns. So to actually build the cast linked list,
27096 * we find the array of casts associated with the type, and loop through it
27097 * adding the casts to the list. The one last trick we need to do is making
27098 * sure the type pointer in the swig_cast_info struct is correct.
27099 *
27100 * First off, we lookup the cast->type name to see if it is already loaded.
27101 * There are three cases to handle:
27102 * 1) If the cast->type has already been loaded AND the type we are adding
27103 * casting info to has not been loaded (it is in this module), THEN we
27104 * replace the cast->type pointer with the type pointer that has already
27105 * been loaded.
27106 * 2) If BOTH types (the one we are adding casting info to, and the
27107 * cast->type) are loaded, THEN the cast info has already been loaded by
27108 * the previous module so we just ignore it.
27109 * 3) Finally, if cast->type has not already been loaded, then we add that
27110 * swig_cast_info to the linked list (because the cast->type) pointer will
27111 * be correct.
27112 * ----------------------------------------------------------------------------- */
27113
27114#ifdef __cplusplus
27115extern "C" {
27116#if 0
27117} /* c-mode */
27118#endif
27119#endif
27120
27121#if 0
27122#define SWIGRUNTIME_DEBUG
27123#endif
27124
27125#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27126#define SWIG_INIT_CLIENT_DATA_TYPE void *
27127#endif
27128
27129SWIGRUNTIME void
27131 size_t i;
27132 swig_module_info *module_head, *iter;
27133 int init;
27134
27135 /* check to see if the circular list has been setup, if not, set it up */
27136 if (swig_module.next==0) {
27137 /* Initialize the swig_module */
27138 swig_module.type_initial = swig_type_initial;
27139 swig_module.cast_initial = swig_cast_initial;
27140 swig_module.next = &swig_module;
27141 init = 1;
27142 } else {
27143 init = 0;
27144 }
27145
27146 /* Try and load any already created modules */
27147 module_head = SWIG_GetModule(clientdata);
27148 if (!module_head) {
27149 /* This is the first module loaded for this interpreter */
27150 /* so set the swig module into the interpreter */
27151 SWIG_SetModule(clientdata, &swig_module);
27152 } else {
27153 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27154 iter=module_head;
27155 do {
27156 if (iter==&swig_module) {
27157 /* Our module is already in the list, so there's nothing more to do. */
27158 return;
27159 }
27160 iter=iter->next;
27161 } while (iter!= module_head);
27162
27163 /* otherwise we must add our module into the list */
27164 swig_module.next = module_head->next;
27165 module_head->next = &swig_module;
27166 }
27167
27168 /* When multiple interpreters are used, a module could have already been initialized in
27169 a different interpreter, but not yet have a pointer in this interpreter.
27170 In this case, we do not want to continue adding types... everything should be
27171 set up already */
27172 if (init == 0) return;
27173
27174 /* Now work on filling in swig_module.types */
27175#ifdef SWIGRUNTIME_DEBUG
27176 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27177#endif
27178 for (i = 0; i < swig_module.size; ++i) {
27179 swig_type_info *type = 0;
27180 swig_type_info *ret;
27181 swig_cast_info *cast;
27182
27183#ifdef SWIGRUNTIME_DEBUG
27184 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27185#endif
27186
27187 /* if there is another module already loaded */
27188 if (swig_module.next != &swig_module) {
27189 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
27190 }
27191 if (type) {
27192 /* Overwrite clientdata field */
27193#ifdef SWIGRUNTIME_DEBUG
27194 printf("SWIG_InitializeModule: found type %s\n", type->name);
27195#endif
27196 if (swig_module.type_initial[i]->clientdata) {
27197 type->clientdata = swig_module.type_initial[i]->clientdata;
27198#ifdef SWIGRUNTIME_DEBUG
27199 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27200#endif
27201 }
27202 } else {
27203 type = swig_module.type_initial[i];
27204 }
27205
27206 /* Insert casting types */
27207 cast = swig_module.cast_initial[i];
27208 while (cast->type) {
27209
27210 /* Don't need to add information already in the list */
27211 ret = 0;
27212#ifdef SWIGRUNTIME_DEBUG
27213 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27214#endif
27215 if (swig_module.next != &swig_module) {
27217#ifdef SWIGRUNTIME_DEBUG
27218 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27219#endif
27220 }
27221 if (ret) {
27222 if (type == swig_module.type_initial[i]) {
27223#ifdef SWIGRUNTIME_DEBUG
27224 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27225#endif
27226 cast->type = ret;
27227 ret = 0;
27228 } else {
27229 /* Check for casting already in the list */
27230 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27231#ifdef SWIGRUNTIME_DEBUG
27232 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27233#endif
27234 if (!ocast) ret = 0;
27235 }
27236 }
27237
27238 if (!ret) {
27239#ifdef SWIGRUNTIME_DEBUG
27240 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27241#endif
27242 if (type->cast) {
27243 type->cast->prev = cast;
27244 cast->next = type->cast;
27245 }
27246 type->cast = cast;
27247 }
27248 cast++;
27249 }
27250 /* Set entry in modules->types array equal to the type */
27251 swig_module.types[i] = type;
27252 }
27253 swig_module.types[i] = 0;
27254
27255#ifdef SWIGRUNTIME_DEBUG
27256 printf("**** SWIG_InitializeModule: Cast List ******\n");
27257 for (i = 0; i < swig_module.size; ++i) {
27258 int j = 0;
27259 swig_cast_info *cast = swig_module.cast_initial[i];
27260 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27261 while (cast->type) {
27262 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27263 cast++;
27264 ++j;
27265 }
27266 printf("---- Total casts: %d\n",j);
27267 }
27268 printf("**** SWIG_InitializeModule: Cast List ******\n");
27269#endif
27270}
27271
27272/* This function will propagate the clientdata field of type to
27273* any new swig_type_info structures that have been added into the list
27274* of equivalent types. It is like calling
27275* SWIG_TypeClientData(type, clientdata) a second time.
27276*/
27277SWIGRUNTIME void
27279 size_t i;
27280 swig_cast_info *equiv;
27281 static int init_run = 0;
27282
27283 if (init_run) return;
27284 init_run = 1;
27285
27286 for (i = 0; i < swig_module.size; i++) {
27287 if (swig_module.types[i]->clientdata) {
27288 equiv = swig_module.types[i]->cast;
27289 while (equiv) {
27290 if (!equiv->converter) {
27291 if (equiv->type && !equiv->type->clientdata)
27292 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
27293 }
27294 equiv = equiv->next;
27295 }
27296 }
27297 }
27298}
27299
27300#ifdef __cplusplus
27301#if 0
27302{ /* c-mode */
27303#endif
27304}
27305#endif
27306
27307
27308
27309static bool SWIG_init_user(octave_swig_type* module_ns);
27310
27312 bool retn = false;
27313 {
27314#if SWIG_OCTAVE_PREREQ(6,0,0)
27315#elif SWIG_OCTAVE_PREREQ(4,2,0)
27316 octave::unwind_protect frame;
27317 frame.protect_var(discard_error_messages); discard_error_messages = true;
27318 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27319#elif SWIG_OCTAVE_PREREQ(3,3,50)
27320 unwind_protect frame;
27321 frame.protect_var(error_state); error_state = 0;
27322 frame.protect_var(warning_state); warning_state = 0;
27323 frame.protect_var(discard_error_messages); discard_error_messages = true;
27324 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27325#else
27326 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27327 unwind_protect_int(error_state); error_state = 0;
27328 unwind_protect_int(warning_state); warning_state = 0;
27329 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27330 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27331#endif
27332#if SWIG_OCTAVE_PREREQ(4,2,0)
27333 try {
27334#if SWIG_OCTAVE_PREREQ(4,4,0)
27335 octave::feval(name, octave_value_list(), 0);
27336#else
27337 feval(name, octave_value_list(), 0);
27338#endif
27339 retn = true;
27340 } catch (octave::execution_exception&) { }
27341#else
27342 feval(name, octave_value_list(), 0);
27343 retn = (error_state == 0);
27344#endif
27345#if !SWIG_OCTAVE_PREREQ(3,3,50)
27346 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27347#endif
27348 }
27349 if (!retn) {
27350 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27351 }
27352 return retn;
27353}
27354
27355SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27356 bool retn = false;
27357 {
27358#if SWIG_OCTAVE_PREREQ(6,0,0)
27359#elif SWIG_OCTAVE_PREREQ(4,2,0)
27360 octave::unwind_protect frame;
27361 frame.protect_var(discard_error_messages); discard_error_messages = true;
27362 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27363#elif SWIG_OCTAVE_PREREQ(3,3,50)
27364 unwind_protect frame;
27365 frame.protect_var(error_state); error_state = 0;
27366 frame.protect_var(warning_state); warning_state = 0;
27367 frame.protect_var(discard_error_messages); discard_error_messages = true;
27368 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27369#else
27370 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27371 unwind_protect_int(error_state); error_state = 0;
27372 unwind_protect_int(warning_state); warning_state = 0;
27373 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27374 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27375#endif
27376 octave_value_list args;
27377 args.append(name);
27378 args.append(octloadfcn->fcn_file_name());
27379#if SWIG_OCTAVE_PREREQ(4,2,0)
27380 try {
27381#if SWIG_OCTAVE_PREREQ(4,4,0)
27382 octave::feval("autoload", args, 0);
27383#else
27384 feval("autoload", args, 0);
27385#endif
27386 retn = true;
27387 } catch (octave::execution_exception&) { }
27388#else
27389 feval("autoload", args, 0);
27390 retn = (error_state == 0);
27391#endif
27392#if !SWIG_OCTAVE_PREREQ(3,3,50)
27393 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27394#endif
27395 }
27396 if (!retn) {
27397 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27398 }
27399 return retn;
27400}
27401
27402static const char *const subclass_usage = "-*- texinfo -*- \n\
27403@deftypefn {Loadable Function} {} subclass()\n\
27404@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27405Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27406\n\
27407See the SWIG manual for usage examples.\n\
27408@end deftypefn";
27409
27410DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27412 for (int j = 0; j < args.length(); ++j) {
27413 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27414 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27415 octave_swig_type *ost = osr->get_ptr();
27416 if (!ost->is_owned()) {
27417 error("subclass: cannot subclass object not constructed on octave side");
27418 return octave_value_list();
27419 }
27420 top->merge(*ost);
27421 } else if (args(j).is_function_handle()) {
27422 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27423 } else if (args(j).is_string()) {
27424 if (j + 1 >= args.length()) {
27425 error("subclass: member assignments must be of string,value form");
27426 return octave_value_list();
27427 }
27428 top->assign(args(j).string_value(), args(j + 1));
27429 ++j;
27430 } else {
27431 error("subclass: invalid arguments to subclass()");
27432 return octave_value_list();
27433 }
27434 }
27435 return octave_value(Swig::swig_value_ref(top));
27436}
27437
27438static const char *const swig_type_usage = "-*- texinfo -*- \n\
27439@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27440Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27441@end deftypefn";
27442
27443DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27444 if (args.length() != 1) {
27445 error("swig_type: must be called with only a single object");
27446 return octave_value_list();
27447 }
27449 if (!ost) {
27450 error("swig_type: object is not a swig_ref");
27451 return octave_value_list();
27452 }
27453 return octave_value(ost->swig_type_name());
27454}
27455
27456static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27457@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27458Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27459otherwise return `<unknown>'.\n\
27460@end deftypefn";
27461
27462DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27463 if (args.length() != 1 || !args(0).is_string()) {
27464 error("swig_typequery: must be called with single string argument");
27465 return octave_value_list();
27466 }
27467 swig_module_info *module = SWIG_GetModule(0);
27468 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27469 if (!type)
27470 return octave_value("<unknown>");
27471 return octave_value(type->name);
27472}
27473
27474static const char *const swig_this_usage = "-*- texinfo -*- \n\
27475@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27476Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27477@end deftypefn";
27478
27479DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27480 if (args.length() != 1) {
27481 error("swig_this: must be called with only a single object");
27482 return octave_value_list();
27483 }
27484 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27485 return octave_value(octave_uint64(0));
27487 if (!ost) {
27488 error("swig_this: object is not a swig_ref");
27489 return octave_value_list();
27490 }
27491 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27492}
27493
27494static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27495@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27496Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27497@end deftypefn";
27498
27499DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27500 if (args.length() != 3) {
27501 error("swig_octave_prereq: must be called with 3 arguments");
27502 return octave_value_list();
27503 }
27504 const int major = args(0).int_value();
27505 const int minor = args(1).int_value();
27506 const int patch = args(2).int_value();
27507 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27508 return octave_value(prereq);
27509}
27510
27511static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27512@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27513Exit Octave without performing any memory cleanup.\n\
27514@end deftypefn";
27515
27516DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27517 if (args.length() > 1) {
27518 error("swig_exit: must be called with at most one arguments");
27519 return octave_value_list();
27520 }
27521 int exit_status = 0;
27522 if (args.length() == 1) {
27523 exit_status = args(0).int_value();
27524 }
27525 ::_Exit(exit_status);
27526 return octave_value();
27527}
27528
27529static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27530@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27531Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27532@end deftypefn";
27533
27535
27536 static octave_swig_type* module_ns = 0;
27537
27538 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27539 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27540 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27541 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27542 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27543 // can be turned off with macro definition.
27544#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27545#if !SWIG_OCTAVE_PREREQ(4,4,0)
27546#if SWIG_OCTAVE_PREREQ(3,2,0)
27547 octave_exit = ::_Exit;
27548#endif
27549#endif
27550#endif
27551
27552 // check for no input and output args
27553 if (args.length() != 0 || nargout != 0) {
27554 print_usage();
27555 return octave_value_list();
27556 }
27557
27558 // create module on first function call
27559 if (!module_ns) {
27560
27561 // workaround bug in octave where installing global variable of custom type and then
27562 // exiting without explicitly clearing the variable causes octave to segfault.
27563#if SWIG_OCTAVE_PREREQ(3,2,0)
27564 octave_value_list eval_args;
27565 eval_args.append("base");
27566 eval_args.append("function __swig_atexit__; "
27567 " if mislocked() "
27568 " clear -all; "
27569 " else "
27570 " mlock(); "
27571 " endif; "
27572 "endfunction; "
27573 "__swig_atexit__; "
27574 "atexit(\"__swig_atexit__\", false); "
27575 "atexit(\"__swig_atexit__\")");
27576#if SWIG_OCTAVE_PREREQ(4,4,0)
27577 octave::feval("evalin", eval_args, 0);
27578#else
27579 feval("evalin", eval_args, 0);
27580#endif
27581#endif
27582
27583#if SWIG_OCTAVE_PREREQ(4,4,0)
27584 {
27585 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27586 string_vector types = typeinfo.installed_type_names();
27587 bool register_octave_swig_ref = true;
27588 bool register_octave_swig_packed = true;
27589 for (int i = 0; i < types.numel(); ++i) {
27590 if (types(i) == octave_swig_ref::static_type_name()) {
27591 register_octave_swig_ref = false;
27592 octave_swig_ref::set_type_id(i);
27593 }
27594 if (types(i) == octave_swig_packed::static_type_name()) {
27595 register_octave_swig_packed = false;
27596 octave_swig_packed::set_type_id(i);
27597 }
27598 }
27599 if (register_octave_swig_ref) {
27600 octave_swig_ref::register_type();
27601 }
27602 if (register_octave_swig_packed) {
27603 octave_swig_packed::register_type();
27604 }
27605 }
27606#else
27607 octave_swig_ref::register_type();
27608 octave_swig_packed::register_type();
27609#endif
27612
27613#if SWIG_OCTAVE_PREREQ(8,0,0)
27614 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27615 octave_function *me = tree_eval.current_function();
27616#elif SWIG_OCTAVE_PREREQ(6,0,0)
27617 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27618 octave::call_stack& stack = tree_eval.get_call_stack();
27619 octave_function *me = stack.current_function();
27620#elif SWIG_OCTAVE_PREREQ(4,4,0)
27621 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27622 octave_function *me = stack.current();
27623#else
27624 octave_function *me = octave_call_stack::current();
27625#endif
27626
27627 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27628 return octave_value_list();
27629 }
27630 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27631 return octave_value_list();
27632 }
27633 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27634 return octave_value_list();
27635 }
27636 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27637 return octave_value_list();
27638 }
27639 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27640 return octave_value_list();
27641 }
27642 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27643 return octave_value_list();
27644 }
27645
27646 octave_swig_type* cvar_ns=0;
27647 if (std::string(SWIG_global_name) != ".") {
27648 cvar_ns=new octave_swig_type;
27649 for (int j=0;swig_globals[j].name;++j)
27650 if (swig_globals[j].get_method)
27651 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27652 }
27653
27654 module_ns=new octave_swig_type(0, 0, 0, true);
27655 if (std::string(SWIG_global_name) != ".") {
27656 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27657 }
27658 else {
27659 for (int j=0;swig_globals[j].name;++j)
27660 if (swig_globals[j].get_method)
27661 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27662 }
27663 for (int j=0;swig_globals[j].name;++j)
27664 if (swig_globals[j].method)
27665 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27666
27667 // * need better solution here; swig_type -> octave_class mapping is
27668 // * really n-to-1, in some cases such as template partial spec, etc.
27669 // * see failing tests.
27670 for (int j=0;swig_types[j];++j)
27671 if (swig_types[j]->clientdata) {
27673 module_ns->assign(c->name,
27675 (new octave_swig_type(0,swig_types[j])));
27676 }
27677
27678 if (!SWIG_init_user(module_ns)) {
27679 delete module_ns;
27680 module_ns=0;
27681 return octave_value_list();
27682 }
27683
27684 SWIG_InstallOps(octave_swig_ref::static_type_id());
27685
27687 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27688 if (mb->second.first && mb->second.first->method) {
27689 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27690 return octave_value_list();
27691 }
27692 }
27693 }
27694
27695#if SWIG_OCTAVE_PREREQ(4,4,0)
27696 octave::interpreter::the_interpreter()->mlock();
27697#elif SWIG_OCTAVE_PREREQ(3,2,0)
27698 mlock();
27699#else
27700 mlock(me->name());
27701#endif
27702
27703 }
27704
27706 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27707 if (mb->second.second.is_defined()) {
27708 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27709 SWIG_Octave_LinkGlobalValue(mb->first);
27710 }
27711 }
27712
27715
27716 return octave_value_list();
27717
27718}
27719
27720
27721static bool SWIG_init_user(octave_swig_type* module_ns)
27722{
27723 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27724 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27725 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27726 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27727 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27728 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27729 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27730 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27731 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27732 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27733 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27734 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27735 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27736 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27737 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27738 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27739 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27740 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27741 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27742 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27743 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27744 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27745 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27746 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27747 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27748 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27749 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27750 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27751 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27752 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27753 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27754 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27755 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27756 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27757 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27758 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27759 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27760 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27761 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27762 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27763 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27764 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27765 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27766 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27767 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27768 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27769 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27770 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27771 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27772 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27773 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27774 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27775 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27811 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27812 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27813 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27814 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27815 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27816 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27817 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27818 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27819 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27820 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27821 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27822 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27823 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27824 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27825 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27826 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27827 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27828 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27829 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27830 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27831 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27832 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27833 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27834 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27835 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27836 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27837 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27838 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27839 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27840 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27841 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27842 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27843 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27844 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27845 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27846 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27847 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27848 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27849 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27850 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27851 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27852 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27853 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27854 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27855 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27856 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27857 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27858 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27859 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27860 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27861 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27862 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27863 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27864 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27865 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27866 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27867 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27868 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27869 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27870 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27871 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27872 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27873 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27874 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27875 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27876 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27877 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27878 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27879 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27880 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27881 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27882 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27883 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27884 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27885 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27886 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27887 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27888 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27889 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27890 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27891 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27892 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27893 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27894 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27895 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27896 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27897 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27898 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27899 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27900 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27901 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27902 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27903 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27904 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27905 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27906 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27907 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27908 return true;
27909}
27910
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
int cast(void **vptr, swig_type_info *type, int *own, int flags)
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
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)
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
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 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 plmap
Definition plplot.h:764
#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 plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#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 plmapline
Definition plplot.h:765
#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 plmapstring
Definition plplot.h:766
#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 plmeridians
Definition plplot.h:769
#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)
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plvpas_texinfo
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
static const char * _wrap_plmkstrm_texinfo
#define SWIG_global_name
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
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 const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
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
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
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plscolor_texinfo
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
struct swig_cast_info swig_cast_info
static const char * _wrap_plfill_texinfo
static const struct swig_octave_member swig_globals[]
static const char * _wrap_pllightsource_texinfo
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plscmap0_texinfo
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
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plend1_texinfo
static const char * _wrap_plgcolbga_texinfo
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plprec_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
static const char *const SWIG_name_usage
static const char * _wrap_plgpage_texinfo
static const char * _wrap_plschr_texinfo
static int _arraylen(const octave_value &o_obj)
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
static const char * _wrap_plsurf3d_texinfo
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_plgfnam_texinfo
static const char * _wrap_plenv0_texinfo
#define swigreg_binary_op(name)
static const char * _wrap_plenv_texinfo
#define SWIG_as_voidptrptr(a)
static const char * _wrap_plsym_texinfo
static const char * _wrap_plmapstring_texinfo
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)
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
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
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 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
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)
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 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
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
#define SWIG_POINTER_RELEASE
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)
SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type)
static const char * _wrap_plsdiplz_texinfo
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
#define SWIG_POINTER_CLEAR
static const char * _wrap_plssub_texinfo
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
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
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_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
#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
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 const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
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)
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)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_plsmin_texinfo
static const char * _wrap_plglevel_texinfo
static const char * _wrap_plvpor_texinfo
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
octave_function * fcnLabelFunc
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
static const char * _wrap_plgfci_texinfo
static const char * _wrap_plsfont_texinfo
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_pllegend_texinfo
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)
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
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
static const char shade or gradient plots n n or n gradient plots(See pllegend for similar functionality for creating\n\ legends with discrete elements). The arguments of plcolorbar provide\n\ control over the location and size of the color bar as well as the\n\ location and characteristics of the elements(most of which are\n\ optional) within that color bar. The resulting color bar is clipped\n\ at the boundaries of the current subpage.(N.B. the adopted coordinate\n\ system used for some of the parameters is defined in the documentation\n\ of the position parameter.)\n\ \n\ Redacted form reads the desired grid location from the input vectors n xg[nptsx] and yg[nptsy]
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
octave_function * fcnMapForm
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
static const char * _wrap_pllab_texinfo
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 swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plpoin_texinfo
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)
#define SWIG_ERROR_RELEASE_NOT_OWNED
static const char * _wrap_plclear_texinfo
#define SWIG_CAST_NEW_MEMORY
struct swig_module_info swig_module_info
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plpath_texinfo
static const char * _wrap_plimagefr_texinfo
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define SWIG_ERROR
static const char * _wrap_pljoin_texinfo
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 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
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 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)
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
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
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)
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)
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
#define SWIG_IsOK(r)
static const char * _wrap_plspal1_texinfo
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plcont_texinfo
static const char * _wrap_plctime_texinfo
static const char * _wrap_plscolbg_texinfo
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
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)
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_texinfo
#define SWIG_OK
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)
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
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_plstransform(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
#define SWIG_Error(code, msg)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
#define SWIG_ErrorType(code)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
struct swig_type_info swig_type_info
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
static swig_cast_info * swig_cast_initial[]
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
#define SWIG_TypeQuery(name)
static int _wrap_plend(lua_State *L)
#define SWIG_POINTER_OWN
#define SWIG_SyntaxError
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_TypeError
static PLINT Alen
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
static int _wrap_plGetCursor(lua_State *L)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
#define SWIG_RuntimeError
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIG_ConvertPtr(L, idx, ptr, type, flags)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
#define SWIGRUNTIME
#define SWIG_RUNTIME_VERSION
#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)
#define SWIG_ValueError
static int _wrap_new_PLGraphicsIn(lua_State *L)
#define SWIG_AddCast(r)
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
#define SWIG_IsNewObj(r)
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
static swig_type_info * swig_types[13]
static int _wrap_plResetOpts(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static int _wrap_plot3dcl(lua_State *L)
static int _wrap_plOptUsage(lua_State *L)
static swig_module_info swig_module
static const char * swig_PLGraphicsIn_base_names[]
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
static PLINT Ylen
static swig_type_info _swigt__p_double
#define SWIG_SetModule(clientdata, pointer)
#define SWIG_INIT_CLIENT_DATA_TYPE
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
static swig_type_info _swigt__p_p_char
static int _wrap_plend1(lua_State *L)
#define SWIGTYPE_p_int
#define SWIG_check_num_args(func_name, a, b)
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int _wrap_plClearOpts(lua_State *L)
static swig_cast_info _swigc__p_char[]
static int _wrap_plot3d(lua_State *L)
PLINT(* defined_func)(PLFLT, PLFLT)
#define SWIG_NewPointerObj(L, ptr, type, owner)
#define SWIGINTERN
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
#define SWIG_ArgError(r)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define SWIG_POINTER_NO_NULL
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_IOError
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_PLGraphicsIn
#define SWIG_IsTmpObj(r)
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
static int _wrap_plot3dc(lua_State *L)
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
#define SWIG_NEWOBJ
#define SWIG_TMPOBJ
#define SWIG_DelNewMask(r)
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
#define SWIG_GetModule(clientdata)
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGRUNTIME void SWIG_PropagateClientData(void)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static int _wrap_plSetUsage(lua_State *L)
#define SWIG_init_user
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
#define SWIG_ERROR
#define SWIG_name
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
static swig_type_info * swig_type_initial[]
static swig_cast_info _swigc__p_PLGraphicsIn[]
static swig_cast_info _swigc__p_p_char[]
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
#define SWIG_MemoryError
#define SWIG_SystemError
#define SWIG_DivisionByZero
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
static swig_type_info _swigt__p_char
#define SWIG_OverflowError
#define SWIG_IsOK(r)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_IndexError
static swig_lua_class _wrap_class_PLGraphicsIn
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
#define SWIG_OK
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
#define SWIGINTERNINLINE
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
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 Tcl_Interp * interp
Definition tkMain.c:120
static const char * name
Definition tkMain.c:135