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.0
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 0x040300
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 <cstdlib>
192#include <climits>
193#include <iostream>
194#include <exception>
195#include <functional>
196#include <complex>
197#include <string>
198#include <vector>
199#include <map>
200
201// Minimal headers to define Octave version
202#include <octave/oct.h>
203#include <octave/version.h>
204
205// Macro for enabling features which require Octave version >= major.minor.patch
206// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
207#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
208 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
209
210// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
211#if !defined(OCTAVE_MAJOR_VERSION)
212
213# if !defined(OCTAVE_API_VERSION_NUMBER)
214
215// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
216// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
217# include <octave/ov.h>
218# if defined(octave_ov_h)
219# define OCTAVE_MAJOR_VERSION 3
220# define OCTAVE_MINOR_VERSION 8
221# define OCTAVE_PATCH_VERSION 0
222# else
223
224// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
225# define ComplexLU __ignore
226# include <octave/CmplxLU.h>
227# undef ComplexLU
228# if defined(octave_Complex_LU_h)
229
230// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
231# define OCTAVE_MAJOR_VERSION 3
232# define OCTAVE_MINOR_VERSION 1
233# define OCTAVE_PATCH_VERSION 99
234
235# else
236
237// OCTAVE_API_VERSION_NUMBER == 37
238# define OCTAVE_MAJOR_VERSION 3
239# define OCTAVE_MINOR_VERSION 2
240# define OCTAVE_PATCH_VERSION 0
241
242# endif // defined(octave_Complex_LU_h)
243
244# endif // defined(octave_ov_h)
245
246// Correlation between Octave API and version numbers extracted from Octave's
247// ChangeLogs; version is the *earliest* released Octave with that API number
248# elif OCTAVE_API_VERSION_NUMBER >= 48
249# define OCTAVE_MAJOR_VERSION 3
250# define OCTAVE_MINOR_VERSION 6
251# define OCTAVE_PATCH_VERSION 0
252
253# elif OCTAVE_API_VERSION_NUMBER >= 45
254# define OCTAVE_MAJOR_VERSION 3
255# define OCTAVE_MINOR_VERSION 4
256# define OCTAVE_PATCH_VERSION 1
257
258# elif OCTAVE_API_VERSION_NUMBER >= 42
259# define OCTAVE_MAJOR_VERSION 3
260# define OCTAVE_MINOR_VERSION 3
261# define OCTAVE_PATCH_VERSION 54
262
263# elif OCTAVE_API_VERSION_NUMBER >= 41
264# define OCTAVE_MAJOR_VERSION 3
265# define OCTAVE_MINOR_VERSION 3
266# define OCTAVE_PATCH_VERSION 53
267
268# elif OCTAVE_API_VERSION_NUMBER >= 40
269# define OCTAVE_MAJOR_VERSION 3
270# define OCTAVE_MINOR_VERSION 3
271# define OCTAVE_PATCH_VERSION 52
272
273# elif OCTAVE_API_VERSION_NUMBER >= 39
274# define OCTAVE_MAJOR_VERSION 3
275# define OCTAVE_MINOR_VERSION 3
276# define OCTAVE_PATCH_VERSION 51
277
278# else // OCTAVE_API_VERSION_NUMBER == 38
279# define OCTAVE_MAJOR_VERSION 3
280# define OCTAVE_MINOR_VERSION 3
281# define OCTAVE_PATCH_VERSION 50
282
283# endif // !defined(OCTAVE_API_VERSION_NUMBER)
284
285#endif // !defined(OCTAVE_MAJOR_VERSION)
286
287// Required Octave headers
288#include <octave/Cell.h>
289#include <octave/dynamic-ld.h>
290#include <octave/oct-env.h>
291#include <octave/oct-map.h>
292#include <octave/ov-scalar.h>
293#include <octave/ov-fcn-handle.h>
294#include <octave/parse.h>
295#if SWIG_OCTAVE_PREREQ(4,2,0)
296#include <octave/interpreter.h>
297#else
298#include <octave/toplev.h>
299#endif
300#include <octave/unwind-prot.h>
301#if SWIG_OCTAVE_PREREQ(4,2,0)
302#include <octave/call-stack.h>
303#endif
304
305#endif // !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
306
307/* -----------------------------------------------------------------------------
308 * swigrun.swg
309 *
310 * This file contains generic C API SWIG runtime support for pointer
311 * type checking.
312 * ----------------------------------------------------------------------------- */
313
314/* This should only be incremented when either the layout of swig_type_info changes,
315 or for whatever reason, the runtime changes incompatibly */
316#define SWIG_RUNTIME_VERSION "4"
317
318/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
319#ifdef SWIG_TYPE_TABLE
320# define SWIG_QUOTE_STRING(x) #x
321# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
322# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
323#else
324# define SWIG_TYPE_TABLE_NAME
325#endif
326
327/*
328 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
329 creating a static or dynamic library from the SWIG runtime code.
330 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
331
332 But only do this if strictly necessary, ie, if you have problems
333 with your compiler or suchlike.
334*/
335
336#ifndef SWIGRUNTIME
337# define SWIGRUNTIME SWIGINTERN
338#endif
339
340#ifndef SWIGRUNTIMEINLINE
341# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
342#endif
343
344/* Generic buffer size */
345#ifndef SWIG_BUFFER_SIZE
346# define SWIG_BUFFER_SIZE 1024
347#endif
348
349/* Flags for pointer conversions */
350#define SWIG_POINTER_DISOWN 0x1
351#define SWIG_CAST_NEW_MEMORY 0x2
352#define SWIG_POINTER_NO_NULL 0x4
353#define SWIG_POINTER_CLEAR 0x8
354#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
355
356/* Flags for new pointer objects */
357#define SWIG_POINTER_OWN 0x1
358
359
360/*
361 Flags/methods for returning states.
362
363 The SWIG conversion methods, as ConvertPtr, return an integer
364 that tells if the conversion was successful or not. And if not,
365 an error code can be returned (see swigerrors.swg for the codes).
366
367 Use the following macros/flags to set or process the returning
368 states.
369
370 In old versions of SWIG, code such as the following was usually written:
371
372 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
373 // success code
374 } else {
375 //fail code
376 }
377
378 Now you can be more explicit:
379
380 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
381 if (SWIG_IsOK(res)) {
382 // success code
383 } else {
384 // fail code
385 }
386
387 which is the same really, but now you can also do
388
389 Type *ptr;
390 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
391 if (SWIG_IsOK(res)) {
392 // success code
393 if (SWIG_IsNewObj(res) {
394 ...
395 delete *ptr;
396 } else {
397 ...
398 }
399 } else {
400 // fail code
401 }
402
403 I.e., now SWIG_ConvertPtr can return new objects and you can
404 identify the case and take care of the deallocation. Of course that
405 also requires SWIG_ConvertPtr to return new result values, such as
406
407 int SWIG_ConvertPtr(obj, ptr,...) {
408 if (<obj is ok>) {
409 if (<need new object>) {
410 *ptr = <ptr to new allocated object>;
411 return SWIG_NEWOBJ;
412 } else {
413 *ptr = <ptr to old object>;
414 return SWIG_OLDOBJ;
415 }
416 } else {
417 return SWIG_BADOBJ;
418 }
419 }
420
421 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
422 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
423 SWIG errors code.
424
425 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
426 allows returning the 'cast rank', for example, if you have this
427
428 int food(double)
429 int fooi(int);
430
431 and you call
432
433 food(1) // cast rank '1' (1 -> 1.0)
434 fooi(1) // cast rank '0'
435
436 just use the SWIG_AddCast()/SWIG_CheckState()
437*/
438
439#define SWIG_OK (0)
440/* Runtime errors are < 0 */
441#define SWIG_ERROR (-1)
442/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
443/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
444/* Errors < -200 are generic runtime specific errors */
445#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
446
447#define SWIG_IsOK(r) (r >= 0)
448#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
449
450/* The CastRankLimit says how many bits are used for the cast rank */
451#define SWIG_CASTRANKLIMIT (1 << 8)
452/* The NewMask denotes the object was created (using new/malloc) */
453#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
454/* The TmpMask is for in/out typemaps that use temporary objects */
455#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
456/* Simple returning values */
457#define SWIG_BADOBJ (SWIG_ERROR)
458#define SWIG_OLDOBJ (SWIG_OK)
459#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
460#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
461/* Check, add and del object mask methods */
462#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
463#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
464#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
465#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
466#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
467#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
468
469/* Cast-Rank Mode */
470#if defined(SWIG_CASTRANK_MODE)
471# ifndef SWIG_TypeRank
472# define SWIG_TypeRank unsigned long
473# endif
474# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
475# define SWIG_MAXCASTRANK (2)
476# endif
477# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
478# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
480 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
481}
483 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
484}
485#else /* no cast-rank mode */
486# define SWIG_AddCast(r) (r)
487# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
488#endif
489
490
491#include <string.h>
492
493#ifdef __cplusplus
494extern "C" {
495#endif
496
497typedef void *(*swig_converter_func)(void *, int *);
498typedef struct swig_type_info *(*swig_dycast_func)(void **);
499
500/* Structure to store information on one type */
501typedef struct swig_type_info {
502 const char *name; /* mangled name of this type */
503 const char *str; /* human readable name of this type */
504 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
505 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
506 void *clientdata; /* language specific type data */
507 int owndata; /* flag if the structure owns the clientdata */
509
510/* Structure to store a type and conversion function used for casting */
511typedef struct swig_cast_info {
512 swig_type_info *type; /* pointer to type that is equivalent to this type */
513 swig_converter_func converter; /* function to cast the void pointers */
514 struct swig_cast_info *next; /* pointer to next cast in linked list */
515 struct swig_cast_info *prev; /* pointer to the previous cast */
517
518/* Structure used to store module information
519 * Each module generates one structure like this, and the runtime collects
520 * all of these structures and stores them in a circularly linked list.*/
521typedef struct swig_module_info {
522 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
523 size_t size; /* Number of types in this module */
524 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
525 swig_type_info **type_initial; /* Array of initially generated type structures */
526 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
527 void *clientdata; /* Language specific module data */
529
530/*
531 Compare two type names skipping the space characters, therefore
532 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
533
534 Return 0 when the two name types are equivalent, as in
535 strncmp, but skipping ' '.
536*/
537SWIGRUNTIME int
538SWIG_TypeNameComp(const char *f1, const char *l1,
539 const char *f2, const char *l2) {
540 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
541 while ((*f1 == ' ') && (f1 != l1)) ++f1;
542 while ((*f2 == ' ') && (f2 != l2)) ++f2;
543 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
544 }
545 return (int)((l1 - f1) - (l2 - f2));
546}
547
548/*
549 Check type equivalence in a name list like <name1>|<name2>|...
550 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
551*/
552SWIGRUNTIME int
553SWIG_TypeCmp(const char *nb, const char *tb) {
554 int equiv = 1;
555 const char* te = tb + strlen(tb);
556 const char* ne = nb;
557 while (equiv != 0 && *ne) {
558 for (nb = ne; *ne; ++ne) {
559 if (*ne == '|') break;
560 }
561 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
562 if (*ne) ++ne;
563 }
564 return equiv;
565}
566
567/*
568 Check type equivalence in a name list like <name1>|<name2>|...
569 Return 0 if not equal, 1 if equal
570*/
571SWIGRUNTIME int
572SWIG_TypeEquiv(const char *nb, const char *tb) {
573 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
574}
575
576/*
577 Check the typename
578*/
580SWIG_TypeCheck(const char *c, swig_type_info *ty) {
581 if (ty) {
582 swig_cast_info *iter = ty->cast;
583 while (iter) {
584 if (strcmp(iter->type->name, c) == 0) {
585 if (iter == ty->cast)
586 return iter;
587 /* Move iter to the top of the linked list */
588 iter->prev->next = iter->next;
589 if (iter->next)
590 iter->next->prev = iter->prev;
591 iter->next = ty->cast;
592 iter->prev = 0;
593 if (ty->cast) ty->cast->prev = iter;
594 ty->cast = iter;
595 return iter;
596 }
597 iter = iter->next;
598 }
599 }
600 return 0;
601}
602
603/*
604 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
605*/
608 if (ty) {
609 swig_cast_info *iter = ty->cast;
610 while (iter) {
611 if (iter->type == from) {
612 if (iter == ty->cast)
613 return iter;
614 /* Move iter to the top of the linked list */
615 iter->prev->next = iter->next;
616 if (iter->next)
617 iter->next->prev = iter->prev;
618 iter->next = ty->cast;
619 iter->prev = 0;
620 if (ty->cast) ty->cast->prev = iter;
621 ty->cast = iter;
622 return iter;
623 }
624 iter = iter->next;
625 }
626 }
627 return 0;
628}
629
630/*
631 Cast a pointer up an inheritance hierarchy
632*/
634SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
635 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
636}
637
638/*
639 Dynamic pointer casting. Down an inheritance hierarchy
640*/
643 swig_type_info *lastty = ty;
644 if (!ty || !ty->dcast) return ty;
645 while (ty && (ty->dcast)) {
646 ty = (*ty->dcast)(ptr);
647 if (ty) lastty = ty;
648 }
649 return lastty;
650}
651
652/*
653 Return the name associated with this type
654*/
655SWIGRUNTIMEINLINE const char *
657 return ty->name;
658}
659
660/*
661 Return the pretty name associated with this type,
662 that is an unmangled type name in a form presentable to the user.
663*/
664SWIGRUNTIME const char *
666 /* The "str" field contains the equivalent pretty names of the
667 type, separated by vertical-bar characters. Choose the last
668 name. It should be the most specific; a fully resolved name
669 but not necessarily with default template parameters expanded. */
670 if (!type) return NULL;
671 if (type->str != NULL) {
672 const char *last_name = type->str;
673 const char *s;
674 for (s = type->str; *s; s++)
675 if (*s == '|') last_name = s+1;
676 return last_name;
677 }
678 else
679 return type->name;
680}
681
682/*
683 Set the clientdata field for a type
684*/
685SWIGRUNTIME void
687 swig_cast_info *cast = ti->cast;
688 /* if (ti->clientdata == clientdata) return; */
690
691 while (cast) {
692 if (!cast->converter) {
693 swig_type_info *tc = cast->type;
694 if (!tc->clientdata) {
696 }
697 }
698 cast = cast->next;
699 }
700}
701SWIGRUNTIME void
706
707/*
708 Search for a swig_type_info structure only by mangled name
709 Search is a O(log #types)
710
711 We start searching at module start, and finish searching when start == end.
712 Note: if start == end at the beginning of the function, we go all the way around
713 the circular list.
714*/
717 swig_module_info *end,
718 const char *name) {
719 swig_module_info *iter = start;
720 do {
721 if (iter->size) {
722 size_t l = 0;
723 size_t r = iter->size - 1;
724 do {
725 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
726 size_t i = (l + r) >> 1;
727 const char *iname = iter->types[i]->name;
728 if (iname) {
729 int compare = strcmp(name, iname);
730 if (compare == 0) {
731 return iter->types[i];
732 } else if (compare < 0) {
733 if (i) {
734 r = i - 1;
735 } else {
736 break;
737 }
738 } else if (compare > 0) {
739 l = i + 1;
740 }
741 } else {
742 break; /* should never happen */
743 }
744 } while (l <= r);
745 }
746 iter = iter->next;
747 } while (iter != end);
748 return 0;
749}
750
751/*
752 Search for a swig_type_info structure for either a mangled name or a human readable name.
753 It first searches the mangled names of the types, which is a O(log #types)
754 If a type is not found it then searches the human readable names, which is O(#types).
755
756 We start searching at module start, and finish searching when start == end.
757 Note: if start == end at the beginning of the function, we go all the way around
758 the circular list.
759*/
762 swig_module_info *end,
763 const char *name) {
764 /* STEP 1: Search the name field using binary search */
766 if (ret) {
767 return ret;
768 } else {
769 /* STEP 2: If the type hasn't been found, do a complete search
770 of the str field (the human readable name) */
771 swig_module_info *iter = start;
772 do {
773 size_t i = 0;
774 for (; i < iter->size; ++i) {
775 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
776 return iter->types[i];
777 }
778 iter = iter->next;
779 } while (iter != end);
780 }
781
782 /* neither found a match */
783 return 0;
784}
785
786/*
787 Pack binary data into a string
788*/
789SWIGRUNTIME char *
790SWIG_PackData(char *c, void *ptr, size_t sz) {
791 static const char hex[17] = "0123456789abcdef";
792 const unsigned char *u = (unsigned char *) ptr;
793 const unsigned char *eu = u + sz;
794 for (; u != eu; ++u) {
795 unsigned char uu = *u;
796 *(c++) = hex[(uu & 0xf0) >> 4];
797 *(c++) = hex[uu & 0xf];
798 }
799 return c;
800}
801
802/*
803 Unpack binary data from a string
804*/
805SWIGRUNTIME const char *
806SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
807 unsigned char *u = (unsigned char *) ptr;
808 const unsigned char *eu = u + sz;
809 for (; u != eu; ++u) {
810 char d = *(c++);
811 unsigned char uu;
812 if ((d >= '0') && (d <= '9'))
813 uu = (unsigned char)((d - '0') << 4);
814 else if ((d >= 'a') && (d <= 'f'))
815 uu = (unsigned char)((d - ('a'-10)) << 4);
816 else
817 return (char *) 0;
818 d = *(c++);
819 if ((d >= '0') && (d <= '9'))
820 uu |= (unsigned char)(d - '0');
821 else if ((d >= 'a') && (d <= 'f'))
822 uu |= (unsigned char)(d - ('a'-10));
823 else
824 return (char *) 0;
825 *u = uu;
826 }
827 return c;
828}
829
830/*
831 Pack 'void *' into a string buffer.
832*/
833SWIGRUNTIME char *
834SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
835 char *r = buff;
836 if ((2*sizeof(void *) + 2) > bsz) return 0;
837 *(r++) = '_';
838 r = SWIG_PackData(r,&ptr,sizeof(void *));
839 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
840 strcpy(r,name);
841 return buff;
842}
843
844SWIGRUNTIME const char *
845SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
846 if (*c != '_') {
847 if (strcmp(c,"NULL") == 0) {
848 *ptr = (void *) 0;
849 return name;
850 } else {
851 return 0;
852 }
853 }
854 return SWIG_UnpackData(++c,ptr,sizeof(void *));
855}
856
857SWIGRUNTIME char *
858SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
859 char *r = buff;
860 size_t lname = (name ? strlen(name) : 0);
861 if ((2*sz + 2 + lname) > bsz) return 0;
862 *(r++) = '_';
863 r = SWIG_PackData(r,ptr,sz);
864 if (lname) {
865 strncpy(r,name,lname+1);
866 } else {
867 *r = 0;
868 }
869 return buff;
870}
871
872SWIGRUNTIME const char *
873SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
874 if (*c != '_') {
875 if (strcmp(c,"NULL") == 0) {
876 memset(ptr,0,sz);
877 return name;
878 } else {
879 return 0;
880 }
881 }
882 return SWIG_UnpackData(++c,ptr,sz);
883}
884
885#ifdef __cplusplus
886}
887#endif
888
889/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
890#define SWIG_UnknownError -1
891#define SWIG_IOError -2
892#define SWIG_RuntimeError -3
893#define SWIG_IndexError -4
894#define SWIG_TypeError -5
895#define SWIG_DivisionByZero -6
896#define SWIG_OverflowError -7
897#define SWIG_SyntaxError -8
898#define SWIG_ValueError -9
899#define SWIG_SystemError -10
900#define SWIG_AttributeError -11
901#define SWIG_MemoryError -12
902#define SWIG_NullReferenceError -13
903
904
905#if !SWIG_OCTAVE_PREREQ(3,2,0)
906#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
907#else
908#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
909#endif
910
911SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
912 if (num_args > max_args && !varargs)
913 error("function %s takes at most %i arguments", func_name, max_args);
914 else if (num_args < min_args)
915 error("function %s requires at least %i arguments", func_name, min_args);
916 else
917 return true;
918 return false;
919}
920
921SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
922 ovl->append(ov);
923 return ovl;
924}
925
926SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
927 switch (code) {
928 case SWIG_MemoryError:
929 return "SWIG_MemoryError";
930 case SWIG_IOError:
931 return "SWIG_IOError";
933 return "SWIG_RuntimeError";
934 case SWIG_IndexError:
935 return "SWIG_IndexError";
936 case SWIG_TypeError:
937 return "SWIG_TypeError";
939 return "SWIG_DivisionByZero";
941 return "SWIG_OverflowError";
942 case SWIG_SyntaxError:
943 return "SWIG_SyntaxError";
944 case SWIG_ValueError:
945 return "SWIG_ValueError";
946 case SWIG_SystemError:
947 return "SWIG_SystemError";
949 return "SWIG_AttributeError";
951 return "SWIG_NullReferenceError";
952 }
953 return "SWIG unknown error";
954}
955
956SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
957 octave_value type(SWIG_ErrorType(code));
958 std::string r = msg;
959 r += " (" + type.string_value() + ")";
960 error("%s", r.c_str());
961 return octave_value(r);
962}
963
964#define SWIG_fail goto fail
965
966#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
967#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
968#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
969#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
970#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
971#define swig_owntype int
972
973#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
974#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
975
976#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
977#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
978
979#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
980#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
981
982#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
983#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
984#define SWIG_MODULE_CLIENTDATA_TYPE void*
985
986#define Octave_Error_Occurred() 0
987#define SWIG_Octave_AddErrorMsg(msg) {;}
988
991
992// For backward compatibility only
993#define SWIG_POINTER_EXCEPTION 0
994#define SWIG_arg_fail(arg) 0
995
996// Runtime API implementation
997
998typedef octave_value_list(*octave_func) (const octave_value_list &, int);
999class octave_swig_type;
1000
1001namespace Swig {
1002
1003#ifdef SWIG_DIRECTORS
1004
1005 class Director;
1006
1007 typedef std::map < void *, Director * > rtdir_map;
1008 SWIGINTERN rtdir_map* get_rtdir_map();
1009 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
1010 SWIGINTERNINLINE void erase_rtdir(void *vptr);
1011 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
1012
1013 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
1014 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
1015 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
1016
1017#endif
1018
1019 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
1021 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
1022}
1023
1024#ifdef SWIG_DIRECTORS
1025SWIGRUNTIME void swig_acquire_ownership(void *vptr);
1026SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
1027SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
1028#endif
1029
1031 const char *name;
1035 int flags; // 1 static, 2 global
1036 const char *doc;
1037 bool is_static() const {
1038 return flags &1;
1039 } bool is_global() const {
1040 return flags &2;
1041 }
1042 };
1043
1055
1056#if SWIG_OCTAVE_PREREQ(4,4,0)
1057 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1058 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1059#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1060 class octave_swig_bound_func : public octave_function {
1061 public:
1062
1063 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1064 { }
1065
1066 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1067 : octave_function("", ""), method(_method), first_args(_first_args)
1068 { }
1069
1070 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1071
1072 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1073
1074 ~octave_swig_bound_func(void) = default;
1075
1076 bool is_function(void) const { return true; }
1077
1078 octave_function* function_value(bool = false) { return this; }
1079
1080#if SWIG_OCTAVE_PREREQ(6,0,0)
1081 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1082 return execute(tw,nargout,args);
1083 }
1084#endif
1085#if SWIG_OCTAVE_PREREQ(6,0,0)
1086 octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1087#else
1088 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1089#endif
1090 octave_value_list all_args;
1091 all_args.append(first_args);
1092 all_args.append(args);
1093 return method->call(tw, nargout, all_args);
1094 }
1095
1096 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1097 octave_value_list ovl = subsref(ops, idx, 1);
1098 return ovl.length() ? ovl(0) : octave_value();
1099 }
1100
1101 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1102 assert(ops.size() > 0);
1103 assert(ops.size() == idx.size());
1104 if (ops != "(")
1105 error("invalid function call");
1106 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1107 return call(tw, nargout, *idx.begin());
1108 }
1109
1110 protected:
1111
1112 octave_function* method;
1113 octave_value_list first_args;
1114
1115 std::set<std::string> dispatch_classes;
1116
1117 };
1118#else
1119#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1120#endif
1121
1122 // octave_swig_type plays the role of both the shadow class and the class
1123 // representation within Octave, since there is no support for classes.
1124 //
1125 // These should really be decoupled, with the class support added to Octave
1126 // and the shadow class given by an m-file script. That would dramatically
1127 // reduce the runtime complexity, and be more in line with other modules.
1128
1129 class octave_swig_type:public octave_base_value {
1130 struct cpp_ptr {
1131 void *ptr;
1133 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1134 }};
1135 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1136
1138
1139 const swig_type_info *construct_type; // type of special type object
1140 std::vector < type_ptr_pair > types; // our c++ base classes
1141 int thisown; // whether we call c++ destructors when we die
1142
1143 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1144 typedef std::map < std::string, member_value_pair > member_map;
1147
1148 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1149 if (!type->clientdata)
1150 return 0;
1151 swig_octave_class *c = (swig_octave_class *) type->clientdata;
1152 const swig_octave_member *m;
1153 for (m = c->members; m->name; ++m)
1154 if (m->name == name)
1155 return m;
1156 for (int j = 0; c->base_names[j]; ++j) {
1157 if (!c->base[j]) {
1158 if (!module)
1159 module = SWIG_GetModule(0);
1160 assert(module);
1161 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1162 }
1163 if (!c->base[j])
1164 return 0;
1165 if ((m = find_member(c->base[j], name)))
1166 return m;
1167 }
1168 return 0;
1169 }
1170
1171 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1172 member_map::iterator it = members.find(name);
1173 if (it != members.end())
1174 return &it->second;
1175 const swig_octave_member *m;
1176 for (unsigned int j = 0; j < types.size(); ++j)
1177 if ((m = find_member(types[j].first, name)))
1178 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1179 if (!insert_if_not_found)
1180 return 0;
1181 return &members[name];
1182 }
1183
1184 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1185 if (!base) {
1186 for (unsigned int j = 0; j < types.size(); ++j) {
1187 assert(types[j].first->clientdata);
1188 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1189 if (cj->name == name)
1190 return types[j].first;
1191 }
1192 return 0;
1193 }
1194 assert(base->clientdata);
1196 for (int j = 0; c->base_names[j]; ++j) {
1197 if (!c->base[j]) {
1198 if (!module)
1199 module = SWIG_GetModule(0);
1200 assert(module);
1201 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1202 }
1203 if (!c->base[j])
1204 return 0;
1205 assert(c->base[j]->clientdata);
1207 if (cj->name == name)
1208 return c->base[j];
1209 }
1210 return 0;
1211 }
1212
1213 void load_members(const swig_octave_class* c,member_map& out) const {
1214 for (const swig_octave_member *m = c->members; m->name; ++m) {
1215 if (out.find(m->name) == out.end())
1216 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1217 }
1218 for (int j = 0; c->base_names[j]; ++j) {
1219 if (!c->base[j]) {
1220 if (!module)
1221 module = SWIG_GetModule(0);
1222 assert(module);
1223 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1224 }
1225 if (!c->base[j])
1226 continue;
1227 assert(c->base[j]->clientdata);
1228 const swig_octave_class *cj =
1229 (const swig_octave_class *) c->base[j]->clientdata;
1230 load_members(cj,out);
1231 }
1232 }
1233
1234 void load_members(member_map& out) const {
1235 out=members;
1236 for (unsigned int j = 0; j < types.size(); ++j)
1237 if (types[j].first->clientdata)
1238 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1239 }
1240
1241 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1242 if (m->second.is_defined())
1243 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1244 else if (m->first && m->first->method)
1245 return m->first->method(args, nargout);
1246 error("member not defined or not invocable");
1247 return octave_value_list();
1248 }
1249
1250 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1251 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1252 member_value_pair *m = nc_this->find_member(symbol, false);
1253 if (!m || m->first->is_static() || m->first->is_global())
1254 return false;
1255 octave_value_list args;
1256 args.append(nc_this->as_value());
1257 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1258 if (argout.length() < 1)
1259 return false;
1260 ret = argout(0);
1261 return true;
1262 }
1263
1264 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1265 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1266 member_value_pair *m = nc_this->find_member(symbol, false);
1267 if (!m || m->first->is_static() || m->first->is_global())
1268 return false;
1269 octave_value_list args;
1270 args.append(nc_this->as_value());
1271 args.append(make_value_hack(rhs));
1272 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1273 if (argout.length() < 1)
1274 return false;
1275 ret = argout(0);
1276 return true;
1277 }
1278
1279 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1280 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1281 member_value_pair *m = nc_this->find_member(symbol, false);
1282 if (!m || m->first->is_static() || m->first->is_global())
1283 return false;
1284 octave_value_list args;
1285 args.append(nc_this->as_value());
1286 args.append(rhs);
1287 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1288 if (argout.length() >= 1)
1289 ret = argout(0);
1290 return true;
1291 }
1292
1293 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1294 if (m->second.is_defined()) {
1295 if (m->second.is_function() || m->second.is_function_handle()) {
1296 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1297 } else {
1298 return m->second;
1299 }
1300 } else if (m->first) {
1301 if (m->first->get_method)
1302 return m->first->get_method(args, 1);
1303 else if (m->first->method)
1304 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1305 }
1306 error("undefined member");
1307 return octave_value_list();
1308 }
1309
1310 static octave_value make_value_hack(const octave_base_value &x) {
1311#if SWIG_OCTAVE_PREREQ(9,0,0)
1312 ((octave_swig_type &) x).m_count++;
1313#else
1314 ((octave_swig_type &) x).count++;
1315#endif
1316 return octave_value((octave_base_value *) &x);
1317 }
1318
1321 public:
1322
1323 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1324 bool _always_static = false)
1325 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1326 always_static(_always_static) {
1327 if (_type || _ptr)
1328 types.push_back(std::make_pair(_type, _ptr));
1329#ifdef SWIG_DIRECTORS
1330 if (_ptr) {
1331 Swig::Director *d = Swig::get_rtdir(_ptr);
1332 if (d)
1333 Swig::swig_director_set_self(d, this);
1334 }
1335#endif
1336 }
1337
1339 if (thisown) {
1340#if SWIG_OCTAVE_PREREQ(9,0,0)
1341 ++m_count;
1342#else
1343 ++count;
1344#endif
1345 for (unsigned int j = 0; j < types.size(); ++j) {
1346 if (!types[j].first || !types[j].first->clientdata)
1347 continue;
1348 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1349 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1350 c->destructor(as_value(), 0);
1351 }
1352 }
1353 }
1354#ifdef SWIG_DIRECTORS
1355 for (unsigned int j = 0; j < types.size(); ++j)
1356 Swig::erase_rtdir(types[j].second.ptr);
1357#endif
1358 }
1359
1360 dim_vector dims(void) const {
1361 octave_value out;
1362 if (!dispatch_unary_op("__dims__", out))
1363 return dim_vector(1,1);
1364
1365 // Return value should be cell or matrix of integers
1366#if SWIG_OCTAVE_PREREQ(4,4,0)
1367 if (out.iscell()) {
1368#else
1369 if (out.is_cell()) {
1370#endif
1371 const Cell & c=out.cell_value();
1372 int ndim = c.rows();
1373 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1374
1375 dim_vector d;
1376 d.resize(ndim < 2 ? 2 : ndim);
1377 d(0) = d(1) = 1;
1378
1379 // Fill in dim_vector
1380 for (int k=0;k<ndim;k++) {
1381 const octave_value& obj = c(k);
1382#if SWIG_OCTAVE_PREREQ(6,0,0)
1383 try {
1384 d.elem(k) = obj.int_value();
1385 }
1386 catch (octave::execution_exception& oee) {
1387 // __dims__ should return a cell filled with integers
1388 return dim_vector(1,1);
1389 }
1390#else
1391 d.elem(k) = obj.int_value();
1392
1393 // __dims__ should return a cell filled with integers
1394 if (error_state) return dim_vector(1,1);
1395#endif
1396 }
1397 return d;
1398#if SWIG_OCTAVE_PREREQ(4,4,0)
1399 } else if (out.is_matrix_type() || out.isnumeric() ) {
1400#else
1401 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1402#endif
1403 if (out.rows()==1 || out.columns()==1) {
1404#if SWIG_OCTAVE_PREREQ(6,0,0)
1405 Array<int> a;
1406 try {
1407 a = out.int_vector_value();
1408 }
1409 catch (octave::execution_exception& oee) {
1410 return dim_vector(1,1);
1411 }
1412#else
1413 Array<int> a = out.int_vector_value();
1414 if (error_state) return dim_vector(1,1);
1415#endif
1416 dim_vector d;
1417 d.resize(a.numel() < 2 ? 2 : a.numel());
1418 d(0) = d(1) = 1;
1419 for (int k=0;k<a.numel();k++) {
1420 d.elem(k) = a(k);
1421 }
1422 return d;
1423 } else {
1424 return dim_vector(1,1);
1425 }
1426 } else {
1427 return dim_vector(1,1);
1428 }
1429 }
1430
1431 octave_value as_value() {
1432#if SWIG_OCTAVE_PREREQ(9,0,0)
1433 ++m_count;
1434#else
1435 ++count;
1436#endif
1437 return Swig::swig_value_ref(this);
1438 }
1439
1440 void incref() {
1441#if SWIG_OCTAVE_PREREQ(9,0,0)
1442 ++m_count;
1443#else
1444 ++count;
1445#endif
1446 }
1447
1448 void decref() {
1449#if SWIG_OCTAVE_PREREQ(9,0,0)
1450 if (!--m_count)
1451#else
1452 if (!--count)
1453#endif
1454 delete this;
1455 }
1456
1457 size_t swig_this() const {
1458 if (!types.size())
1459 return (size_t) this;
1460 return (size_t) types[0].second.ptr;
1461 }
1462 const char* help_text() const {
1463 if (!types.size())
1464 return 0;
1465 if (!types[0].first->clientdata)
1466 return 0;
1467 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1468 return c->constructor_doc;
1469 }
1470
1471 std::string swig_type_name() const {
1472 // * need some way to manually name subclasses.
1473 // * eg optional first arg to subclass(), or named_subclass()
1474 std::string ret;
1475 for (unsigned int j = 0; j < types.size(); ++j) {
1476 if (j)
1477 ret += "_";
1478 if (types[j].first->clientdata) {
1479 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1480 ret += c->name;
1481 } else
1482 ret += types[j].first->name;
1483 }
1484 return ret;
1485 }
1486
1488 rhs.thisown = 0;
1489 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1490 assert(!rhs.types[j].second.destroyed);
1491#ifdef SWIG_DIRECTORS
1492 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1493 if (d)
1494 Swig::swig_director_set_self(d, this);
1495#endif
1496 }
1497 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1498 members.insert(rhs.members.begin(), rhs.members.end());
1499#if SWIG_OCTAVE_PREREQ(4,4,0)
1500 assign(rhs.swig_type_name(), rhs.as_value());
1501#else
1502 rhs.types.clear();
1503 rhs.members.clear();
1504#endif
1505 }
1506
1507 typedef member_map::const_iterator swig_member_const_iterator;
1510
1511 int cast(void **vptr, swig_type_info *type, int *own, int flags) {
1512 int res = SWIG_ERROR;
1513 int clear_pointer = 0;
1514
1515 if (own)
1516 *own = 0;
1517 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !thisown) {
1519 } else {
1520 if (own)
1521 *own = *own | thisown;
1522 if (flags & SWIG_POINTER_DISOWN) {
1523 thisown = 0;
1524 }
1525 if (flags & SWIG_POINTER_CLEAR) {
1526 clear_pointer = 1;
1527 }
1528 }
1529
1530 if (!type && types.size()) {
1531 if (vptr) {
1532 *vptr = types[0].second.ptr;
1533 if (clear_pointer)
1534 types[0].second.ptr = 0;
1535 }
1536 return SWIG_OK;
1537 }
1538 for (unsigned int j = 0; j < types.size(); ++j)
1539 if (type == types[j].first) {
1540 if (vptr) {
1541 *vptr = types[j].second.ptr;
1542 if (clear_pointer)
1543 types[j].second.ptr = 0;
1544 }
1545 return SWIG_OK;
1546 }
1547 for (unsigned int j = 0; j < types.size(); ++j) {
1548 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1549 if (!tc)
1550 continue;
1551 if (vptr) {
1552 int newmemory = 0;
1553 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1554 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1555 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1556 if (own)
1557 *own = *own | SWIG_CAST_NEW_MEMORY;
1558 }
1559 if (clear_pointer)
1560 types[j].second.ptr = 0;
1561 }
1562 res = SWIG_OK;
1563 break;
1564 }
1565 return res;
1566 }
1567
1568 bool is_owned() const {
1569 return thisown;
1570 }
1571
1572#ifdef SWIG_DIRECTORS
1573 void director_destroyed(Swig::Director *d) {
1574 bool found = false;
1575 for (unsigned int j = 0; j < types.size(); ++j) {
1576 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1577 if (dj == d) {
1578 types[j].second.destroyed = true;
1579 found = true;
1580 }
1581 }
1582 assert(found);
1583 }
1584#endif
1585
1586 void assign(const std::string &name, const octave_value &ov) {
1587 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1588 }
1589
1590 void assign(const std::string &name, const swig_octave_member *m) {
1591 members[name] = std::make_pair(m, octave_value());
1592 }
1593
1594 octave_base_value *clone() const {
1595 // pass-by-value is probably not desired, and is harder;
1596 // requires calling copy constructors of contained types etc.
1597 assert(0);
1598 *(int *) 0 = 0;
1599 return 0;
1600 }
1601
1602 octave_base_value *empty_clone() const {
1603 return new octave_swig_type();
1604 }
1605
1606 bool is_defined() const {
1607 return true;
1608 }
1609
1610#if SWIG_OCTAVE_PREREQ(6,0,0)
1611 virtual bool isstruct() const {
1612#else
1613 virtual bool is_map() const {
1614#endif
1615 return true;
1616 }
1617
1618 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1619 octave_value_list ovl = subsref(ops, idx, 1);
1620 return ovl.length()? ovl(0) : octave_value();
1621 }
1622
1623 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1624 assert(ops.size() > 0);
1625 assert(ops.size() == idx.size());
1626
1627 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1628 int skip = 0;
1629 octave_value_list sub_ovl;
1630
1631 // constructor invocation
1632 if (ops[skip] == '(' && construct_type) {
1633 assert(construct_type->clientdata);
1634 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1635 if (!c->constructor) {
1636 error("cannot create instance");
1637 return octave_value_list();
1638 }
1639 octave_value_list args;
1640 if (c->director)
1641 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1642 args.append(*idx_it++);
1643 ++skip;
1644 sub_ovl = c->constructor(args, nargout);
1645 }
1646 // member dereference or invocation
1647 else if (ops[skip] == '.') {
1648 std::string subname;
1649 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1650 for (;;) {
1651 octave_value_list subname_ovl(*idx_it++);
1652 ++skip;
1653 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1654 subname = subname_ovl(0).string_value();
1655
1656 const swig_type_info *next_base = find_base(subname, base);
1657 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1658 break;
1659 base = next_base;
1660 }
1661
1662 member_value_pair tmp, *m = &tmp;
1663 if (!base || !(m->first = find_member(base, subname)))
1664 m = find_member(subname, false);
1665 if (!m) {
1666 error("member not found");
1667 return octave_value_list();
1668 }
1669
1670 octave_value_list args;
1671 if (!always_static &&
1672 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1673 args.append(as_value());
1674 if (skip < (int) ops.size() && ops[skip] == '(' &&
1675 ((m->first && m->first->method) || m->second.is_function() ||
1676 m->second.is_function_handle())) {
1677 args.append(*idx_it++);
1678 ++skip;
1679 sub_ovl = member_invoke(m, args, nargout);
1680 } else {
1681 sub_ovl = member_deref(m, args);
1682 }
1683 }
1684 // index operator
1685 else {
1686 if (ops[skip] == '(' || ops[skip] == '{') {
1687 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1688 octave_value_list args;
1689 args.append(*idx_it++);
1690 ++skip;
1691 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1692 error("error evaluating index operator");
1693 return octave_value_list();
1694 }
1695 } else {
1696 error("unsupported subsref");
1697 return octave_value_list();
1698 }
1699 }
1700
1701 if (skip >= (int) ops.size())
1702 return sub_ovl;
1703 if (sub_ovl.length() < 1) {
1704 error("bad subs ref");
1705 return octave_value_list();
1706 }
1707 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1708 }
1709
1710 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1711 assert(ops.size() > 0);
1712 assert(ops.size() == idx.size());
1713
1714 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1715 int skip = 0;
1716
1717 if (ops.size() > 1) {
1718 std::list < octave_value_list >::const_iterator last = idx.end();
1719 --last;
1720 std::list < octave_value_list > next_idx(idx.begin(), last);
1721 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1722 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1723 }
1724
1725 else if (ops[skip] == '(' || ops[skip] == '{') {
1726 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1727 member_value_pair *m = find_member(op_name, false);
1728 if (m) {
1729 octave_value_list args;
1730 args.append(as_value());
1731 args.append(*idx_it);
1732 args.append(rhs);
1733 member_invoke(m, args, 1);
1734 } else
1735 error("%s member not found", op_name);
1736 }
1737
1738 else if (ops[skip] == '.') {
1739 octave_value_list subname_ovl(*idx_it++);
1740 ++skip;
1741 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1742 std::string subname = subname_ovl(0).string_value();
1743
1744 member_value_pair *m = find_member(subname, true);
1745 if (!m->first || !m->first->set_method) {
1746 m->first = 0;
1747 m->second = rhs;
1748 } else if (m->first->set_method) {
1749 octave_value_list args;
1750 if (!m->first->is_static() && !m->first->is_global())
1751 args.append(as_value());
1752 args.append(rhs);
1753 m->first->set_method(args, 1);
1754 } else
1755 error("member not assignable");
1756 } else
1757 error("unsupported subsasgn");
1758
1759 return as_value();
1760 }
1761
1762#if SWIG_OCTAVE_PREREQ(4,4,0)
1763 virtual bool isobject() const {
1764#else
1765 virtual bool is_object() const {
1766#endif
1767 return true;
1768 }
1769
1770 virtual bool is_string() const {
1771 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1772 return !!nc_this->find_member("__str__", false);
1773 }
1774
1775 virtual std::string string_value(bool force = false) const {
1776 octave_value ret;
1777 if (!dispatch_unary_op("__str__", ret)) {
1778 error("__str__ method not defined");
1779 return std::string();
1780 }
1781 if (!ret.is_string()) {
1782 error("__str__ method did not return a string");
1783 return std::string();
1784 }
1785 return ret.string_value();
1786 }
1787
1788 virtual double scalar_value(bool frc_str_conv = false) const {
1789 octave_value ret;
1790 if (!dispatch_unary_op("__float__", ret)) {
1791 error("__float__ method not defined");
1792 }
1793 return ret.scalar_value();
1794 }
1795
1796#if SWIG_OCTAVE_PREREQ(4,2,0)
1797 virtual octave_value as_double(void) const {
1798 octave_value ret;
1799 if (!dispatch_unary_op("__float__", ret)) {
1800 error("__float__ method not defined");
1801 }
1802 return ret.as_double();
1803 }
1804
1805 virtual octave_value as_single(void) const {
1806 octave_value ret;
1807 if (!dispatch_unary_op("__float__", ret)) {
1808 error("__float__ method not defined");
1809 }
1810 return ret.as_single();
1811 }
1812#endif
1813
1814#if SWIG_OCTAVE_PREREQ(3,8,0)
1815 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1816 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1817 octave_value ret;
1818 if (!dispatch_unary_op(opname, ret)) {
1819 error("%s", (opname + std::string(" method not found")).c_str());
1820 return octave_value();
1821 }
1822 return ret;
1823 }
1824#endif
1825
1826#if SWIG_OCTAVE_PREREQ(3,3,52)
1827 virtual octave_map map_value() const {
1828 return octave_map();
1829 }
1830#else
1831 virtual Octave_map map_value() const {
1832 return Octave_map();
1833 }
1834#endif
1835
1836 virtual string_vector map_keys() const {
1837 member_map tmp;
1838 load_members(tmp);
1839
1840 string_vector keys(tmp.size());
1841 int k = 0;
1842 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1843 keys(k++) = it->first;
1844
1845 return keys;
1846 }
1847
1848 virtual bool save_ascii (std::ostream& os) {
1849 return true;
1850 }
1851
1852 virtual bool load_ascii (std::istream& is) {
1853 return true;
1854 }
1855
1856 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1857 return true;
1858 }
1859
1860 virtual bool load_binary (std::istream& is, bool swap,
1861#if SWIG_OCTAVE_PREREQ(6,0,0)
1862 octave::mach_info::float_format fmt) {
1863#else
1864 oct_mach_info::float_format fmt) {
1865#endif
1866 return true;
1867 }
1868
1869#if defined (HAVE_HDF5)
1870# if SWIG_OCTAVE_PREREQ(4,0,0)
1871 virtual bool
1872 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1873 return true;
1874 }
1875
1876 virtual bool
1877 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1878 return true;
1879 }
1880# else
1881 virtual bool
1882 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1883 return true;
1884 }
1885
1886 virtual bool
1887 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1888 return true;
1889 }
1890# endif
1891#endif
1892
1893 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1894 return string_value();
1895 }
1896
1897 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1898 return string_value();
1899 }
1900
1901 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1902 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1903 // (rather than any module namespace).
1904
1905 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1906 if (!fcn)
1907 return false;
1908#if SWIG_OCTAVE_PREREQ(4,4,0)
1909 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1910 octave_value_list retval = fcn->call(tw, 1, args);
1911 if (retval.length() == 1)
1912 ret = retval(0);
1913#else
1914 ret = fcn->do_multi_index_op(1, args)(0);
1915#endif
1916 return true;
1917 }
1918
1919 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1921 assert(ost);
1922
1923 octave_value ret;
1924 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1925 return ret;
1926 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1927 octave_value_list args;
1928 args.append(make_value_hack(x));
1929 if (dispatch_global_op(symbol, args, ret))
1930 return ret;
1931
1932 error("could not dispatch unary operator");
1933 return octave_value();
1934 }
1935
1936 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1939
1940 octave_value ret;
1941 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1942 return ret;
1943 if (rhs_ost) {
1944 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1945 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1946 return ret;
1947 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1948 return ret;
1949 }
1950 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1951 return ret;
1952 }
1953
1954 std::string symbol;
1955 octave_value_list args;
1956 args.append(make_value_hack(lhs));
1957 args.append(make_value_hack(rhs));
1958
1959 symbol = SWIG_op_prefix;
1960 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1961 symbol += "_";
1962 symbol += op_name;
1963 symbol += "_";
1964 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1965 if (dispatch_global_op(symbol, args, ret))
1966 return ret;
1967
1968 symbol = SWIG_op_prefix;
1969 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1970 symbol += "_";
1971 symbol += op_name;
1972 symbol += "_";
1973 symbol += "any";
1974 if (dispatch_global_op(symbol, args, ret))
1975 return ret;
1976
1977 symbol = SWIG_op_prefix;
1978 symbol += "any";
1979 symbol += "_";
1980 symbol += op_name;
1981 symbol += "_";
1982 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1983 if (dispatch_global_op(symbol, args, ret))
1984 return ret;
1985
1986 error("could not dispatch binary operator");
1987 return octave_value();
1988 }
1989
1990#if SWIG_OCTAVE_PREREQ(4,0,0)
1991 void print(std::ostream &os, bool pr_as_read_syntax = false)
1992#else
1993 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1994#endif
1995 {
1996 if (is_string()) {
1997 os << string_value();
1998 return;
1999 }
2000
2001 member_map tmp;
2002 load_members(tmp);
2003
2004 indent(os);
2005 os << "{"; newline(os);
2006 increment_indent_level();
2007 for (unsigned int j = 0; j < types.size(); ++j) {
2008 indent(os);
2009 if (types[j].first->clientdata) {
2010 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
2011 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
2012 } else {
2013 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
2014 }
2015 }
2016 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2017 indent(os);
2018 if (it->second.first) {
2019 const char *objtype = it->second.first->method ? "method" : "variable";
2020 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
2021 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
2022 assert(it->second.first->name == it->first);
2023 } else {
2024 os << it->first; newline(os);
2025 }
2026 }
2027 decrement_indent_level();
2028 indent(os);
2029 os << "}"; newline(os);
2030 }
2031 };
2032
2033 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
2034 // will call clone() via make_unique() if there is more than one outstanding
2035 // reference to the lhs, and forces the clone's reference count to 1
2036 // (so you can't just increment your own count and return this).
2037 //
2038 // One way to fix this (without modifying Octave) is to add a level of
2039 // indirection such that clone copies ref-counted pointer and we keep
2040 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
2041 //
2042 // Supporting both pass-by-{ref,value} and toggling via %feature/option
2043 // might be nice.
2044
2045 class octave_swig_ref:public octave_base_value {
2047 public:
2049 :ptr(_ptr)
2050 {
2051 // Ensure type_id() is set correctly
2052#if SWIG_OCTAVE_PREREQ(9,0,0)
2053 if (s_t_id == -1) {
2054 s_t_id = octave_swig_ref::static_type_id();
2055#else
2056 if (t_id == -1) {
2057 t_id = octave_swig_ref::static_type_id();
2058#endif
2059 }
2060 }
2061
2063 { if (ptr) ptr->decref(); }
2064
2066 { return ptr; }
2067
2068 octave_base_value *clone() const
2069 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2070
2071 octave_base_value *empty_clone() const
2072 { return new octave_swig_ref(0); }
2073
2074 dim_vector dims(void) const
2075 { return ptr->dims(); }
2076
2077 bool is_defined() const
2078 { return ptr->is_defined(); }
2079
2080#if SWIG_OCTAVE_PREREQ(6,0,0)
2081 virtual bool isstruct() const
2082 { return ptr->isstruct(); }
2083#else
2084 virtual bool is_map() const
2085 { return ptr->is_map(); }
2086#endif
2087
2088 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2089 { return ptr->subsref(ops, idx); }
2090
2091 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2092 { return ptr->subsref(ops, idx, nargout); }
2093
2094 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2095 { return ptr->subsasgn(ops, idx, rhs); }
2096
2097#if SWIG_OCTAVE_PREREQ(4,4,0)
2098 virtual bool isobject() const
2099 { return ptr->isobject(); }
2100#else
2101 virtual bool is_object() const
2102 { return ptr->is_object(); }
2103#endif
2104
2105 virtual bool is_string() const
2106 { return ptr->is_string(); }
2107
2108 virtual std::string string_value(bool force = false) const
2109 { return ptr->string_value(force); }
2110
2111 virtual double scalar_value(bool frc_str_conv = false) const
2112 { return ptr->scalar_value(frc_str_conv); }
2113
2114#if SWIG_OCTAVE_PREREQ(4,2,0)
2115 virtual octave_value as_double(void) const
2116 { return ptr->as_double(); }
2117
2118 virtual octave_value as_single(void) const
2119 { return ptr->as_single(); }
2120#endif
2121
2122#if SWIG_OCTAVE_PREREQ(3,8,0)
2123 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2124 { return ptr->map(umap); }
2125#endif
2126
2127#if SWIG_OCTAVE_PREREQ(3,3,52)
2128 virtual octave_map map_value() const
2129 { return ptr->map_value(); }
2130#else
2131 virtual Octave_map map_value() const
2132 { return ptr->map_value(); }
2133#endif
2134
2135 virtual string_vector map_keys() const
2136 { return ptr->map_keys(); }
2137
2138 virtual bool save_ascii (std::ostream& os)
2139 { return ptr->save_ascii(os); }
2140
2141 virtual bool load_ascii (std::istream& is)
2142 { return ptr->load_ascii(is); }
2143
2144 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2145 { return ptr->save_binary(os, save_as_floats); }
2146
2147 virtual bool load_binary (std::istream& is, bool swap,
2148#if SWIG_OCTAVE_PREREQ(6,0,0)
2149 octave::mach_info::float_format fmt)
2150#else
2151 oct_mach_info::float_format fmt)
2152#endif
2153 { return ptr->load_binary(is, swap, fmt); }
2154
2155#if defined (HAVE_HDF5)
2156# if SWIG_OCTAVE_PREREQ(4,0,0)
2157 virtual bool
2158 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2159 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2160
2161 virtual bool
2162 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2163 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2164# else
2165 virtual bool
2166 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2167 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2168
2169 virtual bool
2170 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2171 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2172# endif
2173#endif
2174
2175 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2176 { return ptr->convert_to_str(pad, force, type); }
2177
2178 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2179 { return ptr->convert_to_str_internal(pad, force, type); }
2180
2181#if SWIG_OCTAVE_PREREQ(4,0,0)
2182 void print(std::ostream &os, bool pr_as_read_syntax = false)
2183#else
2184 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2185#endif
2186 { return ptr->print(os, pr_as_read_syntax); }
2187
2188#if SWIG_OCTAVE_PREREQ(9,0,0)
2189 static void set_type_id(int type_id) { s_t_id=type_id; }
2190#else
2191# if SWIG_OCTAVE_PREREQ(4,4,0)
2192 static void set_type_id(int type_id) { t_id=type_id; }
2193# endif
2194#endif
2195
2196 virtual type_conv_info numeric_conversion_function(void) const {
2197 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2198 octave_scalar::static_type_id ());
2199 }
2200
2201 private:
2202 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2203 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2204 return new octave_scalar(v.scalar_value());
2205 }
2206
2207#if !SWIG_OCTAVE_PREREQ(4,0,0)
2209#endif
2211 };
2212#if !SWIG_OCTAVE_PREREQ(4,0,0)
2214#endif
2216
2217 class octave_swig_packed:public octave_base_value {
2219 std::vector < char > buf;
2220 public:
2221
2222 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2223 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2224 {
2225 // Ensure type_id() is set correctly
2226#if SWIG_OCTAVE_PREREQ(9,0,0)
2227 if (s_t_id == -1) {
2228 s_t_id = octave_swig_packed::static_type_id();
2229#else
2230 if (t_id == -1) {
2231 t_id = octave_swig_packed::static_type_id();
2232#endif
2233 }
2234 }
2235
2236 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2237 if (outtype && outtype != type)
2238 return false;
2239 assert(sz <= buf.size());
2240 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2241 return true;
2242 }
2243
2244 octave_base_value *clone() const {
2245 return new octave_swig_packed(*this);
2246 }
2247
2248 octave_base_value *empty_clone() const {
2249 return new octave_swig_packed();
2250 }
2251
2252 bool is_defined() const {
2253 return true;
2254 }
2255
2256#if SWIG_OCTAVE_PREREQ(4,0,0)
2257 void print(std::ostream &os, bool pr_as_read_syntax = false)
2258#else
2259 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2260#endif
2261 {
2262 indent(os);
2263 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2264 }
2265
2266
2267 virtual bool save_ascii (std::ostream& os) {
2268 return true;
2269 }
2270
2271 virtual bool load_ascii (std::istream& is) {
2272 return true;
2273 }
2274
2275 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2276 return true;
2277 }
2278
2279 virtual bool load_binary (std::istream& is, bool swap,
2280#if SWIG_OCTAVE_PREREQ(6,0,0)
2281 octave::mach_info::float_format fmt) {
2282#else
2283 oct_mach_info::float_format fmt) {
2284#endif
2285 return true;
2286 }
2287
2288#if defined (HAVE_HDF5)
2289# if SWIG_OCTAVE_PREREQ(4,0,0)
2290 virtual bool
2291 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2292 return true;
2293 }
2294
2295 virtual bool
2296 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2297 return true;
2298 }
2299# else
2300 virtual bool
2301 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2302 return true;
2303 }
2304
2305 virtual bool
2306 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2307 return true;
2308 }
2309# endif
2310#endif
2311
2312#if SWIG_OCTAVE_PREREQ(9,0,0)
2313 static void set_type_id(int type_id) { s_t_id=type_id; }
2314#else
2315# if SWIG_OCTAVE_PREREQ(4,4,0)
2316 static void set_type_id(int type_id) { t_id=type_id; }
2317# endif
2318#endif
2319
2320 private:
2321#if !SWIG_OCTAVE_PREREQ(4,0,0)
2323#endif
2325 };
2326#if !SWIG_OCTAVE_PREREQ(4,0,0)
2328#endif
2330
2331 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2332 error("attempt to set immutable member variable");
2333 return octave_value_list();
2334 }
2335
2337 const octave_value_list &ovl;
2338 int j;
2339
2340 octave_value_ref(const octave_value_list &_ovl, int _j)
2341 :ovl(_ovl), j(_j) { }
2342
2343 operator octave_value() const {
2344 return ovl(j);
2345 }
2346
2347 octave_value operator*() const {
2348 return ovl(j);
2349 }
2350 };
2351
2352
2353namespace Swig {
2354
2356 return new octave_swig_ref(ost);
2357 }
2358
2360 if (
2361#if SWIG_OCTAVE_PREREQ(4,4,0)
2362 ov.iscell()
2363#else
2364 ov.is_cell()
2365#endif
2366 && ov.rows() == 1 && ov.columns() == 1)
2367 ov = ov.cell_value()(0);
2368 return swig_value_deref(*ov.internal_rep());
2369 }
2370
2371 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2372 if (ov.type_id() != octave_swig_ref::static_type_id())
2373 return 0;
2374 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2375 return osr->get_ptr();
2376 }
2377
2378}
2379
2380
2381#define swig_unary_op(name) \
2382SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2383 return octave_swig_type::dispatch_unary_op(x,#name); \
2384}
2385#define swig_binary_op(name) \
2386SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2387 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2388}
2389#if SWIG_OCTAVE_PREREQ(4,4,0)
2390#define swigreg_unary_op(name) \
2391if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2392typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2393#else
2394#define swigreg_unary_op(name) \
2395if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2396octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2397#endif
2398#if SWIG_OCTAVE_PREREQ(4,4,0)
2399#define swigreg_binary_op(name) \
2400if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2401typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2402#else
2403#define swigreg_binary_op(name) \
2404if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2405octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2406#endif
2407
2411 swig_unary_op(transpose);
2412 swig_unary_op(hermitian);
2415
2422#if !SWIG_OCTAVE_PREREQ(4,2,0)
2425#endif
2438
2440#if SWIG_OCTAVE_PREREQ(4,4,0)
2441 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2442#endif
2443 swigreg_unary_op(not);
2444 swigreg_unary_op(uplus);
2445 swigreg_unary_op(uminus);
2446 swigreg_unary_op(transpose);
2447 swigreg_unary_op(hermitian);
2448 swigreg_unary_op(incr);
2449 swigreg_unary_op(decr);
2450 }
2451 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2452#if SWIG_OCTAVE_PREREQ(4,4,0)
2453 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2454#endif
2455 swigreg_binary_op(add);
2456 swigreg_binary_op(sub);
2457 swigreg_binary_op(mul);
2458 swigreg_binary_op(div);
2459 swigreg_binary_op(pow);
2460 swigreg_binary_op(ldiv);
2461#if !SWIG_OCTAVE_PREREQ(4,2,0)
2462 swigreg_binary_op(lshift);
2463 swigreg_binary_op(rshift);
2464#endif
2471 swigreg_binary_op(el_mul);
2472 swigreg_binary_op(el_div);
2473 swigreg_binary_op(el_pow);
2474 swigreg_binary_op(el_ldiv);
2475 swigreg_binary_op(el_and);
2476 swigreg_binary_op(el_or);
2477 }
2479 // here we assume that tid are conseq integers increasing from zero, and
2480 // that our tid is the last one. might be better to have explicit string
2481 // list of types we should bind to, and use lookup_type to resolve their tid.
2482
2484 SWIG_InstallBinaryOps(tid, tid);
2485 for (int j = 0; j < tid; ++j) {
2486 SWIG_InstallBinaryOps(j, tid);
2487 SWIG_InstallBinaryOps(tid, j);
2488 }
2489 }
2490
2491SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2492 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2493
2494 if (ptr) {
2495#ifdef SWIG_DIRECTORS
2496 Swig::Director *d = Swig::get_rtdir(ptr);
2497 if (d && Swig::swig_director_get_self(d))
2498 return Swig::swig_director_get_self(d)->as_value();
2499#endif
2500 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2501 }
2502 return octave_value(Matrix()); // null matrix
2503}
2504
2505SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2506 if (
2507#if SWIG_OCTAVE_PREREQ(4,4,0)
2508 ov.iscell()
2509#else
2510 ov.is_cell()
2511#endif
2512 && ov.rows() == 1 && ov.columns() == 1)
2513 ov = ov.cell_value()(0);
2514 if (!ov.is_defined() ||
2515 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2516 if (ptr)
2517 *ptr = 0;
2519 }
2520 if (ov.type_id() != octave_swig_ref::static_type_id())
2521 return SWIG_ERROR;
2522 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2523 octave_swig_type *ost = osr->get_ptr();
2524 return ost->cast(ptr, type, own, flags);
2525}
2526
2527SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2528 return new octave_swig_packed(type, (char *) ptr, sz);
2529}
2530
2531SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2532 if (!ov.is_defined())
2533 return SWIG_ERROR;
2534 if (ov.type_id() != octave_swig_packed::static_type_id())
2535 return SWIG_ERROR;
2536 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2537 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2538}
2539
2540SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2541 module_ns->assign(name, ov);
2542}
2543
2545#if SWIG_OCTAVE_PREREQ(6,0,0)
2546 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2547 return interp->global_varval(name);
2548#else
2549#if SWIG_OCTAVE_PREREQ(4,4,0)
2550 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2551 return symtab.global_varval(name);
2552#else
2553 return get_global_value(name, true);
2554#endif
2555#endif
2556}
2557
2558SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2559#if SWIG_OCTAVE_PREREQ(6,0,0)
2560 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2561 interp->global_assign(name, value);
2562#elif SWIG_OCTAVE_PREREQ(4,4,0)
2563 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2564 symtab.global_assign(name, value);
2565#else
2566 set_global_value(name, value);
2567#endif
2568}
2569
2571#if SWIG_OCTAVE_PREREQ(4,4,0)
2572 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2573#if SWIG_OCTAVE_PREREQ(6,0,0)
2574 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2575 interp->assign(name, interp->global_varval(name));
2576 octave::tree_evaluator& tree_eval = interp->get_evaluator();
2577#if SWIG_OCTAVE_PREREQ(8,0,0)
2578 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2579#else
2580 octave::call_stack& callStack = tree_eval.get_call_stack();
2581 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2582#endif
2583 octave::symbol_record sym=symscope.lookup_symbol(name);
2584 stackFrame->mark_global(sym);
2585#else
2586 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2587 symscope.assign(name, symtab.global_varval(name));
2588 symscope.mark_global(name);
2589#endif
2590#else
2591#if !SWIG_OCTAVE_PREREQ(3,2,0)
2592 link_to_global_variable(curr_sym_tab->lookup(name, true));
2593#else
2594#if !SWIG_OCTAVE_PREREQ(3,8,0)
2595 symbol_table::varref(name);
2596#endif
2597 symbol_table::mark_global(name);
2598#endif
2599#endif
2600}
2601
2603 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2604 if (!ov.is_defined() ||
2605 ov.type_id() != octave_swig_packed::static_type_id())
2606 return 0;
2607 const octave_swig_packed* osp =
2608 static_cast < const octave_swig_packed *> (ov.internal_rep());
2609 swig_module_info *pointer = 0;
2610 osp->copy(0, &pointer, sizeof(swig_module_info *));
2611 return pointer;
2612}
2613
2614SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2615 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2617}
2618
2619
2620SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
2621 if (obj.is_string())
2622 error("%s", obj.string_value().c_str());
2623 else
2624 error("C++ side threw an exception of type %s", type);
2625}
2626
2627
2628
2629#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2630
2631#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2632
2633
2634
2635/* -------- TYPES TABLE (BEGIN) -------- */
2636
2637#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2638#define SWIGTYPE_p_char swig_types[1]
2639#define SWIGTYPE_p_double swig_types[2]
2640#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2641#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2642#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2643#define SWIGTYPE_p_int swig_types[6]
2644#define SWIGTYPE_p_p_char swig_types[7]
2645#define SWIGTYPE_p_unsigned_int swig_types[8]
2647static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2648#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2649#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2650
2651/* -------- TYPES TABLE (END) -------- */
2652
2653
2654#ifdef __cplusplus
2655#include <utility>
2656/* SwigValueWrapper is described in swig.swg */
2657template<typename T> class SwigValueWrapper {
2658 struct SwigSmartPointer {
2659 T *ptr;
2660 SwigSmartPointer(T *p) : ptr(p) { }
2661 ~SwigSmartPointer() { delete ptr; }
2662 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
2663 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
2664 } pointer;
2665 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
2666 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
2667public:
2668 SwigValueWrapper() : pointer(0) { }
2669 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
2670#if __cplusplus >=201103L
2671 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
2672 operator T&&() const { return std::move(*pointer.ptr); }
2673#else
2674 operator T&() const { return *pointer.ptr; }
2675#endif
2676 T *operator&() const { return pointer.ptr; }
2677 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2678};
2679
2680/*
2681 * SwigValueInit() is a generic initialisation solution as the following approach:
2682 *
2683 * T c_result = T();
2684 *
2685 * doesn't compile for all types for example:
2686 *
2687 * unsigned int c_result = unsigned int();
2688 */
2689template <typename T> T SwigValueInit() {
2690 return T();
2691}
2692
2693#if __cplusplus >=201103L
2694# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2695#else
2696# define SWIG_STD_MOVE(OBJ) OBJ
2697#endif
2698
2699#endif
2700
2701
2702#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2703#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2704
2705
2706#include <stdexcept>
2707
2708
2709// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2710#undef PACKAGE
2711#undef VERSION
2712
2713#include "plplotP.h"
2714
2715// Temporary fix for problems with -fvisibility=hidden and octave headers.
2716#ifdef OCTAVE_EXPORT
2717 #if defined ( __GNUC__ ) && __GNUC__ > 3
2718 #undef OCTAVE_EXPORT
2719 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2720 #endif
2721#endif
2722
2723
2724
2725// I hate global variables but this is the best way I can think of
2726// to manage consistency checking among function arguments.
2727 static PLINT Alen = 0;
2728 static PLINT Xlen = 0, Ylen = 0;
2729
2730
2731// Convenience functions copied from matwrap-based approach (currently
2732// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2733// tricky scalar case and also adopted so that the resulting
2734// swig-generated source code will look similar to the matwrap-generated
2735// source code.
2736
2737 inline int max( int a, int b )
2738 {
2739 return a >= b ? a : b;
2740 }
2741 inline int min( int a, int b )
2742 {
2743 return a >= b ? a : b;
2744 }
2745
2746//
2747// Function to get the total length (rows*columns) of an octave object of
2748// arbitrary type.
2749// Arguments:
2750// 1) The octave object.
2751//
2752// If the object is a scalar, the array length is 1.
2753//
2754 static int
2755 _arraylen( const octave_value &o_obj )
2756 {
2757 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2758 // max is necessary because sometimes
2759 // rows() or columns() return -1 or 0 for
2760 // scalars.
2761 }
2762
2763//
2764// Function to get the number of dimensions of an object.
2765//
2766 static int
2767 _n_dims( const octave_value &o_obj )
2768 {
2769 if ( max( o_obj.columns(), 1 ) > 1 )
2770 return 2;
2771 // max is necessary because sometimes
2772 // rows() or columns() return -1 or 0 for
2773 // scalars.
2774 else if ( max( o_obj.rows(), 1 ) > 1 )
2775 return 1;
2776 else
2777 return 0;
2778 }
2779
2780//
2781// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2782//
2783 static inline int
2784 _dim( const octave_value &o_obj, int dim_idx )
2785 {
2786 if ( dim_idx == 0 )
2787 return max( o_obj.rows(), 0 );
2788 // max is necessary because sometimes
2789 // rows() or columns() return -1 or 0 for
2790 // scalars.
2791 else if ( dim_idx == 1 )
2792 return max( o_obj.columns(), 0 );
2793 else
2794 return 1;
2795 }
2796
2797//
2798// The following function converts an array of doubles into some other
2799// numeric type. Arguments:
2800// 1) Where to store the result. The type is determined from the type of
2801// this pointer.
2802// 2) A vector of doubles to convert.
2803// 3) The number of doubles.
2804//
2805 template <class FLOAT>
2806 static inline void
2807 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2808 {
2809 while ( n_el-- > 0 )
2810 *out_arr++ = (FLOAT) ( *in_arr++ );
2811 }
2812
2813 template void _cvt_double_to( int *, double *, unsigned );
2814 template void _cvt_double_to( unsigned *, double *, unsigned );
2815 template void _cvt_double_to( long *, double *, unsigned );
2816 template void _cvt_double_to( unsigned long *, double *, unsigned );
2817 template void _cvt_double_to( short *, double *, unsigned );
2818 template void _cvt_double_to( unsigned short *, double *, unsigned );
2819 template void _cvt_double_to( float *, double *, unsigned );
2820 // Instantiate our templates. Octave uses
2821 // manual template instantiation.
2822
2823//
2824// Convert an array of some other type into an array of doubles. Arguments:
2825// 1) The array of objects of other type.
2826// 2) The output array of doubles.
2827// 3) The number of elements to convert.
2828//
2829 template <class FLOAT>
2830 static inline void
2831 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2832 {
2833 while ( n_el-- > 0 )
2834 *d_arr++ = double(*arr++);
2835 }
2836
2837 template void _cvt_to_double( int *, double *, unsigned );
2838 template void _cvt_to_double( unsigned *, double *, unsigned );
2839 template void _cvt_to_double( long *, double *, unsigned );
2840 template void _cvt_to_double( unsigned long *, double *, unsigned );
2841 template void _cvt_to_double( short *, double *, unsigned );
2842 template void _cvt_to_double( unsigned short *, double *, unsigned );
2843 template void _cvt_to_double( float *, double *, unsigned );
2844 // Instantiate our templates. Octave uses
2845 // manual template instantiation.
2846
2847
2848 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2849 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2850 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2851 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2852 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2854 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2855
2856
2857#include <iostream>
2858
2859 octave_function *fcnMapForm;
2860 std::string nameMapForm;
2861
2863 {
2864 octave_idx_type i;
2865 octave_value_list functionArguments;
2866 octave_value_list retval;
2867
2868 Matrix xin( n, 1 );
2869 Matrix yin( n, 1 );
2870 Matrix xout;
2871 Matrix yout;
2872
2873 for ( i = 0; i < n; i++ )
2874 {
2875 xin( i, 0 ) = x[i];
2876 yin( i, 0 ) = y[i];
2877 }
2878
2879 functionArguments( 0 ) = xin;
2880 functionArguments( 1 ) = yin;
2881
2882 if ( fcnMapForm != NULL )
2883#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2884 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2885#else
2886 retval = feval( fcnMapForm, functionArguments, 1 );
2887#endif
2888 else
2889#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2890 retval = octave::feval( nameMapForm, functionArguments, 1 );
2891#else
2892 retval = feval( nameMapForm, functionArguments, 1 );
2893#endif
2894
2895 if ( retval.length() >= 2 )
2896 {
2897 xout = retval( 0 ).matrix_value();
2898 yout = retval( 1 ).matrix_value();
2899
2900 for ( i = 0; i < n; i++ )
2901 {
2902 x[i] = xout( i, 0 );
2903 y[i] = yout( i, 0 );
2904 }
2905 }
2906 }
2907
2908
2909 octave_function *fcnLabelFunc;
2910 std::string nameLabelFunc;
2911
2912 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2913 {
2914 int i;
2915 octave_value_list functionArguments;
2916 octave_value_list retval;
2917
2918 Matrix inAxis( 1, 1 );
2919 Matrix inValue( 1, 1 );
2920 inAxis( 0, 0 ) = axis;
2921 inValue( 0, 0 ) = value;
2922
2923 functionArguments( 0 ) = inAxis;
2924 functionArguments( 1 ) = inValue;
2925
2926 if ( fcnLabelFunc != NULL )
2927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2928 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2929#else
2930 retval = feval( fcnLabelFunc, functionArguments, 1 );
2931#endif
2932 else
2933#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2934 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2935#else
2936 retval = feval( nameLabelFunc, functionArguments, 1 );
2937#endif
2938
2939 strncpy( label, retval( 0 ).string_value().c_str(), length );
2940 }
2941
2942
2943 octave_function *fcnCoordTrans;
2944 std::string nameCoordTrans;
2945
2946 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2947 {
2948 octave_idx_type i;
2949 octave_value_list functionArguments;
2950 octave_value_list retval;
2951
2952 Matrix xin( 1, 1 );
2953 Matrix yin( 1, 1 );
2954 Matrix xout;
2955 Matrix yout;
2956
2957 xin( 0, 0 ) = x;
2958 yin( 0, 0 ) = y;
2959
2960 functionArguments( 0 ) = xin;
2961 functionArguments( 1 ) = yin;
2962
2963 if ( fcnCoordTrans != NULL )
2964#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2965 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2966#else
2967 retval = feval( fcnCoordTrans, functionArguments, 1 );
2968#endif
2969 else
2970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2971 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2972#else
2973 retval = feval( nameCoordTrans, functionArguments, 1 );
2974#endif
2975
2976 if ( retval.length() >= 2 )
2977 {
2978 xout = retval( 0 ).matrix_value();
2979 yout = retval( 1 ).matrix_value();
2980
2981 *xt = xout( 0, 0 );
2982 *yt = yout( 0, 0 );
2983 }
2984 }
2985
2986
2987 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2988 {
2989 PLINT i;
2990 printf( "nlegend =%d\n", nlegend );
2991 for ( i = 0; i < nlegend; i++ )
2992 {
2993 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2994 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2995 printf( "text[%d] =%s\n", i, text[i] );
2996 }
2997 }
2998
2999
3000#include <limits.h>
3001#if !defined(SWIG_NO_LLONG_MAX)
3002# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3003# define LLONG_MAX __LONG_LONG_MAX__
3004# define LLONG_MIN (-LLONG_MAX - 1LL)
3005# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3006# endif
3007#endif
3008
3009
3010 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
3011 {
3012 if (!ov.is_scalar_type())
3013 return SWIG_TypeError;
3014 if (ov.is_complex_scalar())
3015 return SWIG_TypeError;
3016 if (ov.is_double_type()||ov.is_single_type()) {
3017 double v=ov.double_value();
3018 if (v!=floor(v))
3019 return SWIG_TypeError;
3020 }
3021 if (val)
3022 *val = ov.long_value();
3023 return SWIG_OK;
3024 }
3025
3026
3027SWIGINTERN int
3028SWIG_AsVal_int (octave_value obj, int *val)
3029{
3030 long v;
3031 int res = SWIG_AsVal_long (obj, &v);
3032 if (SWIG_IsOK(res)) {
3033 if ((v < INT_MIN || v > INT_MAX)) {
3034 return SWIG_OverflowError;
3035 } else {
3036 if (val) *val = static_cast< int >(v);
3037 }
3038 }
3039 return res;
3040}
3041
3042
3043 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 )
3044 {
3045 PLGraphicsIn gin;
3046 int status; status = plGetCursor( &gin );
3047 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
3048 strncpy( string, gin.string, PL_MAXKEY - 1 );
3049 string[PL_MAXKEY - 1] = '\0';
3050
3051 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
3052 return status;
3053 }
3054
3055
3056SWIGINTERN int
3057SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
3058{
3059 if (
3060#if SWIG_OCTAVE_PREREQ(4,4,0)
3061 ov.iscell()
3062#else
3063 ov.is_cell()
3064#endif
3065 && ov.rows() == 1 && ov.columns() == 1)
3066 ov = ov.cell_value()(0);
3067
3068 if (ov.is_string()) {
3069 std::string str=ov.string_value();
3070 size_t len=str.size();
3071 char* cstr=(char*)str.c_str();
3072 if (alloc) {
3073 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3074 *alloc = SWIG_NEWOBJ;
3075 } else if (cptr)
3076 *cptr = cstr;
3077 if (psize)
3078 *psize = len + 1;
3079 } else if (!ov.is_defined() || (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
3080 if (cptr)
3081 *cptr = 0;
3082 } else {
3083 return SWIG_TypeError;
3084 }
3085 return SWIG_OK;
3086}
3087
3088
3089
3090
3091
3093 {
3094 return octave_value(value);
3095 }
3096
3097
3098SWIGINTERNINLINE octave_value
3100{
3101 return SWIG_From_long (value);
3102}
3103
3104
3106 {
3107 return octave_value(value);
3108 }
3109
3110
3111// Translates relative device coordinates to world coordinates.
3112 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
3113 {
3114 PLGraphicsIn gin;
3115 int st;
3116 gin.dX = x_in; gin.dY = y_in;
3117 st = plTranslateCursor( &gin );
3118 *x = gin.wX; *y = gin.wY;
3119 return st;
3120 }
3121
3122
3123 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
3124 {
3125 if (!ov.is_scalar_type())
3126 return SWIG_TypeError;
3127 if (ov.is_complex_scalar())
3128 return SWIG_TypeError;
3129 if (val)
3130 *val = ov.double_value();
3131 return SWIG_OK;
3132 }
3133
3134
3135// Create 1d stripchart
3136
3137 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3138 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3139 PLFLT xlpos, PLFLT ylpos,
3140 PLBOOL y_ascl, PLBOOL acc,
3141 PLINT colbox, PLINT collab,
3142 const PLINT *colline, const PLINT *styline,
3143 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3144 const char *labx, const char *laby, const char *labtop )
3145 {
3146 const char *legline[4];
3147 legline[0] = legline1; legline[1] = legline2;
3148 legline[2] = legline3; legline[3] = legline4;
3149 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3150 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3151 labx, laby, labtop );
3152 }
3153
3154
3155// One more hack. As it is not possible (and would not be desirable) to pass
3156// an Octave function to plcont(), I have defined three plcont():
3157// plcont uses a defined here xform()
3158// plcont0 uses pltr0()
3159// plcont1 uses pltr1()
3160// plcont2 uses pltr2()
3161// plcont2p uses pltr2p()
3162//
3163// Also, as plplot expect vectorized bidimensional arrays, I provided a
3164// f2c, which is a #define that does the necessary conversion.
3165//
3166
3167 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3168 {
3169 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3170 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3171 }
3172
3173// convert from Fortran like arrays (one vector), to C like 2D arrays
3174
3175#define f2c( f, ff, nx, ny ) \
3176 PLFLT * *ff; \
3177 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3178 for ( int i = 0; i < nx; i++ ) { \
3179 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3180 for ( int j = 0; j < ny; j++ ) \
3181 *( ff[i] + j ) = *( f + nx * j + i );}
3182
3183// simpler plcont() for use with xform()
3184
3185 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3186 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3187 {
3188 f2c( f, ff, nx, ny );
3189 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3190 }
3191
3192// plcont() for use with pltr0() NOT TESTED
3193
3194 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3195 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3196 {
3197 f2c( f, ff, nx, ny );
3198 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3199 }
3200
3201// plcont() for use with pltr1()
3202
3203 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3204 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3205 {
3206 PLcGrid grid1;
3207 grid1.nx = nx; grid1.ny = ny;
3208 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3209 f2c( f, ff, nx, ny );
3210 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3211 }
3212
3213// plcont() for use with pltr2()
3214 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3215 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3216 {
3217 PLcGrid2 grid2;
3218 f2c( xg, xgg, nx, ny );
3219 f2c( yg, ygg, nx, ny );
3220 grid2.nx = nx; grid2.ny = ny;
3221 grid2.xg = xgg; grid2.yg = ygg;
3222 f2c( f, ff, nx, ny );
3223 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3224 }
3225
3226// plcont() for use with pltr2p()
3227
3228 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3229 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3230 {
3231 PLcGrid2 grid2;
3232 f2c( xg, xgg, nx, ny );
3233 f2c( yg, ygg, nx, ny );
3234 grid2.nx = nx; grid2.ny = ny;
3235 grid2.xg = xgg; grid2.yg = ygg;
3236 f2c( f, ff, nx, ny );
3237 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3238 }
3239
3240
3241 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3242 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3243 PLFLT *zg, int type, PLFLT data )
3244 {
3245 f2c( zg, zgg, nptsx, nptsy );
3246 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3247 for ( int i = 0; i < nptsx; i++ )
3248 for ( int j = 0; j < nptsy; j++ )
3249 *( zg + nptsx * j + i ) = zgg[i][j];
3250 }
3251
3252
3253// Plots a mesh representation of the function z[x][y].
3254
3255 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3256 {
3257 f2c( z, zz, nx, ny );
3258 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3259 }
3260
3261// Plots a mesh representation of the function z[x][y] with contour
3262
3263 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3264 {
3265 f2c( z, zz, nx, ny );
3266 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3267 }
3268
3269
3270// Plots a 3-d representation of the function z[x][y].
3271 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3272 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3273 {
3274 f2c( z, zz, nx, ny );
3275 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3276 }
3277
3278// Plots a 3-d representation of the function z[x][y] with contour
3279 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3280 PLINT nx, PLINT ny, PLINT opt,
3281 const PLFLT *clevel, PLINT nlevel )
3282 {
3283 f2c( z, zz, nx, ny );
3284 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3285 }
3286// Plots a 3-d representation of the function z[x][y] with contour with y
3287// index limits
3288 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3289 PLINT nx, PLINT ny, PLINT opt,
3290 const PLFLT * clevel, PLINT nlevel,
3291 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3292 {
3293 f2c( z, zz, nx, ny );
3294 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3295 indexxmin, indexxmax, indexymin, indexymax );
3296 }
3297
3298
3299 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3300 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3301 {
3302 f2c( z, zz, nx, ny );
3303 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3304 }
3305
3306 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3307 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3308 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3309 {
3310 f2c( z, zz, nx, ny );
3311 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3312 indexxmin, indexxmax, indexymin, indexymax );
3313 }
3314
3315
3316// The same as in plcont. I have hardcoded the first function pointer
3317// to plfill(). The second function pointer will use the same convention
3318// as in plcont().
3319//
3320
3321// the simpler plshade()
3322 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3323 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3324 PLFLT shade_min, PLFLT shade_max,
3325 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3326 PLINT min_color, PLINT min_width,
3327 PLINT max_color, PLINT max_width,
3328 PLINT rectangular, PLFLT *tr )
3329 {
3330 f2c( a, aa, nx, ny );
3331 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3332 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3333 min_color, min_width, max_color, max_width,
3334 plfill, rectangular, xform, tr );
3335 }
3336
3337// plshade() for use with pltr1
3338 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3339 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3340 PLFLT shade_min, PLFLT shade_max,
3341 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3342 PLINT min_color, PLINT min_width,
3343 PLINT max_color, PLINT max_width,
3344 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3345 {
3346 PLcGrid grid1;
3347 grid1.nx = nx; grid1.ny = ny;
3348 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3349 f2c( a, aa, nx, ny );
3350 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3351 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3352 min_color, min_width, max_color, max_width,
3353 plfill, rectangular, pltr1, &grid1 );
3354 }
3355
3356// plshade() for use with pltr2
3357 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3358 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3359 PLFLT shade_min, PLFLT shade_max,
3360 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3361 PLINT min_color, PLINT min_width,
3362 PLINT max_color, PLINT max_width,
3363 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3364 {
3365 PLcGrid2 grid2;
3366 f2c( xg, xgg, nx, ny );
3367 f2c( yg, ygg, nx, ny );
3368 grid2.nx = nx; grid2.ny = ny;
3369 grid2.xg = xgg; grid2.yg = ygg;
3370 f2c( a, aa, nx, ny );
3371 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3372 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3373 min_color, min_width, max_color, max_width,
3374 plfill, rectangular, pltr2, &grid2 );
3375 }
3376
3377
3378
3379 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3380 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3381 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3382 PLINT cont_color, PLINT cont_width,
3383 PLINT rectangular )
3384 {
3385 f2c( a, aa, nx, ny );
3386 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3387 clevel, nlevel, fill_width, cont_color, cont_width,
3388 plfill, rectangular, NULL, NULL );
3389 }
3390
3391 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3392 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3393 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3394 PLINT cont_color, PLINT cont_width,
3395 PLINT rectangular, PLFLT *tr )
3396 {
3397 f2c( a, aa, nx, ny );
3398 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3399 clevel, nlevel, fill_width, cont_color, cont_width,
3400 plfill, rectangular, xform, tr );
3401 }
3402
3403 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3404 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3405 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3406 PLINT cont_color, PLINT cont_width,
3407 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3408 {
3409 PLcGrid grid1;
3410 grid1.nx = nx; grid1.ny = ny;
3411 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3412
3413 f2c( a, aa, nx, ny );
3414 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3415 clevel, nlevel, fill_width, cont_color, cont_width,
3416 plfill, rectangular, pltr1, &grid1 );
3417 }
3418
3419 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3420 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3421 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3422 PLINT cont_color, PLINT cont_width,
3423 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3424 {
3425 PLcGrid2 grid2;
3426 f2c( xg, xgg, nx, ny );
3427 f2c( yg, ygg, nx, ny );
3428 grid2.nx = nx; grid2.ny = ny;
3429 grid2.xg = xgg; grid2.yg = ygg;
3430 f2c( a, aa, nx, ny );
3431 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3432 clevel, nlevel, fill_width, cont_color, cont_width,
3433 plfill, rectangular, pltr2, &grid2 );
3434 }
3435
3436
3437// Plot an array of vector arrows - uses the same function pointer
3438// convention as plcont
3439
3440 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3441 {
3442 f2c( u, uu, nx, ny );
3443 f2c( v, vv, nx, ny );
3444 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3445 }
3446
3447// plvect() for use with pltr1
3448 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3449 {
3450 PLcGrid grid1;
3451 grid1.nx = nx; grid1.ny = ny;
3452 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3453 f2c( u, uu, nx, ny );
3454 f2c( v, vv, nx, ny );
3455 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3456 }
3457
3458// plvect() for use with pltr2
3459 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3460 {
3461 PLcGrid2 grid2;
3462 f2c( xg, xgg, nx, ny );
3463 f2c( yg, ygg, nx, ny );
3464 grid2.nx = nx; grid2.ny = ny;
3465 grid2.xg = xgg; grid2.yg = ygg;
3466 f2c( u, uu, nx, ny );
3467 f2c( v, vv, nx, ny );
3468 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3469 }
3470
3471
3472// Plot an image with distortion - uses the same function pointer
3473 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3474 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3475 PLFLT zmin, PLFLT zmax,
3476 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3477 {
3478 f2c( a, aa, nx, ny );
3479 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3480 }
3481
3482// Plot an image with distortion - uses the same function pointer
3483// convention as plcont
3484 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3485 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3486 PLFLT zmin, PLFLT zmax,
3487 PLFLT valuemin, PLFLT valuemax )
3488 {
3489 f2c( a, aa, nx, ny );
3490 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3491 }
3492
3493 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3494 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3495 PLFLT zmin, PLFLT zmax,
3496 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3497 {
3498 f2c( a, aa, nx, ny );
3499 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3500 }
3501
3502// plimagefr() for use with pltr1
3503 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3504 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3505 PLFLT zmin, PLFLT zmax,
3506 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3507 {
3508 PLcGrid grid1;
3509 grid1.nx = nx + 1; grid1.ny = ny + 1;
3510 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3511 f2c( a, aa, nx, ny );
3512 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3513 }
3514
3515// plimagefr() for use with pltr2
3516 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3517 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3518 PLFLT zmin, PLFLT zmax,
3519 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3520 {
3521 PLcGrid2 grid2;
3522 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3523 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3524 grid2.nx = nx + 1; grid2.ny = ny + 1;
3525 grid2.xg = xgg; grid2.yg = ygg;
3526 f2c( a, aa, nx, ny );
3527 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3528 }
3529
3530
3531
3532 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3533 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3534 PLFLT x_length, PLFLT y_length,
3535 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3536 PLFLT low_cap_color, PLFLT high_cap_color,
3537 PLINT cont_color, PLFLT cont_width,
3538 PLINT n_labels, const PLINT *label_opts, const char **label,
3539 PLINT n_axes, const char ** axis_opts,
3540 const PLFLT *ticks, const PLINT *sub_ticks,
3541 const PLINT *n_values, const PLFLT *a )
3542 {
3543 PLINT nx, ny, i;
3544 nx = n_axes;
3545 ny = -1;
3546 for ( i = 0; i < nx; i++ )
3547 if ( n_values[i] > ny )
3548 ny = n_values[i];
3549 f2c( a, aa, nx, ny );
3550 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3551 opt, position, x, y,
3552 x_length, y_length,
3553 bg_color, bb_color, bb_style,
3554 low_cap_color, high_cap_color,
3555 cont_color, cont_width,
3556 n_labels, label_opts, label,
3557 n_axes, axis_opts,
3558 ticks, sub_ticks,
3559 n_values, aa );
3560 }
3561
3562
3563
3564 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3565 {
3566 if (!ov.is_scalar_type())
3567 return SWIG_TypeError;
3568 if (ov.is_complex_scalar())
3569 return SWIG_TypeError;
3570 if (ov.is_double_type()||ov.is_single_type()) {
3571 double v=ov.double_value();
3572 if (v<0)
3573 return SWIG_OverflowError;
3574 if (v!=floor(v))
3575 return SWIG_TypeError;
3576 }
3577 if (ov.is_int8_type()||ov.is_int16_type()||
3578 ov.is_int32_type()) {
3579 long v=ov.long_value();
3580 if (v<0)
3581 return SWIG_OverflowError;
3582 }
3583 if (ov.is_int64_type()) {
3584 long long v=ov.int64_scalar_value().value();
3585 if (v<0)
3586 return SWIG_OverflowError;
3587 }
3588 if (val)
3589 *val = ov.ulong_value();
3590 return SWIG_OK;
3591 }
3592
3593
3594SWIGINTERN int
3595SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3596{
3597 unsigned long v;
3598 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3599 if (SWIG_IsOK(res)) {
3600 if ((v > UINT_MAX)) {
3601 return SWIG_OverflowError;
3602 } else {
3603 if (val) *val = static_cast< unsigned int >(v);
3604 }
3605 }
3606 return res;
3607}
3608
3609
3611 {
3612 return octave_value(value);
3613 }
3614
3615
3616SWIGINTERNINLINE octave_value
3618{
3620}
3621
3622
3623SWIGINTERN int
3624SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3625{
3626 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3627 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3628 if (SWIG_IsOK(res)) {
3629 /* special case of single char conversion when we don't need space for NUL */
3630 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3631 if (csize <= size) {
3632 if (val) {
3633 if (csize) memcpy(val, cptr, csize*sizeof(char));
3634 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3635 }
3636 if (alloc == SWIG_NEWOBJ) {
3637 delete[] cptr;
3638 res = SWIG_DelNewMask(res);
3639 }
3640 return res;
3641 }
3642 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3643 }
3644 return SWIG_TypeError;
3645}
3646
3647
3650{
3651 static int init = 0;
3652 static swig_type_info* info = 0;
3653 if (!init) {
3654 info = SWIG_TypeQuery("_p_char");
3655 init = 1;
3656 }
3657 return info;
3658}
3659
3660
3661SWIGINTERNINLINE octave_value
3662SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3663{
3664 return std::string(carray,carray+size);
3665}
3666
3667
3668SWIGINTERN size_t
3669SWIG_strnlen(const char* s, size_t maxlen)
3670{
3671 const char *p;
3672 for (p = s; maxlen-- && *p; p++)
3673 ;
3674 return p - s;
3675}
3676
3677
3678SWIGINTERN int
3679SWIG_AsVal_char (octave_value obj, char *val)
3680{
3681 int res = SWIG_AsCharArray(obj, val, 1);
3682 if (!SWIG_IsOK(res)) {
3683 long v;
3684 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3685 if (SWIG_IsOK(res)) {
3686 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3687 if (val) *val = static_cast< char >(v);
3688 } else {
3689 res = SWIG_OverflowError;
3690 }
3691 }
3692 }
3693 return res;
3694}
3695
3696static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3697Set up transformation from metafile coordinates\n\
3698\n\
3699DESCRIPTION:\n\
3700\n\
3701 Set up transformation from metafile coordinates. The size of the plot\n\
3702 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3703 general-purpose facility just yet (not sure why the user would need\n\
3704 it, for one).\n\
3705\n\
3706 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3707 dimypmm)\n\
3708\n\
3709 This function is not used in any examples.\n\
3710\n\
3711\n\
3712\n\
3713SYNOPSIS:\n\
3714\n\
3715plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3716\n\
3717ARGUMENTS:\n\
3718\n\
3719 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3720\n\
3721 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3722\n\
3723 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3724\n\
3725 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3726\n\
3727 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3728\n\
3729 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3730";
3731static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3732Set the cmap0 palette using the specified cmap0*.pal format file\n\
3733\n\
3734DESCRIPTION:\n\
3735\n\
3736 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3737\n\
3738 Redacted form: plspal0(filename)\n\
3739\n\
3740 This function is in example 16.\n\
3741\n\
3742\n\
3743\n\
3744SYNOPSIS:\n\
3745\n\
3746plspal0(filename)\n\
3747\n\
3748ARGUMENTS:\n\
3749\n\
3750 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3751 containing the name of the cmap0*.pal file. If this string is\n\
3752 empty, use the default cmap0*.pal file.\n\
3753";
3754static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3755Set the cmap1 palette using the specified cmap1*.pal format file\n\
3756\n\
3757DESCRIPTION:\n\
3758\n\
3759 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3760\n\
3761 Redacted form: plspal1(filename, interpolate)\n\
3762\n\
3763 This function is used in example 16.\n\
3764\n\
3765\n\
3766\n\
3767SYNOPSIS:\n\
3768\n\
3769plspal1(filename, interpolate)\n\
3770\n\
3771ARGUMENTS:\n\
3772\n\
3773 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3774 containing the name of the cmap1*.pal file. If this string is\n\
3775 empty, use the default cmap1*.pal file.\n\
3776\n\
3777 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3778 columns containing the intensity index, r, g, b, alpha and\n\
3779 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3780 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3781 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3782 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3783 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3784 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3785 are used instead to set the cmap1 palette directly with a call to\n\
3786 plscmap1a.\n\
3787";
3788static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3789Draw a line in 3 space\n\
3790\n\
3791DESCRIPTION:\n\
3792\n\
3793 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3794 first set up the viewport, the 2d viewing window (in world\n\
3795 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3796 more info.\n\
3797\n\
3798 Redacted form: plline3(x, y, z)\n\
3799\n\
3800 This function is used in example 18.\n\
3801\n\
3802\n\
3803\n\
3804SYNOPSIS:\n\
3805\n\
3806plline3(n, x, y, z)\n\
3807\n\
3808ARGUMENTS:\n\
3809\n\
3810 n (PLINT, input) : Number of points defining line.\n\
3811\n\
3812 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3813 points.\n\
3814\n\
3815 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3816 points.\n\
3817\n\
3818 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3819 points.\n\
3820";
3821static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3822Magnitude colored plot surface mesh with contour\n\
3823\n\
3824DESCRIPTION:\n\
3825\n\
3826 A more powerful form of plmesh: the surface mesh can be colored\n\
3827 accordingly to the current z value being plotted, a contour plot can\n\
3828 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3829 plotted function border and the base XY plane.\n\
3830\n\
3831 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3832\n\
3833 This function is used in example 11.\n\
3834\n\
3835\n\
3836\n\
3837SYNOPSIS:\n\
3838\n\
3839plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3840\n\
3841ARGUMENTS:\n\
3842\n\
3843 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3844 which the function is evaluated.\n\
3845\n\
3846 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3847 which the function is evaluated.\n\
3848\n\
3849 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3850 plot. Should have dimensions of\n\
3851 nx by\n\
3852 ny.\n\
3853\n\
3854 nx (PLINT, input) : Number of x values at which function is\n\
3855 evaluated.\n\
3856\n\
3857 ny (PLINT, input) : Number of y values at which function is\n\
3858 evaluated.\n\
3859\n\
3860 opt (PLINT, input) : Determines the way in which the surface is\n\
3861 represented. To specify more than one option just add the options,\n\
3862 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3863 showing z as a function of x for each value of y[j] .\n\
3864 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3865 for each value of x[i] .\n\
3866 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3867 at which function is defined.\n\
3868 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3869 the z value being plotted. The color is used from the current\n\
3870 cmap1.\n\
3871 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3872 using parameters\n\
3873 nlevel and\n\
3874 clevel.\n\
3875 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3876 the borders of the plotted function.\n\
3877\n\
3878\n\
3879 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3880 levels.\n\
3881\n\
3882 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3883";
3884static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3885Draw a line between two points, accounting for coordinate transforms\n\
3886\n\
3887DESCRIPTION:\n\
3888\n\
3889 Joins the point (\n\
3890 x1,\n\
3891 y1) to (\n\
3892 x2,\n\
3893 y2) . If a global coordinate transform is defined then the line is\n\
3894 broken in to n segments to approximate the path. If no transform is\n\
3895 defined then this simply acts like a call to pljoin.\n\
3896\n\
3897 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3898\n\
3899 This function is used in example 22.\n\
3900\n\
3901\n\
3902\n\
3903SYNOPSIS:\n\
3904\n\
3905plpath(n, x1, y1, x2, y2)\n\
3906\n\
3907ARGUMENTS:\n\
3908\n\
3909 n (PLINT, input) : number of points to use to approximate the path.\n\
3910\n\
3911 x1 (PLFLT, input) : x coordinate of first point.\n\
3912\n\
3913 y1 (PLFLT, input) : y coordinate of first point.\n\
3914\n\
3915 x2 (PLFLT, input) : x coordinate of second point.\n\
3916\n\
3917 y2 (PLFLT, input) : y coordinate of second point.\n\
3918";
3919static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3920Write text inside the viewport\n\
3921\n\
3922DESCRIPTION:\n\
3923\n\
3924 Writes text at a specified position and inclination within the\n\
3925 viewport. Text is clipped at the viewport boundaries. The reference\n\
3926 point of a string lies along a line passing through the string at half\n\
3927 the height of a capital letter. The position of the reference point\n\
3928 along this line is determined by just, the reference point is placed\n\
3929 at world coordinates (\n\
3930 x,\n\
3931 y) within the viewport. The inclination of the string is specified\n\
3932 in terms of differences of world coordinates making it easy to write\n\
3933 text parallel to a line in a graph.\n\
3934\n\
3935 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3936\n\
3937 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3938\n\
3939\n\
3940\n\
3941SYNOPSIS:\n\
3942\n\
3943plptex(x, y, dx, dy, just, text)\n\
3944\n\
3945ARGUMENTS:\n\
3946\n\
3947 x (PLFLT, input) : x coordinate of reference point of string.\n\
3948\n\
3949 y (PLFLT, input) : y coordinate of reference point of string.\n\
3950\n\
3951 dx (PLFLT, input) : Together with dy, this specifies the\n\
3952 inclination of the string. The baseline of the string is parallel\n\
3953 to a line joining (\n\
3954 x,\n\
3955 y) to (\n\
3956 x+\n\
3957 dx,\n\
3958 y+\n\
3959 dy) .\n\
3960\n\
3961 dy (PLFLT, input) : Together with dx, this specifies the\n\
3962 inclination of the string.\n\
3963\n\
3964 just (PLFLT, input) : Specifies the position of the string relative\n\
3965 to its reference point. If just=0. , the reference point is at\n\
3966 the left and if just=1. , it is at the right of the string. Other\n\
3967 values of just give intermediate justifications.\n\
3968\n\
3969 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3970 written out.\n\
3971";
3972static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3973Set family file parameters\n\
3974\n\
3975DESCRIPTION:\n\
3976\n\
3977 Sets variables dealing with output file familying. Does nothing if\n\
3978 familying not supported by the driver. This routine, if used, must be\n\
3979 called before initializing PLplot. See the PLplot documentation for\n\
3980 more information.\n\
3981\n\
3982 Redacted form: plsfam(fam, num, bmax)\n\
3983\n\
3984 This function is used in examples 14 and 31.\n\
3985\n\
3986\n\
3987\n\
3988SYNOPSIS:\n\
3989\n\
3990plsfam(fam, num, bmax)\n\
3991\n\
3992ARGUMENTS:\n\
3993\n\
3994 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3995 is enabled.\n\
3996\n\
3997 num (PLINT, input) : Current family file number.\n\
3998\n\
3999 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
4000 file.\n\
4001";
4002static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
4003Set y axis parameters\n\
4004\n\
4005DESCRIPTION:\n\
4006\n\
4007 Identical to plsxax, except that arguments are flags for y axis. See\n\
4008 the description of plsxax for more detail.\n\
4009\n\
4010 Redacted form: plsyax(digmax, digits)\n\
4011\n\
4012 This function is used in examples 1, 14, and 31.\n\
4013\n\
4014\n\
4015\n\
4016SYNOPSIS:\n\
4017\n\
4018plsyax(digmax, digits)\n\
4019\n\
4020ARGUMENTS:\n\
4021\n\
4022 digmax (PLINT, input) : Variable to set the maximum number of\n\
4023 digits for the y axis. If nonzero, the printed label will be\n\
4024 switched to a floating-point representation when the number of\n\
4025 digits exceeds digmax.\n\
4026\n\
4027 digits (PLINT, input) : Field digits value. Currently, changing\n\
4028 its value here has no effect since it is set only by plbox or\n\
4029 plbox3. However, the user may obtain its value after a call to\n\
4030 either of these functions by calling plgyax.\n\
4031";
4032static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
4033Get z axis parameters\n\
4034\n\
4035DESCRIPTION:\n\
4036\n\
4037 Identical to plgxax, except that arguments are flags for z axis. See\n\
4038 the description of plgxax for more detail.\n\
4039\n\
4040 Redacted form: plgzax(p_digmax, p_digits)\n\
4041\n\
4042 This function is used in example 31.\n\
4043\n\
4044\n\
4045\n\
4046SYNOPSIS:\n\
4047\n\
4048plgzax(p_digmax, p_digits)\n\
4049\n\
4050ARGUMENTS:\n\
4051\n\
4052 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4053 number of digits for the z axis. If nonzero, the printed label\n\
4054 has been switched to a floating-point representation when the\n\
4055 number of digits exceeds this value.\n\
4056\n\
4057 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4058 number of digits for the numeric labels (z axis) from the last\n\
4059 plot.\n\
4060";
4061static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
4062Set format of numerical label for contours\n\
4063\n\
4064DESCRIPTION:\n\
4065\n\
4066 Set format of numerical label for contours.\n\
4067\n\
4068 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4069\n\
4070 This function is used example 9.\n\
4071\n\
4072\n\
4073\n\
4074SYNOPSIS:\n\
4075\n\
4076pl_setcontlabelformat(lexp, sigdig)\n\
4077\n\
4078ARGUMENTS:\n\
4079\n\
4080 lexp (PLINT, input) : If the contour numerical label is greater\n\
4081 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4082 format is used. Default value of lexp is 4.\n\
4083\n\
4084 sigdig (PLINT, input) : Number of significant digits. Default\n\
4085 value is 2.\n\
4086";
4087static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4088Set pen width\n\
4089\n\
4090DESCRIPTION:\n\
4091\n\
4092 Sets the pen width.\n\
4093\n\
4094 Redacted form: plwidth(width)\n\
4095\n\
4096 This function is used in examples 1 and 2.\n\
4097\n\
4098\n\
4099\n\
4100SYNOPSIS:\n\
4101\n\
4102plwidth(width)\n\
4103\n\
4104ARGUMENTS:\n\
4105\n\
4106 width (PLFLT, input) : The desired pen width. If width is negative\n\
4107 or the same as the previous value no action is taken. width = 0.\n\
4108 should be interpreted as as the minimum valid pen width for the\n\
4109 device. The interpretation of positive width values is also\n\
4110 device dependent.\n\
4111";
4112static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4113Get parameters that define current plot-space window\n\
4114\n\
4115DESCRIPTION:\n\
4116\n\
4117 Get relative minima and maxima that define current plot-space window.\n\
4118 If plsdiplt has not been called the default values pointed to by\n\
4119 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4120\n\
4121 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4122\n\
4123 This function is used in example 31.\n\
4124\n\
4125\n\
4126\n\
4127SYNOPSIS:\n\
4128\n\
4129plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4130\n\
4131ARGUMENTS:\n\
4132\n\
4133 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4134 minimum in x.\n\
4135\n\
4136 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4137 minimum in y.\n\
4138\n\
4139 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4140 maximum in x.\n\
4141\n\
4142 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4143 maximum in y.\n\
4144";
4145static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4146Set the cmap1 argument range for continuous color plots\n\
4147\n\
4148DESCRIPTION:\n\
4149\n\
4150 Set the cmap1 argument range for continuous color plots that\n\
4151 corresponds to the range of data values. The maximum range\n\
4152 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4153 the cmap1 argument range that is specified with this routine, the\n\
4154 smaller the subset of the cmap1 color palette that is used to\n\
4155 represent the continuous data being plotted. If\n\
4156 min_color is greater than\n\
4157 max_color or\n\
4158 max_color is greater than 1.0 or\n\
4159 min_color is less than 0.0 then no change is made to the cmap1\n\
4160 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4161\n\
4162 Redacted form: plscmap1_range(min_color, max_color)\n\
4163\n\
4164 This function is currently used in example 33.\n\
4165\n\
4166\n\
4167\n\
4168SYNOPSIS:\n\
4169\n\
4170plscmap1_range(min_color, max_color)\n\
4171\n\
4172ARGUMENTS:\n\
4173\n\
4174 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4175 than 0.0, then 0.0 is used instead.\n\
4176\n\
4177 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4178 than 1.0, then 1.0 is used instead.\n\
4179";
4180static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4181Select standard viewport\n\
4182\n\
4183DESCRIPTION:\n\
4184\n\
4185 Selects the largest viewport within the subpage that leaves a standard\n\
4186 margin (left-hand margin of eight character heights, and a margin\n\
4187 around the other three sides of five character heights).\n\
4188\n\
4189 Redacted form: plvsta()\n\
4190\n\
4191 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4192\n\
4193\n\
4194\n\
4195SYNOPSIS:\n\
4196\n\
4197plvsta()\n\
4198";
4199static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4200Load Hershey fonts\n\
4201\n\
4202DESCRIPTION:\n\
4203\n\
4204 Loads the Hershey fonts used for text and symbols. This routine may\n\
4205 be called before or after initializing PLplot. If not explicitly\n\
4206 called before PLplot initialization, then by default that\n\
4207 initialization loads Hershey fonts with the extended character set.\n\
4208 This routine only has a practical effect for devices that still use\n\
4209 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4210 system fonts instead of Hershey fonts).\n\
4211\n\
4212 Redacted form: plfontld(fnt)\n\
4213\n\
4214 This function is used in examples 1 and 7.\n\
4215\n\
4216\n\
4217\n\
4218SYNOPSIS:\n\
4219\n\
4220plfontld(fnt)\n\
4221\n\
4222ARGUMENTS:\n\
4223\n\
4224 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4225 A zero value specifies Hershey fonts with the standard character\n\
4226 set and a non-zero value (the default assumed if plfontld is never\n\
4227 called) specifies Hershey fonts with the extended character set.\n\
4228";
4229static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4230Draw error bars in x direction\n\
4231\n\
4232DESCRIPTION:\n\
4233\n\
4234 Draws a set of n error bars in x direction, the i\'th error bar\n\
4235 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4236 of the error bars are of length equal to the minor tick length\n\
4237 (settable using plsmin).\n\
4238\n\
4239 Redacted form: General: plerrx(xmin, ymax, y)\n\
4240\n\
4241\n\
4242 This function is used in example 29.\n\
4243\n\
4244\n\
4245\n\
4246SYNOPSIS:\n\
4247\n\
4248plerrx(n, xmin, xmax, y)\n\
4249\n\
4250ARGUMENTS:\n\
4251\n\
4252 n (PLINT, input) : Number of error bars to draw.\n\
4253\n\
4254 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4255 of the left-hand endpoints of the error bars.\n\
4256\n\
4257 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4258 of the right-hand endpoints of the error bars.\n\
4259\n\
4260 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4261 the error bars.\n\
4262";
4263static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4264Plot shaded 3-d surface plot\n\
4265\n\
4266DESCRIPTION:\n\
4267\n\
4268 Plots a three-dimensional shaded surface plot within the environment\n\
4269 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4270 z[\n\
4271 nx][\n\
4272 ny], the point z[i][j] being the value of the function at (\n\
4273 x[i],\n\
4274 y[j]). Note that the points in vectors x and y do not need to be\n\
4275 equally spaced, but must be stored in ascending order. For further\n\
4276 details see the PLplot documentation.\n\
4277\n\
4278 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4279\n\
4280 This function is not used in any examples.\n\
4281\n\
4282\n\
4283\n\
4284SYNOPSIS:\n\
4285\n\
4286plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4287\n\
4288ARGUMENTS:\n\
4289\n\
4290 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4291 which the function is evaluated.\n\
4292\n\
4293 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4294 which the function is evaluated.\n\
4295\n\
4296 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4297 plot. Should have dimensions of\n\
4298 nx by\n\
4299 ny.\n\
4300\n\
4301 nx (PLINT, input) : Number of x values at which function is\n\
4302 evaluated.\n\
4303\n\
4304 ny (PLINT, input) : Number of y values at which function is\n\
4305 evaluated.\n\
4306\n\
4307 opt (PLINT, input) : Determines the way in which the surface is\n\
4308 represented. To specify more than one option just add the options,\n\
4309 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4310 connecting points at which function is defined.\n\
4311 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4312 using parameters\n\
4313 nlevel and\n\
4314 clevel.\n\
4315 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4316 using parameters\n\
4317 nlevel and\n\
4318 clevel.\n\
4319 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4320 the borders of the plotted function.\n\
4321 opt=MAG_COLOR : the surface is colored according to the value\n\
4322 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4323 according to the intensity of the reflected light in the\n\
4324 surface from a light source whose position is set using\n\
4325 pllightsource.\n\
4326\n\
4327\n\
4328 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4329 levels.\n\
4330\n\
4331 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4332";
4333static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4334Get the current library version number\n\
4335\n\
4336DESCRIPTION:\n\
4337\n\
4338 Get the current library version number. Note: you must have allocated\n\
4339 space for this (80 characters is safe).\n\
4340\n\
4341 Redacted form: plgver(p_ver)\n\
4342\n\
4343 This function is used in example 1.\n\
4344\n\
4345\n\
4346\n\
4347SYNOPSIS:\n\
4348\n\
4349plgver(p_ver)\n\
4350\n\
4351ARGUMENTS:\n\
4352\n\
4353 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4354 (with preallocated length of 80 characters or more) containing the\n\
4355 PLplot version number.\n\
4356";
4357static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4358End plotting session for current stream\n\
4359\n\
4360DESCRIPTION:\n\
4361\n\
4362 Ends a plotting session for the current output stream only. See\n\
4363 plsstrm for more info.\n\
4364\n\
4365 Redacted form: plend1()\n\
4366\n\
4367 This function is used in examples 1 and 20.\n\
4368\n\
4369\n\
4370\n\
4371SYNOPSIS:\n\
4372\n\
4373plend1()\n\
4374";
4375static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4376Draw error bars in the y direction\n\
4377\n\
4378DESCRIPTION:\n\
4379\n\
4380 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4381 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4382 of the error bars are of length equal to the minor tick length\n\
4383 (settable using plsmin).\n\
4384\n\
4385 Redacted form: General: plerry(x, ymin, ymax)\n\
4386\n\
4387\n\
4388 This function is used in example 29.\n\
4389\n\
4390\n\
4391\n\
4392SYNOPSIS:\n\
4393\n\
4394plerry(n, x, ymin, ymax)\n\
4395\n\
4396ARGUMENTS:\n\
4397\n\
4398 n (PLINT, input) : Number of error bars to draw.\n\
4399\n\
4400 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4401 the error bars.\n\
4402\n\
4403 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4404 of the lower endpoints of the error bars.\n\
4405\n\
4406 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4407 of the upper endpoints of the error bars.\n\
4408";
4409static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4410Set seed for internal random number generator.\n\
4411\n\
4412DESCRIPTION:\n\
4413\n\
4414 Set the seed for the internal random number generator. See plrandd for\n\
4415 further details.\n\
4416\n\
4417 Redacted form: plseed(seed)\n\
4418\n\
4419 This function is used in example 21.\n\
4420\n\
4421\n\
4422\n\
4423SYNOPSIS:\n\
4424\n\
4425plseed(seed)\n\
4426\n\
4427ARGUMENTS:\n\
4428\n\
4429 seed (unsigned int, input) : Seed for random number generator.\n\
4430";
4431static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4432Specify viewport using normalized subpage coordinates\n\
4433\n\
4434DESCRIPTION:\n\
4435\n\
4436 Device-independent routine for setting up the viewport. This defines\n\
4437 the viewport in terms of normalized subpage coordinates which run from\n\
4438 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4439 current subpage. Use the alternate routine plsvpa in order to create\n\
4440 a viewport of a definite size.\n\
4441\n\
4442 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4443\n\
4444 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4445 24, 26, 27, and 31.\n\
4446\n\
4447\n\
4448\n\
4449SYNOPSIS:\n\
4450\n\
4451plvpor(xmin, xmax, ymin, ymax)\n\
4452\n\
4453ARGUMENTS:\n\
4454\n\
4455 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4456 left-hand edge of the viewport.\n\
4457\n\
4458 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4459 right-hand edge of the viewport.\n\
4460\n\
4461 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4462 bottom edge of the viewport.\n\
4463\n\
4464 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4465 edge of the viewport.\n\
4466";
4467static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4468Plot surface mesh\n\
4469\n\
4470DESCRIPTION:\n\
4471\n\
4472 Plots a surface mesh within the environment set up by plw3d. The\n\
4473 surface is defined by the matrix z[\n\
4474 nx][\n\
4475 ny] , the point z[i][j] being the value of the function at (\n\
4476 x[i],\n\
4477 y[j]). Note that the points in vectors x and y do not need to be\n\
4478 equally spaced, but must be stored in ascending order. The parameter\n\
4479 opt controls the way in which the surface is displayed. For further\n\
4480 details see the PLplot documentation.\n\
4481\n\
4482 Redacted form: plmesh(x, y, z, opt)\n\
4483\n\
4484 This function is used in example 11.\n\
4485\n\
4486\n\
4487\n\
4488SYNOPSIS:\n\
4489\n\
4490plmesh(x, y, z, nx, ny, opt)\n\
4491\n\
4492ARGUMENTS:\n\
4493\n\
4494 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4495 which the function is evaluated.\n\
4496\n\
4497 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4498 which the function is evaluated.\n\
4499\n\
4500 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4501 plot. Should have dimensions of\n\
4502 nx by\n\
4503 ny.\n\
4504\n\
4505 nx (PLINT, input) : Number of x values at which function has been\n\
4506 evaluated.\n\
4507\n\
4508 ny (PLINT, input) : Number of y values at which function has been\n\
4509 evaluated.\n\
4510\n\
4511 opt (PLINT, input) : Determines the way in which the surface is\n\
4512 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4513 function of x for each value of y[j] .\n\
4514 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4515 for each value of x[i] .\n\
4516 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4517 at which function is defined.\n\
4518";
4519static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4520Get the cmap1 argument range for continuous color plots\n\
4521\n\
4522DESCRIPTION:\n\
4523\n\
4524 Get the cmap1 argument range for continuous color plots. (Use\n\
4525 plscmap1_range to set the cmap1 argument range.)\n\
4526\n\
4527 Redacted form: plgcmap1_range(min_color, max_color)\n\
4528\n\
4529 This function is currently not used in any example.\n\
4530\n\
4531\n\
4532\n\
4533SYNOPSIS:\n\
4534\n\
4535plgcmap1_range(min_color, max_color)\n\
4536\n\
4537ARGUMENTS:\n\
4538\n\
4539 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4540 minimum cmap1 argument.\n\
4541\n\
4542 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4543 maximum cmap1 argument.\n\
4544";
4545static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4546Set arrow style for vector plots\n\
4547\n\
4548DESCRIPTION:\n\
4549\n\
4550 Set the style for the arrow used by plvect to plot vectors.\n\
4551\n\
4552 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4553\n\
4554 This function is used in example 22.\n\
4555\n\
4556\n\
4557\n\
4558SYNOPSIS:\n\
4559\n\
4560plsvect(arrowx, arrowy, npts, fill)\n\
4561\n\
4562ARGUMENTS:\n\
4563\n\
4564 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4565 the x and y points which make up the arrow. The arrow is plotted\n\
4566 by joining these points to form a polygon. The scaling assumes\n\
4567 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4568 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4569 will be reset to its default.\n\
4570\n\
4571 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4572 arrowy.\n\
4573\n\
4574 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4575 fill is false then the arrow is open.\n\
4576";
4577static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4578Draw filled polygon\n\
4579\n\
4580DESCRIPTION:\n\
4581\n\
4582 Fills the polygon defined by the n points (\n\
4583 x[i],\n\
4584 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4585 style is a solid fill. The routine will automatically close the\n\
4586 polygon between the last and first vertices. If multiple closed\n\
4587 polygons are passed in x and y then plfill will fill in between them.\n\
4588\n\
4589 Redacted form: plfill(x,y)\n\
4590\n\
4591 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4592\n\
4593\n\
4594\n\
4595SYNOPSIS:\n\
4596\n\
4597plfill(n, x, y)\n\
4598\n\
4599ARGUMENTS:\n\
4600\n\
4601 n (PLINT, input) : Number of vertices in polygon.\n\
4602\n\
4603 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4604 vertices.\n\
4605\n\
4606 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4607 vertices.\n\
4608";
4609static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4610Convert HLS color to RGB\n\
4611\n\
4612DESCRIPTION:\n\
4613\n\
4614 Convert HLS color coordinates to RGB.\n\
4615\n\
4616 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4617\n\
4618\n\
4619 This function is used in example 2.\n\
4620\n\
4621\n\
4622\n\
4623SYNOPSIS:\n\
4624\n\
4625plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4626\n\
4627ARGUMENTS:\n\
4628\n\
4629 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4630 cylinder.\n\
4631\n\
4632 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4633 the axis of the color cylinder.\n\
4634\n\
4635 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4636 the radius of the color cylinder.\n\
4637\n\
4638 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4639 (0.0-1.0) of the color.\n\
4640\n\
4641 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4642 intensity (0.0-1.0) of the color.\n\
4643\n\
4644 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4645 intensity (0.0-1.0) of the color.\n\
4646";
4647static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4648Set format for date / time labels\n\
4649\n\
4650DESCRIPTION:\n\
4651\n\
4652 Sets the format for date / time labels. To enable date / time format\n\
4653 labels see the options to plbox, plbox3, and plenv.\n\
4654\n\
4655 Redacted form: pltimefmt(fmt)\n\
4656\n\
4657 This function is used in example 29.\n\
4658\n\
4659\n\
4660\n\
4661SYNOPSIS:\n\
4662\n\
4663pltimefmt(fmt)\n\
4664\n\
4665ARGUMENTS:\n\
4666\n\
4667 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4668 interpreted similarly to the format specifier of typical system\n\
4669 strftime routines except that PLplot ignores locale and also\n\
4670 supplies some useful extensions in the context of plotting. All\n\
4671 text in the string is printed as-is other than conversion\n\
4672 specifications which take the form of a \'%\' character followed by\n\
4673 further conversion specification character. The conversion\n\
4674 specifications which are similar to those provided by system\n\
4675 strftime routines are the following: %a: The abbreviated (English)\n\
4676 weekday name.\n\
4677 %A: The full (English) weekday name.\n\
4678 %b: The abbreviated (English) month name.\n\
4679 %B: The full (English) month name.\n\
4680 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4681 %C: The century number (year/100) as a 2-digit integer.\n\
4682 %d: The day of the month as a decimal number (range 01 to 31).\n\
4683 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4684 %e: Like %d, but a leading zero is replaced by a space.\n\
4685 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4686 %h: Equivalent to %b.\n\
4687 %H: The hour as a decimal number using a 24-hour clock (range\n\
4688 00 to 23).\n\
4689 %I: The hour as a decimal number using a 12-hour clock (range\n\
4690 01 to 12).\n\
4691 %j: The day of the year as a decimal number (range 001 to\n\
4692 366).\n\
4693 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4694 23); single digits are preceded by a blank. (See also %H.)\n\
4695 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4696 12); single digits are preceded by a blank. (See also %I.)\n\
4697 %m: The month as a decimal number (range 01 to 12).\n\
4698 %M: The minute as a decimal number (range 00 to 59).\n\
4699 %n: A newline character.\n\
4700 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4701 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4702 %r: Equivalent to %I:%M:%S %p.\n\
4703 %R: The time in 24-hour notation (%H:%M). For a version\n\
4704 including the seconds, see %T below.\n\
4705 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4706 +0000 (UTC).\n\
4707 %S: The second as a decimal number (range 00 to 60). (The\n\
4708 range is up to 60 to allow for occasional leap seconds.)\n\
4709 %t: A tab character.\n\
4710 %T: The time in 24-hour notation (%H:%M:%S).\n\
4711 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4712 being 1. See also %w.\n\
4713 %U: The week number of the current year as a decimal number,\n\
4714 range 00 to 53, starting with the first Sunday as the first\n\
4715 day of week 01. See also %V and %W.\n\
4716 %v: Equivalent to %e-%b-%Y.\n\
4717 %V: The ISO 8601 week number of the current year as a decimal\n\
4718 number, range 01 to 53, where week 1 is the first week that\n\
4719 has at least 4 days in the new year. See also %U and %W.\n\
4720 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4721 being 0. See also %u.\n\
4722 %W: The week number of the current year as a decimal number,\n\
4723 range 00 to 53, starting with the first Monday as the first\n\
4724 day of week 01.\n\
4725 %x: Equivalent to %a %b %d %Y.\n\
4726 %X: Equivalent to %T.\n\
4727 %y: The year as a decimal number without a century (range 00\n\
4728 to 99).\n\
4729 %Y: The year as a decimal number including a century.\n\
4730 %z: The UTC time-zone string = \"+0000\".\n\
4731 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4732 %+: The UTC date and time in default format of the Unix date\n\
4733 command which is equivalent to %a %b %d %T %Z %Y.\n\
4734 %%: A literal \"%\" character.\n\
4735 The conversion specifications which are extensions to those normally\n\
4736 provided by system strftime routines are the following: %(0-9):\n\
4737 The fractional part of the seconds field (including leading\n\
4738 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4739 seconds to millisecond accuracy (00.000).\n\
4740 %.: The fractional part of the seconds field (including\n\
4741 leading decimal point) to the maximum available accuracy. Thus\n\
4742 %S%. would give seconds with fractional part up to 9 decimal\n\
4743 places if available.\n\
4744";
4745static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4746Get current subpage parameters\n\
4747\n\
4748DESCRIPTION:\n\
4749\n\
4750 Gets the size of the current subpage in millimeters measured from the\n\
4751 bottom left hand corner of the output device page or screen. Can be\n\
4752 used in conjunction with plsvpa for setting the size of a viewport in\n\
4753 absolute coordinates (millimeters).\n\
4754\n\
4755 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4756\n\
4757 This function is used in example 23.\n\
4758\n\
4759\n\
4760\n\
4761SYNOPSIS:\n\
4762\n\
4763plgspa(xmin, xmax, ymin, ymax)\n\
4764\n\
4765ARGUMENTS:\n\
4766\n\
4767 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4768 the left hand edge of the subpage in millimeters.\n\
4769\n\
4770 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4771 the right hand edge of the subpage in millimeters.\n\
4772\n\
4773 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4774 the bottom edge of the subpage in millimeters.\n\
4775\n\
4776 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4777 the top edge of the subpage in millimeters.\n\
4778";
4779static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4780Calculate world coordinates and corresponding window index from relative device coordinates\n\
4781\n\
4782DESCRIPTION:\n\
4783\n\
4784 Calculate world coordinates, wx and wy, and corresponding window index\n\
4785 from relative device coordinates, rx and ry.\n\
4786\n\
4787 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4788\n\
4789\n\
4790 This function is used in example 31.\n\
4791\n\
4792\n\
4793\n\
4794SYNOPSIS:\n\
4795\n\
4796plcalc_world(rx, ry, wx, wy, window)\n\
4797\n\
4798ARGUMENTS:\n\
4799\n\
4800 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4801 the x coordinate.\n\
4802\n\
4803 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4804 the y coordinate.\n\
4805\n\
4806 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4807 coordinate corresponding to the relative device coordinates rx and\n\
4808 ry.\n\
4809\n\
4810 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4811 coordinate corresponding to the relative device coordinates rx and\n\
4812 ry.\n\
4813\n\
4814 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4815 defined window index that corresponds to the input relative device\n\
4816 coordinates (and the returned world coordinates). To give some\n\
4817 background on the window index, for each page the initial window\n\
4818 index is set to zero, and each time plwind is called within the\n\
4819 page, world and device coordinates are stored for the window and\n\
4820 the window index is incremented. Thus, for a simple page layout\n\
4821 with non-overlapping viewports and one window per viewport, window\n\
4822 corresponds to the viewport index (in the order which the\n\
4823 viewport/windows were created) of the only viewport/window\n\
4824 corresponding to rx and ry. However, for more complicated layouts\n\
4825 with potentially overlapping viewports and possibly more than one\n\
4826 window (set of world coordinates) per viewport, window and the\n\
4827 corresponding output world coordinates corresponds to the last\n\
4828 window created that fulfills the criterion that the relative\n\
4829 device coordinates are inside it. Finally, in all cases where the\n\
4830 input relative device coordinates are not inside any\n\
4831 viewport/window, then the returned value of the last defined\n\
4832 window index is set to -1.\n\
4833";
4834static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4835Get output file name\n\
4836\n\
4837DESCRIPTION:\n\
4838\n\
4839 Gets the current output file name, if applicable.\n\
4840\n\
4841 Redacted form: plgfnam(fnam)\n\
4842\n\
4843 This function is used in example 31.\n\
4844\n\
4845\n\
4846\n\
4847SYNOPSIS:\n\
4848\n\
4849plgfnam(fnam)\n\
4850\n\
4851ARGUMENTS:\n\
4852\n\
4853 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4854 (with preallocated length of 80 characters or more) containing the\n\
4855 file name.\n\
4856";
4857static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4858Vector plot\n\
4859\n\
4860DESCRIPTION:\n\
4861\n\
4862 Draws a plot of vector data contained in the matrices (\n\
4863 u[\n\
4864 nx][\n\
4865 ny],\n\
4866 v[\n\
4867 nx][\n\
4868 ny]) . The scaling factor for the vectors is given by scale. A\n\
4869 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4870 additional data required by the transformation routine to map indices\n\
4871 within the matrices to the world coordinates. The style of the vector\n\
4872 arrow may be set using plsvect.\n\
4873\n\
4874 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4875 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4876 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4877 with either one or two dimensions.\n\
4878\n\
4879 This function is used in example 22.\n\
4880\n\
4881\n\
4882\n\
4883SYNOPSIS:\n\
4884\n\
4885plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4886\n\
4887ARGUMENTS:\n\
4888\n\
4889 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4890 and y components of the vector data to be plotted.\n\
4891\n\
4892 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4893\n\
4894 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4895 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4896 automatically calculated for the data. If scale < 0 then the\n\
4897 scaling factor is automatically calculated for the data and then\n\
4898 multiplied by -\n\
4899 scale. If scale > 0 then the scaling factor is set to scale.\n\
4900\n\
4901 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4902 defines the transformation between the zero-based indices of the\n\
4903 matrices u and v and world coordinates.For the C case,\n\
4904 transformation functions are provided in the PLplot library: pltr0\n\
4905 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4906 mappings respectively defined by vectors and matrices. In\n\
4907 addition, C callback routines for the transformation can be\n\
4908 supplied by the user such as the mypltr function in\n\
4909 examples/c/x09c.c which provides a general linear transformation\n\
4910 between index coordinates and world coordinates.For languages\n\
4911 other than C you should consult the PLplot documentation for the\n\
4912 details concerning how PLTRANSFORM_callback arguments are\n\
4913 interfaced. However, in general, a particular pattern of\n\
4914 callback-associated arguments such as a tr vector with 6 elements;\n\
4915 xg and yg vectors; or xg and yg matrices are respectively\n\
4916 interfaced to a linear-transformation routine similar to the above\n\
4917 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4918 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4919 support native language callbacks for handling index to\n\
4920 world-coordinate transformations. Examples of these various\n\
4921 approaches are given in examples/<language>x09*,\n\
4922 examples/<language>x16*, examples/<language>x20*,\n\
4923 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4924 supported languages.\n\
4925\n\
4926 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4927 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4928 that is externally supplied.\n\
4929";
4930static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4931Plot a glyph at the specified points\n\
4932\n\
4933DESCRIPTION:\n\
4934\n\
4935 Plot a glyph at the specified points. (This function is largely\n\
4936 superseded by plstring which gives access to many[!] more glyphs.)\n\
4937\n\
4938 Redacted form: plsym(x, y, code)\n\
4939\n\
4940 This function is used in example 7.\n\
4941\n\
4942\n\
4943\n\
4944SYNOPSIS:\n\
4945\n\
4946plsym(n, x, y, code)\n\
4947\n\
4948ARGUMENTS:\n\
4949\n\
4950 n (PLINT, input) : Number of points in the x and y vectors.\n\
4951\n\
4952 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4953 the points.\n\
4954\n\
4955 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4956 the points.\n\
4957\n\
4958 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4959 to be plotted at each of the n points.\n\
4960";
4961static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4962Get viewport limits in normalized device coordinates\n\
4963\n\
4964DESCRIPTION:\n\
4965\n\
4966 Get viewport limits in normalized device coordinates.\n\
4967\n\
4968 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4969\n\
4970\n\
4971 This function is used in example 31.\n\
4972\n\
4973\n\
4974\n\
4975SYNOPSIS:\n\
4976\n\
4977plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4978\n\
4979ARGUMENTS:\n\
4980\n\
4981 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4982 viewport limit of the normalized device coordinate in x.\n\
4983\n\
4984 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4985 viewport limit of the normalized device coordinate in x.\n\
4986\n\
4987 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4988 viewport limit of the normalized device coordinate in y.\n\
4989\n\
4990 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4991 viewport limit of the normalized device coordinate in y.\n\
4992";
4993static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4994Get page parameters\n\
4995\n\
4996DESCRIPTION:\n\
4997\n\
4998 Gets the current page configuration. The length and offset values are\n\
4999 expressed in units that are specific to the current driver. For\n\
5000 instance: screen drivers will usually interpret them as number of\n\
5001 pixels, whereas printer drivers will usually use mm.\n\
5002\n\
5003 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5004\n\
5005 This function is used in examples 14 and 31.\n\
5006\n\
5007\n\
5008\n\
5009SYNOPSIS:\n\
5010\n\
5011plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5012\n\
5013ARGUMENTS:\n\
5014\n\
5015 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5016 pixels/inch (DPI) in x.\n\
5017\n\
5018 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5019 pixels/inch (DPI) in y.\n\
5020\n\
5021 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5022 length.\n\
5023\n\
5024 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5025 length.\n\
5026\n\
5027 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5028 offset.\n\
5029\n\
5030 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5031 offset.\n\
5032";
5033static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
5034Plot a glyph at the specified 3D points\n\
5035\n\
5036DESCRIPTION:\n\
5037\n\
5038 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5039 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5040 this function similar to what is done for plline3. The glyph is\n\
5041 specified with a PLplot user string. Note that the user string is not\n\
5042 actually limited to one glyph so it is possible (but not normally\n\
5043 useful) to plot more than one glyph at the specified points with this\n\
5044 function. As with plmtex and plptex, the user string can contain FCI\n\
5045 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5046 else PLplot escapes for Hershey or unicode text to determine the\n\
5047 glyph.\n\
5048\n\
5049 Redacted form: plstring3(x, y, z, string)\n\
5050\n\
5051 This function is used in example 18.\n\
5052\n\
5053\n\
5054\n\
5055SYNOPSIS:\n\
5056\n\
5057plstring3(n, x, y, z, string)\n\
5058\n\
5059ARGUMENTS:\n\
5060\n\
5061 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5062\n\
5063 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5064 the points.\n\
5065\n\
5066 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5067 the points.\n\
5068\n\
5069 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5070 the points.\n\
5071\n\
5072 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5073 the glyph(s) to be plotted at each of the n points. points.\n\
5074";
5075static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
5076Shade regions on the basis of value\n\
5077\n\
5078DESCRIPTION:\n\
5079\n\
5080 Shade regions on the basis of value. This is the high-level routine\n\
5081 for making continuous color shaded plots with cmap1 while plshade\n\
5082 should be used to plot individual shaded regions using either cmap0 or\n\
5083 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5084 our supported languages.\n\
5085\n\
5086 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5087 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5088 pltr_data)\n\
5089\n\
5090\n\
5091 This function is used in examples 16, 21, and 22.\n\
5092\n\
5093\n\
5094\n\
5095SYNOPSIS:\n\
5096\n\
5097plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5098\n\
5099ARGUMENTS:\n\
5100\n\
5101 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5102 plot. Should have dimensions of\n\
5103 nx by\n\
5104 ny.\n\
5105\n\
5106 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5107\n\
5108 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5109\n\
5110 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5111 the region that should be plotted in the shade plot. This\n\
5112 function accepts x and y coordinates as input arguments and must\n\
5113 return 1 if the point is to be included in the shade plot and 0\n\
5114 otherwise. If you want to plot the entire shade plot (the usual\n\
5115 case), this argument should be set to NULL.\n\
5116\n\
5117 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5118 pltr below for how these arguments are used (only for the special case\n\
5119 when the callback function\n\
5120 pltr is not supplied).\n\
5121\n\
5122 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5123 corresponding to the edges of each shaded region that will be\n\
5124 plotted by this function. To work properly the levels should be\n\
5125 monotonic.\n\
5126\n\
5127 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5128 of shade edge values in clevel).\n\
5129\n\
5130 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5131 pattern.\n\
5132\n\
5133 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5134 contours defining edges of shaded regions. The pen color is only\n\
5135 temporary set for the contour drawing. Set this value to zero or\n\
5136 less if no shade edge contours are wanted.\n\
5137\n\
5138 cont_width (PLFLT, input) : Defines line width used for contours\n\
5139 defining edges of shaded regions. This value may not be honored\n\
5140 by all drivers. The pen width is only temporary set for the\n\
5141 contour drawing. Set this value to zero or less if no shade edge\n\
5142 contours are wanted.\n\
5143\n\
5144 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5145 region. Use plfill for this purpose.\n\
5146\n\
5147 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5148 map to rectangles after coordinate transformation with pltrl.\n\
5149 Otherwise, set rectangular to false. If rectangular is set to\n\
5150 true, plshade tries to save time by filling large rectangles.\n\
5151 This optimization fails if the coordinate transformation distorts\n\
5152 the shape of rectangles. For example a plot in polar coordinates\n\
5153 has to have rectangular set to false.\n\
5154\n\
5155 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5156 defines the transformation between the zero-based indices of the\n\
5157 matrix a and world coordinates. If\n\
5158 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5159 indices of a are mapped to the range\n\
5160 xmin through\n\
5161 xmax and the y indices of a are mapped to the range\n\
5162 ymin through\n\
5163 ymax.For the C case, transformation functions are provided in the\n\
5164 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5165 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5166 matrices. In addition, C callback routines for the transformation\n\
5167 can be supplied by the user such as the mypltr function in\n\
5168 examples/c/x09c.c which provides a general linear transformation\n\
5169 between index coordinates and world coordinates.For languages\n\
5170 other than C you should consult the PLplot documentation for the\n\
5171 details concerning how PLTRANSFORM_callback arguments are\n\
5172 interfaced. However, in general, a particular pattern of\n\
5173 callback-associated arguments such as a tr vector with 6 elements;\n\
5174 xg and yg vectors; or xg and yg matrices are respectively\n\
5175 interfaced to a linear-transformation routine similar to the above\n\
5176 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5177 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5178 support native language callbacks for handling index to\n\
5179 world-coordinate transformations. Examples of these various\n\
5180 approaches are given in examples/<language>x09*,\n\
5181 examples/<language>x16*, examples/<language>x20*,\n\
5182 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5183 supported languages.\n\
5184\n\
5185 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5186 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5187 externally supplied.\n\
5188";
5189static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5190Set output file name\n\
5191\n\
5192DESCRIPTION:\n\
5193\n\
5194 Sets the current output file name, if applicable. If the file name\n\
5195 has not been specified and is required by the driver, the user will be\n\
5196 prompted for it. If using the X-windows output driver, this sets the\n\
5197 display name. This routine, if used, must be called before\n\
5198 initializing PLplot.\n\
5199\n\
5200 Redacted form: plsfnam(fnam)\n\
5201\n\
5202 This function is used in examples 1 and 20.\n\
5203\n\
5204\n\
5205\n\
5206SYNOPSIS:\n\
5207\n\
5208plsfnam(fnam)\n\
5209\n\
5210ARGUMENTS:\n\
5211\n\
5212 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5213 the file name.\n\
5214";
5215static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5216Contour plot\n\
5217\n\
5218DESCRIPTION:\n\
5219\n\
5220 Draws a contour plot of the data in f[\n\
5221 nx][\n\
5222 ny], using the nlevel contour levels specified by clevel. Only the\n\
5223 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5224 where all these index ranges are interpreted as one-based for\n\
5225 historical reasons. A transformation routine pointed to by pltr with\n\
5226 a generic pointer pltr_data for additional data required by the\n\
5227 transformation routine is used to map indices within the matrix to the\n\
5228 world coordinates.\n\
5229\n\
5230 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5231 where (see above discussion) the pltr, pltr_data callback arguments\n\
5232 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5233 vectors; or xg and yg matrices.\n\
5234\n\
5235 This function is used in examples 9, 14, 16, and 22.\n\
5236\n\
5237\n\
5238\n\
5239SYNOPSIS:\n\
5240\n\
5241plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5242\n\
5243ARGUMENTS:\n\
5244\n\
5245 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5246\n\
5247 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5248\n\
5249 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5250 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5251 zero-based for historical backwards-compatibility reasons.\n\
5252\n\
5253 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5254 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5255 zero-based for historical backwards-compatibility reasons.\n\
5256\n\
5257 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5258 which to draw contours.\n\
5259\n\
5260 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5261\n\
5262 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5263 defines the transformation between the zero-based indices of the\n\
5264 matrix f and the world coordinates.For the C case, transformation\n\
5265 functions are provided in the PLplot library: pltr0 for the\n\
5266 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5267 respectively defined by vectors and matrices. In addition, C\n\
5268 callback routines for the transformation can be supplied by the\n\
5269 user such as the mypltr function in examples/c/x09c.c which\n\
5270 provides a general linear transformation between index coordinates\n\
5271 and world coordinates.For languages other than C you should\n\
5272 consult the PLplot documentation for the details concerning how\n\
5273 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5274 general, a particular pattern of callback-associated arguments\n\
5275 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5276 yg matrices are respectively interfaced to a linear-transformation\n\
5277 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5278 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5279 the PLplot documentation) support native language callbacks for\n\
5280 handling index to world-coordinate transformations. Examples of\n\
5281 these various approaches are given in examples/<language>x09*,\n\
5282 examples/<language>x16*, examples/<language>x20*,\n\
5283 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5284 supported languages.\n\
5285\n\
5286 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5287 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5288 that is externally supplied.\n\
5289";
5290static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5291Set parameters that define current plot-space window\n\
5292\n\
5293DESCRIPTION:\n\
5294\n\
5295 Set relative minima and maxima that define the current plot-space\n\
5296 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5297 xmax, and ymax are 0., 0., 1., and 1.\n\
5298\n\
5299 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5300\n\
5301 This function is used in example 31.\n\
5302\n\
5303\n\
5304\n\
5305SYNOPSIS:\n\
5306\n\
5307plsdiplt(xmin, ymin, xmax, ymax)\n\
5308\n\
5309ARGUMENTS:\n\
5310\n\
5311 xmin (PLFLT, input) : Relative minimum in x.\n\
5312\n\
5313 ymin (PLFLT, input) : Relative minimum in y.\n\
5314\n\
5315 xmax (PLFLT, input) : Relative maximum in x.\n\
5316\n\
5317 ymax (PLFLT, input) : Relative maximum in y.\n\
5318";
5319static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5320Write text inside the viewport of a 3D plot\n\
5321\n\
5322DESCRIPTION:\n\
5323\n\
5324 Writes text at a specified position and inclination and with a\n\
5325 specified shear within the viewport. Text is clipped at the viewport\n\
5326 boundaries. The reference point of a string lies along a line passing\n\
5327 through the string at half the height of a capital letter. The\n\
5328 position of the reference point along this line is determined by just,\n\
5329 and the reference point is placed at world coordinates (\n\
5330 wx,\n\
5331 wy,\n\
5332 wz) within the viewport. The inclination and shear of the string is\n\
5333 specified in terms of differences of world coordinates making it easy\n\
5334 to write text parallel to a line in a graph.\n\
5335\n\
5336 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5337\n\
5338 This function is used in example 28.\n\
5339\n\
5340\n\
5341\n\
5342SYNOPSIS:\n\
5343\n\
5344plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5345\n\
5346ARGUMENTS:\n\
5347\n\
5348 wx (PLFLT, input) : x world coordinate of reference point of\n\
5349 string.\n\
5350\n\
5351 wy (PLFLT, input) : y world coordinate of reference point of\n\
5352 string.\n\
5353\n\
5354 wz (PLFLT, input) : z world coordinate of reference point of\n\
5355 string.\n\
5356\n\
5357 dx (PLFLT, input) : Together with dy and\n\
5358 dz , this specifies the inclination of the string. The baseline of\n\
5359 the string is parallel to a line joining (\n\
5360 x,\n\
5361 y,\n\
5362 z) to (\n\
5363 x+\n\
5364 dx,\n\
5365 y+\n\
5366 dy,\n\
5367 z+\n\
5368 dz) .\n\
5369\n\
5370 dy (PLFLT, input) : Together with dx and\n\
5371 dz, this specifies the inclination of the string.\n\
5372\n\
5373 dz (PLFLT, input) : Together with dx and\n\
5374 dy, this specifies the inclination of the string.\n\
5375\n\
5376 sx (PLFLT, input) : Together with sy and\n\
5377 sz , this specifies the shear of the string. The string is sheared so\n\
5378 that the characters are vertically parallel to a line joining (\n\
5379 x,\n\
5380 y,\n\
5381 z) to (\n\
5382 x+\n\
5383 sx,\n\
5384 y+\n\
5385 sy,\n\
5386 z+\n\
5387 sz) . If sx =\n\
5388 sy =\n\
5389 sz = 0.) then the text is not sheared.\n\
5390\n\
5391 sy (PLFLT, input) : Together with sx and\n\
5392 sz, this specifies shear of the string.\n\
5393\n\
5394 sz (PLFLT, input) : Together with sx and\n\
5395 sy, this specifies shear of the string.\n\
5396\n\
5397 just (PLFLT, input) : Specifies the position of the string relative\n\
5398 to its reference point. If just=0. , the reference point is at\n\
5399 the left and if just=1. , it is at the right of the string. Other\n\
5400 values of just give intermediate justifications.\n\
5401\n\
5402 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5403 written out.\n\
5404";
5405static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5406Plot continental outline or shapefile data in world coordinates\n\
5407\n\
5408DESCRIPTION:\n\
5409\n\
5410 Plots continental outlines or shapefile data in world coordinates. A\n\
5411 demonstration of how to use this function to create different\n\
5412 projections can be found in examples/c/x19c. PLplot is provided with\n\
5413 basic coastal outlines and USA state borders. To use the map\n\
5414 functionality PLplot must be compiled with the shapelib library.\n\
5415 Shapefiles have become a popular standard for geographical data and\n\
5416 data in this format can be easily found from a number of online\n\
5417 sources. Shapefile data is actually provided as three or more files\n\
5418 with the same filename, but different extensions. The .shp and .shx\n\
5419 files are required for plotting Shapefile data with PLplot.\n\
5420\n\
5421 PLplot currently supports the point, multipoint, polyline and polygon\n\
5422 objects within shapefiles. However holes in polygons are not\n\
5423 supported. When plmap is used the type of object is derived from the\n\
5424 shapefile, if you wish to override the type then use one of the other\n\
5425 plmap variants. The built in maps have line data only.\n\
5426\n\
5427 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5428\n\
5429 This function is used in example 19.\n\
5430\n\
5431\n\
5432\n\
5433SYNOPSIS:\n\
5434\n\
5435plmap(mapform, name, minx, maxx, miny, maxy)\n\
5436\n\
5437ARGUMENTS:\n\
5438\n\
5439 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5440 transform the original map data coordinates to a new coordinate\n\
5441 system. The PLplot-supplied map data is provided as latitudes and\n\
5442 longitudes; other Shapefile data may be provided in other\n\
5443 coordinate systems as can be found in their .prj plain text files.\n\
5444 For example, by using this transform we can change from a\n\
5445 longitude, latitude coordinate to a polar stereographic\n\
5446 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5447 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5448 corresponding y coordinates (latitudes for the PLplot supplied\n\
5449 data). After the call to mapform(), x[] and y[] should be\n\
5450 replaced by the corresponding plot coordinates. If no transform is\n\
5451 desired, mapform can be replaced by NULL.\n\
5452\n\
5453 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5454 the type of map plotted. This is either one of the PLplot built-in\n\
5455 maps or the file name of a set of Shapefile files without the file\n\
5456 extensions. For the PLplot built-in maps the possible values are:\n\
5457 \"globe\" -- continental outlines\n\
5458 \"usa\" -- USA and state boundaries\n\
5459 \"cglobe\" -- continental outlines and countries\n\
5460 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5461\n\
5462\n\
5463 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5464 drawn. The units must match the shapefile (built in maps are\n\
5465 degrees lat/lon). Objects in the file which do not encroach on the\n\
5466 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5467 note this is simply an optimisation, not a clipping so for objects\n\
5468 with some points inside the box and some points outside the box\n\
5469 all the points will be rendered. These parameters also define\n\
5470 latitude and longitude wrapping for shapefiles using these units.\n\
5471 Longitude points will be wrapped by integer multiples of 360\n\
5472 degrees to place them in the box. This allows the same data to be\n\
5473 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5474 you plot from -180-540 you will get two cycles of data drawn. The\n\
5475 value of minx must be less than the value of maxx. Passing in a\n\
5476 nan, max/-max floating point number or +/-infinity will case the\n\
5477 bounding box from the shapefile to be used.\n\
5478\n\
5479 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5480 drawn - see minx.\n\
5481\n\
5482 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5483 drawn - see minx.\n\
5484\n\
5485 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5486 drawn - see minx.\n\
5487";
5488static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5489Specify viewport using coordinates and aspect ratio\n\
5490\n\
5491DESCRIPTION:\n\
5492\n\
5493 Device-independent routine for setting up the viewport. The viewport\n\
5494 is chosen to be the largest with the given aspect ratio that fits\n\
5495 within the specified region (in terms of normalized subpage\n\
5496 coordinates). This routine is functionally equivalent to plvpor when\n\
5497 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5498 routine reserves no extra space at the edges for labels.\n\
5499\n\
5500 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5501\n\
5502 This function is used in example 9.\n\
5503\n\
5504\n\
5505\n\
5506SYNOPSIS:\n\
5507\n\
5508plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5509\n\
5510ARGUMENTS:\n\
5511\n\
5512 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5513 left-hand edge of the viewport.\n\
5514\n\
5515 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5516 right-hand edge of the viewport.\n\
5517\n\
5518 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5519 bottom edge of the viewport.\n\
5520\n\
5521 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5522 edge of the viewport.\n\
5523\n\
5524 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5525 axis.\n\
5526";
5527static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5528Set the pause (on end-of-page) status\n\
5529\n\
5530DESCRIPTION:\n\
5531\n\
5532 Set the pause (on end-of-page) status.\n\
5533\n\
5534 Redacted form: plspause(pause)\n\
5535\n\
5536 This function is in examples 14,20.\n\
5537\n\
5538\n\
5539\n\
5540SYNOPSIS:\n\
5541\n\
5542plspause(pause)\n\
5543\n\
5544ARGUMENTS:\n\
5545\n\
5546 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5547 end-of-page for those drivers which support this. Otherwise there\n\
5548 is no pause.\n\
5549";
5550static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5551Plot 3-d surface plot\n\
5552\n\
5553DESCRIPTION:\n\
5554\n\
5555 Plots a three-dimensional surface plot within the environment set up\n\
5556 by plw3d. The surface is defined by the matrix z[\n\
5557 nx][\n\
5558 ny] , the point z[i][j] being the value of the function at (\n\
5559 x[i],\n\
5560 y[j]). Note that the points in vectors x and y do not need to be\n\
5561 equally spaced, but must be stored in ascending order. The parameter\n\
5562 opt controls the way in which the surface is displayed. For further\n\
5563 details see the PLplot documentation. The only difference between\n\
5564 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5565 while plot3d only draws the surface as viewed from the top.\n\
5566\n\
5567 Redacted form: plot3d(x, y, z, opt, side)\n\
5568\n\
5569 This function is used in examples 11 and 21.\n\
5570\n\
5571\n\
5572\n\
5573SYNOPSIS:\n\
5574\n\
5575plot3d(x, y, z, nx, ny, opt, side)\n\
5576\n\
5577ARGUMENTS:\n\
5578\n\
5579 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5580 which the function is evaluated.\n\
5581\n\
5582 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5583 which the function is evaluated.\n\
5584\n\
5585 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5586 plot. Should have dimensions of\n\
5587 nx by\n\
5588 ny.\n\
5589\n\
5590 nx (PLINT, input) : Number of x values at which function is\n\
5591 evaluated.\n\
5592\n\
5593 ny (PLINT, input) : Number of y values at which function is\n\
5594 evaluated.\n\
5595\n\
5596 opt (PLINT, input) : Determines the way in which the surface is\n\
5597 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5598 function of x for each value of y[j] .\n\
5599 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5600 for each value of x[i] .\n\
5601 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5602 at which function is defined.\n\
5603\n\
5604\n\
5605 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5606 should be draw on the figure. If side is true sides are drawn,\n\
5607 otherwise no sides are drawn.\n\
5608";
5609static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5610Copy state parameters from the reference stream to the current stream\n\
5611\n\
5612DESCRIPTION:\n\
5613\n\
5614 Copies state parameters from the reference stream to the current\n\
5615 stream. Tell driver interface to map device coordinates unless flags\n\
5616 == 1.\n\
5617\n\
5618 This function is used for making save files of selected plots (e.g.\n\
5619 from the TK driver). After initializing, you can get a copy of the\n\
5620 current plot to the specified device by switching to this stream and\n\
5621 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5622 appropriate. The plot buffer must have previously been enabled (done\n\
5623 automatically by some display drivers, such as X).\n\
5624\n\
5625 Redacted form: plcpstrm(iplsr, flags)\n\
5626\n\
5627 This function is used in example 1,20.\n\
5628\n\
5629\n\
5630\n\
5631SYNOPSIS:\n\
5632\n\
5633plcpstrm(iplsr, flags)\n\
5634\n\
5635ARGUMENTS:\n\
5636\n\
5637 iplsr (PLINT, input) : Number of reference stream.\n\
5638\n\
5639 flags (PLBOOL, input) : If flags is set to true the device\n\
5640 coordinates are not copied from the reference to current stream.\n\
5641";
5642static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5643Set page parameters\n\
5644\n\
5645DESCRIPTION:\n\
5646\n\
5647 Sets the page configuration (optional). If an individual parameter is\n\
5648 zero then that parameter value is not updated. Not all parameters are\n\
5649 recognized by all drivers and the interpretation is device-dependent.\n\
5650 The X-window driver uses the length and offset parameters to determine\n\
5651 the window size and location. The length and offset values are\n\
5652 expressed in units that are specific to the current driver. For\n\
5653 instance: screen drivers will usually interpret them as number of\n\
5654 pixels, whereas printer drivers will usually use mm.\n\
5655\n\
5656 This routine, if used, must be called before initializing PLplot. It\n\
5657 may be called at later times for interactive drivers to change only\n\
5658 the dpi for subsequent redraws which you can force via a call to\n\
5659 plreplot. If this function is not called then the page size defaults\n\
5660 to landscape A4 for drivers which use real world page sizes and 744\n\
5661 pixels wide by 538 pixels high for raster drivers. The default value\n\
5662 for dx and dy is 90 pixels per inch for raster drivers.\n\
5663\n\
5664\n\
5665\n\
5666 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5667\n\
5668 This function is used in examples 14 and 31.\n\
5669\n\
5670\n\
5671\n\
5672SYNOPSIS:\n\
5673\n\
5674plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5675\n\
5676ARGUMENTS:\n\
5677\n\
5678 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5679 by raster drivers, ignored by drivers which use \"real world\" units\n\
5680 (e.g. mm).\n\
5681\n\
5682 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5683 by raster drivers, ignored by drivers which use \"real world\" units\n\
5684 (e.g. mm).\n\
5685\n\
5686 xleng (PLINT, input) : Page length, x.\n\
5687\n\
5688 yleng (PLINT, input) : Page length, y.\n\
5689\n\
5690 xoff (PLINT, input) : Page offset, x.\n\
5691\n\
5692 yoff (PLINT, input) : Page offset, y.\n\
5693";
5694static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5695Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5696\n\
5697DESCRIPTION:\n\
5698\n\
5699 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5700 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5701 Values are negative if an invalid color id is given.\n\
5702\n\
5703 Redacted form: plgcola(r, g, b)\n\
5704\n\
5705 This function is used in example 30.\n\
5706\n\
5707\n\
5708\n\
5709SYNOPSIS:\n\
5710\n\
5711plgcol0a(icol0, r, g, b, alpha)\n\
5712\n\
5713ARGUMENTS:\n\
5714\n\
5715 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5716\n\
5717 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5718 in the range from 0 to 255.\n\
5719\n\
5720 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5721 in the range from 0 to 255.\n\
5722\n\
5723 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5724 in the range from 0 to 255.\n\
5725\n\
5726 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5727 transparency in the range from (0.0-1.0).\n\
5728";
5729static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5730Returns 8-bit RGB values for given color index from cmap0\n\
5731\n\
5732DESCRIPTION:\n\
5733\n\
5734 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5735 PLplot documentation). Values are negative if an invalid color id is\n\
5736 given.\n\
5737\n\
5738 Redacted form: plgcol0(icol0, r, g, b)\n\
5739\n\
5740 This function is used in example 2.\n\
5741\n\
5742\n\
5743\n\
5744SYNOPSIS:\n\
5745\n\
5746plgcol0(icol0, r, g, b)\n\
5747\n\
5748ARGUMENTS:\n\
5749\n\
5750 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5751\n\
5752 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5753 value.\n\
5754\n\
5755 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5756 value.\n\
5757\n\
5758 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5759 value.\n\
5760";
5761static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5762Set parameters incrementally (zoom mode) that define current plot-space window\n\
5763\n\
5764DESCRIPTION:\n\
5765\n\
5766 Set relative minima and maxima incrementally (zoom mode) that define\n\
5767 the current plot-space window. This function has the same effect as\n\
5768 plsdiplt if that function has not been previously called. Otherwise,\n\
5769 this function implements zoom mode using the transformation min_used =\n\
5770 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5771 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5772 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5773\n\
5774 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5775\n\
5776 This function is used in example 31.\n\
5777\n\
5778\n\
5779\n\
5780SYNOPSIS:\n\
5781\n\
5782plsdiplz(xmin, ymin, xmax, ymax)\n\
5783\n\
5784ARGUMENTS:\n\
5785\n\
5786 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5787\n\
5788 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5789\n\
5790 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5791\n\
5792 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5793";
5794static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5795Plot all or a subset of Shapefile data, filling the polygons\n\
5796\n\
5797DESCRIPTION:\n\
5798\n\
5799 As per plmapline, however the items are filled in the same way as\n\
5800 plfill.\n\
5801\n\
5802 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5803 plotentries)\n\
5804\n\
5805 This function is used in example 19.\n\
5806\n\
5807\n\
5808\n\
5809SYNOPSIS:\n\
5810\n\
5811plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5812\n\
5813ARGUMENTS:\n\
5814\n\
5815 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5816 transform the coordinates given in the shapefile into a plot\n\
5817 coordinate system. By using this transform, we can change from a\n\
5818 longitude, latitude coordinate to a polar stereographic project,\n\
5819 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5820 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5821 mapform(), x[] and y[] should be replaced by the corresponding\n\
5822 plot coordinates. If no transform is desired, mapform can be\n\
5823 replaced by NULL.\n\
5824\n\
5825 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5826 the file name of a set of Shapefile files without the file\n\
5827 extension.\n\
5828\n\
5829 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5830 be in the same units as used by the Shapefile. You could use a\n\
5831 very large negative number to plot everything, but you can improve\n\
5832 performance by limiting the area drawn. The units must match those\n\
5833 of the Shapefile projection, which may be for example longitude or\n\
5834 distance. The value of minx must be less than the value of maxx.\n\
5835\n\
5836 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5837 use a very large number to plot everything, but you can improve\n\
5838 performance by limiting the area drawn.\n\
5839\n\
5840 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5841 be in the same units as used by the Shapefile. You could use a\n\
5842 very large negative number to plot everything, but you can improve\n\
5843 performance by limiting the area drawn. The units must match those\n\
5844 of the Shapefile projection, which may be for example latitude or\n\
5845 distance. The value of miny must be less than the value of maxy.\n\
5846\n\
5847 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5848 use a very large number to plot everything, but you can improve\n\
5849 performance by limiting the area drawn.\n\
5850\n\
5851 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5852 zero-based indices of the Shapefile elements which will be drawn.\n\
5853 Setting\n\
5854 plotentries to NULL will plot all elements of the Shapefile.\n\
5855\n\
5856 nplotentries (PLINT, input) : The number of items in\n\
5857 plotentries. Ignored if\n\
5858 plotentries is NULL.\n\
5859";
5860static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5861Draw a line\n\
5862\n\
5863DESCRIPTION:\n\
5864\n\
5865 Draws line defined by n points in x and y.\n\
5866\n\
5867 Redacted form: plline(x, y)\n\
5868\n\
5869 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5870 25-27, and 29.\n\
5871\n\
5872\n\
5873\n\
5874SYNOPSIS:\n\
5875\n\
5876plline(n, x, y)\n\
5877\n\
5878ARGUMENTS:\n\
5879\n\
5880 n (PLINT, input) : Number of points defining line.\n\
5881\n\
5882 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5883 points.\n\
5884\n\
5885 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5886 points.\n\
5887";
5888static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5889Get viewport limits in world coordinates\n\
5890\n\
5891DESCRIPTION:\n\
5892\n\
5893 Get viewport limits in world coordinates.\n\
5894\n\
5895 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5896\n\
5897\n\
5898 This function is used in example 31.\n\
5899\n\
5900\n\
5901\n\
5902SYNOPSIS:\n\
5903\n\
5904plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5905\n\
5906ARGUMENTS:\n\
5907\n\
5908 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5909 viewport limit of the world coordinate in x.\n\
5910\n\
5911 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5912 viewport limit of the world coordinate in x.\n\
5913\n\
5914 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5915 viewport limit of the world coordinate in y.\n\
5916\n\
5917 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5918 viewport limit of the world coordinate in y.\n\
5919";
5920static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5921Set area line fill pattern\n\
5922\n\
5923DESCRIPTION:\n\
5924\n\
5925 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5926 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5927 inclinations and spacings. The arguments to this routine are the\n\
5928 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5929 elements) specifying the inclinations in tenths of a degree and the\n\
5930 spacing in micrometers. (See also plpsty)\n\
5931\n\
5932 Redacted form: General: plpat(inc, del)\n\
5933\n\
5934\n\
5935 This function is used in example 15.\n\
5936\n\
5937\n\
5938\n\
5939SYNOPSIS:\n\
5940\n\
5941plpat(nlin, inc, del)\n\
5942\n\
5943ARGUMENTS:\n\
5944\n\
5945 nlin (PLINT, input) : Number of sets of lines making up the\n\
5946 pattern, either 1 or 2.\n\
5947\n\
5948 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5949 inclination in tenths of a degree. (Should be between -900 and\n\
5950 900).\n\
5951\n\
5952 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5953 spacing in micrometers between the lines making up the pattern.\n\
5954";
5955static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5956Set x axis parameters\n\
5957\n\
5958DESCRIPTION:\n\
5959\n\
5960 Sets values of the digmax and digits flags for the x axis. See the\n\
5961 PLplot documentation for more information.\n\
5962\n\
5963 Redacted form: plsxax(digmax, digits)\n\
5964\n\
5965 This function is used in example 31.\n\
5966\n\
5967\n\
5968\n\
5969SYNOPSIS:\n\
5970\n\
5971plsxax(digmax, digits)\n\
5972\n\
5973ARGUMENTS:\n\
5974\n\
5975 digmax (PLINT, input) : Variable to set the maximum number of\n\
5976 digits for the x axis. If nonzero, the printed label will be\n\
5977 switched to a floating-point representation when the number of\n\
5978 digits exceeds digmax.\n\
5979\n\
5980 digits (PLINT, input) : Field digits value. Currently, changing\n\
5981 its value here has no effect since it is set only by plbox or\n\
5982 plbox3. However, the user may obtain its value after a call to\n\
5983 either of these functions by calling plgxax.\n\
5984";
5985static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5986Get family file parameters\n\
5987\n\
5988DESCRIPTION:\n\
5989\n\
5990 Gets information about current family file, if familying is enabled.\n\
5991 See the PLplot documentation for more information.\n\
5992\n\
5993 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5994\n\
5995 This function is used in examples 14 and 31.\n\
5996\n\
5997\n\
5998\n\
5999SYNOPSIS:\n\
6000\n\
6001plgfam(p_fam, p_num, p_bmax)\n\
6002\n\
6003ARGUMENTS:\n\
6004\n\
6005 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6006 family flag value. If nonzero, familying is enabled for the\n\
6007 current device.\n\
6008\n\
6009 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6010 family file number.\n\
6011\n\
6012 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6013 file size (in bytes) for a family file.\n\
6014";
6015static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
6016Get y axis parameters\n\
6017\n\
6018DESCRIPTION:\n\
6019\n\
6020 Identical to plgxax, except that arguments are flags for y axis. See\n\
6021 the description of plgxax for more detail.\n\
6022\n\
6023 Redacted form: plgyax(p_digmax, p_digits)\n\
6024\n\
6025 This function is used in example 31.\n\
6026\n\
6027\n\
6028\n\
6029SYNOPSIS:\n\
6030\n\
6031plgyax(p_digmax, p_digits)\n\
6032\n\
6033ARGUMENTS:\n\
6034\n\
6035 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6036 number of digits for the y axis. If nonzero, the printed label\n\
6037 has been switched to a floating-point representation when the\n\
6038 number of digits exceeds this value.\n\
6039\n\
6040 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6041 number of digits for the numeric labels (y axis) from the last\n\
6042 plot.\n\
6043";
6044static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6045Plot a glyph at the specified points\n\
6046\n\
6047DESCRIPTION:\n\
6048\n\
6049 Plot a glyph at the specified points. (This function is largely\n\
6050 superseded by plstring which gives access to many[!] more glyphs.)\n\
6051 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6052 and a draw at the same place. Not ideal, since a sufficiently\n\
6053 intelligent output device may optimize it away, or there may be faster\n\
6054 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6055 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6056 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6057 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6058 code <= 127 the corresponding printable ASCII character is plotted.\n\
6059\n\
6060 Redacted form: plpoin(x, y, code)\n\
6061\n\
6062 This function is used in examples 1, 6, 14, and 29.\n\
6063\n\
6064\n\
6065\n\
6066SYNOPSIS:\n\
6067\n\
6068plpoin(n, x, y, code)\n\
6069\n\
6070ARGUMENTS:\n\
6071\n\
6072 n (PLINT, input) : Number of points in the x and y vectors.\n\
6073\n\
6074 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6075 points.\n\
6076\n\
6077 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6078 points.\n\
6079\n\
6080 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6081 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6082 each of the n points.\n\
6083";
6084static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6085Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6086\n\
6087DESCRIPTION:\n\
6088\n\
6089 As per plmapline, however the items are plotted as strings or points\n\
6090 in the same way as plstring.\n\
6091\n\
6092 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6093 maxy, plotentries)\n\
6094\n\
6095 This function is not used in any examples.\n\
6096\n\
6097\n\
6098\n\
6099SYNOPSIS:\n\
6100\n\
6101plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6102\n\
6103ARGUMENTS:\n\
6104\n\
6105 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6106 transform the coordinates given in the shapefile into a plot\n\
6107 coordinate system. By using this transform, we can change from a\n\
6108 longitude, latitude coordinate to a polar stereographic project,\n\
6109 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6110 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6111 mapform(), x[] and y[] should be replaced by the corresponding\n\
6112 plot coordinates. If no transform is desired, mapform can be\n\
6113 replaced by NULL.\n\
6114\n\
6115 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6116 the file name of a set of Shapefile files without the file\n\
6117 extension.\n\
6118\n\
6119 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6120 drawn.\n\
6121\n\
6122 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6123 be in the same units as used by the Shapefile. You could use a\n\
6124 very large negative number to plot everything, but you can improve\n\
6125 performance by limiting the area drawn. The units must match those\n\
6126 of the Shapefile projection, which may be for example longitude or\n\
6127 distance. The value of minx must be less than the value of maxx.\n\
6128\n\
6129 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6130 use a very large number to plot everything, but you can improve\n\
6131 performance by limiting the area drawn.\n\
6132\n\
6133 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6134 be in the same units as used by the Shapefile. You could use a\n\
6135 very large negative number to plot everything, but you can improve\n\
6136 performance by limiting the area drawn. The units must match those\n\
6137 of the Shapefile projection, which may be for example latitude or\n\
6138 distance. The value of miny must be less than the value of maxy.\n\
6139\n\
6140 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6141 use a very large number to plot everything, but you can improve\n\
6142 performance by limiting the area drawn.\n\
6143\n\
6144 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6145 zero-based indices of the Shapefile elements which will be drawn.\n\
6146 Setting\n\
6147 plotentries to NULL will plot all elements of the Shapefile.\n\
6148\n\
6149 nplotentries (PLINT, input) : The number of items in\n\
6150 plotentries. Ignored if\n\
6151 plotentries is NULL.\n\
6152";
6153static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6154Select area fill pattern\n\
6155\n\
6156DESCRIPTION:\n\
6157\n\
6158 If\n\
6159 patt is zero or less use either a hardware solid fill if the drivers\n\
6160 have that capability (virtually all do) or fall back to a software\n\
6161 emulation of a solid fill using the eighth area line fill pattern. If\n\
6162 0 <\n\
6163 patt <= 8, then select one of eight predefined area line fill patterns\n\
6164 to use (see plpat if you desire other patterns).\n\
6165\n\
6166 Redacted form: plpsty(patt)\n\
6167\n\
6168 This function is used in examples 12, 13, 15, 16, and 25.\n\
6169\n\
6170\n\
6171\n\
6172SYNOPSIS:\n\
6173\n\
6174plpsty(patt)\n\
6175\n\
6176ARGUMENTS:\n\
6177\n\
6178 patt (PLINT, input) : The desired pattern index. If\n\
6179 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6180 above) used. For\n\
6181 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6182 line fill capability itself (most deliberately do not so that line\n\
6183 fill patterns look identical for those drivers), the patterns\n\
6184 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6185 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6186 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6187 (8) lines at both 45 degrees and -45 degrees.\n\
6188";
6189static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6190Set 8-bit RGB values for given cmap0 color index\n\
6191\n\
6192DESCRIPTION:\n\
6193\n\
6194 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6195 index. Overwrites the previous color value for the given index and,\n\
6196 thus, does not result in any additional allocation of space for\n\
6197 colors.\n\
6198\n\
6199 Redacted form: plscol0(icol0, r, g, b)\n\
6200\n\
6201 This function is used in any example 31.\n\
6202\n\
6203\n\
6204\n\
6205SYNOPSIS:\n\
6206\n\
6207plscol0(icol0, r, g, b)\n\
6208\n\
6209ARGUMENTS:\n\
6210\n\
6211 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6212 number of colors (which is set by default, by plscmap0n, or even\n\
6213 by plscmap0).\n\
6214\n\
6215 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6216 degree of red in the color.\n\
6217\n\
6218 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6219 degree of green in the color.\n\
6220\n\
6221 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6222 degree of blue in the color.\n\
6223";
6224static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6225Used to globally turn color output on/off\n\
6226\n\
6227DESCRIPTION:\n\
6228\n\
6229 Used to globally turn color output on/off for those drivers/devices\n\
6230 that support it.\n\
6231\n\
6232 Redacted form: plscolor(color)\n\
6233\n\
6234 This function is used in example 31.\n\
6235\n\
6236\n\
6237\n\
6238SYNOPSIS:\n\
6239\n\
6240plscolor(color)\n\
6241\n\
6242ARGUMENTS:\n\
6243\n\
6244 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6245 turned off. If non-zero, color is turned on.\n\
6246";
6247static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6248End plotting session\n\
6249\n\
6250DESCRIPTION:\n\
6251\n\
6252 Ends a plotting session, tidies up all the output files, switches\n\
6253 interactive devices back into text mode and frees up any memory that\n\
6254 was allocated. Must be called before end of program.\n\
6255\n\
6256 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6257 wait state after a call to plend or other functions which trigger the\n\
6258 end of a plot page. To avoid this, use the plspause function.\n\
6259\n\
6260 Redacted form: plend()\n\
6261\n\
6262 This function is used in all of the examples.\n\
6263\n\
6264\n\
6265\n\
6266SYNOPSIS:\n\
6267\n\
6268plend()\n\
6269";
6270static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6271Plot a histogram from binned data\n\
6272\n\
6273DESCRIPTION:\n\
6274\n\
6275 Plots a histogram consisting of nbin bins. The value associated with\n\
6276 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6277 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6278 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6279 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6280 placed midway between the values in the x vector. Also see plhist for\n\
6281 drawing histograms from unbinned data.\n\
6282\n\
6283 Redacted form: General: plbin(x, y, opt)\n\
6284 Python: plbin(nbin, x, y, opt)\n\
6285\n\
6286\n\
6287 This function is not used in any examples.\n\
6288\n\
6289\n\
6290\n\
6291SYNOPSIS:\n\
6292\n\
6293plbin(nbin, x, y, opt)\n\
6294\n\
6295ARGUMENTS:\n\
6296\n\
6297 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6298 and y vectors.)\n\
6299\n\
6300 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6301 with bins. These must form a strictly increasing sequence.\n\
6302\n\
6303 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6304 proportional to the number of points in each bin. This is a PLFLT\n\
6305 (instead of PLINT) vector so as to allow histograms of\n\
6306 probabilities, etc.\n\
6307\n\
6308 opt (PLINT, input) : Is a combination of several flags:\n\
6309 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6310 outer bins are expanded to fill up the entire x-axis and bins of\n\
6311 zero height are simply drawn.\n\
6312 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6313 between the x values. If the values in x are equally spaced,\n\
6314 the values are the center values of the bins.\n\
6315 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6316 size as the ones inside.\n\
6317 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6318 (there is a gap for such bins).\n\
6319";
6320static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6321Plot a 2D matrix using cmap1\n\
6322\n\
6323DESCRIPTION:\n\
6324\n\
6325 Plot a 2D matrix using cmap1.\n\
6326\n\
6327 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6328 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6329\n\
6330\n\
6331 This function is used in example 20.\n\
6332\n\
6333\n\
6334\n\
6335SYNOPSIS:\n\
6336\n\
6337plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6338\n\
6339ARGUMENTS:\n\
6340\n\
6341 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6342 plot. Should have dimensions of\n\
6343 nx by\n\
6344 ny.\n\
6345\n\
6346 nx, ny (PLINT, input) : Dimensions of idata\n\
6347\n\
6348 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6349 pltr below for how these arguments are used (only for the special case\n\
6350 when the callback function\n\
6351 pltr is not supplied).\n\
6352\n\
6353 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6354 (inclusive) will be plotted.\n\
6355\n\
6356 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6357 values to use for value to color mappings. A datum equal to or\n\
6358 less than valuemin will be plotted with color 0.0, while a datum\n\
6359 equal to or greater than valuemax will be plotted with color 1.0.\n\
6360 Data between valuemin and valuemax map linearly to colors in the\n\
6361 range (0.0-1.0).\n\
6362\n\
6363 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6364 defines the transformation between the zero-based indices of the\n\
6365 matrix idata and world coordinates. If\n\
6366 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6367 indices of idata are mapped to the range\n\
6368 xmin through\n\
6369 xmax and the y indices of idata are mapped to the range\n\
6370 ymin through\n\
6371 ymax.For the C case, transformation functions are provided in the\n\
6372 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6373 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6374 matrices. In addition, C callback routines for the transformation\n\
6375 can be supplied by the user such as the mypltr function in\n\
6376 examples/c/x09c.c which provides a general linear transformation\n\
6377 between index coordinates and world coordinates.For languages\n\
6378 other than C you should consult the PLplot documentation for the\n\
6379 details concerning how PLTRANSFORM_callback arguments are\n\
6380 interfaced. However, in general, a particular pattern of\n\
6381 callback-associated arguments such as a tr vector with 6 elements;\n\
6382 xg and yg vectors; or xg and yg matrices are respectively\n\
6383 interfaced to a linear-transformation routine similar to the above\n\
6384 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6385 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6386 support native language callbacks for handling index to\n\
6387 world-coordinate transformations. Examples of these various\n\
6388 approaches are given in examples/<language>x09*,\n\
6389 examples/<language>x16*, examples/<language>x20*,\n\
6390 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6391 supported languages.\n\
6392\n\
6393 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6394 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6395 externally supplied.\n\
6396";
6397static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6398Sets the 3D position of the light source\n\
6399\n\
6400DESCRIPTION:\n\
6401\n\
6402 Sets the 3D position of the light source for use with plsurf3d and\n\
6403 plsurf3dl\n\
6404\n\
6405 Redacted form: pllightsource(x, y, z)\n\
6406\n\
6407 This function is used in example 8.\n\
6408\n\
6409\n\
6410\n\
6411SYNOPSIS:\n\
6412\n\
6413pllightsource(x, y, z)\n\
6414\n\
6415ARGUMENTS:\n\
6416\n\
6417 x (PLFLT, input) : X-coordinate of the light source.\n\
6418\n\
6419 y (PLFLT, input) : Y-coordinate of the light source.\n\
6420\n\
6421 z (PLFLT, input) : Z-coordinate of the light source.\n\
6422";
6423static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6424Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6425\n\
6426DESCRIPTION:\n\
6427\n\
6428 When the implementation is completed this variant of plot3dc (see that\n\
6429 function\'s documentation for more details) should be suitable for the\n\
6430 case where the area of the x, y coordinate grid where z is defined can\n\
6431 be non-rectangular. The implementation is incomplete so the last 4\n\
6432 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6433 indexymax; are currently ignored and the functionality is otherwise\n\
6434 identical to that of plot3dc.\n\
6435\n\
6436 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6437 indexymin, indexymax)\n\
6438\n\
6439\n\
6440 This function is not used in any example.\n\
6441\n\
6442\n\
6443\n\
6444SYNOPSIS:\n\
6445\n\
6446plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6447\n\
6448ARGUMENTS:\n\
6449\n\
6450 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6451 which the function is evaluated.\n\
6452\n\
6453 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6454 which the function is evaluated.\n\
6455\n\
6456 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6457 plot. Should have dimensions of\n\
6458 nx by\n\
6459 ny.\n\
6460\n\
6461 nx (PLINT, input) : Number of x values at which the function is\n\
6462 evaluated.\n\
6463\n\
6464 ny (PLINT, input) : Number of y values at which the function is\n\
6465 evaluated.\n\
6466\n\
6467 opt (PLINT, input) : Determines the way in which the surface is\n\
6468 represented. To specify more than one option just add the options,\n\
6469 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6470 showing z as a function of x for each value of y[j] .\n\
6471 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6472 for each value of x[i] .\n\
6473 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6474 at which function is defined.\n\
6475 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6476 the z value being plotted. The color is used from the current\n\
6477 cmap1.\n\
6478 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6479 using parameters\n\
6480 nlevel and\n\
6481 clevel.\n\
6482 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6483 the borders of the plotted function.\n\
6484\n\
6485\n\
6486 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6487 levels.\n\
6488\n\
6489 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6490\n\
6491 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6492 corresponds to the first x index where z is defined.\n\
6493\n\
6494 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6495 which corresponds (by convention) to one more than the last x\n\
6496 index value where z is defined.\n\
6497\n\
6498 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6499 values which all must be ≥ 0. These values are the first y index\n\
6500 where z is defined for a particular x index in the range from\n\
6501 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6502 indexxmax.\n\
6503\n\
6504 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6505 values which all must be ≤ ny. These values correspond (by\n\
6506 convention) to one more than the last y index where z is defined\n\
6507 for a particular x index in the range from indexxmin to indexxmax\n\
6508 - 1. The dimension of indexymax is indexxmax.\n\
6509";
6510static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6511Creates a new stream and makes it the default\n\
6512\n\
6513DESCRIPTION:\n\
6514\n\
6515 Creates a new stream and makes it the default. Differs from using\n\
6516 plsstrm, in that a free stream number is found, and returned.\n\
6517 Unfortunately, I have to start at stream 1 and work upward, since\n\
6518 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6519 that no initial, library-opening call is required. So stream 0 must\n\
6520 be preallocated, and there is no simple way of determining whether it\n\
6521 is already in use or not.\n\
6522\n\
6523 Redacted form: plmkstrm(p_strm)\n\
6524\n\
6525 This function is used in examples 1 and 20.\n\
6526\n\
6527\n\
6528\n\
6529SYNOPSIS:\n\
6530\n\
6531plmkstrm(p_strm)\n\
6532\n\
6533ARGUMENTS:\n\
6534\n\
6535 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6536 number of the created stream.\n\
6537";
6538static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6539Set FCI (font characterization integer)\n\
6540\n\
6541DESCRIPTION:\n\
6542\n\
6543 Sets font characteristics to be used at the start of the next string\n\
6544 using the FCI approach. See the PLplot documentation for more\n\
6545 information. Note, plsfont (which calls plsfci internally) provides a\n\
6546 more user-friendly API for setting the font characterisitics.\n\
6547\n\
6548 Redacted form: General: plsfci(fci)\n\
6549\n\
6550\n\
6551 This function is used in example 23.\n\
6552\n\
6553\n\
6554\n\
6555SYNOPSIS:\n\
6556\n\
6557plsfci(fci)\n\
6558\n\
6559ARGUMENTS:\n\
6560\n\
6561 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6562 of FCI.\n\
6563";
6564static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6565Initialize PLplot\n\
6566\n\
6567DESCRIPTION:\n\
6568\n\
6569 Initializing the plotting package. The program prompts for the device\n\
6570 keyword or number of the desired output device. Hitting a RETURN in\n\
6571 response to the prompt is the same as selecting the first device.\n\
6572 plinit will issue no prompt if either the device was specified\n\
6573 previously (via command line flag, the plsetopt function, or the\n\
6574 plsdev function), or if only one device is enabled when PLplot is\n\
6575 installed. If subpages have been specified, the output device is\n\
6576 divided into nx by ny subpages, each of which may be used\n\
6577 independently. If plinit is called again during a program, the\n\
6578 previously opened file will be closed. The subroutine pladv is used\n\
6579 to advance from one subpage to the next.\n\
6580\n\
6581 Redacted form: plinit()\n\
6582\n\
6583 This function is used in all of the examples.\n\
6584\n\
6585\n\
6586\n\
6587SYNOPSIS:\n\
6588\n\
6589plinit()\n\
6590";
6591static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6592Set line style\n\
6593\n\
6594DESCRIPTION:\n\
6595\n\
6596 This sets up the line style for all lines subsequently drawn. A line\n\
6597 consists of segments in which the pen is alternately down and up. The\n\
6598 lengths of these segments are passed in the vectors mark and space\n\
6599 respectively. The number of mark-space pairs is specified by nms. In\n\
6600 order to return the line style to the default continuous line, plstyl\n\
6601 should be called with nms =0 .(see also pllsty)\n\
6602\n\
6603 Redacted form: plstyl(mark, space)\n\
6604\n\
6605 This function is used in examples 1, 9, and 14.\n\
6606\n\
6607\n\
6608\n\
6609SYNOPSIS:\n\
6610\n\
6611plstyl(nms, mark, space)\n\
6612\n\
6613ARGUMENTS:\n\
6614\n\
6615 nms (PLINT, input) : The number of mark and space elements in a\n\
6616 line. Thus a simple broken line can be obtained by setting nms=1\n\
6617 . A continuous line is specified by setting nms=0 .\n\
6618\n\
6619 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6620 segments during which the pen is down, measured in micrometers.\n\
6621\n\
6622 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6623 the segments during which the pen is up, measured in micrometers.\n\
6624";
6625static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6626Set length of minor ticks\n\
6627\n\
6628DESCRIPTION:\n\
6629\n\
6630 This sets up the length of the minor ticks and the length of the\n\
6631 terminals on error bars. The actual length is the product of the\n\
6632 default length and a scaling factor as for character height.\n\
6633\n\
6634 Redacted form: plsmin(def, scale)\n\
6635\n\
6636 This function is used in example 29.\n\
6637\n\
6638\n\
6639\n\
6640SYNOPSIS:\n\
6641\n\
6642plsmin(def, scale)\n\
6643\n\
6644ARGUMENTS:\n\
6645\n\
6646 def (PLFLT, input) : The default length of a minor tick in\n\
6647 millimeters, should be set to zero if the default length is to\n\
6648 remain unchanged.\n\
6649\n\
6650 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6651 actual tick length.\n\
6652";
6653static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6654Draw a box with axes, etc, in 3-d\n\
6655\n\
6656DESCRIPTION:\n\
6657\n\
6658 Draws axes, numeric and text labels for a three-dimensional surface\n\
6659 plot. For a more complete description of three-dimensional plotting\n\
6660 see the PLplot documentation.\n\
6661\n\
6662 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6663 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6664\n\
6665\n\
6666 This function is used in examples 8, 11, 18, and 21.\n\
6667\n\
6668\n\
6669\n\
6670SYNOPSIS:\n\
6671\n\
6672plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6673\n\
6674ARGUMENTS:\n\
6675\n\
6676 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6677 options for the x axis. The string can include any combination of\n\
6678 the following letters (upper or lower case) in any order: b: Draws\n\
6679 axis at base, at height z=\n\
6680 zmin where zmin is defined by call to plw3d. This character must be\n\
6681 specified in order to use any of the other options.\n\
6682 d: Plot labels as date / time. Values are assumed to be\n\
6683 seconds since the epoch (as used by gmtime).\n\
6684 f: Always use fixed point numeric labels.\n\
6685 i: Inverts tick marks, so they are drawn downwards, rather\n\
6686 than upwards.\n\
6687 l: Labels axis logarithmically. This only affects the labels,\n\
6688 not the data, and so it is necessary to compute the logarithms\n\
6689 of data points before passing them to any of the drawing\n\
6690 routines.\n\
6691 n: Writes numeric labels at major tick intervals.\n\
6692 o: Use custom labelling function to generate axis label text.\n\
6693 The custom labelling function can be defined with the\n\
6694 plslabelfunc command.\n\
6695 s: Enables subticks between major ticks, only valid if t is\n\
6696 also specified.\n\
6697 t: Draws major ticks.\n\
6698 u: If this is specified, the text label for the axis is\n\
6699 written under the axis.\n\
6700\n\
6701\n\
6702 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6703 the text label for the x axis. It is only drawn if u is in the\n\
6704 xopt string.\n\
6705\n\
6706 xtick (PLFLT, input) : World coordinate interval between major\n\
6707 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6708 generates a suitable tick interval.\n\
6709\n\
6710 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6711 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6712 generates a suitable minor tick interval.\n\
6713\n\
6714 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6715 options for the y axis. The string is interpreted in the same way\n\
6716 as xopt.\n\
6717\n\
6718 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6719 the text label for the y axis. It is only drawn if u is in the\n\
6720 yopt string.\n\
6721\n\
6722 ytick (PLFLT, input) : World coordinate interval between major\n\
6723 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6724 generates a suitable tick interval.\n\
6725\n\
6726 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6727 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6728 generates a suitable minor tick interval.\n\
6729\n\
6730 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6731 options for the z axis. The string can include any combination of\n\
6732 the following letters (upper or lower case) in any order: b: Draws\n\
6733 z axis to the left of the surface plot.\n\
6734 c: Draws z axis to the right of the surface plot.\n\
6735 d: Draws grid lines parallel to the x-y plane behind the\n\
6736 figure. These lines are not drawn until after plot3d or\n\
6737 plmesh are called because of the need for hidden line removal.\n\
6738 e: Plot labels as date / time. Values are assumed to be\n\
6739 seconds since the epoch (as used by gmtime). Note this\n\
6740 suboption is interpreted the same as the d suboption for xopt\n\
6741 and yopt, but it has to be identified as e for zopt since d\n\
6742 has already been used for the different purpose above.\n\
6743 f: Always use fixed point numeric labels.\n\
6744 i: Inverts tick marks, so they are drawn away from the center.\n\
6745 l: Labels axis logarithmically. This only affects the labels,\n\
6746 not the data, and so it is necessary to compute the logarithms\n\
6747 of data points before passing them to any of the drawing\n\
6748 routines.\n\
6749 m: Writes numeric labels at major tick intervals on the\n\
6750 right-hand z axis.\n\
6751 n: Writes numeric labels at major tick intervals on the\n\
6752 left-hand z axis.\n\
6753 o: Use custom labelling function to generate axis label text.\n\
6754 The custom labelling function can be defined with the\n\
6755 plslabelfunc command.\n\
6756 s: Enables subticks between major ticks, only valid if t is\n\
6757 also specified.\n\
6758 t: Draws major ticks.\n\
6759 u: If this is specified, the text label is written beside the\n\
6760 left-hand axis.\n\
6761 v: If this is specified, the text label is written beside the\n\
6762 right-hand axis.\n\
6763\n\
6764\n\
6765 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6766 the text label for the z axis. It is only drawn if u or v are in\n\
6767 the zopt string.\n\
6768\n\
6769 ztick (PLFLT, input) : World coordinate interval between major\n\
6770 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6771 generates a suitable tick interval.\n\
6772\n\
6773 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6774 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6775 generates a suitable minor tick interval.\n\
6776";
6777static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6778Set character size\n\
6779\n\
6780DESCRIPTION:\n\
6781\n\
6782 This sets up the size of all subsequent characters drawn. The actual\n\
6783 height of a character is the product of the default character size and\n\
6784 a scaling factor.\n\
6785\n\
6786 Redacted form: plschr(def, scale)\n\
6787\n\
6788 This function is used in examples 2, 13, 23, and 24.\n\
6789\n\
6790\n\
6791\n\
6792SYNOPSIS:\n\
6793\n\
6794plschr(def, scale)\n\
6795\n\
6796ARGUMENTS:\n\
6797\n\
6798 def (PLFLT, input) : The default height of a character in\n\
6799 millimeters, should be set to zero if the default height is to\n\
6800 remain unchanged. For rasterized drivers the dx and dy values\n\
6801 specified in plspage are used to convert from mm to pixels (note\n\
6802 the different unit systems used). This dpi aware scaling is not\n\
6803 implemented for all drivers yet.\n\
6804\n\
6805 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6806 actual character height.\n\
6807";
6808static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6809Calculate continuous time from broken-down time for the current stream\n\
6810\n\
6811DESCRIPTION:\n\
6812\n\
6813 Calculate continuous time, ctime, from broken-down time for the\n\
6814 current stream. The broken-down\n\
6815 time is specified by the following parameters: year, month, day, hour,\n\
6816 min, and sec. This function is the inverse of plbtime.\n\
6817\n\
6818 The PLplot definition of broken-down time is a calendar time that\n\
6819 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6820 responsibility to apply those offsets (if so desired) before using the\n\
6821 PLplot time API. By default broken-down time is defined using the\n\
6822 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6823 continuous time is defined as the number of seconds since the Unix\n\
6824 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6825 broken-down and continuous time are possible, see plconfigtime which\n\
6826 specifies that transformation for the current stream.\n\
6827\n\
6828 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6829 ctime)\n\
6830\n\
6831\n\
6832 This function is used in example 29.\n\
6833\n\
6834\n\
6835\n\
6836SYNOPSIS:\n\
6837\n\
6838plctime(year, month, day, hour, min, sec, ctime)\n\
6839\n\
6840ARGUMENTS:\n\
6841\n\
6842 year (PLINT, input) : Input year.\n\
6843\n\
6844 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6845 (December).\n\
6846\n\
6847 day (PLINT, input) : Input day in range from 1 to 31.\n\
6848\n\
6849 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6850\n\
6851 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6852\n\
6853 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6854\n\
6855 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6856 time calculated from the broken-down time specified by the\n\
6857 previous parameters.\n\
6858";
6859static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6860Set color, cmap0\n\
6861\n\
6862DESCRIPTION:\n\
6863\n\
6864 Sets the color index for cmap0 (see the PLplot documentation).\n\
6865\n\
6866 Redacted form: plcol0(icol0)\n\
6867\n\
6868 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6869\n\
6870\n\
6871\n\
6872SYNOPSIS:\n\
6873\n\
6874plcol0(icol0)\n\
6875\n\
6876ARGUMENTS:\n\
6877\n\
6878 icol0 (PLINT, input) : Integer representing the color. The\n\
6879 defaults at present are (these may change):\n\
6880 0 black (default background)\n\
6881 1 red (default foreground)\n\
6882 2 yellow\n\
6883 3 green\n\
6884 4 aquamarine\n\
6885 5 pink\n\
6886 6 wheat\n\
6887 7 grey\n\
6888 8 brown\n\
6889 9 blue\n\
6890 10 BlueViolet\n\
6891 11 cyan\n\
6892 12 turquoise\n\
6893 13 magenta\n\
6894 14 salmon\n\
6895 15 white\n\
6896\n\
6897 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6898 change an individual color in the cmap0 color palette.\n\
6899";
6900static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6901Set color, cmap1\n\
6902\n\
6903DESCRIPTION:\n\
6904\n\
6905 Sets the color for cmap1 (see the PLplot documentation).\n\
6906\n\
6907 Redacted form: plcol1(col1)\n\
6908\n\
6909 This function is used in examples 12 and 21.\n\
6910\n\
6911\n\
6912\n\
6913SYNOPSIS:\n\
6914\n\
6915plcol1(col1)\n\
6916\n\
6917ARGUMENTS:\n\
6918\n\
6919 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6920 is mapped to color using the continuous cmap1 palette which by\n\
6921 default ranges from blue to the background color to red. The\n\
6922 cmap1 palette can also be straightforwardly changed by the user\n\
6923 with plscmap1 or plscmap1l.\n\
6924";
6925static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6926Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6927\n\
6928DESCRIPTION:\n\
6929\n\
6930 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6931\n\
6932 Redacted form: plgcolbg(r, g, b)\n\
6933\n\
6934 This function is used in example 31.\n\
6935\n\
6936\n\
6937\n\
6938SYNOPSIS:\n\
6939\n\
6940plgcolbg(r, g, b)\n\
6941\n\
6942ARGUMENTS:\n\
6943\n\
6944 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6945 in the range from 0 to 255.\n\
6946\n\
6947 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6948 in the range from 0 to 255.\n\
6949\n\
6950 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6951 in the range from 0 to 255.\n\
6952";
6953static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6954Draw a circular or elliptical arc\n\
6955\n\
6956DESCRIPTION:\n\
6957\n\
6958 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6959 semiminor axis b, starting at angle1 and ending at angle2.\n\
6960\n\
6961 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6962 fill)\n\
6963\n\
6964\n\
6965 This function is used in examples 3 and 27.\n\
6966\n\
6967\n\
6968\n\
6969SYNOPSIS:\n\
6970\n\
6971plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6972\n\
6973ARGUMENTS:\n\
6974\n\
6975 x (PLFLT, input) : X coordinate of arc center.\n\
6976\n\
6977 y (PLFLT, input) : Y coordinate of arc center.\n\
6978\n\
6979 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6980\n\
6981 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6982\n\
6983 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6984 semimajor axis.\n\
6985\n\
6986 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6987 semimajor axis.\n\
6988\n\
6989 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6990 X-axis.\n\
6991\n\
6992 fill (PLBOOL, input) : Draw a filled arc.\n\
6993";
6994static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6995Parse command-line arguments\n\
6996\n\
6997DESCRIPTION:\n\
6998\n\
6999 Parse command-line arguments.\n\
7000\n\
7001 plparseopts removes all recognized flags (decreasing argc\n\
7002 accordingly), so that invalid input may be readily detected. It can\n\
7003 also be used to process user command line flags. The user can merge\n\
7004 an option table of type PLOptionTable into the internal option table\n\
7005 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7006 the external table(s) be parsed by calling plClearOpts before\n\
7007 plMergeOpts.\n\
7008\n\
7009 The default action taken by plparseopts is as follows:\n\
7010 Returns with an error if an unrecognized option or badly formed\n\
7011 option-value pair are encountered.\n\
7012 Returns immediately (return code 0) when the first non-option command\n\
7013 line argument is found.\n\
7014 Returns with the return code of the option handler, if one was called.\n\
7015\n\
7016 Deletes command line arguments from argv list as they are found, and\n\
7017 decrements argc accordingly.\n\
7018 Does not show \"invisible\" options in usage or help messages.\n\
7019 Assumes the program name is contained in argv[0].\n\
7020\n\
7021 These behaviors may be controlled through the\n\
7022 mode argument.\n\
7023\n\
7024 Redacted form: General: plparseopts(argv, mode)\n\
7025\n\
7026\n\
7027 This function is used in all of the examples.\n\
7028\n\
7029\n\
7030\n\
7031SYNOPSIS:\n\
7032\n\
7033PLINT plparseopts(p_argc, argv, mode)\n\
7034\n\
7035ARGUMENTS:\n\
7036\n\
7037 p_argc (int *, input/output) : Number of arguments.\n\
7038\n\
7039 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7040 strings containing *p_argc command-line arguments.\n\
7041\n\
7042 mode (PLINT, input) : Parsing mode with the following\n\
7043 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7044 and all error messages enabled, including program exit when an\n\
7045 error occurs. Anything on the command line that isn\'t recognized\n\
7046 as a valid option or option argument is flagged as an error.\n\
7047 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7048 of errors.\n\
7049 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7050 arguments.\n\
7051 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7052 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7053 pointer to the program name.\n\
7054 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7055 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7056 unrecognized arguments.\n\
7057";
7058static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
7059Get parameters that define current device-space window\n\
7060\n\
7061DESCRIPTION:\n\
7062\n\
7063 Get relative margin width, aspect ratio, and relative justification\n\
7064 that define current device-space window. If plsdidev has not been\n\
7065 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7066 p_jy will all be 0.\n\
7067\n\
7068 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7069\n\
7070 This function is used in example 31.\n\
7071\n\
7072\n\
7073\n\
7074SYNOPSIS:\n\
7075\n\
7076plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7077\n\
7078ARGUMENTS:\n\
7079\n\
7080 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7081 margin width.\n\
7082\n\
7083 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7084 ratio.\n\
7085\n\
7086 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7087 justification in x.\n\
7088\n\
7089 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7090 justification in y.\n\
7091";
7092static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7093Assign a function to use for generating custom axis labels\n\
7094\n\
7095DESCRIPTION:\n\
7096\n\
7097 This function allows a user to provide their own function to provide\n\
7098 axis label text. The user function is given the numeric value for a\n\
7099 point on an axis and returns a string label to correspond with that\n\
7100 value. Custom axis labels can be enabled by passing appropriate\n\
7101 arguments to plenv, plbox, plbox3 and similar functions.\n\
7102\n\
7103 This function is used in example 19.\n\
7104\n\
7105\n\
7106\n\
7107SYNOPSIS:\n\
7108\n\
7109plslabelfunc(label_func, label_data)\n\
7110\n\
7111ARGUMENTS:\n\
7112\n\
7113 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7114 label function. In order to reset to the default labelling, set\n\
7115 this to NULL. The labelling function parameters are, in order:\n\
7116 axis: This indicates which axis a label is being requested for.\n\
7117 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7118\n\
7119 value: This is the value along the axis which is being labelled.\n\
7120\n\
7121 label_text: The string representation of the label value.\n\
7122\n\
7123 length: The maximum length in characters allowed for label_text.\n\
7124\n\
7125\n\
7126 label_data (PLPointer, input) : This parameter may be used to pass\n\
7127 data to the label_func function.\n\
7128";
7129static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7130Get the (current) run level\n\
7131\n\
7132DESCRIPTION:\n\
7133\n\
7134 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7135 1, initialized\n\
7136 2, viewport defined\n\
7137 3, world coordinates defined\n\
7138\n\
7139\n\
7140 Redacted form: plglevel(p_level)\n\
7141\n\
7142 This function is used in example 31.\n\
7143\n\
7144\n\
7145\n\
7146SYNOPSIS:\n\
7147\n\
7148plglevel(p_level)\n\
7149\n\
7150ARGUMENTS:\n\
7151\n\
7152 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7153 level.\n\
7154";
7155static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7156Select line style\n\
7157\n\
7158DESCRIPTION:\n\
7159\n\
7160 This sets the line style according to one of eight predefined patterns\n\
7161 (also see plstyl).\n\
7162\n\
7163 Redacted form: pllsty(lin)\n\
7164\n\
7165 This function is used in examples 9, 12, 22, and 25.\n\
7166\n\
7167\n\
7168\n\
7169SYNOPSIS:\n\
7170\n\
7171pllsty(lin)\n\
7172\n\
7173ARGUMENTS:\n\
7174\n\
7175 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7176 a continuous line, line style 2 is a line with short dashes and\n\
7177 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7178 4 has long dashes and short gaps and so on.\n\
7179";
7180static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7181Set up standard window and draw box\n\
7182\n\
7183DESCRIPTION:\n\
7184\n\
7185 Sets up plotter environment for simple graphs by calling pladv and\n\
7186 setting up viewport and window to sensible default values. plenv\n\
7187 leaves a standard margin (left-hand margin of eight character heights,\n\
7188 and a margin around the other three sides of five character heights)\n\
7189 around most graphs for axis labels and a title. When these defaults\n\
7190 are not suitable, use the individual routines plvpas, plvpor, or\n\
7191 plvasp for setting up the viewport, plwind for defining the window,\n\
7192 and plbox for drawing the box.\n\
7193\n\
7194 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7195\n\
7196 This function is used in example 1,3,9,13,14,19-22,29.\n\
7197\n\
7198\n\
7199\n\
7200SYNOPSIS:\n\
7201\n\
7202plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7203\n\
7204ARGUMENTS:\n\
7205\n\
7206 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7207 world coordinates).\n\
7208\n\
7209 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7210 world coordinates).\n\
7211\n\
7212 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7213 coordinates).\n\
7214\n\
7215 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7216 coordinates).\n\
7217\n\
7218 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7219 scales will not be set, the user must set up the scale before\n\
7220 calling plenv using plsvpa, plvasp or other.\n\
7221 0: the x and y axes are scaled independently to use as much of\n\
7222 the screen as possible.\n\
7223 1: the scales of the x and y axes are made equal.\n\
7224 2: the axis of the x and y axes are made equal, and the plot\n\
7225 box will be square.\n\
7226\n\
7227\n\
7228 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7229 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7230 -1: draw box only.\n\
7231 0: draw box, ticks, and numeric tick labels.\n\
7232 1: also draw coordinate axes at x=0 and y=0.\n\
7233 2: also draw a grid at major tick positions in both\n\
7234 coordinates.\n\
7235 3: also draw a grid at minor tick positions in both\n\
7236 coordinates.\n\
7237 10: same as 0 except logarithmic x tick marks. (The x data\n\
7238 have to be converted to logarithms separately.)\n\
7239 11: same as 1 except logarithmic x tick marks. (The x data\n\
7240 have to be converted to logarithms separately.)\n\
7241 12: same as 2 except logarithmic x tick marks. (The x data\n\
7242 have to be converted to logarithms separately.)\n\
7243 13: same as 3 except logarithmic x tick marks. (The x data\n\
7244 have to be converted to logarithms separately.)\n\
7245 20: same as 0 except logarithmic y tick marks. (The y data\n\
7246 have to be converted to logarithms separately.)\n\
7247 21: same as 1 except logarithmic y tick marks. (The y data\n\
7248 have to be converted to logarithms separately.)\n\
7249 22: same as 2 except logarithmic y tick marks. (The y data\n\
7250 have to be converted to logarithms separately.)\n\
7251 23: same as 3 except logarithmic y tick marks. (The y data\n\
7252 have to be converted to logarithms separately.)\n\
7253 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7254 and y data have to be converted to logarithms separately.)\n\
7255 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7256 and y data have to be converted to logarithms separately.)\n\
7257 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7258 and y data have to be converted to logarithms separately.)\n\
7259 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7260 and y data have to be converted to logarithms separately.)\n\
7261 40: same as 0 except date / time x labels.\n\
7262 41: same as 1 except date / time x labels.\n\
7263 42: same as 2 except date / time x labels.\n\
7264 43: same as 3 except date / time x labels.\n\
7265 50: same as 0 except date / time y labels.\n\
7266 51: same as 1 except date / time y labels.\n\
7267 52: same as 2 except date / time y labels.\n\
7268 53: same as 3 except date / time y labels.\n\
7269 60: same as 0 except date / time x and y labels.\n\
7270 61: same as 1 except date / time x and y labels.\n\
7271 62: same as 2 except date / time x and y labels.\n\
7272 63: same as 3 except date / time x and y labels.\n\
7273 70: same as 0 except custom x and y labels.\n\
7274 71: same as 1 except custom x and y labels.\n\
7275 72: same as 2 except custom x and y labels.\n\
7276 73: same as 3 except custom x and y labels.\n\
7277";
7278static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7279Initialization\n\
7280\n\
7281DESCRIPTION:\n\
7282\n\
7283 Alternative to plstar for initializing the plotting package. The\n\
7284 device name keyword for the desired output device must be supplied as\n\
7285 an argument. These keywords are the same as those printed out by\n\
7286 plstar. If the requested device is not available, or if the input\n\
7287 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7288 is used. This routine also divides the output device page into nx by\n\
7289 ny subpages, each of which may be used independently. The subroutine\n\
7290 pladv is used to advance from one subpage to the next.\n\
7291\n\
7292 Redacted form: General: plstart(devname, nx, ny)\n\
7293\n\
7294\n\
7295 This function is not used in any examples.\n\
7296\n\
7297\n\
7298\n\
7299SYNOPSIS:\n\
7300\n\
7301plstart(devname, nx, ny)\n\
7302\n\
7303ARGUMENTS:\n\
7304\n\
7305 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7306 containing the device name keyword of the required output device.\n\
7307 If\n\
7308 devname is NULL or if the first character of the string is a ``?\'\',\n\
7309 the normal (prompted) start up is used.\n\
7310\n\
7311 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7312 x direction.\n\
7313\n\
7314 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7315 y direction.\n\
7316";
7317static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7318Plot a glyph at the specified points\n\
7319\n\
7320DESCRIPTION:\n\
7321\n\
7322 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7323 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7324 is specified with a PLplot user string. Note that the user string is\n\
7325 not actually limited to one glyph so it is possible (but not normally\n\
7326 useful) to plot more than one glyph at the specified points with this\n\
7327 function. As with plmtex and plptex, the user string can contain FCI\n\
7328 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7329 else PLplot escapes for Hershey or unicode text to determine the\n\
7330 glyph.\n\
7331\n\
7332 Redacted form: plstring(x, y, string)\n\
7333\n\
7334 This function is used in examples 4, 21 and 26.\n\
7335\n\
7336\n\
7337\n\
7338SYNOPSIS:\n\
7339\n\
7340plstring(n, x, y, string)\n\
7341\n\
7342ARGUMENTS:\n\
7343\n\
7344 n (PLINT, input) : Number of points in the x and y vectors.\n\
7345\n\
7346 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7347 the points.\n\
7348\n\
7349 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7350 the points.\n\
7351\n\
7352 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7353 the glyph(s) to be plotted at each of the n points.\n\
7354";
7355static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7356Write text relative to viewport boundaries in 3D plots\n\
7357\n\
7358DESCRIPTION:\n\
7359\n\
7360 Writes text at a specified position relative to the viewport\n\
7361 boundaries. Text may be written inside or outside the viewport, but\n\
7362 is clipped at the subpage boundaries. The reference point of a string\n\
7363 lies along a line passing through the string at half the height of a\n\
7364 capital letter. The position of the reference point along this line\n\
7365 is determined by just, and the position of the reference point\n\
7366 relative to the viewport is set by disp and pos.\n\
7367\n\
7368 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7369\n\
7370 This function is used in example 28.\n\
7371\n\
7372\n\
7373\n\
7374SYNOPSIS:\n\
7375\n\
7376plmtex3(side, disp, pos, just, text)\n\
7377\n\
7378ARGUMENTS:\n\
7379\n\
7380 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7381 the side of the viewport along which the text is to be written.\n\
7382 The string should contain one or more of the following characters:\n\
7383 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7384 only label the X axis, not both the X and Y axes. x: Label the X\n\
7385 axis.\n\
7386 y: Label the Y axis.\n\
7387 z: Label the Z axis.\n\
7388 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7389 For X it is the axis that starts at y-min. For Y it is the\n\
7390 axis that starts at x-min.\n\
7391 s: Label the secondary axis.\n\
7392 v: Draw the text perpendicular to the axis.\n\
7393\n\
7394\n\
7395 disp (PLFLT, input) : Position of the reference point of string,\n\
7396 measured outwards from the specified viewport edge in units of the\n\
7397 current character height. Use negative disp to write within the\n\
7398 viewport.\n\
7399\n\
7400 pos (PLFLT, input) : Position of the reference point of string\n\
7401 along the specified edge, expressed as a fraction of the length of\n\
7402 the edge.\n\
7403\n\
7404 just (PLFLT, input) : Specifies the position of the string relative\n\
7405 to its reference point. If just=0. , the reference point is at\n\
7406 the left and if just=1. , it is at the right of the string. Other\n\
7407 values of just give intermediate justifications.\n\
7408\n\
7409 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7410 written out.\n\
7411";
7412static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7413Get plot orientation\n\
7414\n\
7415DESCRIPTION:\n\
7416\n\
7417 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7418 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7419 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7420 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7421 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7422 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7423 not been called the default value pointed to by p_rot will be 0.\n\
7424\n\
7425 Redacted form: plgdiori(p_rot)\n\
7426\n\
7427 This function is not used in any examples.\n\
7428\n\
7429\n\
7430\n\
7431SYNOPSIS:\n\
7432\n\
7433plgdiori(p_rot)\n\
7434\n\
7435ARGUMENTS:\n\
7436\n\
7437 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7438 parameter.\n\
7439";
7440static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7441Simple routine to write labels\n\
7442\n\
7443DESCRIPTION:\n\
7444\n\
7445 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7446\n\
7447 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7448\n\
7449 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7450\n\
7451\n\
7452\n\
7453SYNOPSIS:\n\
7454\n\
7455pllab(xlabel, ylabel, tlabel)\n\
7456\n\
7457ARGUMENTS:\n\
7458\n\
7459 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7460 the label for the x axis.\n\
7461\n\
7462 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7463 the label for the y axis.\n\
7464\n\
7465 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7466 the title of the plot.\n\
7467";
7468static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7469Switch to text screen\n\
7470\n\
7471DESCRIPTION:\n\
7472\n\
7473 Sets an interactive device to text mode, used in conjunction with\n\
7474 plgra to allow graphics and text to be interspersed. On a device\n\
7475 which supports separate text and graphics windows, this command causes\n\
7476 control to be switched to the text window. This can be useful for\n\
7477 printing diagnostic messages or getting user input, which would\n\
7478 otherwise interfere with the plots. The program must switch back to\n\
7479 the graphics window before issuing plot commands, as the text (or\n\
7480 console) device will probably become quite confused otherwise. If\n\
7481 already in text mode, this command is ignored. It is also ignored on\n\
7482 devices which only support a single window or use a different method\n\
7483 for shifting focus (see also plgra).\n\
7484\n\
7485 Redacted form: pltext()\n\
7486\n\
7487 This function is used in example 1.\n\
7488\n\
7489\n\
7490\n\
7491SYNOPSIS:\n\
7492\n\
7493pltext()\n\
7494";
7495static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7496Plot all or a subset of Shapefile data using lines in world coordinates\n\
7497\n\
7498DESCRIPTION:\n\
7499\n\
7500 Plot all or a subset of Shapefile data using lines in world\n\
7501 coordinates. Our 19th standard example demonstrates how to use this\n\
7502 function. This function plots data from a Shapefile using lines as in\n\
7503 plmap, however it also has the option of also only drawing specified\n\
7504 elements from the Shapefile. The vector of indices of the required\n\
7505 elements are passed as a function argument. The Shapefile data should\n\
7506 include a metadata file (extension.dbf) listing all items within the\n\
7507 Shapefile. This file can be opened by most popular spreadsheet\n\
7508 programs and can be used to decide which indices to pass to this\n\
7509 function.\n\
7510\n\
7511 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7512 plotentries)\n\
7513\n\
7514 This function is used in example 19.\n\
7515\n\
7516\n\
7517\n\
7518SYNOPSIS:\n\
7519\n\
7520plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7521\n\
7522ARGUMENTS:\n\
7523\n\
7524 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7525 transform the coordinates given in the shapefile into a plot\n\
7526 coordinate system. By using this transform, we can change from a\n\
7527 longitude, latitude coordinate to a polar stereographic project,\n\
7528 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7529 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7530 mapform(), x[] and y[] should be replaced by the corresponding\n\
7531 plot coordinates. If no transform is desired, mapform can be\n\
7532 replaced by NULL.\n\
7533\n\
7534 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7535 the file name of a set of Shapefile files without the file\n\
7536 extension.\n\
7537\n\
7538 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7539 be in the same units as used by the Shapefile. You could use a\n\
7540 very large negative number to plot everything, but you can improve\n\
7541 performance by limiting the area drawn. The units must match those\n\
7542 of the Shapefile projection, which may be for example longitude or\n\
7543 distance. The value of minx must be less than the value of maxx.\n\
7544\n\
7545 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7546 use a very large number to plot everything, but you can improve\n\
7547 performance by limiting the area drawn.\n\
7548\n\
7549 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7550 be in the same units as used by the Shapefile. You could use a\n\
7551 very large negative number to plot everything, but you can improve\n\
7552 performance by limiting the area drawn. The units must match those\n\
7553 of the Shapefile projection, which may be for example latitude or\n\
7554 distance. The value of miny must be less than the value of maxy.\n\
7555\n\
7556 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7557 use a very large number to plot everything, but you can improve\n\
7558 performance by limiting the area drawn.\n\
7559\n\
7560 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7561 zero-based indices of the Shapefile elements which will be drawn.\n\
7562 Setting\n\
7563 plotentries to NULL will plot all elements of the Shapefile.\n\
7564\n\
7565 nplotentries (PLINT, input) : The number of items in\n\
7566 plotentries. Ignored if\n\
7567 plotentries is NULL.\n\
7568";
7569static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7570Set precision in numeric labels\n\
7571\n\
7572DESCRIPTION:\n\
7573\n\
7574 Sets the number of places after the decimal point in numeric labels.\n\
7575\n\
7576 Redacted form: plprec(setp, prec)\n\
7577\n\
7578 This function is used in example 29.\n\
7579\n\
7580\n\
7581\n\
7582SYNOPSIS:\n\
7583\n\
7584plprec(setp, prec)\n\
7585\n\
7586ARGUMENTS:\n\
7587\n\
7588 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7589 automatically determines the number of places to use after the\n\
7590 decimal point in numeric labels (like those used to label axes).\n\
7591 If setp is 1 then prec sets the number of places.\n\
7592\n\
7593 prec (PLINT, input) : The number of characters to draw after the\n\
7594 decimal point in numeric labels.\n\
7595";
7596static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7597Draw a line between two points\n\
7598\n\
7599DESCRIPTION:\n\
7600\n\
7601 Joins the point (\n\
7602 x1,\n\
7603 y1) to (\n\
7604 x2,\n\
7605 y2).\n\
7606\n\
7607 Redacted form: pljoin(x1,y1,x2,y2)\n\
7608\n\
7609 This function is used in examples 3 and 14.\n\
7610\n\
7611\n\
7612\n\
7613SYNOPSIS:\n\
7614\n\
7615pljoin(x1, y1, x2, y2)\n\
7616\n\
7617ARGUMENTS:\n\
7618\n\
7619 x1 (PLFLT, input) : x coordinate of first point.\n\
7620\n\
7621 y1 (PLFLT, input) : y coordinate of first point.\n\
7622\n\
7623 x2 (PLFLT, input) : x coordinate of second point.\n\
7624\n\
7625 y2 (PLFLT, input) : y coordinate of second point.\n\
7626";
7627static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7628Set the device (keyword) name\n\
7629\n\
7630DESCRIPTION:\n\
7631\n\
7632 Set the device (keyword) name.\n\
7633\n\
7634 Redacted form: plsdev(devname)\n\
7635\n\
7636 This function is used in examples 1, 14, and 20.\n\
7637\n\
7638\n\
7639\n\
7640SYNOPSIS:\n\
7641\n\
7642plsdev(devname)\n\
7643\n\
7644ARGUMENTS:\n\
7645\n\
7646 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7647 containing the device name keyword of the required output device.\n\
7648 If\n\
7649 devname is NULL or if the first character of the string is a ``?\'\',\n\
7650 the normal (prompted) start up is used.\n\
7651";
7652static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7653Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7654\n\
7655DESCRIPTION:\n\
7656\n\
7657 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7658 (see the PLplot documentation) index. Overwrites the previous color\n\
7659 value for the given index and, thus, does not result in any additional\n\
7660 allocation of space for colors.\n\
7661\n\
7662 This function is used in example 30.\n\
7663\n\
7664\n\
7665\n\
7666SYNOPSIS:\n\
7667\n\
7668plscol0a(icol0, r, g, b, alpha)\n\
7669\n\
7670ARGUMENTS:\n\
7671\n\
7672 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7673 number of colors (which is set by default, by plscmap0n, or even\n\
7674 by plscmap0).\n\
7675\n\
7676 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7677 degree of red in the color.\n\
7678\n\
7679 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7680 degree of green in the color.\n\
7681\n\
7682 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7683 degree of blue in the color.\n\
7684\n\
7685 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7686 (0.0-1.0).\n\
7687";
7688static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7689Draw filled polygon in 3D\n\
7690\n\
7691DESCRIPTION:\n\
7692\n\
7693 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7694 vectors using the pattern defined by plpsty or plpat. The routine\n\
7695 will automatically close the polygon between the last and first\n\
7696 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7697 plfill3 will fill in between them.\n\
7698\n\
7699 Redacted form: General: plfill3(x, y, z)\n\
7700\n\
7701\n\
7702 This function is used in example 15.\n\
7703\n\
7704\n\
7705\n\
7706SYNOPSIS:\n\
7707\n\
7708plfill3(n, x, y, z)\n\
7709\n\
7710ARGUMENTS:\n\
7711\n\
7712 n (PLINT, input) : Number of vertices in polygon.\n\
7713\n\
7714 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7715 vertices.\n\
7716\n\
7717 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7718 vertices.\n\
7719\n\
7720 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7721 vertices.\n\
7722";
7723static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7724Specify window\n\
7725\n\
7726DESCRIPTION:\n\
7727\n\
7728 Specify the window, i.e., the world coordinates of the edges of the\n\
7729 viewport.\n\
7730\n\
7731 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7732\n\
7733 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7734 29, and 31.\n\
7735\n\
7736\n\
7737\n\
7738SYNOPSIS:\n\
7739\n\
7740plwind(xmin, xmax, ymin, ymax)\n\
7741\n\
7742ARGUMENTS:\n\
7743\n\
7744 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7745 of the viewport.\n\
7746\n\
7747 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7748 of the viewport.\n\
7749\n\
7750 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7751 the viewport.\n\
7752\n\
7753 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7754 viewport.\n\
7755";
7756static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7757Draw text at points defined by Shapefile data in world coordinates\n\
7758\n\
7759DESCRIPTION:\n\
7760\n\
7761 As per plmapline, however the items are plotted as text in the same\n\
7762 way as plptex.\n\
7763\n\
7764 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7765 miny, maxy, plotentry)\n\
7766\n\
7767 This function is used in example 19.\n\
7768\n\
7769\n\
7770\n\
7771SYNOPSIS:\n\
7772\n\
7773plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7774\n\
7775ARGUMENTS:\n\
7776\n\
7777 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7778 transform the coordinates given in the shapefile into a plot\n\
7779 coordinate system. By using this transform, we can change from a\n\
7780 longitude, latitude coordinate to a polar stereographic project,\n\
7781 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7782 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7783 mapform(), x[] and y[] should be replaced by the corresponding\n\
7784 plot coordinates. If no transform is desired, mapform can be\n\
7785 replaced by NULL.\n\
7786\n\
7787 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7788 the file name of a set of Shapefile files without the file\n\
7789 extension.\n\
7790\n\
7791 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7792 dy/dx.\n\
7793\n\
7794 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7795 dy/dx.\n\
7796\n\
7797 just (PLFLT, input) : Set the justification of the text. The value\n\
7798 given will be the fraction of the distance along the string that\n\
7799 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7800 centralized text and 1.0 gives right aligned text.\n\
7801\n\
7802 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7803\n\
7804 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7805 be in the same units as used by the Shapefile. You could use a\n\
7806 very large negative number to plot everything, but you can improve\n\
7807 performance by limiting the area drawn. The units must match those\n\
7808 of the Shapefile projection, which may be for example longitude or\n\
7809 distance. The value of minx must be less than the value of maxx.\n\
7810\n\
7811 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7812 use a very large number to plot everything, but you can improve\n\
7813 performance by limiting the area drawn.\n\
7814\n\
7815 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7816 be in the same units as used by the Shapefile. You could use a\n\
7817 very large negative number to plot everything, but you can improve\n\
7818 performance by limiting the area drawn. The units must match those\n\
7819 of the Shapefile projection, which may be for example latitude or\n\
7820 distance. The value of miny must be less than the value of maxy.\n\
7821\n\
7822 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7823 use a very large number to plot everything, but you can improve\n\
7824 performance by limiting the area drawn.\n\
7825\n\
7826 plotentry (PLINT, input) : An integer indicating which text string\n\
7827 of the Shapefile (zero indexed) will be drawn.\n\
7828";
7829static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7830Switch to graphics screen\n\
7831\n\
7832DESCRIPTION:\n\
7833\n\
7834 Sets an interactive device to graphics mode, used in conjunction with\n\
7835 pltext to allow graphics and text to be interspersed. On a device\n\
7836 which supports separate text and graphics windows, this command causes\n\
7837 control to be switched to the graphics window. If already in graphics\n\
7838 mode, this command is ignored. It is also ignored on devices which\n\
7839 only support a single window or use a different method for shifting\n\
7840 focus. See also pltext.\n\
7841\n\
7842 Redacted form: plgra()\n\
7843\n\
7844 This function is used in example 1.\n\
7845\n\
7846\n\
7847\n\
7848SYNOPSIS:\n\
7849\n\
7850plgra()\n\
7851";
7852static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7853Set parameters of contour labelling other than format of numerical label\n\
7854\n\
7855DESCRIPTION:\n\
7856\n\
7857 Set parameters of contour labelling other than those handled by\n\
7858 pl_setcontlabelformat.\n\
7859\n\
7860 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7861\n\
7862 This function is used in example 9.\n\
7863\n\
7864\n\
7865\n\
7866SYNOPSIS:\n\
7867\n\
7868pl_setcontlabelparam(offset, size, spacing, active)\n\
7869\n\
7870ARGUMENTS:\n\
7871\n\
7872 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7873 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7874\n\
7875 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7876 Default value is 0.3.\n\
7877\n\
7878 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7879 Default value is 0.1.\n\
7880\n\
7881 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7882 contour labels on. Default is off (0).\n\
7883";
7884static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7885Get family, style and weight of the current font\n\
7886\n\
7887DESCRIPTION:\n\
7888\n\
7889 Gets information about current font. See the PLplot documentation for\n\
7890 more information on font selection.\n\
7891\n\
7892 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7893\n\
7894 This function is used in example 23.\n\
7895\n\
7896\n\
7897\n\
7898SYNOPSIS:\n\
7899\n\
7900plgfont(p_family, p_style, p_weight)\n\
7901\n\
7902ARGUMENTS:\n\
7903\n\
7904 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7905 font family. The available values are given by the PL_FCI_*\n\
7906 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7907 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7908 p_family is NULL then the font family is not returned.\n\
7909\n\
7910 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7911 font style. The available values are given by the PL_FCI_*\n\
7912 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7913 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7914 style is not returned.\n\
7915\n\
7916 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7917 font weight. The available values are given by the PL_FCI_*\n\
7918 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7919 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7920 returned.\n\
7921";
7922static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7923Plot a histogram from unbinned data\n\
7924\n\
7925DESCRIPTION:\n\
7926\n\
7927 Plots a histogram from n data points stored in the data vector. This\n\
7928 routine bins the data into nbin bins equally spaced between datmin and\n\
7929 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7930 opt allows, among other things, the histogram either to be plotted in\n\
7931 an existing window or causes plhist to call plenv with suitable limits\n\
7932 before plotting the histogram.\n\
7933\n\
7934 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7935\n\
7936 This function is used in example 5.\n\
7937\n\
7938\n\
7939\n\
7940SYNOPSIS:\n\
7941\n\
7942plhist(n, data, datmin, datmax, nbin, opt)\n\
7943\n\
7944ARGUMENTS:\n\
7945\n\
7946 n (PLINT, input) : Number of data points.\n\
7947\n\
7948 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7949 n data points.\n\
7950\n\
7951 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7952\n\
7953 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7954\n\
7955 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7956 divide the interval xmin to xmax.\n\
7957\n\
7958 opt (PLINT, input) : Is a combination of several flags:\n\
7959 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7960 the histogram data, the outer bins are expanded to fill up the\n\
7961 entire x-axis, data outside the given extremes are assigned to the\n\
7962 outer bins and bins of zero height are simply drawn.\n\
7963 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7964 to fit the histogram data, without this flag, plenv is called\n\
7965 to set the world coordinates.\n\
7966 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7967 extremes are not taken into account. This option should\n\
7968 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7969 properly present the data.\n\
7970 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7971 size as the ones inside.\n\
7972 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7973 (there is a gap for such bins).\n\
7974";
7975static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7976Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7977\n\
7978DESCRIPTION:\n\
7979\n\
7980 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7981 alpha transparency value.\n\
7982\n\
7983 This function is used in example 31.\n\
7984\n\
7985\n\
7986\n\
7987SYNOPSIS:\n\
7988\n\
7989plgcolbga(r, g, b, alpha)\n\
7990\n\
7991ARGUMENTS:\n\
7992\n\
7993 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7994 in the range from 0 to 255.\n\
7995\n\
7996 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7997 in the range from 0 to 255.\n\
7998\n\
7999 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
8000 in the range from 0 to 255.\n\
8001\n\
8002 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8003 transparency in the range (0.0-1.0).\n\
8004";
8005static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
8006Set orientation\n\
8007\n\
8008DESCRIPTION:\n\
8009\n\
8010 Set integer plot orientation parameter. This function is identical to\n\
8011 plsdiori except for the type of the argument, and should be used in\n\
8012 the same way. See the documentation of plsdiori for details.\n\
8013\n\
8014 Redacted form: plsori(ori)\n\
8015\n\
8016 This function is used in example 3.\n\
8017\n\
8018\n\
8019\n\
8020SYNOPSIS:\n\
8021\n\
8022plsori(ori)\n\
8023\n\
8024ARGUMENTS:\n\
8025\n\
8026 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8027 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8028 angle.\n\
8029";
8030static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
8031Plot latitude and longitude lines\n\
8032\n\
8033DESCRIPTION:\n\
8034\n\
8035 Displays latitude and longitude on the current plot. The lines are\n\
8036 plotted in the current color and line style.\n\
8037\n\
8038 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8039 minlat, maxlat)\n\
8040\n\
8041 This function is used in example 19.\n\
8042\n\
8043\n\
8044\n\
8045SYNOPSIS:\n\
8046\n\
8047plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8048\n\
8049ARGUMENTS:\n\
8050\n\
8051 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8052 transform the coordinate longitudes and latitudes to a plot\n\
8053 coordinate system. By using this transform, we can change from a\n\
8054 longitude, latitude coordinate to a polar stereographic project,\n\
8055 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8056 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8057 mapform(), x[] and y[] should be replaced by the corresponding\n\
8058 plot coordinates. If no transform is desired, mapform can be\n\
8059 replaced by NULL.\n\
8060\n\
8061 dlong (PLFLT, input) : The interval in degrees at which the\n\
8062 longitude lines are to be plotted.\n\
8063\n\
8064 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8065 lines are to be plotted.\n\
8066\n\
8067 minlong (PLFLT, input) : The value of the longitude on the left\n\
8068 side of the plot. The value of minlong must be less than the value\n\
8069 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8070 equal to 360.\n\
8071\n\
8072 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8073 side of the plot.\n\
8074\n\
8075 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8076 background. One can always use -90.0 as the boundary outside the\n\
8077 plot window will be automatically eliminated. However, the\n\
8078 program will be faster if one can reduce the size of the\n\
8079 background plotted.\n\
8080\n\
8081 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8082 background. One can always use 90.0 as the boundary outside the\n\
8083 plot window will be automatically eliminated.\n\
8084";
8085static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8086Clear current (sub)page\n\
8087\n\
8088DESCRIPTION:\n\
8089\n\
8090 Clears the current page, effectively erasing everything that have been\n\
8091 drawn. This command only works with interactive drivers; if the\n\
8092 driver does not support this, the page is filled with the background\n\
8093 color in use. If the current page is divided into subpages, only the\n\
8094 current subpage is erased. The nth subpage can be selected with\n\
8095 pladv(n).\n\
8096\n\
8097 Redacted form: General: plclear()\n\
8098\n\
8099\n\
8100 This function is not used in any examples.\n\
8101\n\
8102\n\
8103\n\
8104SYNOPSIS:\n\
8105\n\
8106plclear()\n\
8107";
8108static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8109Initialization\n\
8110\n\
8111DESCRIPTION:\n\
8112\n\
8113 Initializing the plotting package. The program prompts for the device\n\
8114 keyword or number of the desired output device. Hitting a RETURN in\n\
8115 response to the prompt is the same as selecting the first device. If\n\
8116 only one device is enabled when PLplot is installed, plstar will issue\n\
8117 no prompt. The output device is divided into nx by ny subpages, each\n\
8118 of which may be used independently. The subroutine pladv is used to\n\
8119 advance from one subpage to the next.\n\
8120\n\
8121 Redacted form: plstar(nx, ny)\n\
8122\n\
8123 This function is used in example 1.\n\
8124\n\
8125\n\
8126\n\
8127SYNOPSIS:\n\
8128\n\
8129plstar(nx, ny)\n\
8130\n\
8131ARGUMENTS:\n\
8132\n\
8133 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8134 x direction.\n\
8135\n\
8136 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8137 y direction.\n\
8138";
8139static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8140Write text relative to viewport boundaries\n\
8141\n\
8142DESCRIPTION:\n\
8143\n\
8144 Writes text at a specified position relative to the viewport\n\
8145 boundaries. Text may be written inside or outside the viewport, but\n\
8146 is clipped at the subpage boundaries. The reference point of a string\n\
8147 lies along a line passing through the string at half the height of a\n\
8148 capital letter. The position of the reference point along this line\n\
8149 is determined by just, and the position of the reference point\n\
8150 relative to the viewport is set by disp and pos.\n\
8151\n\
8152 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8153\n\
8154\n\
8155 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8156 26.\n\
8157\n\
8158\n\
8159\n\
8160SYNOPSIS:\n\
8161\n\
8162plmtex(side, disp, pos, just, text)\n\
8163\n\
8164ARGUMENTS:\n\
8165\n\
8166 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8167 the side of the viewport along which the text is to be written.\n\
8168 The string must be one of: b: Bottom of viewport, text written\n\
8169 parallel to edge.\n\
8170 bv: Bottom of viewport, text written at right angles to edge.\n\
8171 l: Left of viewport, text written parallel to edge.\n\
8172 lv: Left of viewport, text written at right angles to edge.\n\
8173 r: Right of viewport, text written parallel to edge.\n\
8174 rv: Right of viewport, text written at right angles to edge.\n\
8175 t: Top of viewport, text written parallel to edge.\n\
8176 tv: Top of viewport, text written at right angles to edge.\n\
8177\n\
8178\n\
8179 disp (PLFLT, input) : Position of the reference point of string,\n\
8180 measured outwards from the specified viewport edge in units of the\n\
8181 current character height. Use negative disp to write within the\n\
8182 viewport.\n\
8183\n\
8184 pos (PLFLT, input) : Position of the reference point of string\n\
8185 along the specified edge, expressed as a fraction of the length of\n\
8186 the edge.\n\
8187\n\
8188 just (PLFLT, input) : Specifies the position of the string relative\n\
8189 to its reference point. If just=0. , the reference point is at\n\
8190 the left and if just=1. , it is at the right of the string. Other\n\
8191 values of just give intermediate justifications.\n\
8192\n\
8193 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8194 written out.\n\
8195";
8196static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8197Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8198\n\
8199DESCRIPTION:\n\
8200\n\
8201 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8202 PLFLT alpha transparency value (see the PLplot documentation).\n\
8203\n\
8204 This function is used in example 31.\n\
8205\n\
8206\n\
8207\n\
8208SYNOPSIS:\n\
8209\n\
8210plscolbga(r, g, b, alpha)\n\
8211\n\
8212ARGUMENTS:\n\
8213\n\
8214 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8215 degree of red in the color.\n\
8216\n\
8217 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8218 degree of green in the color.\n\
8219\n\
8220 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8221 degree of blue in the color.\n\
8222\n\
8223 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8224 (0.0-1.0).\n\
8225";
8226static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8227Replays contents of plot buffer to current device/file\n\
8228\n\
8229DESCRIPTION:\n\
8230\n\
8231 Replays contents of plot buffer to current device/file.\n\
8232\n\
8233 Redacted form: plreplot()\n\
8234\n\
8235 This function is used in example 1,20.\n\
8236\n\
8237\n\
8238\n\
8239SYNOPSIS:\n\
8240\n\
8241plreplot()\n\
8242";
8243static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8244Plot a glyph at the specified 3D points\n\
8245\n\
8246DESCRIPTION:\n\
8247\n\
8248 Plot a glyph at the specified 3D points. (This function is largely\n\
8249 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8250 Set up the call to this function similar to what is done for plline3.\n\
8251 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8252 and a draw at the same place. Not ideal, since a sufficiently\n\
8253 intelligent output device may optimize it away, or there may be faster\n\
8254 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8255 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8256 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8257 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8258 code <= 127 the corresponding printable ASCII character is plotted.\n\
8259\n\
8260 Redacted form: plpoin3(x, y, z, code)\n\
8261\n\
8262 This function is not used in any example.\n\
8263\n\
8264\n\
8265\n\
8266SYNOPSIS:\n\
8267\n\
8268plpoin3(n, x, y, z, code)\n\
8269\n\
8270ARGUMENTS:\n\
8271\n\
8272 n (PLINT, input) : Number of points in the x and y vectors.\n\
8273\n\
8274 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8275 points.\n\
8276\n\
8277 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8278 points.\n\
8279\n\
8280 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8281 points.\n\
8282\n\
8283 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8284 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8285 each of the n points.\n\
8286";
8287static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8288Set family, style and weight of the current font\n\
8289\n\
8290DESCRIPTION:\n\
8291\n\
8292 Sets the current font. See the PLplot documentation for more\n\
8293 information on font selection.\n\
8294\n\
8295 Redacted form: plsfont(family, style, weight)\n\
8296\n\
8297 This function is used in example 23.\n\
8298\n\
8299\n\
8300\n\
8301SYNOPSIS:\n\
8302\n\
8303plsfont(family, style, weight)\n\
8304\n\
8305ARGUMENTS:\n\
8306\n\
8307 family (PLINT, input) : Font family to select for the current font.\n\
8308 The available values are given by the PL_FCI_* constants in\n\
8309 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8310 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8311 signifies that the font family should not be altered.\n\
8312\n\
8313 style (PLINT, input) : Font style to select for the current font.\n\
8314 The available values are given by the PL_FCI_* constants in\n\
8315 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8316 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8317 should not be altered.\n\
8318\n\
8319 weight (PLINT, input) : Font weight to select for the current font.\n\
8320 The available values are given by the PL_FCI_* constants in\n\
8321 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8322 negative value signifies that the font weight should not be\n\
8323 altered.\n\
8324";
8325static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8326Draw a box with axes, etc. with arbitrary origin\n\
8327\n\
8328DESCRIPTION:\n\
8329\n\
8330 Draws a box around the currently defined viewport with arbitrary\n\
8331 world-coordinate origin specified by x0 and y0 and labels it with\n\
8332 world coordinate values appropriate to the window. Thus plaxes should\n\
8333 only be called after defining both viewport and window. The ascii\n\
8334 character strings xopt and yopt specify how the box should be drawn as\n\
8335 described below. If ticks and/or subticks are to be drawn for a\n\
8336 particular axis, the tick intervals and number of subintervals may be\n\
8337 specified explicitly, or they may be defaulted by setting the\n\
8338 appropriate arguments to zero.\n\
8339\n\
8340 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8341 ytick, nysub)\n\
8342\n\
8343\n\
8344 This function is not used in any examples.\n\
8345\n\
8346\n\
8347\n\
8348SYNOPSIS:\n\
8349\n\
8350plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8351\n\
8352ARGUMENTS:\n\
8353\n\
8354 x0 (PLFLT, input) : World X coordinate of origin.\n\
8355\n\
8356 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8357\n\
8358 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8359 options for the x axis. The string can include any combination of\n\
8360 the following letters (upper or lower case) in any order: a: Draws\n\
8361 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8362 (x=0).\n\
8363 b: Draws bottom (X) or left (Y) edge of frame.\n\
8364 c: Draws top (X) or right (Y) edge of frame.\n\
8365 d: Plot labels as date / time. Values are assumed to be\n\
8366 seconds since the epoch (as used by gmtime).\n\
8367 f: Always use fixed point numeric labels.\n\
8368 g: Draws a grid at the major tick interval.\n\
8369 h: Draws a grid at the minor tick interval.\n\
8370 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8371 inwards.\n\
8372 l: Labels axis logarithmically. This only affects the labels,\n\
8373 not the data, and so it is necessary to compute the logarithms\n\
8374 of data points before passing them to any of the drawing\n\
8375 routines.\n\
8376 m: Writes numeric labels at major tick intervals in the\n\
8377 unconventional location (above box for X, right of box for Y).\n\
8378 n: Writes numeric labels at major tick intervals in the\n\
8379 conventional location (below box for X, left of box for Y).\n\
8380 o: Use custom labelling function to generate axis label text.\n\
8381 The custom labelling function can be defined with the\n\
8382 plslabelfunc command.\n\
8383 s: Enables subticks between major ticks, only valid if t is\n\
8384 also specified.\n\
8385 t: Draws major ticks.\n\
8386 u: Exactly like \"b\" except don\'t draw edge line.\n\
8387 w: Exactly like \"c\" except don\'t draw edge line.\n\
8388 x: Exactly like \"t\" (including the side effect of the\n\
8389 numerical labels for the major ticks) except exclude drawing\n\
8390 the major and minor tick marks.\n\
8391\n\
8392\n\
8393 xtick (PLFLT, input) : World coordinate interval between major\n\
8394 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8395 generates a suitable tick interval.\n\
8396\n\
8397 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8398 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8399 generates a suitable minor tick interval.\n\
8400\n\
8401 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8402 options for the y axis. The string can include any combination of\n\
8403 the letters defined above for xopt, and in addition may contain:\n\
8404 v: Write numeric labels for the y axis parallel to the base of the\n\
8405 graph, rather than parallel to the axis.\n\
8406\n\
8407\n\
8408 ytick (PLFLT, input) : World coordinate interval between major\n\
8409 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8410 generates a suitable tick interval.\n\
8411\n\
8412 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8413 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8414 generates a suitable minor tick interval.\n\
8415";
8416static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8417Begin a new page\n\
8418\n\
8419DESCRIPTION:\n\
8420\n\
8421 Begins a new page. For a file driver, the output file is opened if\n\
8422 necessary. Advancing the page via pleop and plbop is useful when a\n\
8423 page break is desired at a particular point when plotting to subpages.\n\
8424 Another use for pleop and plbop is when plotting pages to different\n\
8425 files, since you can manually set the file name by calling plsfnam\n\
8426 after the call to pleop. (In fact some drivers may only support a\n\
8427 single page per file, making this a necessity.) One way to handle\n\
8428 this case automatically is to page advance via pladv, but enable\n\
8429 familying (see plsfam) with a small limit on the file size so that a\n\
8430 new family member file will be created on each page break.\n\
8431\n\
8432 Redacted form: plbop()\n\
8433\n\
8434 This function is used in examples 2 and 20.\n\
8435\n\
8436\n\
8437\n\
8438SYNOPSIS:\n\
8439\n\
8440plbop()\n\
8441";
8442static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8443Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8444\n\
8445DESCRIPTION:\n\
8446\n\
8447 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8448 and PLFLT alpha transparency value. This sets the entire color map --\n\
8449 only as many colors as specified will be allocated.\n\
8450\n\
8451 Redacted form: plscmap0a(r, g, b, alpha)\n\
8452\n\
8453 This function is used in examples 30.\n\
8454\n\
8455\n\
8456\n\
8457SYNOPSIS:\n\
8458\n\
8459plscmap0a(r, g, b, alpha, ncol0)\n\
8460\n\
8461ARGUMENTS:\n\
8462\n\
8463 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8464 integers (0-255) representing the degree of red in the color.\n\
8465\n\
8466 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8467 integers (0-255) representing the degree of green in the color.\n\
8468\n\
8469 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8470 integers (0-255) representing the degree of blue in the color.\n\
8471\n\
8472 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8473 representing the alpha transparency of the color.\n\
8474\n\
8475 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8476 vectors.\n\
8477";
8478static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8479Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8480\n\
8481DESCRIPTION:\n\
8482\n\
8483 This is a variant of plscmap1l that supports alpha channel\n\
8484 transparency. It sets cmap1 colors using a piece-wise linear\n\
8485 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8486 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8487 transparency value (0.0-1.0). It may be called at any time.\n\
8488\n\
8489 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8490 alpha, alt_hue_path)\n\
8491\n\
8492 This function is used in example 30.\n\
8493\n\
8494\n\
8495\n\
8496SYNOPSIS:\n\
8497\n\
8498plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8499\n\
8500ARGUMENTS:\n\
8501\n\
8502 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8503\n\
8504 npts (PLINT, input) : number of control points.\n\
8505\n\
8506 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8507 intensity index (0.0-1.0) in ascending order for each control\n\
8508 point.\n\
8509\n\
8510 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8511 coordinate (H or R) for each control point.\n\
8512\n\
8513 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8514 coordinate (L or G) for each control point.\n\
8515\n\
8516 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8517 coordinate (S or B) for each control point.\n\
8518\n\
8519 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8520 transparency value (0.0-1.0) for each control point.\n\
8521\n\
8522 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8523 npts - 1 elements) containing the alternative interpolation method\n\
8524 Boolean value for each control point interval. (alt_hue_path[i]\n\
8525 refers to the interpolation interval between the i and i + 1\n\
8526 control points).\n\
8527";
8528static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8529Enter or leave xor mode\n\
8530\n\
8531DESCRIPTION:\n\
8532\n\
8533 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8534 those drivers (e.g., the xwin driver) that support it. Enables\n\
8535 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8536 is not capable of xor operation it returns a status of false.\n\
8537\n\
8538 Redacted form: plxormod(mode, status)\n\
8539\n\
8540 This function is used in examples 1 and 20.\n\
8541\n\
8542\n\
8543\n\
8544SYNOPSIS:\n\
8545\n\
8546plxormod(mode, status)\n\
8547\n\
8548ARGUMENTS:\n\
8549\n\
8550 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8551 is false means leave xor mode.\n\
8552\n\
8553 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8554 modestatus of true (false) means driver is capable (incapable) of\n\
8555 xor mode.\n\
8556";
8557static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8558Eject current page\n\
8559\n\
8560DESCRIPTION:\n\
8561\n\
8562 Clears the graphics screen of an interactive device, or ejects a page\n\
8563 on a plotter. See plbop for more information.\n\
8564\n\
8565 Redacted form: pleop()\n\
8566\n\
8567 This function is used in example 2,14.\n\
8568\n\
8569\n\
8570\n\
8571SYNOPSIS:\n\
8572\n\
8573pleop()\n\
8574";
8575static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8576Draw a box with axes, etc\n\
8577\n\
8578DESCRIPTION:\n\
8579\n\
8580 Draws a box around the currently defined viewport, and labels it with\n\
8581 world coordinate values appropriate to the window. Thus plbox should\n\
8582 only be called after defining both viewport and window. The ascii\n\
8583 character strings xopt and yopt specify how the box should be drawn as\n\
8584 described below. If ticks and/or subticks are to be drawn for a\n\
8585 particular axis, the tick intervals and number of subintervals may be\n\
8586 specified explicitly, or they may be defaulted by setting the\n\
8587 appropriate arguments to zero.\n\
8588\n\
8589 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8590\n\
8591\n\
8592 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8593 and 29.\n\
8594\n\
8595\n\
8596\n\
8597SYNOPSIS:\n\
8598\n\
8599plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8600\n\
8601ARGUMENTS:\n\
8602\n\
8603 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8604 options for the x axis. The string can include any combination of\n\
8605 the following letters (upper or lower case) in any order: a: Draws\n\
8606 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8607 (x=0).\n\
8608 b: Draws bottom (X) or left (Y) edge of frame.\n\
8609 c: Draws top (X) or right (Y) edge of frame.\n\
8610 d: Plot labels as date / time. Values are assumed to be\n\
8611 seconds since the epoch (as used by gmtime).\n\
8612 f: Always use fixed point numeric labels.\n\
8613 g: Draws a grid at the major tick interval.\n\
8614 h: Draws a grid at the minor tick interval.\n\
8615 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8616 inwards.\n\
8617 l: Labels axis logarithmically. This only affects the labels,\n\
8618 not the data, and so it is necessary to compute the logarithms\n\
8619 of data points before passing them to any of the drawing\n\
8620 routines.\n\
8621 m: Writes numeric labels at major tick intervals in the\n\
8622 unconventional location (above box for X, right of box for Y).\n\
8623 n: Writes numeric labels at major tick intervals in the\n\
8624 conventional location (below box for X, left of box for Y).\n\
8625 o: Use custom labelling function to generate axis label text.\n\
8626 The custom labelling function can be defined with the\n\
8627 plslabelfunc command.\n\
8628 s: Enables subticks between major ticks, only valid if t is\n\
8629 also specified.\n\
8630 t: Draws major ticks.\n\
8631 u: Exactly like \"b\" except don\'t draw edge line.\n\
8632 w: Exactly like \"c\" except don\'t draw edge line.\n\
8633 x: Exactly like \"t\" (including the side effect of the\n\
8634 numerical labels for the major ticks) except exclude drawing\n\
8635 the major and minor tick marks.\n\
8636\n\
8637\n\
8638 xtick (PLFLT, input) : World coordinate interval between major\n\
8639 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8640 generates a suitable tick interval.\n\
8641\n\
8642 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8643 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8644 generates a suitable minor tick interval.\n\
8645\n\
8646 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8647 options for the y axis. The string can include any combination of\n\
8648 the letters defined above for xopt, and in addition may contain:\n\
8649 v: Write numeric labels for the y axis parallel to the base of the\n\
8650 graph, rather than parallel to the axis.\n\
8651\n\
8652\n\
8653 ytick (PLFLT, input) : World coordinate interval between major\n\
8654 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8655 generates a suitable tick interval.\n\
8656\n\
8657 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8658 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8659 generates a suitable minor tick interval.\n\
8660";
8661static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8662Get x axis parameters\n\
8663\n\
8664DESCRIPTION:\n\
8665\n\
8666 Returns current values of the p_digmax and p_digits flags for the x\n\
8667 axis. p_digits is updated after the plot is drawn, so this routine\n\
8668 should only be called after the call to plbox (or plbox3) is complete.\n\
8669 See the PLplot documentation for more information.\n\
8670\n\
8671 Redacted form: plgxax(p_digmax, p_digits)\n\
8672\n\
8673 This function is used in example 31.\n\
8674\n\
8675\n\
8676\n\
8677SYNOPSIS:\n\
8678\n\
8679plgxax(p_digmax, p_digits)\n\
8680\n\
8681ARGUMENTS:\n\
8682\n\
8683 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8684 number of digits for the x axis. If nonzero, the printed label\n\
8685 has been switched to a floating-point representation when the\n\
8686 number of digits exceeds this value.\n\
8687\n\
8688 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8689 number of digits for the numeric labels (x axis) from the last\n\
8690 plot.\n\
8691";
8692static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8693Set font\n\
8694\n\
8695DESCRIPTION:\n\
8696\n\
8697 Sets the font used for subsequent text and symbols. For devices that\n\
8698 still use Hershey fonts this routine has no effect unless the Hershey\n\
8699 fonts with extended character set are loaded (see plfontld). For\n\
8700 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8701 this routine calls the plsfci routine with argument set up\n\
8702 appropriately for the various cases below. However, this method of\n\
8703 specifying the font for unicode-aware devices is deprecated, and the\n\
8704 much more flexible method of calling plsfont directly is recommended\n\
8705 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8706\n\
8707 Redacted form: plfont(ifont)\n\
8708\n\
8709 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8710\n\
8711\n\
8712\n\
8713SYNOPSIS:\n\
8714\n\
8715plfont(ifont)\n\
8716\n\
8717ARGUMENTS:\n\
8718\n\
8719 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8720 (simplest and fastest)\n\
8721 2: Serif font\n\
8722 3: Italic font\n\
8723 4: Script font\n\
8724";
8725static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8726Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8727\n\
8728DESCRIPTION:\n\
8729\n\
8730 Routine for creating a discrete plot legend with a plotted filled box,\n\
8731 line, and/or line of symbols for each annotated legend entry. (See\n\
8732 plcolorbar for similar functionality for creating continuous color\n\
8733 bars.) The arguments of pllegend provide control over the location\n\
8734 and size of the legend as well as the location and characteristics of\n\
8735 the elements (most of which are optional) within that legend. The\n\
8736 resulting legend is clipped at the boundaries of the current subpage.\n\
8737 (N.B. the adopted coordinate system used for some of the parameters is\n\
8738 defined in the documentation of the position parameter.)\n\
8739\n\
8740 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8741 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8742 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8743 test_justification, text_colors, text, box_colors, box_patterns,\n\
8744 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8745 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8746\n\
8747 This function is used in examples 4, 26, and 33.\n\
8748\n\
8749\n\
8750\n\
8751SYNOPSIS:\n\
8752\n\
8753pllegend(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\
8754\n\
8755ARGUMENTS:\n\
8756\n\
8757 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8758 legend width in adopted coordinates. This quantity is calculated\n\
8759 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8760 the routine depending on nlegend and nrow), and the length\n\
8761 (calculated internally) of the longest text string.\n\
8762\n\
8763 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8764 legend height in adopted coordinates. This quantity is calculated\n\
8765 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8766 the routine depending on nlegend and nrow).\n\
8767\n\
8768 opt (PLINT, input) : opt contains bits controlling the overall\n\
8769 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8770 on the left of the legend and the plotted area on the right.\n\
8771 Otherwise, put the text area on the right of the legend and the\n\
8772 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8773 plot a (semitransparent) background for the legend. If the\n\
8774 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8775 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8776 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8777 plot the resulting array of legend entries in row-major order.\n\
8778 Otherwise, plot the legend entries in column-major order.\n\
8779\n\
8780 position (PLINT, input) : position contains bits which control the\n\
8781 overall position of the legend and the definition of the adopted\n\
8782 coordinates used for positions just like what is done for the\n\
8783 position argument for plcolorbar. However, note that the defaults\n\
8784 for the position bits (see below) are different than the\n\
8785 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8786 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8787 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8788 the 16 possible standard positions (the 4 corners and centers of\n\
8789 the 4 sides for both the inside and outside cases) of the legend\n\
8790 relative to the adopted coordinate system. The corner positions\n\
8791 are specified by the appropriate combination of two of the\n\
8792 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8793 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8794 value of one of those bits. The adopted coordinates are\n\
8795 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8796 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8797 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8798 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8799 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8800 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8801 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8802 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8803\n\
8804 x (PLFLT, input) : X offset of the legend position in adopted\n\
8805 coordinates from the specified standard position of the legend.\n\
8806 For positive x, the direction of motion away from the standard\n\
8807 position is inward/outward from the standard corner positions or\n\
8808 standard left or right positions if the\n\
8809 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8810 For the standard top or bottom positions, the direction of motion\n\
8811 is toward positive X.\n\
8812\n\
8813 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8814 coordinates from the specified standard position of the legend.\n\
8815 For positive y, the direction of motion away from the standard\n\
8816 position is inward/outward from the standard corner positions or\n\
8817 standard top or bottom positions if the\n\
8818 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8819 the standard left or right positions, the direction of motion is\n\
8820 toward positive Y.\n\
8821\n\
8822 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8823 of the plot area (where the colored boxes, lines, and/or lines of\n\
8824 symbols are drawn) of the legend.\n\
8825\n\
8826 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8827 legend (PL_LEGEND_BACKGROUND).\n\
8828\n\
8829 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8830 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8831\n\
8832 bb_style (PLINT, input) : The pllsty style number for the\n\
8833 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8834\n\
8835 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8836 render the\n\
8837 nlegend legend entries. For internal transformations of\n\
8838 nrow, see further remarks under\n\
8839 nlegend.\n\
8840\n\
8841 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8842 to render the\n\
8843 nlegend legend entries. For internal transformations of\n\
8844 ncolumn, see further remarks under\n\
8845 nlegend.\n\
8846\n\
8847 nlegend (PLINT, input) : Number of legend entries. The above\n\
8848 nrow and\n\
8849 ncolumn values are transformed internally to be consistent with\n\
8850 nlegend. If either\n\
8851 nrow or\n\
8852 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8853 of\n\
8854 nrow and\n\
8855 ncolumn is less than\n\
8856 nlegend, the smaller of the two (or\n\
8857 nrow, if\n\
8858 nrow ==\n\
8859 ncolumn) is increased so the product is >=\n\
8860 nlegend. Thus, for example, the common\n\
8861 nrow = 0,\n\
8862 ncolumn = 0 case is transformed internally to\n\
8863 nrow =\n\
8864 nlegend,\n\
8865 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8866 column.\n\
8867\n\
8868 opt_array (PLINT_VECTOR, input) : A vector of\n\
8869 nlegend values of options to control each individual plotted area\n\
8870 corresponding to a legend entry. If the\n\
8871 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8872 area. If the\n\
8873 PL_LEGEND_COLOR_BOX,\n\
8874 PL_LEGEND_LINE, and/or\n\
8875 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8876 entry is plotted with a colored box; a line; and/or a line of\n\
8877 symbols.\n\
8878\n\
8879 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8880 area in units of character width.\n\
8881\n\
8882 text_scale (PLFLT, input) : Character height scale for text\n\
8883 annotations.\n\
8884\n\
8885 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8886 character height from one legend entry to the next.\n\
8887\n\
8888 text_justification (PLFLT, input) : Justification parameter used\n\
8889 for text justification. The most common values of\n\
8890 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8891 is left justified, centred, or right justified within the text\n\
8892 area, but other values are allowed as well.\n\
8893\n\
8894 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8895 nlegend cmap0 text colors.\n\
8896\n\
8897 text (PLCHAR_MATRIX, input) : A vector of\n\
8898 nlegend UTF-8 character strings containing the legend annotations.\n\
8899\n\
8900 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8901 nlegend cmap0 colors for the discrete colored boxes (\n\
8902 PL_LEGEND_COLOR_BOX).\n\
8903\n\
8904 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8905 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8906 PL_LEGEND_COLOR_BOX).\n\
8907\n\
8908 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8909 nlegend scales (units of fraction of character height) for the height\n\
8910 of the discrete colored boxes (\n\
8911 PL_LEGEND_COLOR_BOX).\n\
8912\n\
8913 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8914 nlegend line widths for the patterns specified by box_patterns (\n\
8915 PL_LEGEND_COLOR_BOX).\n\
8916\n\
8917 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8918 nlegend cmap0 line colors (\n\
8919 PL_LEGEND_LINE).\n\
8920\n\
8921 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8922 nlegend line styles (plsty indices) (\n\
8923 PL_LEGEND_LINE).\n\
8924\n\
8925 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8926 nlegend line widths (\n\
8927 PL_LEGEND_LINE).\n\
8928\n\
8929 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8930 nlegend cmap0 symbol colors (\n\
8931 PL_LEGEND_SYMBOL).\n\
8932\n\
8933 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8934 nlegend scale values for the symbol height (\n\
8935 PL_LEGEND_SYMBOL).\n\
8936\n\
8937 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8938 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8939 area (\n\
8940 PL_LEGEND_SYMBOL).\n\
8941\n\
8942 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8943 nlegend UTF-8 character strings containing the legend symbols. (\n\
8944 PL_LEGEND_SYMBOL).\n\
8945";
8946static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8947Set the background color by 8-bit RGB value\n\
8948\n\
8949DESCRIPTION:\n\
8950\n\
8951 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8952 the PLplot documentation).\n\
8953\n\
8954 Redacted form: plscolbg(r, g, b)\n\
8955\n\
8956 This function is used in examples 15 and 31.\n\
8957\n\
8958\n\
8959\n\
8960SYNOPSIS:\n\
8961\n\
8962plscolbg(r, g, b)\n\
8963\n\
8964ARGUMENTS:\n\
8965\n\
8966 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8967 degree of red in the color.\n\
8968\n\
8969 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8970 degree of green in the color.\n\
8971\n\
8972 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8973 degree of blue in the color.\n\
8974";
8975static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8976Set parameters that define current device-space window\n\
8977\n\
8978DESCRIPTION:\n\
8979\n\
8980 Set relative margin width, aspect ratio, and relative justification\n\
8981 that define current device-space window. If you want to just use the\n\
8982 previous value for any of these, just pass in the magic value\n\
8983 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8984 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8985 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8986 to a device-specific value.\n\
8987\n\
8988 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8989\n\
8990 This function is used in example 31.\n\
8991\n\
8992\n\
8993\n\
8994SYNOPSIS:\n\
8995\n\
8996plsdidev(mar, aspect, jx, jy)\n\
8997\n\
8998ARGUMENTS:\n\
8999\n\
9000 mar (PLFLT, input) : Relative margin width.\n\
9001\n\
9002 aspect (PLFLT, input) : Aspect ratio.\n\
9003\n\
9004 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9005 the range -0.5 to 0.5.\n\
9006\n\
9007 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9008 the range -0.5 to 0.5.\n\
9009";
9010static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9011Specify viewport using aspect ratio only\n\
9012\n\
9013DESCRIPTION:\n\
9014\n\
9015 Selects the largest viewport with the given aspect ratio within the\n\
9016 subpage that leaves a standard margin (left-hand margin of eight\n\
9017 character heights, and a margin around the other three sides of five\n\
9018 character heights).\n\
9019\n\
9020 Redacted form: plvasp(aspect)\n\
9021\n\
9022 This function is used in example 13.\n\
9023\n\
9024\n\
9025\n\
9026SYNOPSIS:\n\
9027\n\
9028plvasp(aspect)\n\
9029\n\
9030ARGUMENTS:\n\
9031\n\
9032 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9033 axis of resulting viewport.\n\
9034";
9035static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
9036Configure the transformations required for projecting a 3D surface on a 2D window\n\
9037\n\
9038DESCRIPTION:\n\
9039\n\
9040 Configure the transformations required for projecting a 3D surface on\n\
9041 an existing 2D window. Those transformations (see the PLplot\n\
9042 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9043 surface which has its limits expressed in 3D world coordinates and\n\
9044 also normalized 3D coordinates (used for interpreting the altitude and\n\
9045 azimuth of the viewing angle). The transformations consist of the\n\
9046 linear transform from 3D world coordinates to normalized 3D\n\
9047 coordinates, and the 3D rotation of normalized coordinates required to\n\
9048 align the pole of the new 3D coordinate system with the viewing\n\
9049 direction specified by altitude and azimuth so that x and y of the\n\
9050 surface elements in that transformed coordinate system are the\n\
9051 projection of the 3D surface with given viewing direction on the 2D\n\
9052 window.\n\
9053\n\
9054 The enclosing rectangular cuboid for the surface plot is defined by\n\
9055 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9056 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9057 sizes of basex by basey by height so that xmin maps to -\n\
9058 basex/2, xmax maps to basex/2, ymin maps to -\n\
9059 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9060 The resulting rectangular cuboid in normalized coordinates is then\n\
9061 viewed by an observer at altitude alt and azimuth az. This routine\n\
9062 must be called before plbox3 or any of the 3D surface plotting\n\
9063 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9064 plsurf3dl or plfill3.\n\
9065\n\
9066 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9067 zmin, zmax, alt, az)\n\
9068\n\
9069 This function is examples 8, 11, 18, and 21.\n\
9070\n\
9071\n\
9072\n\
9073SYNOPSIS:\n\
9074\n\
9075plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9076\n\
9077ARGUMENTS:\n\
9078\n\
9079 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9080 rectangular cuboid.\n\
9081\n\
9082 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9083 rectangular cuboid.\n\
9084\n\
9085 height (PLFLT, input) : The normalized z coordinate size of the\n\
9086 rectangular cuboid.\n\
9087\n\
9088 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9089 rectangular cuboid.\n\
9090\n\
9091 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9092 rectangular cuboid.\n\
9093\n\
9094 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9095 rectangular cuboid.\n\
9096\n\
9097 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9098 rectangular cuboid.\n\
9099\n\
9100 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9101 rectangular cuboid.\n\
9102\n\
9103 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9104 rectangular cuboid.\n\
9105\n\
9106 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9107 plane of the rectangular cuboid in normalized coordinates.\n\
9108\n\
9109 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9110 rectangular cuboid in normalized coordinates. When az=0, the\n\
9111 observer is looking face onto the zx plane of the rectangular\n\
9112 cuboid in normalized coordinates, and as az is increased, the\n\
9113 observer moves clockwise around that cuboid when viewed from above\n\
9114 the xy plane.\n\
9115";
9116static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9117Wait for graphics input event and translate to world coordinates.\n\
9118\n\
9119DESCRIPTION:\n\
9120\n\
9121 Wait for graphics input event and translate to world coordinates.\n\
9122 Returns 0 if no translation to world coordinates is possible.\n\
9123\n\
9124 This function returns 1 on success and 0 if no translation to world\n\
9125 coordinates is possible.\n\
9126\n\
9127 Redacted form: plGetCursor(gin)\n\
9128\n\
9129 This function is used in examples 1 and 20.\n\
9130\n\
9131\n\
9132\n\
9133SYNOPSIS:\n\
9134\n\
9135PLINT plGetCursor(gin)\n\
9136\n\
9137ARGUMENTS:\n\
9138\n\
9139 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9140 which will contain the output. The structure is not allocated by\n\
9141 the routine and must exist before the function is called.\n\
9142";
9143static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9144Set number of colors in cmap0\n\
9145\n\
9146DESCRIPTION:\n\
9147\n\
9148 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9149 (or reallocate) cmap0, and fill with default values for those colors\n\
9150 not previously allocated. The first 16 default colors are given in\n\
9151 the plcol0 documentation. For larger indices the default color is\n\
9152 red.\n\
9153\n\
9154 The drivers are not guaranteed to support more than 16 colors.\n\
9155\n\
9156 Redacted form: plscmap0n(ncol0)\n\
9157\n\
9158 This function is used in examples 15, 16, and 24.\n\
9159\n\
9160\n\
9161\n\
9162SYNOPSIS:\n\
9163\n\
9164plscmap0n(ncol0)\n\
9165\n\
9166ARGUMENTS:\n\
9167\n\
9168 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9169 the cmap0 palette. If this number is zero or less, then the value\n\
9170 from the previous call to plscmap0n is used and if there is no\n\
9171 previous call, then a default value is used.\n\
9172";
9173static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9174Set z axis parameters\n\
9175\n\
9176DESCRIPTION:\n\
9177\n\
9178 Identical to plsxax, except that arguments are flags for z axis. See\n\
9179 the description of plsxax for more detail.\n\
9180\n\
9181 Redacted form: plszax(digmax, digits)\n\
9182\n\
9183 This function is used in example 31.\n\
9184\n\
9185\n\
9186\n\
9187SYNOPSIS:\n\
9188\n\
9189plszax(digmax, digits)\n\
9190\n\
9191ARGUMENTS:\n\
9192\n\
9193 digmax (PLINT, input) : Variable to set the maximum number of\n\
9194 digits for the z axis. If nonzero, the printed label will be\n\
9195 switched to a floating-point representation when the number of\n\
9196 digits exceeds digmax.\n\
9197\n\
9198 digits (PLINT, input) : Field digits value. Currently, changing\n\
9199 its value here has no effect since it is set only by plbox or\n\
9200 plbox3. However, the user may obtain its value after a call to\n\
9201 either of these functions by calling plgzax.\n\
9202";
9203static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9204Get FCI (font characterization integer)\n\
9205\n\
9206DESCRIPTION:\n\
9207\n\
9208 Gets information about the current font using the FCI approach. See\n\
9209 the PLplot documentation for more information.\n\
9210\n\
9211 Redacted form: plgfci(p_fci)\n\
9212\n\
9213 This function is used in example 23.\n\
9214\n\
9215\n\
9216\n\
9217SYNOPSIS:\n\
9218\n\
9219plgfci(p_fci)\n\
9220\n\
9221ARGUMENTS:\n\
9222\n\
9223 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9224 FCI value.\n\
9225";
9226static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9227Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9228\n\
9229DESCRIPTION:\n\
9230\n\
9231 Sets up plotter environment for simple graphs by calling pladv and\n\
9232 setting up viewport and window to sensible default values. plenv0\n\
9233 leaves a standard margin (left-hand margin of eight character heights,\n\
9234 and a margin around the other three sides of five character heights)\n\
9235 around most graphs for axis labels and a title. When these defaults\n\
9236 are not suitable, use the individual routines plvpas, plvpor, or\n\
9237 plvasp for setting up the viewport, plwind for defining the window,\n\
9238 and plbox for drawing the box.\n\
9239\n\
9240 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9241\n\
9242 This function is used in example 21.\n\
9243\n\
9244\n\
9245\n\
9246SYNOPSIS:\n\
9247\n\
9248plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9249\n\
9250ARGUMENTS:\n\
9251\n\
9252 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9253 world coordinates).\n\
9254\n\
9255 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9256 world coordinates).\n\
9257\n\
9258 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9259 coordinates).\n\
9260\n\
9261 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9262 coordinates).\n\
9263\n\
9264 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9265 scales will not be set, the user must set up the scale before\n\
9266 calling plenv0 using plsvpa, plvasp or other.\n\
9267 0: the x and y axes are scaled independently to use as much of\n\
9268 the screen as possible.\n\
9269 1: the scales of the x and y axes are made equal.\n\
9270 2: the axis of the x and y axes are made equal, and the plot\n\
9271 box will be square.\n\
9272\n\
9273\n\
9274 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9275 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9276 -1: draw box only.\n\
9277 0: draw box, ticks, and numeric tick labels.\n\
9278 1: also draw coordinate axes at x=0 and y=0.\n\
9279 2: also draw a grid at major tick positions in both\n\
9280 coordinates.\n\
9281 3: also draw a grid at minor tick positions in both\n\
9282 coordinates.\n\
9283 10: same as 0 except logarithmic x tick marks. (The x data\n\
9284 have to be converted to logarithms separately.)\n\
9285 11: same as 1 except logarithmic x tick marks. (The x data\n\
9286 have to be converted to logarithms separately.)\n\
9287 12: same as 2 except logarithmic x tick marks. (The x data\n\
9288 have to be converted to logarithms separately.)\n\
9289 13: same as 3 except logarithmic x tick marks. (The x data\n\
9290 have to be converted to logarithms separately.)\n\
9291 20: same as 0 except logarithmic y tick marks. (The y data\n\
9292 have to be converted to logarithms separately.)\n\
9293 21: same as 1 except logarithmic y tick marks. (The y data\n\
9294 have to be converted to logarithms separately.)\n\
9295 22: same as 2 except logarithmic y tick marks. (The y data\n\
9296 have to be converted to logarithms separately.)\n\
9297 23: same as 3 except logarithmic y tick marks. (The y data\n\
9298 have to be converted to logarithms separately.)\n\
9299 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9300 and y data have to be converted to logarithms separately.)\n\
9301 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9302 and y data have to be converted to logarithms separately.)\n\
9303 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9304 and y data have to be converted to logarithms separately.)\n\
9305 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9306 and y data have to be converted to logarithms separately.)\n\
9307 40: same as 0 except date / time x labels.\n\
9308 41: same as 1 except date / time x labels.\n\
9309 42: same as 2 except date / time x labels.\n\
9310 43: same as 3 except date / time x labels.\n\
9311 50: same as 0 except date / time y labels.\n\
9312 51: same as 1 except date / time y labels.\n\
9313 52: same as 2 except date / time y labels.\n\
9314 53: same as 3 except date / time y labels.\n\
9315 60: same as 0 except date / time x and y labels.\n\
9316 61: same as 1 except date / time x and y labels.\n\
9317 62: same as 2 except date / time x and y labels.\n\
9318 63: same as 3 except date / time x and y labels.\n\
9319 70: same as 0 except custom x and y labels.\n\
9320 71: same as 1 except custom x and y labels.\n\
9321 72: same as 2 except custom x and y labels.\n\
9322 73: same as 3 except custom x and y labels.\n\
9323";
9324static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9325Set symbol size\n\
9326\n\
9327DESCRIPTION:\n\
9328\n\
9329 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9330 plsym. The actual height of a symbol is the product of the default\n\
9331 symbol size and a scaling factor as for the character height.\n\
9332\n\
9333 Redacted form: plssym(def, scale)\n\
9334\n\
9335 This function is used in example 29.\n\
9336\n\
9337\n\
9338\n\
9339SYNOPSIS:\n\
9340\n\
9341plssym(def, scale)\n\
9342\n\
9343ARGUMENTS:\n\
9344\n\
9345 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9346 should be set to zero if the default height is to remain\n\
9347 unchanged.\n\
9348\n\
9349 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9350 actual symbol height.\n\
9351";
9352static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9353Set plot orientation\n\
9354\n\
9355DESCRIPTION:\n\
9356\n\
9357 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9358 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9359 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9360 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9361 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9362 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9363 not called the default value of rot is 0.\n\
9364\n\
9365 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9366 probably want to change the aspect ratio to a value suitable for the\n\
9367 plot orientation using a call to plsdidev or the command-line options\n\
9368 -a or -freeaspect. For more documentation of those options see the\n\
9369 PLplot documentation. Such command-line options can be set internally\n\
9370 using plsetopt or set directly using the command line and parsed using\n\
9371 a call to plparseopts.\n\
9372\n\
9373 Redacted form: plsdiori(rot)\n\
9374\n\
9375 This function is not used in any examples.\n\
9376\n\
9377\n\
9378\n\
9379SYNOPSIS:\n\
9380\n\
9381plsdiori(rot)\n\
9382\n\
9383ARGUMENTS:\n\
9384\n\
9385 rot (PLFLT, input) : Plot orientation parameter.\n\
9386";
9387static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9388Advance the (sub-)page\n\
9389\n\
9390DESCRIPTION:\n\
9391\n\
9392 Advances to the next subpage if sub=0, performing a page advance if\n\
9393 there are no remaining subpages on the current page. If subpages\n\
9394 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9395 PLplot switches to the specified subpage. Note that this allows you\n\
9396 to overwrite a plot on the specified subpage; if this is not what you\n\
9397 intended, use pleop followed by plbop to first advance the page. This\n\
9398 routine is called automatically (with page=0) by plenv, but if plenv\n\
9399 is not used, pladv must be called after initializing PLplot but before\n\
9400 defining the viewport.\n\
9401\n\
9402 Redacted form: pladv(page)\n\
9403\n\
9404 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9405 29, and 31.\n\
9406\n\
9407\n\
9408\n\
9409SYNOPSIS:\n\
9410\n\
9411pladv(page)\n\
9412\n\
9413ARGUMENTS:\n\
9414\n\
9415 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9416 in the top left corner and increasing along the rows) to which to\n\
9417 advance. Set to zero to advance to the next subpage (or to the\n\
9418 next page if subpages are not being used).\n\
9419";
9420static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9421Set cmap0 colors by 8-bit RGB values\n\
9422\n\
9423DESCRIPTION:\n\
9424\n\
9425 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9426 documentation). This sets the entire color map -- only as many colors\n\
9427 as specified will be allocated.\n\
9428\n\
9429 Redacted form: plscmap0(r, g, b)\n\
9430\n\
9431 This function is used in examples 2 and 24.\n\
9432\n\
9433\n\
9434\n\
9435SYNOPSIS:\n\
9436\n\
9437plscmap0(r, g, b, ncol0)\n\
9438\n\
9439ARGUMENTS:\n\
9440\n\
9441 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9442 integers (0-255) representing the degree of red in the color.\n\
9443\n\
9444 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9445 integers (0-255) representing the degree of green in the color.\n\
9446\n\
9447 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9448 integers (0-255) representing the degree of blue in the color.\n\
9449\n\
9450 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9451";
9452static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9453Get character default height and current (scaled) height\n\
9454\n\
9455DESCRIPTION:\n\
9456\n\
9457 Get character default height and current (scaled) height.\n\
9458\n\
9459 Redacted form: plgchr(p_def, p_ht)\n\
9460\n\
9461 This function is used in example 23.\n\
9462\n\
9463\n\
9464\n\
9465SYNOPSIS:\n\
9466\n\
9467plgchr(p_def, p_ht)\n\
9468\n\
9469ARGUMENTS:\n\
9470\n\
9471 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9472 character height (mm).\n\
9473\n\
9474 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9475 character height (mm).\n\
9476";
9477static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9478Set opaque RGB cmap1 colors values\n\
9479\n\
9480DESCRIPTION:\n\
9481\n\
9482 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9483 vector values. This function also sets the number of cmap1 colors.\n\
9484 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9485 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9486 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9487 to\n\
9488 ncol1-1. So in order for this continuous color model to work\n\
9489 properly, it is the responsibility of the user of plscmap1 to insure\n\
9490 that these RGB vectors are continuous functions of their integer\n\
9491 indices.\n\
9492\n\
9493 Redacted form: plscmap1(r, g, b)\n\
9494\n\
9495 This function is used in example 31.\n\
9496\n\
9497\n\
9498\n\
9499SYNOPSIS:\n\
9500\n\
9501plscmap1(r, g, b, ncol1)\n\
9502\n\
9503ARGUMENTS:\n\
9504\n\
9505 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9506 8-bit integers in the range from 0-255) the degree of red in the\n\
9507 color as a continuous function of the integer index of the vector.\n\
9508\n\
9509 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9510 8-bit integers in the range from 0-255) the degree of green in the\n\
9511 color as a continuous function of the integer index of the vector.\n\
9512\n\
9513 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9514 8-bit integers in the range from 0-255) the degree of blue in the\n\
9515 color as a continuous function of the integer index of the vector.\n\
9516\n\
9517 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9518";
9519static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9520Set any command-line option\n\
9521\n\
9522DESCRIPTION:\n\
9523\n\
9524 Set any command-line option internally from a program before it\n\
9525 invokes plinit. opt is the name of the command-line option and optarg\n\
9526 is the corresponding command-line option argument.\n\
9527\n\
9528 This function returns 0 on success.\n\
9529\n\
9530 Redacted form: plsetopt(opt, optarg)\n\
9531\n\
9532 This function is used in example 14.\n\
9533\n\
9534\n\
9535\n\
9536SYNOPSIS:\n\
9537\n\
9538PLINT plsetopt(opt, optarg)\n\
9539\n\
9540ARGUMENTS:\n\
9541\n\
9542 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9543 the command-line option.\n\
9544\n\
9545 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9546 containing the argument of the command-line option.\n\
9547";
9548static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9549Draw linear gradient inside polygon\n\
9550\n\
9551DESCRIPTION:\n\
9552\n\
9553 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9554 points (\n\
9555 x[i],\n\
9556 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9557 polygon coordinates and the gradient angle are all expressed in world\n\
9558 coordinates. The angle from the x axis for both the rotated\n\
9559 coordinate system and the gradient vector is specified by angle. The\n\
9560 magnitude of the gradient vector is the difference between the maximum\n\
9561 and minimum values of x for the vertices in the rotated coordinate\n\
9562 system. The origin of the gradient vector can be interpreted as being\n\
9563 anywhere on the line corresponding to the minimum x value for the\n\
9564 vertices in the rotated coordinate system. The distance along the\n\
9565 gradient vector is linearly transformed to the independent variable of\n\
9566 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9567 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9568 color corresponding to the independent variable of cmap1. For more\n\
9569 information about cmap1 (see the PLplot documentation).\n\
9570\n\
9571 Redacted form: plgradient(x,y,angle)\n\
9572\n\
9573 This function is used in examples 25 and 30.\n\
9574\n\
9575\n\
9576\n\
9577SYNOPSIS:\n\
9578\n\
9579plgradient(n, x, y, angle)\n\
9580\n\
9581ARGUMENTS:\n\
9582\n\
9583 n (PLINT, input) : Number of vertices in polygon.\n\
9584\n\
9585 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9586 vertices.\n\
9587\n\
9588 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9589 vertices.\n\
9590\n\
9591 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9592 axis.\n\
9593";
9594static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9595Set length of major ticks\n\
9596\n\
9597DESCRIPTION:\n\
9598\n\
9599 This sets up the length of the major ticks. The actual length is the\n\
9600 product of the default length and a scaling factor as for character\n\
9601 height.\n\
9602\n\
9603 Redacted form: plsmaj(def, scale)\n\
9604\n\
9605 This function is used in example 29.\n\
9606\n\
9607\n\
9608\n\
9609SYNOPSIS:\n\
9610\n\
9611plsmaj(def, scale)\n\
9612\n\
9613ARGUMENTS:\n\
9614\n\
9615 def (PLFLT, input) : The default length of a major tick in\n\
9616 millimeters, should be set to zero if the default length is to\n\
9617 remain unchanged.\n\
9618\n\
9619 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9620 actual tick length.\n\
9621";
9622static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9623Set a global coordinate transform function\n\
9624\n\
9625DESCRIPTION:\n\
9626\n\
9627 This function can be used to define a coordinate transformation which\n\
9628 affects all elements drawn within the current plot window. The\n\
9629 coordinate_transform callback function is similar to that provided for\n\
9630 the plmap and plmeridians functions. The coordinate_transform_data\n\
9631 parameter may be used to pass extra data to coordinate_transform.\n\
9632\n\
9633 Redacted form: General: plstransform(coordinate_transform,\n\
9634 coordinate_transform_data)\n\
9635\n\
9636\n\
9637 This function is used in examples 19 and 22.\n\
9638\n\
9639\n\
9640\n\
9641SYNOPSIS:\n\
9642\n\
9643plstransform(coordinate_transform, coordinate_transform_data)\n\
9644\n\
9645ARGUMENTS:\n\
9646\n\
9647 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9648 function that defines the transformation from the input (x, y)\n\
9649 world coordinates to new PLplot world coordinates. If\n\
9650 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9651 case), then no transform is applied.\n\
9652\n\
9653 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9654 for\n\
9655 coordinate_transform.\n\
9656";
9657static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9658Configure the transformation between continuous and broken-down time for the current stream\n\
9659\n\
9660DESCRIPTION:\n\
9661\n\
9662 Configure the transformation between continuous and broken-down time\n\
9663 for the current stream. This transformation is used by both plbtime\n\
9664 and plctime.\n\
9665\n\
9666 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9667 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9668\n\
9669\n\
9670 This function is used in example 29.\n\
9671\n\
9672\n\
9673\n\
9674SYNOPSIS:\n\
9675\n\
9676plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9677\n\
9678ARGUMENTS:\n\
9679\n\
9680 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9681 As a special case, if\n\
9682 scale is 0., then all other arguments are ignored, and the result (the\n\
9683 default used by PLplot) is the equivalent of a call to\n\
9684 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9685 That is, for this special case broken-down time is calculated with\n\
9686 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9687 and the continuous time is defined as the number of seconds since\n\
9688 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9689\n\
9690 offset1 (PLFLT, input) : If\n\
9691 ifbtime_offset is true, the parameters\n\
9692 offset1 and\n\
9693 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9694 (with units in days) specify the epoch of the continuous time\n\
9695 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9696 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9697 are used to specify the origin to allow users (by specifying\n\
9698 offset1 as an integer that can be exactly represented by a\n\
9699 floating-point variable and specifying\n\
9700 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9701 the numerical errors of the continuous time representation.\n\
9702\n\
9703 offset2 (PLFLT, input) : See documentation of\n\
9704 offset1.\n\
9705\n\
9706 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9707 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9708 calendar is used for broken-down time rather than the proleptic\n\
9709 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9710 have been historically used to define UTC are inserted into the\n\
9711 broken-down time. Other possibilities for additional control bits\n\
9712 for ccontrol exist such as making the historical time corrections\n\
9713 in the broken-down time corresponding to ET (ephemeris time) or\n\
9714 making the (slightly non-constant) corrections from international\n\
9715 atomic time (TAI) to what astronomers define as terrestrial time\n\
9716 (TT). But those additional possibilities have not been\n\
9717 implemented yet in the qsastime library (one of the PLplot utility\n\
9718 libraries).\n\
9719\n\
9720 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9721 epoch of the continuous time scale is specified by the user. If\n\
9722 ifbtime_offset is false, then\n\
9723 offset1 and\n\
9724 offset2 are used to specify the epoch, and the following broken-down\n\
9725 time parameters are completely ignored. If\n\
9726 ifbtime_offset is true, then\n\
9727 offset1 and\n\
9728 offset2 are completely ignored, and the following broken-down time\n\
9729 parameters are used to specify the epoch.\n\
9730\n\
9731 year (PLINT, input) : Year of epoch.\n\
9732\n\
9733 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9734 11 (December).\n\
9735\n\
9736 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9737\n\
9738 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9739\n\
9740 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9741\n\
9742 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9743";
9744static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9745Flushes the output stream\n\
9746\n\
9747DESCRIPTION:\n\
9748\n\
9749 Flushes the output stream. Use sparingly, if at all.\n\
9750\n\
9751 Redacted form: plflush()\n\
9752\n\
9753 This function is used in examples 1 and 14.\n\
9754\n\
9755\n\
9756\n\
9757SYNOPSIS:\n\
9758\n\
9759plflush()\n\
9760";
9761static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9762Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9763\n\
9764DESCRIPTION:\n\
9765\n\
9766 This variant of plsurf3d (see that function\'s documentation for more\n\
9767 details) should be suitable for the case where the area of the x, y\n\
9768 coordinate grid where z is defined can be non-rectangular. The limits\n\
9769 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9770 indexymin, and indexymax.\n\
9771\n\
9772 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9773 indexymax)\n\
9774\n\
9775 This function is used in example 8.\n\
9776\n\
9777\n\
9778\n\
9779SYNOPSIS:\n\
9780\n\
9781plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9782\n\
9783ARGUMENTS:\n\
9784\n\
9785 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9786 which the function is evaluated.\n\
9787\n\
9788 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9789 which the function is evaluated.\n\
9790\n\
9791 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9792 plot. Should have dimensions of\n\
9793 nx by\n\
9794 ny.\n\
9795\n\
9796 nx (PLINT, input) : Number of x values at which function is\n\
9797 evaluated.\n\
9798\n\
9799 ny (PLINT, input) : Number of y values at which function is\n\
9800 evaluated.\n\
9801\n\
9802 opt (PLINT, input) : Determines the way in which the surface is\n\
9803 represented. To specify more than one option just add the options,\n\
9804 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9805 connecting points at which function is defined.\n\
9806 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9807 using parameters\n\
9808 nlevel and\n\
9809 clevel.\n\
9810 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9811 using parameters\n\
9812 nlevel and\n\
9813 clevel.\n\
9814 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9815 the borders of the plotted function.\n\
9816 opt=MAG_COLOR : the surface is colored according to the value\n\
9817 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9818 according to the intensity of the reflected light in the\n\
9819 surface from a light source whose position is set using\n\
9820 pllightsource.\n\
9821\n\
9822\n\
9823 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9824 levels.\n\
9825\n\
9826 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9827\n\
9828 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9829 corresponds to the first x index where z is defined.\n\
9830\n\
9831 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9832 which corresponds (by convention) to one more than the last x\n\
9833 index value where z is defined.\n\
9834\n\
9835 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9836 values which all must be ≥ 0. These values are the first y index\n\
9837 where z is defined for a particular x index in the range from\n\
9838 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9839 indexxmax.\n\
9840\n\
9841 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9842 values which all must be ≤ ny. These values correspond (by\n\
9843 convention) to one more than the last y index where z is defined\n\
9844 for a particular x index in the range from indexxmin to indexxmax\n\
9845 - 1. The dimension of indexymax is indexxmax.\n\
9846";
9847static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9848Set semitransparent cmap1 RGBA colors.\n\
9849\n\
9850DESCRIPTION:\n\
9851\n\
9852 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9853 RGBA vector values. This function also sets the number of cmap1\n\
9854 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9855 floating-point index in the range from 0.0-1.0 which is linearly\n\
9856 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9857 vectors in the range from 0 to\n\
9858 ncol1-1. So in order for this continuous color model to work\n\
9859 properly, it is the responsibility of the user of plscmap1 to insure\n\
9860 that these RGBA vectors are continuous functions of their integer\n\
9861 indices.\n\
9862\n\
9863 Redacted form: plscmap1a(r, g, b, alpha)\n\
9864\n\
9865 This function is used in example 31.\n\
9866\n\
9867\n\
9868\n\
9869SYNOPSIS:\n\
9870\n\
9871plscmap1a(r, g, b, alpha, ncol1)\n\
9872\n\
9873ARGUMENTS:\n\
9874\n\
9875 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9876 8-bit integers in the range from 0-255) the degree of red in the\n\
9877 color as a continuous function of the integer index of the vector.\n\
9878\n\
9879 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9880 8-bit integers in the range from 0-255) the degree of green in the\n\
9881 color as a continuous function of the integer index of the vector.\n\
9882\n\
9883 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9884 8-bit integers in the range from 0-255) the degree of blue in the\n\
9885 color as a continuous function of the integer index of the vector.\n\
9886\n\
9887 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9888 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9889 completely transparent and 1.0 corresponds to completely opaque)\n\
9890 the alpha transparency of the color as a continuous function of\n\
9891 the integer index of the vector.\n\
9892\n\
9893 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9894 vectors.\n\
9895";
9896static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9897Calculate broken-down time from continuous time for the current stream\n\
9898\n\
9899DESCRIPTION:\n\
9900\n\
9901 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9902 continuous time, ctime for the current stream. This function is the\n\
9903 inverse of plctime.\n\
9904\n\
9905 The PLplot definition of broken-down time is a calendar time that\n\
9906 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9907 responsibility to apply those offsets (if so desired) before using the\n\
9908 PLplot time API. By default broken-down time is defined using the\n\
9909 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9910 continuous time is defined as the number of seconds since the Unix\n\
9911 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9912 broken-down and continuous time are possible, see plconfigtime.\n\
9913\n\
9914 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9915 ctime)\n\
9916\n\
9917\n\
9918 This function is used in example 29.\n\
9919\n\
9920\n\
9921\n\
9922SYNOPSIS:\n\
9923\n\
9924plbtime(year, month, day, hour, min, sec, ctime)\n\
9925\n\
9926ARGUMENTS:\n\
9927\n\
9928 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9929 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9930 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9931 BCE, etc.)\n\
9932\n\
9933 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9934 the year in the range from 0 (January) to 11 (December).\n\
9935\n\
9936 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9937 month in the range from 1 to 31.\n\
9938\n\
9939 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9940 day in the range from 0 to 23.\n\
9941\n\
9942 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9943 hour in the range from 0 to 59\n\
9944\n\
9945 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9946 minute in range from 0. to 60.\n\
9947\n\
9948 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9949 time is calculated.\n\
9950";
9951static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9952Convert RGB color to HLS\n\
9953\n\
9954DESCRIPTION:\n\
9955\n\
9956 Convert RGB color coordinates to HLS\n\
9957\n\
9958 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9959\n\
9960\n\
9961 This function is used in example 2.\n\
9962\n\
9963\n\
9964\n\
9965SYNOPSIS:\n\
9966\n\
9967plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9968\n\
9969ARGUMENTS:\n\
9970\n\
9971 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9972\n\
9973 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9974\n\
9975 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9976\n\
9977 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9978 degrees (0.0-360.0) on the color cylinder.\n\
9979\n\
9980 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9981 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9982 cylinder.\n\
9983\n\
9984 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9985 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9986 cylinder.\n\
9987";
9988static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9989Get the current device (keyword) name\n\
9990\n\
9991DESCRIPTION:\n\
9992\n\
9993 Get the current device (keyword) name. Note: you must have allocated\n\
9994 space for this (80 characters is safe).\n\
9995\n\
9996 Redacted form: plgdev(p_dev)\n\
9997\n\
9998 This function is used in example 14.\n\
9999\n\
10000\n\
10001\n\
10002SYNOPSIS:\n\
10003\n\
10004plgdev(p_dev)\n\
10005\n\
10006ARGUMENTS:\n\
10007\n\
10008 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10009 (with preallocated length of 80 characters or more) containing the\n\
10010 device (keyword) name.\n\
10011";
10012static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
10013Set the number of subpages in x and y\n\
10014\n\
10015DESCRIPTION:\n\
10016\n\
10017 Set the number of subpages in x and y.\n\
10018\n\
10019 Redacted form: plssub(nx, ny)\n\
10020\n\
10021 This function is examples 1,2,14,21,25,27.\n\
10022\n\
10023\n\
10024\n\
10025SYNOPSIS:\n\
10026\n\
10027plssub(nx, ny)\n\
10028\n\
10029ARGUMENTS:\n\
10030\n\
10031 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10032 of window columns).\n\
10033\n\
10034 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10035 of window rows).\n\
10036";
10037static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
10038Get current stream number\n\
10039\n\
10040DESCRIPTION:\n\
10041\n\
10042 Gets the number of the current output stream. See also plsstrm.\n\
10043\n\
10044 Redacted form: plgstrm(p_strm)\n\
10045\n\
10046 This function is used in example 1,20.\n\
10047\n\
10048\n\
10049\n\
10050SYNOPSIS:\n\
10051\n\
10052plgstrm(p_strm)\n\
10053\n\
10054ARGUMENTS:\n\
10055\n\
10056 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10057 stream value.\n\
10058";
10059static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
10060Random number generator returning a real random number in the range [0,1]\n\
10061\n\
10062DESCRIPTION:\n\
10063\n\
10064 Random number generator returning a real random number in the range\n\
10065 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10066 / compilers provide their own random number generator, and so this is\n\
10067 provided purely for convenience and to give a consistent random number\n\
10068 generator across all languages supported by PLplot. This is\n\
10069 particularly useful for comparing results from the test suite of\n\
10070 examples.\n\
10071\n\
10072 Redacted form: plrandd()\n\
10073\n\
10074 This function is used in examples 17 and 21.\n\
10075\n\
10076\n\
10077\n\
10078SYNOPSIS:\n\
10079\n\
10080plrandd()\n\
10081";
10082static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10083Add a point to a strip chart\n\
10084\n\
10085DESCRIPTION:\n\
10086\n\
10087 Add a point to a given pen of a given strip chart. There is no need\n\
10088 for all pens to have the same number of points or to be equally\n\
10089 sampled in the x coordinate. Allocates memory and rescales as\n\
10090 necessary.\n\
10091\n\
10092 Redacted form: plstripa(id, pen, x, y)\n\
10093\n\
10094 This function is used in example 17.\n\
10095\n\
10096\n\
10097\n\
10098SYNOPSIS:\n\
10099\n\
10100plstripa(id, pen, x, y)\n\
10101\n\
10102ARGUMENTS:\n\
10103\n\
10104 id (PLINT, input) : Identification number of the strip chart (set\n\
10105 up in plstripc).\n\
10106\n\
10107 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10108\n\
10109 x (PLFLT, input) : X coordinate of point to plot.\n\
10110\n\
10111 y (PLFLT, input) : Y coordinate of point to plot.\n\
10112";
10113static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10114Set device-compression level\n\
10115\n\
10116DESCRIPTION:\n\
10117\n\
10118 Set device-compression level. Only used for drivers that provide\n\
10119 compression. This function, if used, should be invoked before a call\n\
10120 to plinit.\n\
10121\n\
10122 Redacted form: plscompression(compression)\n\
10123\n\
10124 This function is used in example 31.\n\
10125\n\
10126\n\
10127\n\
10128SYNOPSIS:\n\
10129\n\
10130plscompression(compression)\n\
10131\n\
10132ARGUMENTS:\n\
10133\n\
10134 compression (PLINT, input) : The desired compression level. This is\n\
10135 a device-dependent value. Currently only the jpeg and png devices\n\
10136 use these values. For jpeg value is the jpeg quality which should\n\
10137 normally be in the range 0-95. Higher values denote higher quality\n\
10138 and hence larger image sizes. For png values are in the range -1\n\
10139 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10140 A value of -1 denotes the default zlib compression level. Values\n\
10141 in the range 10-99 are divided by 10 and then used as the zlib\n\
10142 compression level. Higher compression levels correspond to greater\n\
10143 compression and small file sizes at the expense of more\n\
10144 computation.\n\
10145";
10146static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10147Specify viewport in absolute coordinates\n\
10148\n\
10149DESCRIPTION:\n\
10150\n\
10151 Alternate routine to plvpor for setting up the viewport. This routine\n\
10152 should be used only if the viewport is required to have a definite\n\
10153 size in millimeters. The routine plgspa is useful for finding out the\n\
10154 size of the current subpage.\n\
10155\n\
10156 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10157\n\
10158 This function is used in example 10.\n\
10159\n\
10160\n\
10161\n\
10162SYNOPSIS:\n\
10163\n\
10164plsvpa(xmin, xmax, ymin, ymax)\n\
10165\n\
10166ARGUMENTS:\n\
10167\n\
10168 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10169 viewport from the left-hand edge of the subpage in millimeters.\n\
10170\n\
10171 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10172 viewport from the left-hand edge of the subpage in millimeters.\n\
10173\n\
10174 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10175 viewport from the bottom edge of the subpage in millimeters.\n\
10176\n\
10177 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10178 from the bottom edge of the subpage in millimeters.\n\
10179";
10180static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10181Draw a polygon in 3 space\n\
10182\n\
10183DESCRIPTION:\n\
10184\n\
10185 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10186 like plline3, but differs from that function in that plpoly3 attempts\n\
10187 to determine if the polygon is viewable depending on the order of the\n\
10188 points within the vector and the value of ifcc. If the back of\n\
10189 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10190 you want, then use plline3 instead.\n\
10191\n\
10192 The points are assumed to be in a plane, and the directionality of the\n\
10193 plane is determined from the first three points. Additional points do\n\
10194 not have to lie on the plane defined by the first three, but if they\n\
10195 do not, then the determination of visibility obviously can\'t be 100%\n\
10196 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10197 consider breaking them into smaller polygons. 3 points define a plane\n\
10198 :-).\n\
10199\n\
10200 Bugs: If one of the first two segments is of zero length, or if they\n\
10201 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10202 being correct. Avoid such situations :-). See x18c.c for an example\n\
10203 of this problem. (Search for 20.1).\n\
10204\n\
10205 Redacted form: plpoly3(x, y, z, code)\n\
10206\n\
10207 This function is used in example 18.\n\
10208\n\
10209\n\
10210\n\
10211SYNOPSIS:\n\
10212\n\
10213plpoly3(n, x, y, z, draw, ifcc)\n\
10214\n\
10215ARGUMENTS:\n\
10216\n\
10217 n (PLINT, input) : Number of points defining line.\n\
10218\n\
10219 x (PLFLT_VECTOR, input) : A vector containing\n\
10220 n x coordinates of points.\n\
10221\n\
10222 y (PLFLT_VECTOR, input) : A vector containing\n\
10223 n y coordinates of points.\n\
10224\n\
10225 z (PLFLT_VECTOR, input) : A vector containing\n\
10226 n z coordinates of points.\n\
10227\n\
10228 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10229 n-1 Boolean values which control drawing the segments of the polygon.\n\
10230 If draw[i] is true, then the polygon segment from index [i] to\n\
10231 [i+1] is drawn, otherwise, not.\n\
10232\n\
10233 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10234 polygon is determined by assuming the points are laid out in a\n\
10235 counter-clockwise order. Otherwise, the directionality of the\n\
10236 polygon is determined by assuming the points are laid out in a\n\
10237 clockwise order.\n\
10238";
10239static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10240Magnitude colored plot surface with contour\n\
10241\n\
10242DESCRIPTION:\n\
10243\n\
10244 Aside from dropping the\n\
10245 side functionality this is a more powerful form of plot3d: the surface\n\
10246 mesh can be colored accordingly to the current z value being plotted,\n\
10247 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10248 drawn between the plotted function border and the base XY plane. The\n\
10249 arguments are identical to those of plmeshc. The only difference\n\
10250 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10251 the surface, while plot3dc only draws the surface as viewed from the\n\
10252 top.\n\
10253\n\
10254 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10255\n\
10256\n\
10257 This function is used in example 21.\n\
10258\n\
10259\n\
10260\n\
10261SYNOPSIS:\n\
10262\n\
10263plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10264\n\
10265ARGUMENTS:\n\
10266\n\
10267 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10268 which the function is evaluated.\n\
10269\n\
10270 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10271 which the function is evaluated.\n\
10272\n\
10273 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10274 plot. Should have dimensions of\n\
10275 nx by\n\
10276 ny.\n\
10277\n\
10278 nx (PLINT, input) : Number of x values at which function is\n\
10279 evaluated.\n\
10280\n\
10281 ny (PLINT, input) : Number of y values at which function is\n\
10282 evaluated.\n\
10283\n\
10284 opt (PLINT, input) : Determines the way in which the surface is\n\
10285 represented. To specify more than one option just add the options,\n\
10286 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10287 showing z as a function of x for each value of y[j] .\n\
10288 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10289 for each value of x[i] .\n\
10290 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10291 at which function is defined.\n\
10292 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10293 the z value being plotted. The color is used from the current\n\
10294 cmap1.\n\
10295 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10296 using parameters\n\
10297 nlevel and\n\
10298 clevel.\n\
10299 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10300 the borders of the plotted function.\n\
10301\n\
10302\n\
10303 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10304 levels.\n\
10305\n\
10306 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10307";
10308static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10309Create a 4-pen strip chart\n\
10310\n\
10311DESCRIPTION:\n\
10312\n\
10313 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10314\n\
10315 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10316 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10317 styline, legline, labx, laby, labz)\n\
10318\n\
10319\n\
10320 This function is used in example 17.\n\
10321\n\
10322\n\
10323\n\
10324SYNOPSIS:\n\
10325\n\
10326plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10327\n\
10328ARGUMENTS:\n\
10329\n\
10330 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10331 number of the strip chart to use on plstripa and plstripd.\n\
10332\n\
10333 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10334 the x-axis specification as in plbox.\n\
10335\n\
10336 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10337 the y-axis specification as in plbox.\n\
10338\n\
10339 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10340 change as data are added.\n\
10341\n\
10342 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10343 change as data are added.\n\
10344\n\
10345 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10346 is multiplied by the factor (1 +\n\
10347 xjump) .\n\
10348\n\
10349 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10350 change as data are added.\n\
10351\n\
10352 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10353 change as data are added.\n\
10354\n\
10355 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10356\n\
10357 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10358\n\
10359 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10360 true, otherwise not.\n\
10361\n\
10362 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10363 otherwise slide display.\n\
10364\n\
10365 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10366\n\
10367 collab (PLINT, input) : Legend color index (cmap0).\n\
10368\n\
10369 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10370 indices for the 4 pens.\n\
10371\n\
10372 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10373 indices for the 4 pens.\n\
10374\n\
10375 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10376 strings containing legends for the 4 pens.\n\
10377\n\
10378 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10379 the label for the x axis.\n\
10380\n\
10381 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10382 the label for the y axis.\n\
10383\n\
10384 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10385 the plot title.\n\
10386";
10387static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10388Deletes and releases memory used by a strip chart\n\
10389\n\
10390DESCRIPTION:\n\
10391\n\
10392 Deletes and releases memory used by a strip chart.\n\
10393\n\
10394 Redacted form: plstripd(id)\n\
10395\n\
10396 This function is used in example 17.\n\
10397\n\
10398\n\
10399\n\
10400SYNOPSIS:\n\
10401\n\
10402plstripd(id)\n\
10403\n\
10404ARGUMENTS:\n\
10405\n\
10406 id (PLINT, input) : Identification number of strip chart to delete.\n\
10407";
10408static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10409Set cmap1 colors using a piece-wise linear relationship\n\
10410\n\
10411DESCRIPTION:\n\
10412\n\
10413 Set cmap1 colors using a piece-wise linear relationship between the\n\
10414 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10415 (see the PLplot documentation). May be called at any time.\n\
10416\n\
10417 The idea here is to specify a number of control points that define the\n\
10418 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10419 these points, linear interpolation is used which gives a smooth\n\
10420 variation of color with intensity index. Any number of control points\n\
10421 may be specified, located at arbitrary positions, although typically 2\n\
10422 - 4 are enough. Another way of stating this is that we are traversing\n\
10423 a given number of lines through HLS or RGB space as we move through\n\
10424 cmap1 intensity indices. The control points at the minimum and\n\
10425 maximum position (0 and 1) must always be specified. By adding more\n\
10426 control points you can get more variation. One good technique for\n\
10427 plotting functions that vary about some expected average is to use an\n\
10428 additional 2 control points in the center (position ~= 0.5) that are\n\
10429 the same lightness as the background (typically white for paper\n\
10430 output, black for crt), and same hue as the boundary control points.\n\
10431 This allows the highs and lows to be very easily distinguished.\n\
10432\n\
10433 Each control point must specify the cmap1 intensity index and the\n\
10434 associated three coordinates in HLS or RGB space. The first point\n\
10435 must correspond to position = 0, and the last to position = 1.\n\
10436\n\
10437 If RGB colors are provided then the interpolation takes place in RGB\n\
10438 space and is trivial. However if HLS colors are provided then, because\n\
10439 of the circular nature of the color wheel for the hue coordinate, the\n\
10440 interpolation could be performed in either direction around the color\n\
10441 wheel. The default behaviour is for the hue to be linearly\n\
10442 interpolated ignoring this circular property of hue. So for example,\n\
10443 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10444 green and cyan. If instead you wish to interpolate the other way\n\
10445 around the color wheel you have two options. You may provide hues\n\
10446 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10447 for red the interpolation will proceed via magenta. Alternatively you\n\
10448 can utilise the alt_hue_path variable to reverse the direction of\n\
10449 interpolation if you need to provide hues within the [0-360) range.\n\
10450\n\
10451 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10452 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10453 -120]falsegreen-yellow-red-magenta-blue[240\n\
10454 480]falseblue-magenta-red-yellow-green[120\n\
10455 240]truegreen-yellow-red-magenta-blue[240\n\
10456 120]trueblue-magenta-red-yellow-green\n\
10457\n\
10458 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10459 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10460 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10461\n\
10462 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10463 alt_hue_path)\n\
10464\n\
10465 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10466\n\
10467\n\
10468\n\
10469SYNOPSIS:\n\
10470\n\
10471plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10472\n\
10473ARGUMENTS:\n\
10474\n\
10475 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10476\n\
10477 npts (PLINT, input) : number of control points\n\
10478\n\
10479 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10480 intensity index (0.0-1.0) in ascending order for each control\n\
10481 point.\n\
10482\n\
10483 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10484 coordinate (H or R) for each control point.\n\
10485\n\
10486 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10487 coordinate (L or G) for each control point.\n\
10488\n\
10489 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10490 coordinate (S or B) for each control point.\n\
10491\n\
10492 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10493 npts - 1 elements), each containing either true to use the reversed\n\
10494 HLS interpolation or false to use the regular HLS interpolation.\n\
10495 (alt_hue_path[i] refers to the interpolation interval between the\n\
10496 i and i + 1 control points). This parameter is not used for RGB\n\
10497 colors (\n\
10498 itype = true).\n\
10499";
10500static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10501Shade individual region on the basis of value\n\
10502\n\
10503DESCRIPTION:\n\
10504\n\
10505 Shade individual region on the basis of value. Use plshades if you\n\
10506 want to shade a number of contiguous regions using continuous colors.\n\
10507 In particular the edge contours are treated properly in plshades. If\n\
10508 you attempt to do contiguous regions with plshade the contours at the\n\
10509 edge of the shade are partially obliterated by subsequent plots of\n\
10510 contiguous shaded regions.\n\
10511\n\
10512 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10513 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10514 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10515\n\
10516\n\
10517 This function is used in example 15.\n\
10518\n\
10519\n\
10520\n\
10521SYNOPSIS:\n\
10522\n\
10523plshade(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\
10524\n\
10525ARGUMENTS:\n\
10526\n\
10527 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10528 plot. Should have dimensions of\n\
10529 nx by\n\
10530 ny.\n\
10531\n\
10532 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10533\n\
10534 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10535\n\
10536 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10537 the region that should be plotted in the shade plot. This\n\
10538 function accepts x and y coordinates as input arguments and must\n\
10539 return 1 if the point is to be included in the shade plot and 0\n\
10540 otherwise. If you want to plot the entire shade plot (the usual\n\
10541 case), this argument should be set to NULL.\n\
10542\n\
10543 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10544 pltr below for how these arguments are used (only for the special case\n\
10545 when the callback function\n\
10546 pltr is not supplied).\n\
10547\n\
10548 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10549 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10550\n\
10551 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10552 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10553\n\
10554 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10555 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10556 then sh_color is interpreted as a cmap1 argument in the range\n\
10557 (0.0-1.0).\n\
10558\n\
10559 sh_color (PLFLT, input) : Defines color map index with integer\n\
10560 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10561\n\
10562 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10563\n\
10564 min_color (PLINT, input) : Defines pen color, width used by the\n\
10565 boundary of shaded region. The min values are used for the\n\
10566 shade_min boundary, and the max values are used on the shade_max\n\
10567 boundary. Set color and width to zero for no plotted boundaries.\n\
10568\n\
10569 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10570 boundary of shaded region. The min values are used for the\n\
10571 shade_min boundary, and the max values are used on the shade_max\n\
10572 boundary. Set color and width to zero for no plotted boundaries.\n\
10573\n\
10574 max_color (PLINT, input) : Defines pen color, width used by the\n\
10575 boundary of shaded region. The min values are used for the\n\
10576 shade_min boundary, and the max values are used on the shade_max\n\
10577 boundary. Set color and width to zero for no plotted boundaries.\n\
10578\n\
10579 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10580 boundary of shaded region. The min values are used for the\n\
10581 shade_min boundary, and the max values are used on the shade_max\n\
10582 boundary. Set color and width to zero for no plotted boundaries.\n\
10583\n\
10584 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10585 Use plfill. Future version of PLplot may have other fill\n\
10586 routines.\n\
10587\n\
10588 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10589 map to rectangles after coordinate transformation with pltrl.\n\
10590 Otherwise, set rectangular to false. If rectangular is set to\n\
10591 true, plshade tries to save time by filling large rectangles.\n\
10592 This optimization fails if the coordinate transformation distorts\n\
10593 the shape of rectangles. For example a plot in polar coordinates\n\
10594 has to have rectangular set to false.\n\
10595\n\
10596 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10597 defines the transformation between the zero-based indices of the\n\
10598 matrix a and world coordinates. If\n\
10599 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10600 indices of a are mapped to the range\n\
10601 xmin through\n\
10602 xmax and the y indices of a are mapped to the range\n\
10603 ymin through\n\
10604 ymax.For the C case, transformation functions are provided in the\n\
10605 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10606 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10607 matrices. In addition, C callback routines for the transformation\n\
10608 can be supplied by the user such as the mypltr function in\n\
10609 examples/c/x09c.c which provides a general linear transformation\n\
10610 between index coordinates and world coordinates.For languages\n\
10611 other than C you should consult the PLplot documentation for the\n\
10612 details concerning how PLTRANSFORM_callback arguments are\n\
10613 interfaced. However, in general, a particular pattern of\n\
10614 callback-associated arguments such as a tr vector with 6 elements;\n\
10615 xg and yg vectors; or xg and yg matrices are respectively\n\
10616 interfaced to a linear-transformation routine similar to the above\n\
10617 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10618 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10619 support native language callbacks for handling index to\n\
10620 world-coordinate transformations. Examples of these various\n\
10621 approaches are given in examples/<language>x09*,\n\
10622 examples/<language>x16*, examples/<language>x20*,\n\
10623 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10624 supported languages.\n\
10625\n\
10626 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10627 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10628 externally supplied.\n\
10629";
10630static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10631Set number of colors in cmap1\n\
10632\n\
10633DESCRIPTION:\n\
10634\n\
10635 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10636 values if this is the first allocation (see the PLplot documentation).\n\
10637\n\
10638 Redacted form: plscmap1n(ncol1)\n\
10639\n\
10640 This function is used in examples 8, 11, 20, and 21.\n\
10641\n\
10642\n\
10643\n\
10644SYNOPSIS:\n\
10645\n\
10646plscmap1n(ncol1)\n\
10647\n\
10648ARGUMENTS:\n\
10649\n\
10650 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10651 the cmap1 palette. If this number is zero or less, then the value\n\
10652 from the previous call to plscmap1n is used and if there is no\n\
10653 previous call, then a default value is used.\n\
10654";
10655static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10656Advance to the next family file on the next new page\n\
10657\n\
10658DESCRIPTION:\n\
10659\n\
10660 Advance to the next family file on the next new page.\n\
10661\n\
10662 Redacted form: plfamadv()\n\
10663\n\
10664 This function is not used in any examples.\n\
10665\n\
10666\n\
10667\n\
10668SYNOPSIS:\n\
10669\n\
10670plfamadv()\n\
10671";
10672static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10673Set the escape character for text strings\n\
10674\n\
10675DESCRIPTION:\n\
10676\n\
10677 Set the escape character for text strings. From C (in contrast to\n\
10678 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10679 characters are allowed to prevent the user from shooting himself in\n\
10680 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10681 use of backslash as a character escape). Here are the allowed escape\n\
10682 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10683 #, ASCII 35\n\
10684 $, ASCII 36\n\
10685 %, ASCII 37\n\
10686 &, ASCII 38\n\
10687 *, ASCII 42\n\
10688 @, ASCII 64\n\
10689 ^, ASCII 94\n\
10690 ~, ASCII 126\n\
10691\n\
10692\n\
10693 Redacted form: General: plsesc(esc)\n\
10694\n\
10695\n\
10696 This function is used in example 29.\n\
10697\n\
10698\n\
10699\n\
10700SYNOPSIS:\n\
10701\n\
10702plsesc(esc)\n\
10703\n\
10704ARGUMENTS:\n\
10705\n\
10706 esc (char, input) : Escape character.\n\
10707";
10708static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10709Plot color bar for image, shade or gradient plots\n\
10710\n\
10711DESCRIPTION:\n\
10712\n\
10713 Routine for creating a continuous color bar for image, shade, or\n\
10714 gradient plots. (See pllegend for similar functionality for creating\n\
10715 legends with discrete elements). The arguments of plcolorbar provide\n\
10716 control over the location and size of the color bar as well as the\n\
10717 location and characteristics of the elements (most of which are\n\
10718 optional) within that color bar. The resulting color bar is clipped\n\
10719 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10720 system used for some of the parameters is defined in the documentation\n\
10721 of the position parameter.)\n\
10722\n\
10723 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10724 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10725 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10726 labels, axis_opts, ticks, sub_ticks, values)\n\
10727\n\
10728 This function is used in examples 16 and 33.\n\
10729\n\
10730\n\
10731\n\
10732SYNOPSIS:\n\
10733\n\
10734plcolorbar(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\
10735\n\
10736ARGUMENTS:\n\
10737\n\
10738 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10739 labelled and decorated color bar width in adopted coordinates.\n\
10740\n\
10741 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10742 labelled and decorated color bar height in adopted coordinates.\n\
10743\n\
10744 opt (PLINT, input) : opt contains bits controlling the overall\n\
10745 color bar. The orientation (direction of the maximum value) of\n\
10746 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10747 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10748 specified, the default orientation is toward the top if the\n\
10749 colorbar is placed on the left or right of the viewport or toward\n\
10750 the right if the colorbar is placed on the top or bottom of the\n\
10751 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10752 (semitransparent) background for the color bar. If the\n\
10753 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10754 color bar. The type of color bar must be specified with one of\n\
10755 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10756 more than one of those bits is set only the first one in the above\n\
10757 list is honored. The position of the (optional) label/title can be\n\
10758 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10759 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10760 will be drawn. If more than one of this list of bits is specified,\n\
10761 only the first one on the list is honored. End-caps for the color\n\
10762 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10763 If a particular color bar cap option is not specified then no cap\n\
10764 will be drawn for that end. As a special case for\n\
10765 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10766 specified. If this option is provided then any tick marks and tick\n\
10767 labels will be placed at the breaks between shaded segments. TODO:\n\
10768 This should be expanded to support custom placement of tick marks\n\
10769 and tick labels at custom value locations for any color bar type.\n\
10770\n\
10771 position (PLINT, input) : position contains bits which control the\n\
10772 overall position of the color bar and the definition of the\n\
10773 adopted coordinates used for positions just like what is done for\n\
10774 the position argument for pllegend. However, note that the\n\
10775 defaults for the position bits (see below) are different than the\n\
10776 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10777 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10778 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10779 the 16 possible standard positions (the 4 corners and centers of\n\
10780 the 4 sides for both the inside and outside cases) of the color\n\
10781 bar relative to the adopted coordinate system. The corner\n\
10782 positions are specified by the appropriate combination of two of\n\
10783 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10784 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10785 value of one of those bits. The adopted coordinates are\n\
10786 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10787 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10788 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10789 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10790 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10791 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10792 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10793 PL_POSITION_VIEWPORT.\n\
10794\n\
10795 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10796 coordinates from the specified standard position of the color bar.\n\
10797 For positive x, the direction of motion away from the standard\n\
10798 position is inward/outward from the standard corner positions or\n\
10799 standard left or right positions if the\n\
10800 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10801 For the standard top or bottom positions, the direction of motion\n\
10802 is toward positive X.\n\
10803\n\
10804 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10805 coordinates from the specified standard position of the color bar.\n\
10806 For positive y, the direction of motion away from the standard\n\
10807 position is inward/outward from the standard corner positions or\n\
10808 standard top or bottom positions if the\n\
10809 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10810 For the standard left or right positions, the direction of motion\n\
10811 is toward positive Y.\n\
10812\n\
10813 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10814 the X direction in adopted coordinates.\n\
10815\n\
10816 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10817 the Y direction in adopted coordinates.\n\
10818\n\
10819 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10820 color bar (PL_COLORBAR_BACKGROUND).\n\
10821\n\
10822 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10823 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10824\n\
10825 bb_style (PLINT, input) : The pllsty style number for the\n\
10826 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10827\n\
10828 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10829 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10830\n\
10831 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10832 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10833\n\
10834 cont_color (PLINT, input) : The cmap0 contour color for\n\
10835 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10836 it will be interpreted according to the design of plshades.\n\
10837\n\
10838 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10839 plots. This is passed directly to plshades, so it will be\n\
10840 interpreted according to the design of plshades.\n\
10841\n\
10842 n_labels (PLINT, input) : Number of labels to place around the\n\
10843 color bar.\n\
10844\n\
10845 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10846 n_labels labels.\n\
10847\n\
10848 labels (PLCHAR_MATRIX, input) : A vector of\n\
10849 n_labels UTF-8 character strings containing the labels for the color\n\
10850 bar. Ignored if no label position is specified with one of the\n\
10851 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10852 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10853 corresponding label_opts field.\n\
10854\n\
10855 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10856 value must be greater than 0. It is typically 1 (numerical axis\n\
10857 labels are provided for one of the long edges of the color bar),\n\
10858 but it can be larger if multiple numerical axis labels for the\n\
10859 long edges of the color bar are desired.\n\
10860\n\
10861 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10862 n_axes ascii character strings containing options (interpreted as for\n\
10863 plbox) for the color bar\'s axis definitions.\n\
10864\n\
10865 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10866 spacing of the major tick marks (interpreted as for plbox) for the\n\
10867 color bar\'s axis definitions.\n\
10868\n\
10869 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10870 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10871 axis definitions.\n\
10872\n\
10873 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10874 elements in each of the n_axes rows of the values matrix.\n\
10875\n\
10876 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10877 values for the data range represented by the color bar. For a row\n\
10878 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10879 elements in the row is specified by n_values[i_axis]. For\n\
10880 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10881 is 2, and the corresponding row elements of the values matrix are\n\
10882 the minimum and maximum value represented by the colorbar. For\n\
10883 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10884 of the values matrix is interpreted the same as the nlevel and\n\
10885 clevel arguments of plshades.\n\
10886";
10887static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10888Set current output stream\n\
10889\n\
10890DESCRIPTION:\n\
10891\n\
10892 Sets the number of the current output stream. The stream number\n\
10893 defaults to 0 unless changed by this routine. The first use of this\n\
10894 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10895\n\
10896 Redacted form: plsstrm(strm)\n\
10897\n\
10898 This function is examples 1,14,20.\n\
10899\n\
10900\n\
10901\n\
10902SYNOPSIS:\n\
10903\n\
10904plsstrm(strm)\n\
10905\n\
10906ARGUMENTS:\n\
10907\n\
10908 strm (PLINT, input) : The current stream number.\n\
10909";
10910static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10911Get the current device-compression setting\n\
10912\n\
10913DESCRIPTION:\n\
10914\n\
10915 Get the current device-compression setting. This parameter is only\n\
10916 used for drivers that provide compression.\n\
10917\n\
10918 Redacted form: plgcompression(compression)\n\
10919\n\
10920 This function is used in example 31.\n\
10921\n\
10922\n\
10923\n\
10924SYNOPSIS:\n\
10925\n\
10926plgcompression(compression)\n\
10927\n\
10928ARGUMENTS:\n\
10929\n\
10930 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10931 compression setting for the current device.\n\
10932";
10933static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10934Grid data from irregularly sampled data\n\
10935\n\
10936DESCRIPTION:\n\
10937\n\
10938 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10939 require data organized as a grid, i.e., with x sample point values\n\
10940 independent of y coordinate and vice versa. This function takes\n\
10941 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10942 vectors; reads the desired grid location from the input vectors\n\
10943 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10944 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10945 interpolate the data to the grid is specified with the argument type\n\
10946 which can have one parameter specified in argument data.\n\
10947\n\
10948 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10949 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10950\n\
10951\n\
10952 This function is used in example 21.\n\
10953\n\
10954\n\
10955\n\
10956SYNOPSIS:\n\
10957\n\
10958plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10959\n\
10960ARGUMENTS:\n\
10961\n\
10962 x (PLFLT_VECTOR, input) : The input x vector.\n\
10963\n\
10964 y (PLFLT_VECTOR, input) : The input y vector.\n\
10965\n\
10966 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10967 y[i], z[i] represents one data sample coordinate.\n\
10968\n\
10969 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10970 vectors.\n\
10971\n\
10972 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10973 in the x direction. Usually xg has nptsx equally spaced values\n\
10974 from the minimum to the maximum values of the x input vector.\n\
10975\n\
10976 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10977\n\
10978 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10979 in the y direction. Similar to the xg parameter.\n\
10980\n\
10981 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10982\n\
10983 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10984 where data lies in the grid specified by xg and yg. Therefore the\n\
10985 zg matrix must be dimensioned\n\
10986 nptsx by\n\
10987 nptsy.\n\
10988\n\
10989 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10990 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10991 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10992 GRID_NNI: Natural Neighbors Interpolation\n\
10993 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10994 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10995 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10996 Weighted\n\
10997 For details of the algorithms read the source file plgridd.c.\n\
10998\n\
10999 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
11000 which can be specified through this argument. Currently, for\n\
11001 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11002 use, the lower the value, the noisier (more local) the\n\
11003 approximation is.\n\
11004 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11005 range [1. .. 2.]. High values enable the usage of very thin\n\
11006 triangles for interpolation, possibly resulting in error in\n\
11007 the approximation.\n\
11008 GRID_NNI, only weights greater than data will be accepted. If\n\
11009 0, all weights will be accepted.\n\
11010";
11011
11012SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
11013 PLINT arg1 ;
11014 PLINT *arg2 = (PLINT *) 0 ;
11015 char **arg3 = (char **) 0 ;
11016 Matrix temp1 ;
11017 octave_value_list _out;
11018 octave_value_list *_outp=&_out;
11019 octave_value _outv;
11020
11021 try {
11022 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
11023 SWIG_fail;
11024 }
11025 {
11026 if ( _n_dims( args(0) ) > 1 )
11027 {
11028 error( "argument must be a scalar or vector" ); SWIG_fail;
11029 }
11030 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
11031 arg2 = new PLINT[Alen];
11032 temp1 = args(0).matrix_value();
11033 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
11034 }
11035 {
11036 charMatrix temp_matrix;
11037 Cell temp_cell;
11038 char *tmp_cstring;
11039 std::string str;
11040 size_t max_length = 0, non_blank_length;
11041 int i, ifcell;
11042 if ( _n_dims( args(1) ) > 2 )
11043 {
11044 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11045 }
11046#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11047 if ( !args(1).isempty() )
11048#else
11049 if ( !args(1).is_empty() )
11050#endif
11051 {
11052 if ( _dim( args(1), 0 ) != Alen )
11053 {
11054 error( "first dimension must be same length as previous vector" ); SWIG_fail;
11055 }
11056 arg3 = new char*[Alen];
11057#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11058 ifcell = args(1).iscell();
11059#else
11060 ifcell = args(1).is_cell();
11061#endif
11062 if ( ifcell )
11063 {
11064 temp_cell = args(1).cell_value();
11065 }
11066 else
11067 {
11068 temp_matrix = args(1).char_matrix_value();
11069 // Allow one extra space for null termination.
11070 max_length = _dim( args(1), 1 ) + 1;
11071 }
11072
11073 for ( i = 0; i < Alen; i++ )
11074 {
11075 // Must copy string to "permanent" location because the string
11076 // location corresponding to tmp_cstring gets
11077 // overwritten for each iteration of loop.
11078 if ( ifcell )
11079 {
11080 if ( temp_cell.elem( i ).is_string() )
11081 {
11082 str = temp_cell.elem( i ).string_value();
11083 // leave room for null termination.
11084 max_length = str.size() + 1;
11085 tmp_cstring = (char *) str.c_str();
11086 }
11087 else
11088 {
11089 // Use null string if user attempts to pass a cell array
11090 // with a non-string element (likely an empty element
11091 // since that should be allowed by the PLplot interface
11092 // if that element is going to be unused).
11093 // leave room for null termination.
11094 max_length = 1;
11095 tmp_cstring = (char *) "";
11096 }
11097 }
11098 else
11099 {
11100 str = temp_matrix.row_as_string( i );
11101 tmp_cstring = (char *) str.c_str();
11102 }
11103 arg3[i] = new char[max_length];
11104 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11105 arg3[i][max_length - 1] = '\0';
11106 // All the trailing blank crapola should not be needed for
11107 // string cell arrays.
11108 if ( !ifcell )
11109 {
11110 // remove trailing-blank padding that is used by the
11111 // charMatrix class to insure all strings in a given
11112 // charMatrix instance have the same length.
11113 // This transformation also removes legitimate trailing
11114 // blanks but there is nothing we can do about that
11115 // for the charMatrix class.
11116
11117 // Look for trailing nulls first (just in case, although that
11118 // shouldn't happen if charMatrix implemented as documented)
11119 // before looking for trailing blanks.
11120 non_blank_length = max_length - 2;
11121 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11122 {
11123 non_blank_length--;
11124 }
11125 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11126 {
11127 non_blank_length--;
11128 }
11129 arg3[i][non_blank_length + 1] = '\0';
11130 }
11131 }
11132 }
11133 else
11134 {
11135 arg3 = NULL;
11136 }
11137 }
11138 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11139 _outv = octave_value();
11140 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11141 {
11142 delete [] arg2;
11143 }
11144 {
11145 int i;
11146 if ( arg3 != NULL )
11147 {
11148 for ( i = 0; i < Alen; i++ )
11149 {
11150 delete[] arg3[i];
11151 }
11152 delete[] arg3;
11153 }
11154 }
11155 return _out;
11156 fail:
11157 {
11158 delete [] arg2;
11159 }
11160 {
11161 int i;
11162 if ( arg3 != NULL )
11163 {
11164 for ( i = 0; i < Alen; i++ )
11165 {
11166 delete[] arg3[i];
11167 }
11168 delete[] arg3;
11169 }
11170 }
11171 return octave_value_list();
11172 }
11173 catch(...) {
11174 {
11175 delete [] arg2;
11176 }
11177 {
11178 int i;
11179 if ( arg3 != NULL )
11180 {
11181 for ( i = 0; i < Alen; i++ )
11182 {
11183 delete[] arg3[i];
11184 }
11185 delete[] arg3;
11186 }
11187 }
11188 throw;
11189 }
11190}
11191
11192
11194 int *arg1 = (int *) 0 ;
11195 int *arg2 = (int *) 0 ;
11196 int *arg3 = (int *) 0 ;
11197 char *arg4 = (char *) 0 ;
11198 int *arg5 = (int *) 0 ;
11199 int *arg6 = (int *) 0 ;
11200 PLFLT *arg7 = (PLFLT *) 0 ;
11201 PLFLT *arg8 = (PLFLT *) 0 ;
11202 PLFLT *arg9 = (PLFLT *) 0 ;
11203 PLFLT *arg10 = (PLFLT *) 0 ;
11204 int *arg11 = (int *) 0 ;
11205 int temp1 ;
11206 int res1 = SWIG_TMPOBJ ;
11207 int temp2 ;
11208 int res2 = SWIG_TMPOBJ ;
11209 int temp3 ;
11210 int res3 = SWIG_TMPOBJ ;
11211 char local_string4[80] ;
11212 int temp5 ;
11213 int res5 = SWIG_TMPOBJ ;
11214 int temp6 ;
11215 int res6 = SWIG_TMPOBJ ;
11216 PLFLT temp7 ;
11217 int res7 = SWIG_TMPOBJ ;
11218 PLFLT temp8 ;
11219 int res8 = SWIG_TMPOBJ ;
11220 PLFLT temp9 ;
11221 int res9 = SWIG_TMPOBJ ;
11222 PLFLT temp10 ;
11223 int res10 = SWIG_TMPOBJ ;
11224 int temp11 ;
11225 int res11 = SWIG_TMPOBJ ;
11226 size_t local_string_length4 ;
11227 charMatrix local_charMatrix4 ;
11228 octave_value_list retval4 ;
11229 octave_value_list _out;
11230 octave_value_list *_outp=&_out;
11231 octave_value _outv;
11232 int result;
11233
11234 try {
11235 arg1 = &temp1;
11236 arg2 = &temp2;
11237 arg3 = &temp3;
11238 {
11239 arg4 = local_string4;
11240 }
11241 arg5 = &temp5;
11242 arg6 = &temp6;
11243 arg7 = &temp7;
11244 arg8 = &temp8;
11245 arg9 = &temp9;
11246 arg10 = &temp10;
11247 arg11 = &temp11;
11248 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11249 SWIG_fail;
11250 }
11251 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11252 _outv = SWIG_From_int(static_cast< int >(result));
11253 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11254 if (SWIG_IsTmpObj(res1)) {
11255 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11256 } else {
11257 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11258 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11259 }
11260 if (SWIG_IsTmpObj(res2)) {
11261 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11262 } else {
11263 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11264 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11265 }
11266 if (SWIG_IsTmpObj(res3)) {
11267 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11268 } else {
11269 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11270 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11271 }
11272 {
11273 local_string_length4 = strlen( local_string4 );
11274 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11275 local_charMatrix4.insert( local_string4, 0, 0 );
11276 retval4( 0 ) = octave_value( local_charMatrix4 );
11277 _outp = SWIG_Octave_AppendOutput(_outp, retval4( 0 ));
11278 }
11279 if (SWIG_IsTmpObj(res5)) {
11280 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11281 } else {
11282 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11283 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11284 }
11285 if (SWIG_IsTmpObj(res6)) {
11286 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11287 } else {
11288 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11289 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11290 }
11291 if (SWIG_IsTmpObj(res7)) {
11292 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11293 } else {
11294 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11295 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11296 }
11297 if (SWIG_IsTmpObj(res8)) {
11298 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11299 } else {
11300 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11301 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11302 }
11303 if (SWIG_IsTmpObj(res9)) {
11304 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11305 } else {
11306 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11307 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11308 }
11309 if (SWIG_IsTmpObj(res10)) {
11310 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11311 } else {
11312 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11313 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11314 }
11315 if (SWIG_IsTmpObj(res11)) {
11316 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11317 } else {
11318 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11319 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11320 }
11321 return _out;
11322 fail:
11323 return octave_value_list();
11324 }
11325 catch(...) {
11326 throw;
11327 }
11328}
11329
11330
11331SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11332 PLFLT *arg1 = (PLFLT *) 0 ;
11333 PLFLT *arg2 = (PLFLT *) 0 ;
11334 PLFLT arg3 ;
11335 PLFLT arg4 ;
11336 PLFLT temp1 ;
11337 int res1 = SWIG_TMPOBJ ;
11338 PLFLT temp2 ;
11339 int res2 = SWIG_TMPOBJ ;
11340 double val3 ;
11341 int ecode3 = 0 ;
11342 double val4 ;
11343 int ecode4 = 0 ;
11344 octave_value_list _out;
11345 octave_value_list *_outp=&_out;
11346 octave_value _outv;
11347 int result;
11348
11349 try {
11350 arg1 = &temp1;
11351 arg2 = &temp2;
11352 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11353 SWIG_fail;
11354 }
11355 ecode3 = SWIG_AsVal_double(args(0), &val3);
11356 if (!SWIG_IsOK(ecode3)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11358 }
11359 arg3 = static_cast< PLFLT >(val3);
11360 ecode4 = SWIG_AsVal_double(args(1), &val4);
11361 if (!SWIG_IsOK(ecode4)) {
11362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11363 }
11364 arg4 = static_cast< PLFLT >(val4);
11365 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11366 _outv = SWIG_From_int(static_cast< int >(result));
11367 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11368 if (SWIG_IsTmpObj(res1)) {
11369 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11370 } else {
11371 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11372 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11373 }
11374 if (SWIG_IsTmpObj(res2)) {
11375 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11376 } else {
11377 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11378 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11379 }
11380 return _out;
11381 fail:
11382 return octave_value_list();
11383 }
11384 catch(...) {
11385 throw;
11386 }
11387}
11388
11389
11391 PLINT *arg1 = (PLINT *) 0 ;
11392 char *arg2 = (char *) 0 ;
11393 char *arg3 = (char *) 0 ;
11394 PLFLT arg4 ;
11395 PLFLT arg5 ;
11396 PLFLT arg6 ;
11397 PLFLT arg7 ;
11398 PLFLT arg8 ;
11399 PLFLT arg9 ;
11400 PLFLT arg10 ;
11401 PLBOOL arg11 ;
11402 PLBOOL arg12 ;
11403 PLINT arg13 ;
11404 PLINT arg14 ;
11405 PLINT *arg15 = (PLINT *) 0 ;
11406 PLINT *arg16 = (PLINT *) 0 ;
11407 char *arg17 = (char *) 0 ;
11408 char *arg18 = (char *) 0 ;
11409 char *arg19 = (char *) 0 ;
11410 char *arg20 = (char *) 0 ;
11411 char *arg21 = (char *) 0 ;
11412 char *arg22 = (char *) 0 ;
11413 char *arg23 = (char *) 0 ;
11414 PLINT temp1 ;
11415 int res1 = SWIG_TMPOBJ ;
11416 int res2 ;
11417 char *buf2 = 0 ;
11418 int alloc2 = 0 ;
11419 int res3 ;
11420 char *buf3 = 0 ;
11421 int alloc3 = 0 ;
11422 double val4 ;
11423 int ecode4 = 0 ;
11424 double val5 ;
11425 int ecode5 = 0 ;
11426 double val6 ;
11427 int ecode6 = 0 ;
11428 double val7 ;
11429 int ecode7 = 0 ;
11430 double val8 ;
11431 int ecode8 = 0 ;
11432 double val9 ;
11433 int ecode9 = 0 ;
11434 double val10 ;
11435 int ecode10 = 0 ;
11436 int val11 ;
11437 int ecode11 = 0 ;
11438 int val12 ;
11439 int ecode12 = 0 ;
11440 int val13 ;
11441 int ecode13 = 0 ;
11442 int val14 ;
11443 int ecode14 = 0 ;
11444 Matrix temp15 ;
11445 Matrix temp16 ;
11446 int res17 ;
11447 char *buf17 = 0 ;
11448 int alloc17 = 0 ;
11449 int res18 ;
11450 char *buf18 = 0 ;
11451 int alloc18 = 0 ;
11452 int res19 ;
11453 char *buf19 = 0 ;
11454 int alloc19 = 0 ;
11455 int res20 ;
11456 char *buf20 = 0 ;
11457 int alloc20 = 0 ;
11458 int res21 ;
11459 char *buf21 = 0 ;
11460 int alloc21 = 0 ;
11461 int res22 ;
11462 char *buf22 = 0 ;
11463 int alloc22 = 0 ;
11464 int res23 ;
11465 char *buf23 = 0 ;
11466 int alloc23 = 0 ;
11467 octave_value_list _out;
11468 octave_value_list *_outp=&_out;
11469 octave_value _outv;
11470
11471 try {
11472 arg1 = &temp1;
11473 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11474 SWIG_fail;
11475 }
11476 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11477 if (!SWIG_IsOK(res2)) {
11478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11479 }
11480 arg2 = reinterpret_cast< char * >(buf2);
11481 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11482 if (!SWIG_IsOK(res3)) {
11483 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11484 }
11485 arg3 = reinterpret_cast< char * >(buf3);
11486 ecode4 = SWIG_AsVal_double(args(2), &val4);
11487 if (!SWIG_IsOK(ecode4)) {
11488 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11489 }
11490 arg4 = static_cast< PLFLT >(val4);
11491 ecode5 = SWIG_AsVal_double(args(3), &val5);
11492 if (!SWIG_IsOK(ecode5)) {
11493 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11494 }
11495 arg5 = static_cast< PLFLT >(val5);
11496 ecode6 = SWIG_AsVal_double(args(4), &val6);
11497 if (!SWIG_IsOK(ecode6)) {
11498 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11499 }
11500 arg6 = static_cast< PLFLT >(val6);
11501 ecode7 = SWIG_AsVal_double(args(5), &val7);
11502 if (!SWIG_IsOK(ecode7)) {
11503 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11504 }
11505 arg7 = static_cast< PLFLT >(val7);
11506 ecode8 = SWIG_AsVal_double(args(6), &val8);
11507 if (!SWIG_IsOK(ecode8)) {
11508 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11509 }
11510 arg8 = static_cast< PLFLT >(val8);
11511 ecode9 = SWIG_AsVal_double(args(7), &val9);
11512 if (!SWIG_IsOK(ecode9)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11514 }
11515 arg9 = static_cast< PLFLT >(val9);
11516 ecode10 = SWIG_AsVal_double(args(8), &val10);
11517 if (!SWIG_IsOK(ecode10)) {
11518 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11519 }
11520 arg10 = static_cast< PLFLT >(val10);
11521 ecode11 = SWIG_AsVal_int(args(9), &val11);
11522 if (!SWIG_IsOK(ecode11)) {
11523 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11524 }
11525 arg11 = static_cast< PLBOOL >(val11);
11526 ecode12 = SWIG_AsVal_int(args(10), &val12);
11527 if (!SWIG_IsOK(ecode12)) {
11528 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11529 }
11530 arg12 = static_cast< PLBOOL >(val12);
11531 ecode13 = SWIG_AsVal_int(args(11), &val13);
11532 if (!SWIG_IsOK(ecode13)) {
11533 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11534 }
11535 arg13 = static_cast< PLINT >(val13);
11536 ecode14 = SWIG_AsVal_int(args(12), &val14);
11537 if (!SWIG_IsOK(ecode14)) {
11538 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11539 }
11540 arg14 = static_cast< PLINT >(val14);
11541 {
11542 if ( _n_dims( args(13) ) > 1 )
11543 {
11544 error( "argument must be a scalar or vector" ); SWIG_fail;
11545 }
11546 Alen = (PLINT) ( _dim( args(13), 0 ) );
11547 temp15 = args(13).matrix_value();
11548 arg15 = new PLINT[Alen];
11549 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11550 }
11551 {
11552 if ( _n_dims( args(14) ) > 1 )
11553 {
11554 error( "argument must be a scalar or vector" ); SWIG_fail;
11555 }
11556 if ( _dim( args(14), 0 ) != Alen )
11557 {
11558 error( "argument vectors must be same length" ); SWIG_fail;
11559 }
11560 temp16 = args(14).matrix_value();
11561 arg16 = new PLINT[Alen];
11562 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11563 }
11564 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11565 if (!SWIG_IsOK(res17)) {
11566 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11567 }
11568 arg17 = reinterpret_cast< char * >(buf17);
11569 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11570 if (!SWIG_IsOK(res18)) {
11571 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11572 }
11573 arg18 = reinterpret_cast< char * >(buf18);
11574 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11575 if (!SWIG_IsOK(res19)) {
11576 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11577 }
11578 arg19 = reinterpret_cast< char * >(buf19);
11579 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11580 if (!SWIG_IsOK(res20)) {
11581 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11582 }
11583 arg20 = reinterpret_cast< char * >(buf20);
11584 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11585 if (!SWIG_IsOK(res21)) {
11586 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11587 }
11588 arg21 = reinterpret_cast< char * >(buf21);
11589 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11590 if (!SWIG_IsOK(res22)) {
11591 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11592 }
11593 arg22 = reinterpret_cast< char * >(buf22);
11594 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11595 if (!SWIG_IsOK(res23)) {
11596 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11597 }
11598 arg23 = reinterpret_cast< char * >(buf23);
11599 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);
11600 _outv = octave_value();
11601 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11602 if (SWIG_IsTmpObj(res1)) {
11603 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11604 } else {
11605 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11606 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11607 }
11608 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11609 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11610 {
11611 delete [] arg15;
11612 }
11613 {
11614 delete [] arg16;
11615 }
11616 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11617 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11618 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11619 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11620 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11621 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11622 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11623 return _out;
11624 fail:
11625 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11626 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11627 {
11628 delete [] arg15;
11629 }
11630 {
11631 delete [] arg16;
11632 }
11633 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11634 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11635 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11636 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11637 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11638 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11639 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11640 return octave_value_list();
11641 }
11642 catch(...) {
11643 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11644 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11645 {
11646 delete [] arg15;
11647 }
11648 {
11649 delete [] arg16;
11650 }
11651 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11652 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11653 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11654 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11655 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11656 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11657 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11658 throw;
11659 }
11660}
11661
11662
11664 PLFLT *arg1 = (PLFLT *) 0 ;
11665 PLINT arg2 ;
11666 PLINT arg3 ;
11667 PLINT arg4 ;
11668 PLINT arg5 ;
11669 PLINT arg6 ;
11670 PLINT arg7 ;
11671 PLFLT *arg8 = (PLFLT *) 0 ;
11672 PLINT arg9 ;
11673 PLFLT *arg10 = (PLFLT *) 0 ;
11674 Matrix temp1 ;
11675 int val4 ;
11676 int ecode4 = 0 ;
11677 int val5 ;
11678 int ecode5 = 0 ;
11679 int val6 ;
11680 int ecode6 = 0 ;
11681 int val7 ;
11682 int ecode7 = 0 ;
11683 Matrix temp8 ;
11684 Matrix temp10 ;
11685 octave_value_list _out;
11686 octave_value_list *_outp=&_out;
11687 octave_value _outv;
11688
11689 try {
11690 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11691 SWIG_fail;
11692 }
11693 {
11694 if ( _n_dims( args(0) ) > 2 )
11695 {
11696 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11697 }
11698 temp1 = args(0).matrix_value();
11699 arg1 = &temp1( 0, 0 );
11700 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11701 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11702 }
11703 ecode4 = SWIG_AsVal_int(args(1), &val4);
11704 if (!SWIG_IsOK(ecode4)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11706 }
11707 arg4 = static_cast< PLINT >(val4);
11708 ecode5 = SWIG_AsVal_int(args(2), &val5);
11709 if (!SWIG_IsOK(ecode5)) {
11710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11711 }
11712 arg5 = static_cast< PLINT >(val5);
11713 ecode6 = SWIG_AsVal_int(args(3), &val6);
11714 if (!SWIG_IsOK(ecode6)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11716 }
11717 arg6 = static_cast< PLINT >(val6);
11718 ecode7 = SWIG_AsVal_int(args(4), &val7);
11719 if (!SWIG_IsOK(ecode7)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11721 }
11722 arg7 = static_cast< PLINT >(val7);
11723 {
11724 if ( _n_dims( args(5) ) > 1 )
11725 {
11726 error( "argument must be a scalar or vector" ); SWIG_fail;
11727 }
11728 temp8 = args(5).matrix_value();
11729 arg8 = &temp8( 0, 0 );
11730 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11731 }
11732 {
11733 if ( _n_dims( args(6) ) > 1 )
11734 {
11735 error( "argument must be a scalar or vector" ); SWIG_fail;
11736 }
11737 if ( _dim( args(6), 0 ) != 6 )
11738 {
11739 error( "argument vectors must have length of 6" ); SWIG_fail;
11740 }
11741 temp10 = args(6).matrix_value();
11742 arg10 = &temp10( 0, 0 );
11743 }
11744 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11745 _outv = octave_value();
11746 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11747 {
11748
11749 }
11750 {
11751
11752 }
11753 {
11754
11755 }
11756 return _out;
11757 fail:
11758 {
11759
11760 }
11761 {
11762
11763 }
11764 {
11765
11766 }
11767 return octave_value_list();
11768 }
11769 catch(...) {
11770 {
11771
11772 }
11773 {
11774
11775 }
11776 {
11777
11778 }
11779 throw;
11780 }
11781}
11782
11783
11784SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11785 PLFLT *arg1 = (PLFLT *) 0 ;
11786 PLINT arg2 ;
11787 PLINT arg3 ;
11788 PLINT arg4 ;
11789 PLINT arg5 ;
11790 PLINT arg6 ;
11791 PLINT arg7 ;
11792 PLFLT *arg8 = (PLFLT *) 0 ;
11793 PLINT arg9 ;
11794 Matrix temp1 ;
11795 int val4 ;
11796 int ecode4 = 0 ;
11797 int val5 ;
11798 int ecode5 = 0 ;
11799 int val6 ;
11800 int ecode6 = 0 ;
11801 int val7 ;
11802 int ecode7 = 0 ;
11803 Matrix temp8 ;
11804 octave_value_list _out;
11805 octave_value_list *_outp=&_out;
11806 octave_value _outv;
11807
11808 try {
11809 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11810 SWIG_fail;
11811 }
11812 {
11813 if ( _n_dims( args(0) ) > 2 )
11814 {
11815 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11816 }
11817 temp1 = args(0).matrix_value();
11818 arg1 = &temp1( 0, 0 );
11819 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11820 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11821 }
11822 ecode4 = SWIG_AsVal_int(args(1), &val4);
11823 if (!SWIG_IsOK(ecode4)) {
11824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11825 }
11826 arg4 = static_cast< PLINT >(val4);
11827 ecode5 = SWIG_AsVal_int(args(2), &val5);
11828 if (!SWIG_IsOK(ecode5)) {
11829 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11830 }
11831 arg5 = static_cast< PLINT >(val5);
11832 ecode6 = SWIG_AsVal_int(args(3), &val6);
11833 if (!SWIG_IsOK(ecode6)) {
11834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11835 }
11836 arg6 = static_cast< PLINT >(val6);
11837 ecode7 = SWIG_AsVal_int(args(4), &val7);
11838 if (!SWIG_IsOK(ecode7)) {
11839 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11840 }
11841 arg7 = static_cast< PLINT >(val7);
11842 {
11843 if ( _n_dims( args(5) ) > 1 )
11844 {
11845 error( "argument must be a scalar or vector" ); SWIG_fail;
11846 }
11847 temp8 = args(5).matrix_value();
11848 arg8 = &temp8( 0, 0 );
11849 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11850 }
11851 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11852 _outv = octave_value();
11853 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11854 {
11855
11856 }
11857 {
11858
11859 }
11860 return _out;
11861 fail:
11862 {
11863
11864 }
11865 {
11866
11867 }
11868 return octave_value_list();
11869 }
11870 catch(...) {
11871 {
11872
11873 }
11874 {
11875
11876 }
11877 throw;
11878 }
11879}
11880
11881
11882SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11883 PLFLT *arg1 = (PLFLT *) 0 ;
11884 PLINT arg2 ;
11885 PLINT arg3 ;
11886 PLINT arg4 ;
11887 PLINT arg5 ;
11888 PLINT arg6 ;
11889 PLINT arg7 ;
11890 PLFLT *arg8 = (PLFLT *) 0 ;
11891 PLINT arg9 ;
11892 PLFLT *arg10 = (PLFLT *) 0 ;
11893 PLFLT *arg11 = (PLFLT *) 0 ;
11894 Matrix temp1 ;
11895 int val4 ;
11896 int ecode4 = 0 ;
11897 int val5 ;
11898 int ecode5 = 0 ;
11899 int val6 ;
11900 int ecode6 = 0 ;
11901 int val7 ;
11902 int ecode7 = 0 ;
11903 Matrix temp8 ;
11904 Matrix temp10 ;
11905 Matrix temp11 ;
11906 octave_value_list _out;
11907 octave_value_list *_outp=&_out;
11908 octave_value _outv;
11909
11910 try {
11911 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11912 SWIG_fail;
11913 }
11914 {
11915 if ( _n_dims( args(0) ) > 2 )
11916 {
11917 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11918 }
11919 temp1 = args(0).matrix_value();
11920 arg1 = &temp1( 0, 0 );
11921 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11922 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11923 }
11924 ecode4 = SWIG_AsVal_int(args(1), &val4);
11925 if (!SWIG_IsOK(ecode4)) {
11926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11927 }
11928 arg4 = static_cast< PLINT >(val4);
11929 ecode5 = SWIG_AsVal_int(args(2), &val5);
11930 if (!SWIG_IsOK(ecode5)) {
11931 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11932 }
11933 arg5 = static_cast< PLINT >(val5);
11934 ecode6 = SWIG_AsVal_int(args(3), &val6);
11935 if (!SWIG_IsOK(ecode6)) {
11936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11937 }
11938 arg6 = static_cast< PLINT >(val6);
11939 ecode7 = SWIG_AsVal_int(args(4), &val7);
11940 if (!SWIG_IsOK(ecode7)) {
11941 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11942 }
11943 arg7 = static_cast< PLINT >(val7);
11944 {
11945 if ( _n_dims( args(5) ) > 1 )
11946 {
11947 error( "argument must be a scalar or vector" ); SWIG_fail;
11948 }
11949 temp8 = args(5).matrix_value();
11950 arg8 = &temp8( 0, 0 );
11951 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11952 }
11953 {
11954 if ( _n_dims( args(6) ) > 1 )
11955 {
11956 error( "argument must be a scalar or vector" ); SWIG_fail;
11957 }
11958 if ( _dim( args(6), 0 ) != Xlen )
11959 {
11960 error( "argument vectors must be same length" ); SWIG_fail;
11961 }
11962 temp10 = args(6).matrix_value();
11963 arg10 = &temp10( 0, 0 );
11964 }
11965 {
11966 if ( _n_dims( args(7) ) > 1 )
11967 {
11968 error( "argument must be a scalar or vector" ); SWIG_fail;
11969 }
11970 if ( _dim( args(7), 0 ) != Ylen )
11971 {
11972 error( "argument vectors must be same length" ); SWIG_fail;
11973 }
11974 temp11 = args(7).matrix_value();
11975 arg11 = &temp11( 0, 0 );
11976 }
11977 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11978 _outv = octave_value();
11979 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11980 {
11981
11982 }
11983 {
11984
11985 }
11986 {
11987
11988 }
11989 {
11990
11991 }
11992 return _out;
11993 fail:
11994 {
11995
11996 }
11997 {
11998
11999 }
12000 {
12001
12002 }
12003 {
12004
12005 }
12006 return octave_value_list();
12007 }
12008 catch(...) {
12009 {
12010
12011 }
12012 {
12013
12014 }
12015 {
12016
12017 }
12018 {
12019
12020 }
12021 throw;
12022 }
12023}
12024
12025
12026SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
12027 PLFLT *arg1 = (PLFLT *) 0 ;
12028 PLINT arg2 ;
12029 PLINT arg3 ;
12030 PLINT arg4 ;
12031 PLINT arg5 ;
12032 PLINT arg6 ;
12033 PLINT arg7 ;
12034 PLFLT *arg8 = (PLFLT *) 0 ;
12035 PLINT arg9 ;
12036 PLFLT *arg10 = (PLFLT *) 0 ;
12037 PLFLT *arg11 = (PLFLT *) 0 ;
12038 Matrix temp1 ;
12039 int val4 ;
12040 int ecode4 = 0 ;
12041 int val5 ;
12042 int ecode5 = 0 ;
12043 int val6 ;
12044 int ecode6 = 0 ;
12045 int val7 ;
12046 int ecode7 = 0 ;
12047 Matrix temp8 ;
12048 Matrix temp10 ;
12049 Matrix temp11 ;
12050 octave_value_list _out;
12051 octave_value_list *_outp=&_out;
12052 octave_value _outv;
12053
12054 try {
12055 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
12056 SWIG_fail;
12057 }
12058 {
12059 if ( _n_dims( args(0) ) > 2 )
12060 {
12061 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12062 }
12063 temp1 = args(0).matrix_value();
12064 arg1 = &temp1( 0, 0 );
12065 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12066 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12067 }
12068 ecode4 = SWIG_AsVal_int(args(1), &val4);
12069 if (!SWIG_IsOK(ecode4)) {
12070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
12071 }
12072 arg4 = static_cast< PLINT >(val4);
12073 ecode5 = SWIG_AsVal_int(args(2), &val5);
12074 if (!SWIG_IsOK(ecode5)) {
12075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
12076 }
12077 arg5 = static_cast< PLINT >(val5);
12078 ecode6 = SWIG_AsVal_int(args(3), &val6);
12079 if (!SWIG_IsOK(ecode6)) {
12080 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
12081 }
12082 arg6 = static_cast< PLINT >(val6);
12083 ecode7 = SWIG_AsVal_int(args(4), &val7);
12084 if (!SWIG_IsOK(ecode7)) {
12085 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12086 }
12087 arg7 = static_cast< PLINT >(val7);
12088 {
12089 if ( _n_dims( args(5) ) > 1 )
12090 {
12091 error( "argument must be a scalar or vector" ); SWIG_fail;
12092 }
12093 temp8 = args(5).matrix_value();
12094 arg8 = &temp8( 0, 0 );
12095 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12096 }
12097 {
12098 if ( _n_dims( args(6) ) > 2 )
12099 {
12100 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12101 }
12102 if ( _dim( args(6), 0 ) != Xlen )
12103 {
12104 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12105 }
12106 if ( _dim( args(6), 1 ) != Ylen )
12107 {
12108 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12109 }
12110 temp10 = args(6).matrix_value();
12111 arg10 = &temp10( 0, 0 );
12112 }
12113 {
12114 if ( _n_dims( args(7) ) > 2 )
12115 {
12116 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12117 }
12118 if ( _dim( args(7), 0 ) != Xlen )
12119 {
12120 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12121 }
12122 if ( _dim( args(7), 1 ) != Ylen )
12123 {
12124 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12125 }
12126 temp11 = args(7).matrix_value();
12127 arg11 = &temp11( 0, 0 );
12128 }
12129 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12130 _outv = octave_value();
12131 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12132 {
12133
12134 }
12135 {
12136
12137 }
12138 {
12139
12140 }
12141 {
12142
12143 }
12144 return _out;
12145 fail:
12146 {
12147
12148 }
12149 {
12150
12151 }
12152 {
12153
12154 }
12155 {
12156
12157 }
12158 return octave_value_list();
12159 }
12160 catch(...) {
12161 {
12162
12163 }
12164 {
12165
12166 }
12167 {
12168
12169 }
12170 {
12171
12172 }
12173 throw;
12174 }
12175}
12176
12177
12178SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12179 PLFLT *arg1 = (PLFLT *) 0 ;
12180 PLINT arg2 ;
12181 PLINT arg3 ;
12182 PLINT arg4 ;
12183 PLINT arg5 ;
12184 PLINT arg6 ;
12185 PLINT arg7 ;
12186 PLFLT *arg8 = (PLFLT *) 0 ;
12187 PLINT arg9 ;
12188 PLFLT *arg10 = (PLFLT *) 0 ;
12189 PLFLT *arg11 = (PLFLT *) 0 ;
12190 Matrix temp1 ;
12191 int val4 ;
12192 int ecode4 = 0 ;
12193 int val5 ;
12194 int ecode5 = 0 ;
12195 int val6 ;
12196 int ecode6 = 0 ;
12197 int val7 ;
12198 int ecode7 = 0 ;
12199 Matrix temp8 ;
12200 Matrix temp10 ;
12201 Matrix temp11 ;
12202 octave_value_list _out;
12203 octave_value_list *_outp=&_out;
12204 octave_value _outv;
12205
12206 try {
12207 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12208 SWIG_fail;
12209 }
12210 {
12211 if ( _n_dims( args(0) ) > 2 )
12212 {
12213 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12214 }
12215 temp1 = args(0).matrix_value();
12216 arg1 = &temp1( 0, 0 );
12217 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12218 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12219 }
12220 ecode4 = SWIG_AsVal_int(args(1), &val4);
12221 if (!SWIG_IsOK(ecode4)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12223 }
12224 arg4 = static_cast< PLINT >(val4);
12225 ecode5 = SWIG_AsVal_int(args(2), &val5);
12226 if (!SWIG_IsOK(ecode5)) {
12227 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12228 }
12229 arg5 = static_cast< PLINT >(val5);
12230 ecode6 = SWIG_AsVal_int(args(3), &val6);
12231 if (!SWIG_IsOK(ecode6)) {
12232 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12233 }
12234 arg6 = static_cast< PLINT >(val6);
12235 ecode7 = SWIG_AsVal_int(args(4), &val7);
12236 if (!SWIG_IsOK(ecode7)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12238 }
12239 arg7 = static_cast< PLINT >(val7);
12240 {
12241 if ( _n_dims( args(5) ) > 1 )
12242 {
12243 error( "argument must be a scalar or vector" ); SWIG_fail;
12244 }
12245 temp8 = args(5).matrix_value();
12246 arg8 = &temp8( 0, 0 );
12247 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12248 }
12249 {
12250 if ( _n_dims( args(6) ) > 2 )
12251 {
12252 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12253 }
12254 if ( _dim( args(6), 0 ) != Xlen )
12255 {
12256 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12257 }
12258 if ( _dim( args(6), 1 ) != Ylen )
12259 {
12260 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12261 }
12262 temp10 = args(6).matrix_value();
12263 arg10 = &temp10( 0, 0 );
12264 }
12265 {
12266 if ( _n_dims( args(7) ) > 2 )
12267 {
12268 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12269 }
12270 if ( _dim( args(7), 0 ) != Xlen )
12271 {
12272 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12273 }
12274 if ( _dim( args(7), 1 ) != Ylen )
12275 {
12276 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12277 }
12278 temp11 = args(7).matrix_value();
12279 arg11 = &temp11( 0, 0 );
12280 }
12281 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12282 _outv = octave_value();
12283 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12284 {
12285
12286 }
12287 {
12288
12289 }
12290 {
12291
12292 }
12293 {
12294
12295 }
12296 return _out;
12297 fail:
12298 {
12299
12300 }
12301 {
12302
12303 }
12304 {
12305
12306 }
12307 {
12308
12309 }
12310 return octave_value_list();
12311 }
12312 catch(...) {
12313 {
12314
12315 }
12316 {
12317
12318 }
12319 {
12320
12321 }
12322 {
12323
12324 }
12325 throw;
12326 }
12327}
12328
12329
12330SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12331 PLFLT *arg1 = (PLFLT *) 0 ;
12332 PLFLT *arg2 = (PLFLT *) 0 ;
12333 PLFLT *arg3 = (PLFLT *) 0 ;
12334 PLINT arg4 ;
12335 PLFLT *arg5 = (PLFLT *) 0 ;
12336 PLINT arg6 ;
12337 PLFLT *arg7 = (PLFLT *) 0 ;
12338 PLINT arg8 ;
12339 PLFLT *arg9 = (PLFLT *) 0 ;
12340 PLINT arg10 ;
12341 PLFLT arg11 ;
12342 Matrix temp1 ;
12343 Matrix temp2 ;
12344 Matrix temp3 ;
12345 Matrix temp5 ;
12346 Matrix temp7 ;
12347 octave_value_list retval7 ;
12348 int val10 ;
12349 int ecode10 = 0 ;
12350 double val11 ;
12351 int ecode11 = 0 ;
12352 octave_value_list _out;
12353 octave_value_list *_outp=&_out;
12354 octave_value _outv;
12355
12356 try {
12357 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12358 SWIG_fail;
12359 }
12360 {
12361 if ( _n_dims( args(0) ) > 1 )
12362 {
12363 error( "argument must be a scalar or vector" ); SWIG_fail;
12364 }
12365 Alen = (PLINT) ( _dim( args(0), 0 ) );
12366 temp1 = args(0).matrix_value();
12367 arg1 = &temp1( 0, 0 );
12368 }
12369 {
12370 if ( _n_dims( args(1) ) > 1 )
12371 {
12372 error( "argument must be a scalar or vector" ); SWIG_fail;
12373 }
12374 if ( _dim( args(1), 0 ) != Alen )
12375 {
12376 error( "argument vectors must be same length" ); SWIG_fail;
12377 }
12378 temp2 = args(1).matrix_value();
12379 arg2 = &temp2( 0, 0 );
12380 }
12381 {
12382 if ( _n_dims( args(2) ) > 1 )
12383 {
12384 error( "argument must be a scalar or vector" ); SWIG_fail;
12385 }
12386 if ( _dim( args(2), 0 ) != Alen )
12387 {
12388 error( "argument vectors must be same length" ); SWIG_fail;
12389 }
12390 temp3 = args(2).matrix_value();
12391 arg3 = &temp3( 0, 0 );
12392 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12393 }
12394 {
12395 if ( _n_dims( args(3) ) > 1 )
12396 {
12397 error( "argument must be a scalar or vector" ); SWIG_fail;
12398 }
12399 temp5 = args(3).matrix_value();
12400 arg5 = &temp5( 0, 0 );
12401 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12402 }
12403 {
12404 if ( _n_dims( args(4) ) > 1 )
12405 {
12406 error( "argument must be a scalar or vector" ); SWIG_fail;
12407 }
12408 temp7 = args(4).matrix_value();
12409 arg7 = &temp7( 0, 0 );
12410 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12411 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12412 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12413 }
12414 ecode10 = SWIG_AsVal_int(args(5), &val10);
12415 if (!SWIG_IsOK(ecode10)) {
12416 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12417 }
12418 arg10 = static_cast< PLINT >(val10);
12419 ecode11 = SWIG_AsVal_double(args(6), &val11);
12420 if (!SWIG_IsOK(ecode11)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12422 }
12423 arg11 = static_cast< PLFLT >(val11);
12424 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12425 _outv = octave_value();
12426 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12427 {
12428 _outp = SWIG_Octave_AppendOutput(_outp, retval7( 0 ));
12429 }
12430 {
12431
12432 }
12433 {
12434
12435 }
12436 {
12437
12438 }
12439 {
12440
12441 }
12442 {
12443
12444 }
12445 return _out;
12446 fail:
12447 {
12448
12449 }
12450 {
12451
12452 }
12453 {
12454
12455 }
12456 {
12457
12458 }
12459 {
12460
12461 }
12462 return octave_value_list();
12463 }
12464 catch(...) {
12465 {
12466
12467 }
12468 {
12469
12470 }
12471 {
12472
12473 }
12474 {
12475
12476 }
12477 {
12478
12479 }
12480 throw;
12481 }
12482}
12483
12484
12486 PLFLT *arg1 = (PLFLT *) 0 ;
12487 PLFLT *arg2 = (PLFLT *) 0 ;
12488 PLFLT *arg3 = (PLFLT *) 0 ;
12489 PLINT arg4 ;
12490 PLINT arg5 ;
12491 PLINT arg6 ;
12492 Matrix temp1 ;
12493 Matrix temp2 ;
12494 Matrix temp3 ;
12495 int val6 ;
12496 int ecode6 = 0 ;
12497 octave_value_list _out;
12498 octave_value_list *_outp=&_out;
12499 octave_value _outv;
12500
12501 try {
12502 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12503 SWIG_fail;
12504 }
12505 {
12506 if ( _n_dims( args(0) ) > 1 )
12507 {
12508 error( "argument must be a scalar or vector" ); SWIG_fail;
12509 }
12510 temp1 = args(0).matrix_value();
12511 arg1 = &temp1( 0, 0 );
12512 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12513 }
12514 {
12515 if ( _n_dims( args(1) ) > 1 )
12516 {
12517 error( "argument must be a scalar or vector" ); SWIG_fail;
12518 }
12519 temp2 = args(1).matrix_value();
12520 arg2 = &temp2( 0, 0 );
12521 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12522 }
12523 {
12524 if ( _n_dims( args(2) ) > 2 )
12525 {
12526 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12527 }
12528 if ( _dim( args(2), 0 ) != Xlen )
12529 {
12530 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12531 }
12532 if ( _dim( args(2), 1 ) != Ylen )
12533 {
12534 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12535 }
12536 temp3 = args(2).matrix_value();
12537 arg3 = &temp3( 0, 0 );
12538 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12539 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12540 }
12541 ecode6 = SWIG_AsVal_int(args(3), &val6);
12542 if (!SWIG_IsOK(ecode6)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12544 }
12545 arg6 = static_cast< PLINT >(val6);
12546 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12547 _outv = octave_value();
12548 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12549 {
12550
12551 }
12552 {
12553
12554 }
12555 {
12556
12557 }
12558 return _out;
12559 fail:
12560 {
12561
12562 }
12563 {
12564
12565 }
12566 {
12567
12568 }
12569 return octave_value_list();
12570 }
12571 catch(...) {
12572 {
12573
12574 }
12575 {
12576
12577 }
12578 {
12579
12580 }
12581 throw;
12582 }
12583}
12584
12585
12587 PLFLT *arg1 = (PLFLT *) 0 ;
12588 PLFLT *arg2 = (PLFLT *) 0 ;
12589 PLFLT *arg3 = (PLFLT *) 0 ;
12590 PLINT arg4 ;
12591 PLINT arg5 ;
12592 PLINT arg6 ;
12593 PLFLT *arg7 = (PLFLT *) 0 ;
12594 PLINT arg8 ;
12595 Matrix temp1 ;
12596 Matrix temp2 ;
12597 Matrix temp3 ;
12598 int val6 ;
12599 int ecode6 = 0 ;
12600 Matrix temp7 ;
12601 octave_value_list _out;
12602 octave_value_list *_outp=&_out;
12603 octave_value _outv;
12604
12605 try {
12606 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12607 SWIG_fail;
12608 }
12609 {
12610 if ( _n_dims( args(0) ) > 1 )
12611 {
12612 error( "argument must be a scalar or vector" ); SWIG_fail;
12613 }
12614 temp1 = args(0).matrix_value();
12615 arg1 = &temp1( 0, 0 );
12616 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12617 }
12618 {
12619 if ( _n_dims( args(1) ) > 1 )
12620 {
12621 error( "argument must be a scalar or vector" ); SWIG_fail;
12622 }
12623 temp2 = args(1).matrix_value();
12624 arg2 = &temp2( 0, 0 );
12625 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12626 }
12627 {
12628 if ( _n_dims( args(2) ) > 2 )
12629 {
12630 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12631 }
12632 if ( _dim( args(2), 0 ) != Xlen )
12633 {
12634 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12635 }
12636 if ( _dim( args(2), 1 ) != Ylen )
12637 {
12638 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12639 }
12640 temp3 = args(2).matrix_value();
12641 arg3 = &temp3( 0, 0 );
12642 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12643 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12644 }
12645 ecode6 = SWIG_AsVal_int(args(3), &val6);
12646 if (!SWIG_IsOK(ecode6)) {
12647 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12648 }
12649 arg6 = static_cast< PLINT >(val6);
12650 {
12651 if ( _n_dims( args(4) ) > 1 )
12652 {
12653 error( "argument must be a scalar or vector" ); SWIG_fail;
12654 }
12655 temp7 = args(4).matrix_value();
12656 arg7 = &temp7( 0, 0 );
12657 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12658 }
12659 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12660 _outv = octave_value();
12661 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12662 {
12663
12664 }
12665 {
12666
12667 }
12668 {
12669
12670 }
12671 {
12672
12673 }
12674 return _out;
12675 fail:
12676 {
12677
12678 }
12679 {
12680
12681 }
12682 {
12683
12684 }
12685 {
12686
12687 }
12688 return octave_value_list();
12689 }
12690 catch(...) {
12691 {
12692
12693 }
12694 {
12695
12696 }
12697 {
12698
12699 }
12700 {
12701
12702 }
12703 throw;
12704 }
12705}
12706
12707
12709 PLFLT *arg1 = (PLFLT *) 0 ;
12710 PLFLT *arg2 = (PLFLT *) 0 ;
12711 PLFLT *arg3 = (PLFLT *) 0 ;
12712 PLINT arg4 ;
12713 PLINT arg5 ;
12714 PLINT arg6 ;
12715 PLBOOL arg7 ;
12716 Matrix temp1 ;
12717 Matrix temp2 ;
12718 Matrix temp3 ;
12719 int val6 ;
12720 int ecode6 = 0 ;
12721 int val7 ;
12722 int ecode7 = 0 ;
12723 octave_value_list _out;
12724 octave_value_list *_outp=&_out;
12725 octave_value _outv;
12726
12727 try {
12728 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12729 SWIG_fail;
12730 }
12731 {
12732 if ( _n_dims( args(0) ) > 1 )
12733 {
12734 error( "argument must be a scalar or vector" ); SWIG_fail;
12735 }
12736 temp1 = args(0).matrix_value();
12737 arg1 = &temp1( 0, 0 );
12738 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12739 }
12740 {
12741 if ( _n_dims( args(1) ) > 1 )
12742 {
12743 error( "argument must be a scalar or vector" ); SWIG_fail;
12744 }
12745 temp2 = args(1).matrix_value();
12746 arg2 = &temp2( 0, 0 );
12747 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12748 }
12749 {
12750 if ( _n_dims( args(2) ) > 2 )
12751 {
12752 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12753 }
12754 if ( _dim( args(2), 0 ) != Xlen )
12755 {
12756 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12757 }
12758 if ( _dim( args(2), 1 ) != Ylen )
12759 {
12760 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12761 }
12762 temp3 = args(2).matrix_value();
12763 arg3 = &temp3( 0, 0 );
12764 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12765 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12766 }
12767 ecode6 = SWIG_AsVal_int(args(3), &val6);
12768 if (!SWIG_IsOK(ecode6)) {
12769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12770 }
12771 arg6 = static_cast< PLINT >(val6);
12772 ecode7 = SWIG_AsVal_int(args(4), &val7);
12773 if (!SWIG_IsOK(ecode7)) {
12774 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12775 }
12776 arg7 = static_cast< PLBOOL >(val7);
12777 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12778 _outv = octave_value();
12779 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12780 {
12781
12782 }
12783 {
12784
12785 }
12786 {
12787
12788 }
12789 return _out;
12790 fail:
12791 {
12792
12793 }
12794 {
12795
12796 }
12797 {
12798
12799 }
12800 return octave_value_list();
12801 }
12802 catch(...) {
12803 {
12804
12805 }
12806 {
12807
12808 }
12809 {
12810
12811 }
12812 throw;
12813 }
12814}
12815
12816
12818 PLFLT *arg1 = (PLFLT *) 0 ;
12819 PLFLT *arg2 = (PLFLT *) 0 ;
12820 PLFLT *arg3 = (PLFLT *) 0 ;
12821 PLINT arg4 ;
12822 PLINT arg5 ;
12823 PLINT arg6 ;
12824 PLFLT *arg7 = (PLFLT *) 0 ;
12825 PLINT arg8 ;
12826 Matrix temp1 ;
12827 Matrix temp2 ;
12828 Matrix temp3 ;
12829 int val6 ;
12830 int ecode6 = 0 ;
12831 Matrix temp7 ;
12832 octave_value_list _out;
12833 octave_value_list *_outp=&_out;
12834 octave_value _outv;
12835
12836 try {
12837 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12838 SWIG_fail;
12839 }
12840 {
12841 if ( _n_dims( args(0) ) > 1 )
12842 {
12843 error( "argument must be a scalar or vector" ); SWIG_fail;
12844 }
12845 temp1 = args(0).matrix_value();
12846 arg1 = &temp1( 0, 0 );
12847 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12848 }
12849 {
12850 if ( _n_dims( args(1) ) > 1 )
12851 {
12852 error( "argument must be a scalar or vector" ); SWIG_fail;
12853 }
12854 temp2 = args(1).matrix_value();
12855 arg2 = &temp2( 0, 0 );
12856 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12857 }
12858 {
12859 if ( _n_dims( args(2) ) > 2 )
12860 {
12861 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12862 }
12863 if ( _dim( args(2), 0 ) != Xlen )
12864 {
12865 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12866 }
12867 if ( _dim( args(2), 1 ) != Ylen )
12868 {
12869 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12870 }
12871 temp3 = args(2).matrix_value();
12872 arg3 = &temp3( 0, 0 );
12873 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12874 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12875 }
12876 ecode6 = SWIG_AsVal_int(args(3), &val6);
12877 if (!SWIG_IsOK(ecode6)) {
12878 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12879 }
12880 arg6 = static_cast< PLINT >(val6);
12881 {
12882 if ( _n_dims( args(4) ) > 1 )
12883 {
12884 error( "argument must be a scalar or vector" ); SWIG_fail;
12885 }
12886 temp7 = args(4).matrix_value();
12887 arg7 = &temp7( 0, 0 );
12888 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12889 }
12890 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12891 _outv = octave_value();
12892 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12893 {
12894
12895 }
12896 {
12897
12898 }
12899 {
12900
12901 }
12902 {
12903
12904 }
12905 return _out;
12906 fail:
12907 {
12908
12909 }
12910 {
12911
12912 }
12913 {
12914
12915 }
12916 {
12917
12918 }
12919 return octave_value_list();
12920 }
12921 catch(...) {
12922 {
12923
12924 }
12925 {
12926
12927 }
12928 {
12929
12930 }
12931 {
12932
12933 }
12934 throw;
12935 }
12936}
12937
12938
12940 PLFLT *arg1 = (PLFLT *) 0 ;
12941 PLFLT *arg2 = (PLFLT *) 0 ;
12942 PLFLT *arg3 = (PLFLT *) 0 ;
12943 PLINT arg4 ;
12944 PLINT arg5 ;
12945 PLINT arg6 ;
12946 PLFLT *arg7 = (PLFLT *) 0 ;
12947 PLINT arg8 ;
12948 PLINT arg9 ;
12949 PLINT arg10 ;
12950 PLINT *arg11 = (PLINT *) 0 ;
12951 PLINT *arg12 = (PLINT *) 0 ;
12952 Matrix temp1 ;
12953 Matrix temp2 ;
12954 Matrix temp3 ;
12955 int val6 ;
12956 int ecode6 = 0 ;
12957 Matrix temp7 ;
12958 int val9 ;
12959 int ecode9 = 0 ;
12960 Matrix temp10 ;
12961 Matrix temp12 ;
12962 octave_value_list _out;
12963 octave_value_list *_outp=&_out;
12964 octave_value _outv;
12965
12966 try {
12967 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12968 SWIG_fail;
12969 }
12970 {
12971 if ( _n_dims( args(0) ) > 1 )
12972 {
12973 error( "argument must be a scalar or vector" ); SWIG_fail;
12974 }
12975 temp1 = args(0).matrix_value();
12976 arg1 = &temp1( 0, 0 );
12977 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12978 }
12979 {
12980 if ( _n_dims( args(1) ) > 1 )
12981 {
12982 error( "argument must be a scalar or vector" ); SWIG_fail;
12983 }
12984 temp2 = args(1).matrix_value();
12985 arg2 = &temp2( 0, 0 );
12986 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12987 }
12988 {
12989 if ( _n_dims( args(2) ) > 2 )
12990 {
12991 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12992 }
12993 if ( _dim( args(2), 0 ) != Xlen )
12994 {
12995 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12996 }
12997 if ( _dim( args(2), 1 ) != Ylen )
12998 {
12999 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13000 }
13001 temp3 = args(2).matrix_value();
13002 arg3 = &temp3( 0, 0 );
13003 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13004 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13005 }
13006 ecode6 = SWIG_AsVal_int(args(3), &val6);
13007 if (!SWIG_IsOK(ecode6)) {
13008 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
13009 }
13010 arg6 = static_cast< PLINT >(val6);
13011 {
13012 if ( _n_dims( args(4) ) > 1 )
13013 {
13014 error( "argument must be a scalar or vector" ); SWIG_fail;
13015 }
13016 temp7 = args(4).matrix_value();
13017 arg7 = &temp7( 0, 0 );
13018 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13019 }
13020 ecode9 = SWIG_AsVal_int(args(5), &val9);
13021 if (!SWIG_IsOK(ecode9)) {
13022 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
13023 }
13024 arg9 = static_cast< PLINT >(val9);
13025 {
13026 if ( _n_dims( args(6) ) > 1 )
13027 {
13028 error( "argument must be a scalar or vector" ); SWIG_fail;
13029 }
13030 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13031 arg11 = new PLINT[Alen];
13032 temp10 = args(6).matrix_value();
13033 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13034 }
13035 {
13036 if ( _n_dims( args(7) ) > 1 )
13037 {
13038 error( "argument must be a scalar or vector" ); SWIG_fail;
13039 }
13040 if ( _dim( args(7), 0 ) != Alen )
13041 {
13042 error( "argument vectors must be same length" ); SWIG_fail;
13043 }
13044 temp12 = args(7).matrix_value();
13045 arg12 = new PLINT[Alen];
13046 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13047 }
13048 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);
13049 _outv = octave_value();
13050 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13051 {
13052
13053 }
13054 {
13055
13056 }
13057 {
13058
13059 }
13060 {
13061
13062 }
13063 {
13064 delete [] arg11;
13065 }
13066 {
13067 delete [] arg12;
13068 }
13069 return _out;
13070 fail:
13071 {
13072
13073 }
13074 {
13075
13076 }
13077 {
13078
13079 }
13080 {
13081
13082 }
13083 {
13084 delete [] arg11;
13085 }
13086 {
13087 delete [] arg12;
13088 }
13089 return octave_value_list();
13090 }
13091 catch(...) {
13092 {
13093
13094 }
13095 {
13096
13097 }
13098 {
13099
13100 }
13101 {
13102
13103 }
13104 {
13105 delete [] arg11;
13106 }
13107 {
13108 delete [] arg12;
13109 }
13110 throw;
13111 }
13112}
13113
13114
13116 PLFLT *arg1 = (PLFLT *) 0 ;
13117 PLFLT *arg2 = (PLFLT *) 0 ;
13118 PLFLT *arg3 = (PLFLT *) 0 ;
13119 PLINT arg4 ;
13120 PLINT arg5 ;
13121 PLINT arg6 ;
13122 PLFLT *arg7 = (PLFLT *) 0 ;
13123 PLINT arg8 ;
13124 Matrix temp1 ;
13125 Matrix temp2 ;
13126 Matrix temp3 ;
13127 int val6 ;
13128 int ecode6 = 0 ;
13129 Matrix temp7 ;
13130 octave_value_list _out;
13131 octave_value_list *_outp=&_out;
13132 octave_value _outv;
13133
13134 try {
13135 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13136 SWIG_fail;
13137 }
13138 {
13139 if ( _n_dims( args(0) ) > 1 )
13140 {
13141 error( "argument must be a scalar or vector" ); SWIG_fail;
13142 }
13143 temp1 = args(0).matrix_value();
13144 arg1 = &temp1( 0, 0 );
13145 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13146 }
13147 {
13148 if ( _n_dims( args(1) ) > 1 )
13149 {
13150 error( "argument must be a scalar or vector" ); SWIG_fail;
13151 }
13152 temp2 = args(1).matrix_value();
13153 arg2 = &temp2( 0, 0 );
13154 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13155 }
13156 {
13157 if ( _n_dims( args(2) ) > 2 )
13158 {
13159 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13160 }
13161 if ( _dim( args(2), 0 ) != Xlen )
13162 {
13163 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13164 }
13165 if ( _dim( args(2), 1 ) != Ylen )
13166 {
13167 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13168 }
13169 temp3 = args(2).matrix_value();
13170 arg3 = &temp3( 0, 0 );
13171 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13172 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13173 }
13174 ecode6 = SWIG_AsVal_int(args(3), &val6);
13175 if (!SWIG_IsOK(ecode6)) {
13176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13177 }
13178 arg6 = static_cast< PLINT >(val6);
13179 {
13180 if ( _n_dims( args(4) ) > 1 )
13181 {
13182 error( "argument must be a scalar or vector" ); SWIG_fail;
13183 }
13184 temp7 = args(4).matrix_value();
13185 arg7 = &temp7( 0, 0 );
13186 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13187 }
13188 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13189 _outv = octave_value();
13190 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13191 {
13192
13193 }
13194 {
13195
13196 }
13197 {
13198
13199 }
13200 {
13201
13202 }
13203 return _out;
13204 fail:
13205 {
13206
13207 }
13208 {
13209
13210 }
13211 {
13212
13213 }
13214 {
13215
13216 }
13217 return octave_value_list();
13218 }
13219 catch(...) {
13220 {
13221
13222 }
13223 {
13224
13225 }
13226 {
13227
13228 }
13229 {
13230
13231 }
13232 throw;
13233 }
13234}
13235
13236
13238 PLFLT *arg1 = (PLFLT *) 0 ;
13239 PLFLT *arg2 = (PLFLT *) 0 ;
13240 PLFLT *arg3 = (PLFLT *) 0 ;
13241 PLINT arg4 ;
13242 PLINT arg5 ;
13243 PLINT arg6 ;
13244 PLFLT *arg7 = (PLFLT *) 0 ;
13245 PLINT arg8 ;
13246 PLINT arg9 ;
13247 PLINT arg10 ;
13248 PLINT *arg11 = (PLINT *) 0 ;
13249 PLINT *arg12 = (PLINT *) 0 ;
13250 Matrix temp1 ;
13251 Matrix temp2 ;
13252 Matrix temp3 ;
13253 int val6 ;
13254 int ecode6 = 0 ;
13255 Matrix temp7 ;
13256 int val9 ;
13257 int ecode9 = 0 ;
13258 Matrix temp10 ;
13259 Matrix temp12 ;
13260 octave_value_list _out;
13261 octave_value_list *_outp=&_out;
13262 octave_value _outv;
13263
13264 try {
13265 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13266 SWIG_fail;
13267 }
13268 {
13269 if ( _n_dims( args(0) ) > 1 )
13270 {
13271 error( "argument must be a scalar or vector" ); SWIG_fail;
13272 }
13273 temp1 = args(0).matrix_value();
13274 arg1 = &temp1( 0, 0 );
13275 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13276 }
13277 {
13278 if ( _n_dims( args(1) ) > 1 )
13279 {
13280 error( "argument must be a scalar or vector" ); SWIG_fail;
13281 }
13282 temp2 = args(1).matrix_value();
13283 arg2 = &temp2( 0, 0 );
13284 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13285 }
13286 {
13287 if ( _n_dims( args(2) ) > 2 )
13288 {
13289 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13290 }
13291 if ( _dim( args(2), 0 ) != Xlen )
13292 {
13293 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13294 }
13295 if ( _dim( args(2), 1 ) != Ylen )
13296 {
13297 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13298 }
13299 temp3 = args(2).matrix_value();
13300 arg3 = &temp3( 0, 0 );
13301 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13302 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13303 }
13304 ecode6 = SWIG_AsVal_int(args(3), &val6);
13305 if (!SWIG_IsOK(ecode6)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13307 }
13308 arg6 = static_cast< PLINT >(val6);
13309 {
13310 if ( _n_dims( args(4) ) > 1 )
13311 {
13312 error( "argument must be a scalar or vector" ); SWIG_fail;
13313 }
13314 temp7 = args(4).matrix_value();
13315 arg7 = &temp7( 0, 0 );
13316 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13317 }
13318 ecode9 = SWIG_AsVal_int(args(5), &val9);
13319 if (!SWIG_IsOK(ecode9)) {
13320 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13321 }
13322 arg9 = static_cast< PLINT >(val9);
13323 {
13324 if ( _n_dims( args(6) ) > 1 )
13325 {
13326 error( "argument must be a scalar or vector" ); SWIG_fail;
13327 }
13328 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13329 arg11 = new PLINT[Alen];
13330 temp10 = args(6).matrix_value();
13331 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13332 }
13333 {
13334 if ( _n_dims( args(7) ) > 1 )
13335 {
13336 error( "argument must be a scalar or vector" ); SWIG_fail;
13337 }
13338 if ( _dim( args(7), 0 ) != Alen )
13339 {
13340 error( "argument vectors must be same length" ); SWIG_fail;
13341 }
13342 temp12 = args(7).matrix_value();
13343 arg12 = new PLINT[Alen];
13344 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13345 }
13346 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);
13347 _outv = octave_value();
13348 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13349 {
13350
13351 }
13352 {
13353
13354 }
13355 {
13356
13357 }
13358 {
13359
13360 }
13361 {
13362 delete [] arg11;
13363 }
13364 {
13365 delete [] arg12;
13366 }
13367 return _out;
13368 fail:
13369 {
13370
13371 }
13372 {
13373
13374 }
13375 {
13376
13377 }
13378 {
13379
13380 }
13381 {
13382 delete [] arg11;
13383 }
13384 {
13385 delete [] arg12;
13386 }
13387 return octave_value_list();
13388 }
13389 catch(...) {
13390 {
13391
13392 }
13393 {
13394
13395 }
13396 {
13397
13398 }
13399 {
13400
13401 }
13402 {
13403 delete [] arg11;
13404 }
13405 {
13406 delete [] arg12;
13407 }
13408 throw;
13409 }
13410}
13411
13412
13414 PLFLT *arg1 = (PLFLT *) 0 ;
13415 PLINT arg2 ;
13416 PLINT arg3 ;
13417 PLFLT *arg4 = (PLFLT *) 0 ;
13418 PLFLT arg5 ;
13419 PLFLT arg6 ;
13420 PLFLT arg7 ;
13421 PLFLT arg8 ;
13422 PLFLT arg9 ;
13423 PLFLT arg10 ;
13424 PLINT arg11 ;
13425 PLFLT arg12 ;
13426 PLINT arg13 ;
13427 PLINT arg14 ;
13428 PLINT arg15 ;
13429 PLINT arg16 ;
13430 PLINT arg17 ;
13431 PLBOOL arg18 ;
13432 PLFLT *arg19 = (PLFLT *) 0 ;
13433 Matrix temp1 ;
13434 Matrix temp4 ;
13435 double val5 ;
13436 int ecode5 = 0 ;
13437 double val6 ;
13438 int ecode6 = 0 ;
13439 double val7 ;
13440 int ecode7 = 0 ;
13441 double val8 ;
13442 int ecode8 = 0 ;
13443 double val9 ;
13444 int ecode9 = 0 ;
13445 double val10 ;
13446 int ecode10 = 0 ;
13447 int val11 ;
13448 int ecode11 = 0 ;
13449 double val12 ;
13450 int ecode12 = 0 ;
13451 int val13 ;
13452 int ecode13 = 0 ;
13453 int val14 ;
13454 int ecode14 = 0 ;
13455 int val15 ;
13456 int ecode15 = 0 ;
13457 int val16 ;
13458 int ecode16 = 0 ;
13459 int val17 ;
13460 int ecode17 = 0 ;
13461 int val18 ;
13462 int ecode18 = 0 ;
13463 Matrix temp19 ;
13464 octave_value_list _out;
13465 octave_value_list *_outp=&_out;
13466 octave_value _outv;
13467
13468 try {
13469 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13470 SWIG_fail;
13471 }
13472 {
13473 if ( _n_dims( args(0) ) > 2 )
13474 {
13475 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13476 }
13477 temp1 = args(0).matrix_value();
13478 arg1 = &temp1( 0, 0 );
13479 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13480 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13481 }
13482 {
13483 if ( _n_dims( args(1) ) > 1 )
13484 {
13485 error( "argument must be a scalar or vector" ); SWIG_fail;
13486 }
13487 Alen = (PLINT) ( _dim( args(1), 0 ) );
13488 temp4 = args(1).matrix_value();
13489 arg4 = &temp4( 0, 0 );
13490 }
13491 ecode5 = SWIG_AsVal_double(args(2), &val5);
13492 if (!SWIG_IsOK(ecode5)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13494 }
13495 arg5 = static_cast< PLFLT >(val5);
13496 ecode6 = SWIG_AsVal_double(args(3), &val6);
13497 if (!SWIG_IsOK(ecode6)) {
13498 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13499 }
13500 arg6 = static_cast< PLFLT >(val6);
13501 ecode7 = SWIG_AsVal_double(args(4), &val7);
13502 if (!SWIG_IsOK(ecode7)) {
13503 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13504 }
13505 arg7 = static_cast< PLFLT >(val7);
13506 ecode8 = SWIG_AsVal_double(args(5), &val8);
13507 if (!SWIG_IsOK(ecode8)) {
13508 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13509 }
13510 arg8 = static_cast< PLFLT >(val8);
13511 ecode9 = SWIG_AsVal_double(args(6), &val9);
13512 if (!SWIG_IsOK(ecode9)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13514 }
13515 arg9 = static_cast< PLFLT >(val9);
13516 ecode10 = SWIG_AsVal_double(args(7), &val10);
13517 if (!SWIG_IsOK(ecode10)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13519 }
13520 arg10 = static_cast< PLFLT >(val10);
13521 ecode11 = SWIG_AsVal_int(args(8), &val11);
13522 if (!SWIG_IsOK(ecode11)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13524 }
13525 arg11 = static_cast< PLINT >(val11);
13526 ecode12 = SWIG_AsVal_double(args(9), &val12);
13527 if (!SWIG_IsOK(ecode12)) {
13528 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13529 }
13530 arg12 = static_cast< PLFLT >(val12);
13531 ecode13 = SWIG_AsVal_int(args(10), &val13);
13532 if (!SWIG_IsOK(ecode13)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13534 }
13535 arg13 = static_cast< PLINT >(val13);
13536 ecode14 = SWIG_AsVal_int(args(11), &val14);
13537 if (!SWIG_IsOK(ecode14)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13539 }
13540 arg14 = static_cast< PLINT >(val14);
13541 ecode15 = SWIG_AsVal_int(args(12), &val15);
13542 if (!SWIG_IsOK(ecode15)) {
13543 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13544 }
13545 arg15 = static_cast< PLINT >(val15);
13546 ecode16 = SWIG_AsVal_int(args(13), &val16);
13547 if (!SWIG_IsOK(ecode16)) {
13548 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13549 }
13550 arg16 = static_cast< PLINT >(val16);
13551 ecode17 = SWIG_AsVal_int(args(14), &val17);
13552 if (!SWIG_IsOK(ecode17)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13554 }
13555 arg17 = static_cast< PLINT >(val17);
13556 ecode18 = SWIG_AsVal_int(args(15), &val18);
13557 if (!SWIG_IsOK(ecode18)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13559 }
13560 arg18 = static_cast< PLBOOL >(val18);
13561 {
13562 if ( _n_dims( args(16) ) > 1 )
13563 {
13564 error( "argument must be a scalar or vector" ); SWIG_fail;
13565 }
13566 if ( _dim( args(16), 0 ) != 6 )
13567 {
13568 error( "argument vectors must have length of 6" ); SWIG_fail;
13569 }
13570 temp19 = args(16).matrix_value();
13571 arg19 = &temp19( 0, 0 );
13572 }
13573 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);
13574 _outv = octave_value();
13575 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13576 {
13577
13578 }
13579 {
13580
13581 }
13582 {
13583
13584 }
13585 return _out;
13586 fail:
13587 {
13588
13589 }
13590 {
13591
13592 }
13593 {
13594
13595 }
13596 return octave_value_list();
13597 }
13598 catch(...) {
13599 {
13600
13601 }
13602 {
13603
13604 }
13605 {
13606
13607 }
13608 throw;
13609 }
13610}
13611
13612
13613SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13614 PLFLT *arg1 = (PLFLT *) 0 ;
13615 PLINT arg2 ;
13616 PLINT arg3 ;
13617 char *arg4 = (char *) 0 ;
13618 PLFLT arg5 ;
13619 PLFLT arg6 ;
13620 PLFLT arg7 ;
13621 PLFLT arg8 ;
13622 PLFLT arg9 ;
13623 PLFLT arg10 ;
13624 PLINT arg11 ;
13625 PLFLT arg12 ;
13626 PLINT arg13 ;
13627 PLINT arg14 ;
13628 PLINT arg15 ;
13629 PLINT arg16 ;
13630 PLINT arg17 ;
13631 PLBOOL arg18 ;
13632 PLFLT *arg19 = (PLFLT *) 0 ;
13633 PLFLT *arg20 = (PLFLT *) 0 ;
13634 Matrix temp1 ;
13635 int res4 ;
13636 char *buf4 = 0 ;
13637 int alloc4 = 0 ;
13638 double val5 ;
13639 int ecode5 = 0 ;
13640 double val6 ;
13641 int ecode6 = 0 ;
13642 double val7 ;
13643 int ecode7 = 0 ;
13644 double val8 ;
13645 int ecode8 = 0 ;
13646 double val9 ;
13647 int ecode9 = 0 ;
13648 double val10 ;
13649 int ecode10 = 0 ;
13650 int val11 ;
13651 int ecode11 = 0 ;
13652 double val12 ;
13653 int ecode12 = 0 ;
13654 int val13 ;
13655 int ecode13 = 0 ;
13656 int val14 ;
13657 int ecode14 = 0 ;
13658 int val15 ;
13659 int ecode15 = 0 ;
13660 int val16 ;
13661 int ecode16 = 0 ;
13662 int val17 ;
13663 int ecode17 = 0 ;
13664 int val18 ;
13665 int ecode18 = 0 ;
13666 Matrix temp19 ;
13667 Matrix temp20 ;
13668 octave_value_list _out;
13669 octave_value_list *_outp=&_out;
13670 octave_value _outv;
13671
13672 try {
13673 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13674 SWIG_fail;
13675 }
13676 {
13677 if ( _n_dims( args(0) ) > 2 )
13678 {
13679 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13680 }
13681 temp1 = args(0).matrix_value();
13682 arg1 = &temp1( 0, 0 );
13683 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13684 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13685 }
13686 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13687 if (!SWIG_IsOK(res4)) {
13688 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13689 }
13690 arg4 = reinterpret_cast< char * >(buf4);
13691 ecode5 = SWIG_AsVal_double(args(2), &val5);
13692 if (!SWIG_IsOK(ecode5)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13694 }
13695 arg5 = static_cast< PLFLT >(val5);
13696 ecode6 = SWIG_AsVal_double(args(3), &val6);
13697 if (!SWIG_IsOK(ecode6)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13699 }
13700 arg6 = static_cast< PLFLT >(val6);
13701 ecode7 = SWIG_AsVal_double(args(4), &val7);
13702 if (!SWIG_IsOK(ecode7)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13704 }
13705 arg7 = static_cast< PLFLT >(val7);
13706 ecode8 = SWIG_AsVal_double(args(5), &val8);
13707 if (!SWIG_IsOK(ecode8)) {
13708 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13709 }
13710 arg8 = static_cast< PLFLT >(val8);
13711 ecode9 = SWIG_AsVal_double(args(6), &val9);
13712 if (!SWIG_IsOK(ecode9)) {
13713 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13714 }
13715 arg9 = static_cast< PLFLT >(val9);
13716 ecode10 = SWIG_AsVal_double(args(7), &val10);
13717 if (!SWIG_IsOK(ecode10)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13719 }
13720 arg10 = static_cast< PLFLT >(val10);
13721 ecode11 = SWIG_AsVal_int(args(8), &val11);
13722 if (!SWIG_IsOK(ecode11)) {
13723 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13724 }
13725 arg11 = static_cast< PLINT >(val11);
13726 ecode12 = SWIG_AsVal_double(args(9), &val12);
13727 if (!SWIG_IsOK(ecode12)) {
13728 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13729 }
13730 arg12 = static_cast< PLFLT >(val12);
13731 ecode13 = SWIG_AsVal_int(args(10), &val13);
13732 if (!SWIG_IsOK(ecode13)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13734 }
13735 arg13 = static_cast< PLINT >(val13);
13736 ecode14 = SWIG_AsVal_int(args(11), &val14);
13737 if (!SWIG_IsOK(ecode14)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13739 }
13740 arg14 = static_cast< PLINT >(val14);
13741 ecode15 = SWIG_AsVal_int(args(12), &val15);
13742 if (!SWIG_IsOK(ecode15)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13744 }
13745 arg15 = static_cast< PLINT >(val15);
13746 ecode16 = SWIG_AsVal_int(args(13), &val16);
13747 if (!SWIG_IsOK(ecode16)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13749 }
13750 arg16 = static_cast< PLINT >(val16);
13751 ecode17 = SWIG_AsVal_int(args(14), &val17);
13752 if (!SWIG_IsOK(ecode17)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13754 }
13755 arg17 = static_cast< PLINT >(val17);
13756 ecode18 = SWIG_AsVal_int(args(15), &val18);
13757 if (!SWIG_IsOK(ecode18)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13759 }
13760 arg18 = static_cast< PLBOOL >(val18);
13761 {
13762 if ( _n_dims( args(16) ) > 1 )
13763 {
13764 error( "argument must be a scalar or vector" ); SWIG_fail;
13765 }
13766 if ( _dim( args(16), 0 ) != Xlen )
13767 {
13768 error( "argument vectors must be same length" ); SWIG_fail;
13769 }
13770 temp19 = args(16).matrix_value();
13771 arg19 = &temp19( 0, 0 );
13772 }
13773 {
13774 if ( _n_dims( args(17) ) > 1 )
13775 {
13776 error( "argument must be a scalar or vector" ); SWIG_fail;
13777 }
13778 if ( _dim( args(17), 0 ) != Ylen )
13779 {
13780 error( "argument vectors must be same length" ); SWIG_fail;
13781 }
13782 temp20 = args(17).matrix_value();
13783 arg20 = &temp20( 0, 0 );
13784 }
13785 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);
13786 _outv = octave_value();
13787 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13788 {
13789
13790 }
13791 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13792 {
13793
13794 }
13795 {
13796
13797 }
13798 return _out;
13799 fail:
13800 {
13801
13802 }
13803 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13804 {
13805
13806 }
13807 {
13808
13809 }
13810 return octave_value_list();
13811 }
13812 catch(...) {
13813 {
13814
13815 }
13816 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13817 {
13818
13819 }
13820 {
13821
13822 }
13823 throw;
13824 }
13825}
13826
13827
13828SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13829 PLFLT *arg1 = (PLFLT *) 0 ;
13830 PLINT arg2 ;
13831 PLINT arg3 ;
13832 char *arg4 = (char *) 0 ;
13833 PLFLT arg5 ;
13834 PLFLT arg6 ;
13835 PLFLT arg7 ;
13836 PLFLT arg8 ;
13837 PLFLT arg9 ;
13838 PLFLT arg10 ;
13839 PLINT arg11 ;
13840 PLFLT arg12 ;
13841 PLINT arg13 ;
13842 PLINT arg14 ;
13843 PLINT arg15 ;
13844 PLINT arg16 ;
13845 PLINT arg17 ;
13846 PLBOOL arg18 ;
13847 PLFLT *arg19 = (PLFLT *) 0 ;
13848 PLFLT *arg20 = (PLFLT *) 0 ;
13849 Matrix temp1 ;
13850 int res4 ;
13851 char *buf4 = 0 ;
13852 int alloc4 = 0 ;
13853 double val5 ;
13854 int ecode5 = 0 ;
13855 double val6 ;
13856 int ecode6 = 0 ;
13857 double val7 ;
13858 int ecode7 = 0 ;
13859 double val8 ;
13860 int ecode8 = 0 ;
13861 double val9 ;
13862 int ecode9 = 0 ;
13863 double val10 ;
13864 int ecode10 = 0 ;
13865 int val11 ;
13866 int ecode11 = 0 ;
13867 double val12 ;
13868 int ecode12 = 0 ;
13869 int val13 ;
13870 int ecode13 = 0 ;
13871 int val14 ;
13872 int ecode14 = 0 ;
13873 int val15 ;
13874 int ecode15 = 0 ;
13875 int val16 ;
13876 int ecode16 = 0 ;
13877 int val17 ;
13878 int ecode17 = 0 ;
13879 int val18 ;
13880 int ecode18 = 0 ;
13881 Matrix temp19 ;
13882 Matrix temp20 ;
13883 octave_value_list _out;
13884 octave_value_list *_outp=&_out;
13885 octave_value _outv;
13886
13887 try {
13888 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13889 SWIG_fail;
13890 }
13891 {
13892 if ( _n_dims( args(0) ) > 2 )
13893 {
13894 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13895 }
13896 temp1 = args(0).matrix_value();
13897 arg1 = &temp1( 0, 0 );
13898 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13899 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13900 }
13901 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13902 if (!SWIG_IsOK(res4)) {
13903 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13904 }
13905 arg4 = reinterpret_cast< char * >(buf4);
13906 ecode5 = SWIG_AsVal_double(args(2), &val5);
13907 if (!SWIG_IsOK(ecode5)) {
13908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13909 }
13910 arg5 = static_cast< PLFLT >(val5);
13911 ecode6 = SWIG_AsVal_double(args(3), &val6);
13912 if (!SWIG_IsOK(ecode6)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13914 }
13915 arg6 = static_cast< PLFLT >(val6);
13916 ecode7 = SWIG_AsVal_double(args(4), &val7);
13917 if (!SWIG_IsOK(ecode7)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13919 }
13920 arg7 = static_cast< PLFLT >(val7);
13921 ecode8 = SWIG_AsVal_double(args(5), &val8);
13922 if (!SWIG_IsOK(ecode8)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13924 }
13925 arg8 = static_cast< PLFLT >(val8);
13926 ecode9 = SWIG_AsVal_double(args(6), &val9);
13927 if (!SWIG_IsOK(ecode9)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13929 }
13930 arg9 = static_cast< PLFLT >(val9);
13931 ecode10 = SWIG_AsVal_double(args(7), &val10);
13932 if (!SWIG_IsOK(ecode10)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13934 }
13935 arg10 = static_cast< PLFLT >(val10);
13936 ecode11 = SWIG_AsVal_int(args(8), &val11);
13937 if (!SWIG_IsOK(ecode11)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13939 }
13940 arg11 = static_cast< PLINT >(val11);
13941 ecode12 = SWIG_AsVal_double(args(9), &val12);
13942 if (!SWIG_IsOK(ecode12)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13944 }
13945 arg12 = static_cast< PLFLT >(val12);
13946 ecode13 = SWIG_AsVal_int(args(10), &val13);
13947 if (!SWIG_IsOK(ecode13)) {
13948 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13949 }
13950 arg13 = static_cast< PLINT >(val13);
13951 ecode14 = SWIG_AsVal_int(args(11), &val14);
13952 if (!SWIG_IsOK(ecode14)) {
13953 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13954 }
13955 arg14 = static_cast< PLINT >(val14);
13956 ecode15 = SWIG_AsVal_int(args(12), &val15);
13957 if (!SWIG_IsOK(ecode15)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13959 }
13960 arg15 = static_cast< PLINT >(val15);
13961 ecode16 = SWIG_AsVal_int(args(13), &val16);
13962 if (!SWIG_IsOK(ecode16)) {
13963 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13964 }
13965 arg16 = static_cast< PLINT >(val16);
13966 ecode17 = SWIG_AsVal_int(args(14), &val17);
13967 if (!SWIG_IsOK(ecode17)) {
13968 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13969 }
13970 arg17 = static_cast< PLINT >(val17);
13971 ecode18 = SWIG_AsVal_int(args(15), &val18);
13972 if (!SWIG_IsOK(ecode18)) {
13973 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13974 }
13975 arg18 = static_cast< PLBOOL >(val18);
13976 {
13977 if ( _n_dims( args(16) ) > 2 )
13978 {
13979 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13980 }
13981 temp19 = args(16).matrix_value();
13982 arg19 = &temp19( 0, 0 );
13983 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13984 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13985 }
13986 {
13987 if ( _n_dims( args(17) ) > 2 )
13988 {
13989 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13990 }
13991 temp20 = args(17).matrix_value();
13992 arg20 = &temp20( 0, 0 );
13993 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13994 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13995 }
13996 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);
13997 _outv = octave_value();
13998 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13999 {
14000
14001 }
14002 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14003 {
14004
14005 }
14006 {
14007
14008 }
14009 return _out;
14010 fail:
14011 {
14012
14013 }
14014 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14015 {
14016
14017 }
14018 {
14019
14020 }
14021 return octave_value_list();
14022 }
14023 catch(...) {
14024 {
14025
14026 }
14027 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14028 {
14029
14030 }
14031 {
14032
14033 }
14034 throw;
14035 }
14036}
14037
14038
14040 PLFLT *arg1 = (PLFLT *) 0 ;
14041 PLINT arg2 ;
14042 PLINT arg3 ;
14043 PLFLT arg4 ;
14044 PLFLT arg5 ;
14045 PLFLT arg6 ;
14046 PLFLT arg7 ;
14047 PLFLT *arg8 = (PLFLT *) 0 ;
14048 PLINT arg9 ;
14049 PLINT arg10 ;
14050 PLINT arg11 ;
14051 PLINT arg12 ;
14052 PLBOOL arg13 ;
14053 Matrix temp1 ;
14054 double val4 ;
14055 int ecode4 = 0 ;
14056 double val5 ;
14057 int ecode5 = 0 ;
14058 double val6 ;
14059 int ecode6 = 0 ;
14060 double val7 ;
14061 int ecode7 = 0 ;
14062 Matrix temp8 ;
14063 int val10 ;
14064 int ecode10 = 0 ;
14065 int val11 ;
14066 int ecode11 = 0 ;
14067 int val12 ;
14068 int ecode12 = 0 ;
14069 int val13 ;
14070 int ecode13 = 0 ;
14071 octave_value_list _out;
14072 octave_value_list *_outp=&_out;
14073 octave_value _outv;
14074
14075 try {
14076 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
14077 SWIG_fail;
14078 }
14079 {
14080 if ( _n_dims( args(0) ) > 2 )
14081 {
14082 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14083 }
14084 temp1 = args(0).matrix_value();
14085 arg1 = &temp1( 0, 0 );
14086 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14087 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14088 }
14089 ecode4 = SWIG_AsVal_double(args(1), &val4);
14090 if (!SWIG_IsOK(ecode4)) {
14091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14092 }
14093 arg4 = static_cast< PLFLT >(val4);
14094 ecode5 = SWIG_AsVal_double(args(2), &val5);
14095 if (!SWIG_IsOK(ecode5)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14097 }
14098 arg5 = static_cast< PLFLT >(val5);
14099 ecode6 = SWIG_AsVal_double(args(3), &val6);
14100 if (!SWIG_IsOK(ecode6)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14102 }
14103 arg6 = static_cast< PLFLT >(val6);
14104 ecode7 = SWIG_AsVal_double(args(4), &val7);
14105 if (!SWIG_IsOK(ecode7)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14107 }
14108 arg7 = static_cast< PLFLT >(val7);
14109 {
14110 if ( _n_dims( args(5) ) > 1 )
14111 {
14112 error( "argument must be a scalar or vector" ); SWIG_fail;
14113 }
14114 temp8 = args(5).matrix_value();
14115 arg8 = &temp8( 0, 0 );
14116 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14117 }
14118 ecode10 = SWIG_AsVal_int(args(6), &val10);
14119 if (!SWIG_IsOK(ecode10)) {
14120 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14121 }
14122 arg10 = static_cast< PLINT >(val10);
14123 ecode11 = SWIG_AsVal_int(args(7), &val11);
14124 if (!SWIG_IsOK(ecode11)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14126 }
14127 arg11 = static_cast< PLINT >(val11);
14128 ecode12 = SWIG_AsVal_int(args(8), &val12);
14129 if (!SWIG_IsOK(ecode12)) {
14130 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14131 }
14132 arg12 = static_cast< PLINT >(val12);
14133 ecode13 = SWIG_AsVal_int(args(9), &val13);
14134 if (!SWIG_IsOK(ecode13)) {
14135 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14136 }
14137 arg13 = static_cast< PLBOOL >(val13);
14138 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14139 _outv = octave_value();
14140 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14141 {
14142
14143 }
14144 {
14145
14146 }
14147 return _out;
14148 fail:
14149 {
14150
14151 }
14152 {
14153
14154 }
14155 return octave_value_list();
14156 }
14157 catch(...) {
14158 {
14159
14160 }
14161 {
14162
14163 }
14164 throw;
14165 }
14166}
14167
14168
14169SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14170 PLFLT *arg1 = (PLFLT *) 0 ;
14171 PLINT arg2 ;
14172 PLINT arg3 ;
14173 PLFLT arg4 ;
14174 PLFLT arg5 ;
14175 PLFLT arg6 ;
14176 PLFLT arg7 ;
14177 PLFLT *arg8 = (PLFLT *) 0 ;
14178 PLINT arg9 ;
14179 PLINT arg10 ;
14180 PLINT arg11 ;
14181 PLINT arg12 ;
14182 PLBOOL arg13 ;
14183 PLFLT *arg14 = (PLFLT *) 0 ;
14184 Matrix temp1 ;
14185 double val4 ;
14186 int ecode4 = 0 ;
14187 double val5 ;
14188 int ecode5 = 0 ;
14189 double val6 ;
14190 int ecode6 = 0 ;
14191 double val7 ;
14192 int ecode7 = 0 ;
14193 Matrix temp8 ;
14194 int val10 ;
14195 int ecode10 = 0 ;
14196 int val11 ;
14197 int ecode11 = 0 ;
14198 int val12 ;
14199 int ecode12 = 0 ;
14200 int val13 ;
14201 int ecode13 = 0 ;
14202 Matrix temp14 ;
14203 octave_value_list _out;
14204 octave_value_list *_outp=&_out;
14205 octave_value _outv;
14206
14207 try {
14208 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14209 SWIG_fail;
14210 }
14211 {
14212 if ( _n_dims( args(0) ) > 2 )
14213 {
14214 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14215 }
14216 temp1 = args(0).matrix_value();
14217 arg1 = &temp1( 0, 0 );
14218 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14219 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14220 }
14221 ecode4 = SWIG_AsVal_double(args(1), &val4);
14222 if (!SWIG_IsOK(ecode4)) {
14223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14224 }
14225 arg4 = static_cast< PLFLT >(val4);
14226 ecode5 = SWIG_AsVal_double(args(2), &val5);
14227 if (!SWIG_IsOK(ecode5)) {
14228 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14229 }
14230 arg5 = static_cast< PLFLT >(val5);
14231 ecode6 = SWIG_AsVal_double(args(3), &val6);
14232 if (!SWIG_IsOK(ecode6)) {
14233 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14234 }
14235 arg6 = static_cast< PLFLT >(val6);
14236 ecode7 = SWIG_AsVal_double(args(4), &val7);
14237 if (!SWIG_IsOK(ecode7)) {
14238 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14239 }
14240 arg7 = static_cast< PLFLT >(val7);
14241 {
14242 if ( _n_dims( args(5) ) > 1 )
14243 {
14244 error( "argument must be a scalar or vector" ); SWIG_fail;
14245 }
14246 temp8 = args(5).matrix_value();
14247 arg8 = &temp8( 0, 0 );
14248 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14249 }
14250 ecode10 = SWIG_AsVal_int(args(6), &val10);
14251 if (!SWIG_IsOK(ecode10)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14253 }
14254 arg10 = static_cast< PLINT >(val10);
14255 ecode11 = SWIG_AsVal_int(args(7), &val11);
14256 if (!SWIG_IsOK(ecode11)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14258 }
14259 arg11 = static_cast< PLINT >(val11);
14260 ecode12 = SWIG_AsVal_int(args(8), &val12);
14261 if (!SWIG_IsOK(ecode12)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14263 }
14264 arg12 = static_cast< PLINT >(val12);
14265 ecode13 = SWIG_AsVal_int(args(9), &val13);
14266 if (!SWIG_IsOK(ecode13)) {
14267 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14268 }
14269 arg13 = static_cast< PLBOOL >(val13);
14270 {
14271 if ( _n_dims( args(10) ) > 1 )
14272 {
14273 error( "argument must be a scalar or vector" ); SWIG_fail;
14274 }
14275 if ( _dim( args(10), 0 ) != 6 )
14276 {
14277 error( "argument vectors must have length of 6" ); SWIG_fail;
14278 }
14279 temp14 = args(10).matrix_value();
14280 arg14 = &temp14( 0, 0 );
14281 }
14282 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14283 _outv = octave_value();
14284 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14285 {
14286
14287 }
14288 {
14289
14290 }
14291 {
14292
14293 }
14294 return _out;
14295 fail:
14296 {
14297
14298 }
14299 {
14300
14301 }
14302 {
14303
14304 }
14305 return octave_value_list();
14306 }
14307 catch(...) {
14308 {
14309
14310 }
14311 {
14312
14313 }
14314 {
14315
14316 }
14317 throw;
14318 }
14319}
14320
14321
14322SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14323 PLFLT *arg1 = (PLFLT *) 0 ;
14324 PLINT arg2 ;
14325 PLINT arg3 ;
14326 PLFLT arg4 ;
14327 PLFLT arg5 ;
14328 PLFLT arg6 ;
14329 PLFLT arg7 ;
14330 PLFLT *arg8 = (PLFLT *) 0 ;
14331 PLINT arg9 ;
14332 PLINT arg10 ;
14333 PLINT arg11 ;
14334 PLINT arg12 ;
14335 PLBOOL arg13 ;
14336 PLFLT *arg14 = (PLFLT *) 0 ;
14337 PLFLT *arg15 = (PLFLT *) 0 ;
14338 Matrix temp1 ;
14339 double val4 ;
14340 int ecode4 = 0 ;
14341 double val5 ;
14342 int ecode5 = 0 ;
14343 double val6 ;
14344 int ecode6 = 0 ;
14345 double val7 ;
14346 int ecode7 = 0 ;
14347 Matrix temp8 ;
14348 int val10 ;
14349 int ecode10 = 0 ;
14350 int val11 ;
14351 int ecode11 = 0 ;
14352 int val12 ;
14353 int ecode12 = 0 ;
14354 int val13 ;
14355 int ecode13 = 0 ;
14356 Matrix temp14 ;
14357 Matrix temp15 ;
14358 octave_value_list _out;
14359 octave_value_list *_outp=&_out;
14360 octave_value _outv;
14361
14362 try {
14363 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14364 SWIG_fail;
14365 }
14366 {
14367 if ( _n_dims( args(0) ) > 2 )
14368 {
14369 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14370 }
14371 temp1 = args(0).matrix_value();
14372 arg1 = &temp1( 0, 0 );
14373 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14374 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14375 }
14376 ecode4 = SWIG_AsVal_double(args(1), &val4);
14377 if (!SWIG_IsOK(ecode4)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14379 }
14380 arg4 = static_cast< PLFLT >(val4);
14381 ecode5 = SWIG_AsVal_double(args(2), &val5);
14382 if (!SWIG_IsOK(ecode5)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14384 }
14385 arg5 = static_cast< PLFLT >(val5);
14386 ecode6 = SWIG_AsVal_double(args(3), &val6);
14387 if (!SWIG_IsOK(ecode6)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14389 }
14390 arg6 = static_cast< PLFLT >(val6);
14391 ecode7 = SWIG_AsVal_double(args(4), &val7);
14392 if (!SWIG_IsOK(ecode7)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14394 }
14395 arg7 = static_cast< PLFLT >(val7);
14396 {
14397 if ( _n_dims( args(5) ) > 1 )
14398 {
14399 error( "argument must be a scalar or vector" ); SWIG_fail;
14400 }
14401 temp8 = args(5).matrix_value();
14402 arg8 = &temp8( 0, 0 );
14403 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14404 }
14405 ecode10 = SWIG_AsVal_int(args(6), &val10);
14406 if (!SWIG_IsOK(ecode10)) {
14407 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14408 }
14409 arg10 = static_cast< PLINT >(val10);
14410 ecode11 = SWIG_AsVal_int(args(7), &val11);
14411 if (!SWIG_IsOK(ecode11)) {
14412 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14413 }
14414 arg11 = static_cast< PLINT >(val11);
14415 ecode12 = SWIG_AsVal_int(args(8), &val12);
14416 if (!SWIG_IsOK(ecode12)) {
14417 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14418 }
14419 arg12 = static_cast< PLINT >(val12);
14420 ecode13 = SWIG_AsVal_int(args(9), &val13);
14421 if (!SWIG_IsOK(ecode13)) {
14422 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14423 }
14424 arg13 = static_cast< PLBOOL >(val13);
14425 {
14426 if ( _n_dims( args(10) ) > 1 )
14427 {
14428 error( "argument must be a scalar or vector" ); SWIG_fail;
14429 }
14430 if ( _dim( args(10), 0 ) != Xlen )
14431 {
14432 error( "argument vectors must be same length" ); SWIG_fail;
14433 }
14434 temp14 = args(10).matrix_value();
14435 arg14 = &temp14( 0, 0 );
14436 }
14437 {
14438 if ( _n_dims( args(11) ) > 1 )
14439 {
14440 error( "argument must be a scalar or vector" ); SWIG_fail;
14441 }
14442 if ( _dim( args(11), 0 ) != Ylen )
14443 {
14444 error( "argument vectors must be same length" ); SWIG_fail;
14445 }
14446 temp15 = args(11).matrix_value();
14447 arg15 = &temp15( 0, 0 );
14448 }
14449 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);
14450 _outv = octave_value();
14451 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14452 {
14453
14454 }
14455 {
14456
14457 }
14458 {
14459
14460 }
14461 {
14462
14463 }
14464 return _out;
14465 fail:
14466 {
14467
14468 }
14469 {
14470
14471 }
14472 {
14473
14474 }
14475 {
14476
14477 }
14478 return octave_value_list();
14479 }
14480 catch(...) {
14481 {
14482
14483 }
14484 {
14485
14486 }
14487 {
14488
14489 }
14490 {
14491
14492 }
14493 throw;
14494 }
14495}
14496
14497
14498SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14499 PLFLT *arg1 = (PLFLT *) 0 ;
14500 PLINT arg2 ;
14501 PLINT arg3 ;
14502 PLFLT arg4 ;
14503 PLFLT arg5 ;
14504 PLFLT arg6 ;
14505 PLFLT arg7 ;
14506 PLFLT *arg8 = (PLFLT *) 0 ;
14507 PLINT arg9 ;
14508 PLINT arg10 ;
14509 PLINT arg11 ;
14510 PLINT arg12 ;
14511 PLBOOL arg13 ;
14512 PLFLT *arg14 = (PLFLT *) 0 ;
14513 PLFLT *arg15 = (PLFLT *) 0 ;
14514 Matrix temp1 ;
14515 double val4 ;
14516 int ecode4 = 0 ;
14517 double val5 ;
14518 int ecode5 = 0 ;
14519 double val6 ;
14520 int ecode6 = 0 ;
14521 double val7 ;
14522 int ecode7 = 0 ;
14523 Matrix temp8 ;
14524 int val10 ;
14525 int ecode10 = 0 ;
14526 int val11 ;
14527 int ecode11 = 0 ;
14528 int val12 ;
14529 int ecode12 = 0 ;
14530 int val13 ;
14531 int ecode13 = 0 ;
14532 Matrix temp14 ;
14533 Matrix temp15 ;
14534 octave_value_list _out;
14535 octave_value_list *_outp=&_out;
14536 octave_value _outv;
14537
14538 try {
14539 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14540 SWIG_fail;
14541 }
14542 {
14543 if ( _n_dims( args(0) ) > 2 )
14544 {
14545 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14546 }
14547 temp1 = args(0).matrix_value();
14548 arg1 = &temp1( 0, 0 );
14549 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14550 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14551 }
14552 ecode4 = SWIG_AsVal_double(args(1), &val4);
14553 if (!SWIG_IsOK(ecode4)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14555 }
14556 arg4 = static_cast< PLFLT >(val4);
14557 ecode5 = SWIG_AsVal_double(args(2), &val5);
14558 if (!SWIG_IsOK(ecode5)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14560 }
14561 arg5 = static_cast< PLFLT >(val5);
14562 ecode6 = SWIG_AsVal_double(args(3), &val6);
14563 if (!SWIG_IsOK(ecode6)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14565 }
14566 arg6 = static_cast< PLFLT >(val6);
14567 ecode7 = SWIG_AsVal_double(args(4), &val7);
14568 if (!SWIG_IsOK(ecode7)) {
14569 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14570 }
14571 arg7 = static_cast< PLFLT >(val7);
14572 {
14573 if ( _n_dims( args(5) ) > 1 )
14574 {
14575 error( "argument must be a scalar or vector" ); SWIG_fail;
14576 }
14577 temp8 = args(5).matrix_value();
14578 arg8 = &temp8( 0, 0 );
14579 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14580 }
14581 ecode10 = SWIG_AsVal_int(args(6), &val10);
14582 if (!SWIG_IsOK(ecode10)) {
14583 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14584 }
14585 arg10 = static_cast< PLINT >(val10);
14586 ecode11 = SWIG_AsVal_int(args(7), &val11);
14587 if (!SWIG_IsOK(ecode11)) {
14588 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14589 }
14590 arg11 = static_cast< PLINT >(val11);
14591 ecode12 = SWIG_AsVal_int(args(8), &val12);
14592 if (!SWIG_IsOK(ecode12)) {
14593 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14594 }
14595 arg12 = static_cast< PLINT >(val12);
14596 ecode13 = SWIG_AsVal_int(args(9), &val13);
14597 if (!SWIG_IsOK(ecode13)) {
14598 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14599 }
14600 arg13 = static_cast< PLBOOL >(val13);
14601 {
14602 if ( _n_dims( args(10) ) > 2 )
14603 {
14604 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14605 }
14606 temp14 = args(10).matrix_value();
14607 arg14 = &temp14( 0, 0 );
14608 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14609 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14610 }
14611 {
14612 if ( _n_dims( args(11) ) > 2 )
14613 {
14614 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14615 }
14616 temp15 = args(11).matrix_value();
14617 arg15 = &temp15( 0, 0 );
14618 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14619 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14620 }
14621 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);
14622 _outv = octave_value();
14623 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14624 {
14625
14626 }
14627 {
14628
14629 }
14630 {
14631
14632 }
14633 {
14634
14635 }
14636 return _out;
14637 fail:
14638 {
14639
14640 }
14641 {
14642
14643 }
14644 {
14645
14646 }
14647 {
14648
14649 }
14650 return octave_value_list();
14651 }
14652 catch(...) {
14653 {
14654
14655 }
14656 {
14657
14658 }
14659 {
14660
14661 }
14662 {
14663
14664 }
14665 throw;
14666 }
14667}
14668
14669
14671 PLFLT *arg1 = (PLFLT *) 0 ;
14672 PLFLT *arg2 = (PLFLT *) 0 ;
14673 PLINT arg3 ;
14674 PLINT arg4 ;
14675 PLFLT arg5 ;
14676 PLFLT *arg6 = (PLFLT *) 0 ;
14677 Matrix temp1 ;
14678 Matrix temp2 ;
14679 double val5 ;
14680 int ecode5 = 0 ;
14681 Matrix temp6 ;
14682 octave_value_list _out;
14683 octave_value_list *_outp=&_out;
14684 octave_value _outv;
14685
14686 try {
14687 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14688 SWIG_fail;
14689 }
14690 {
14691 if ( _n_dims( args(0) ) > 2 )
14692 {
14693 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14694 }
14695 temp1 = args(0).matrix_value();
14696 arg1 = &temp1( 0, 0 );
14697 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14698 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14699 }
14700 {
14701 if ( _n_dims( args(1) ) > 2 )
14702 {
14703 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14704 }
14705 if ( _dim( args(1), 0 ) != Xlen )
14706 {
14707 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14708 }
14709 if ( _dim( args(1), 1 ) != Ylen )
14710 {
14711 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14712 }
14713 temp2 = args(1).matrix_value();
14714 arg2 = &temp2( 0, 0 );
14715 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14716 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14717 }
14718 ecode5 = SWIG_AsVal_double(args(2), &val5);
14719 if (!SWIG_IsOK(ecode5)) {
14720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14721 }
14722 arg5 = static_cast< PLFLT >(val5);
14723 {
14724 if ( _n_dims( args(3) ) > 1 )
14725 {
14726 error( "argument must be a scalar or vector" ); SWIG_fail;
14727 }
14728 if ( _dim( args(3), 0 ) != 6 )
14729 {
14730 error( "argument vectors must have length of 6" ); SWIG_fail;
14731 }
14732 temp6 = args(3).matrix_value();
14733 arg6 = &temp6( 0, 0 );
14734 }
14735 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14736 _outv = octave_value();
14737 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14738 {
14739
14740 }
14741 {
14742
14743 }
14744 {
14745
14746 }
14747 return _out;
14748 fail:
14749 {
14750
14751 }
14752 {
14753
14754 }
14755 {
14756
14757 }
14758 return octave_value_list();
14759 }
14760 catch(...) {
14761 {
14762
14763 }
14764 {
14765
14766 }
14767 {
14768
14769 }
14770 throw;
14771 }
14772}
14773
14774
14775SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14776 PLFLT *arg1 = (PLFLT *) 0 ;
14777 PLFLT *arg2 = (PLFLT *) 0 ;
14778 PLINT arg3 ;
14779 PLINT arg4 ;
14780 PLFLT arg5 ;
14781 PLFLT *arg6 = (PLFLT *) 0 ;
14782 PLFLT *arg7 = (PLFLT *) 0 ;
14783 Matrix temp1 ;
14784 Matrix temp2 ;
14785 double val5 ;
14786 int ecode5 = 0 ;
14787 Matrix temp6 ;
14788 Matrix temp7 ;
14789 octave_value_list _out;
14790 octave_value_list *_outp=&_out;
14791 octave_value _outv;
14792
14793 try {
14794 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14795 SWIG_fail;
14796 }
14797 {
14798 if ( _n_dims( args(0) ) > 2 )
14799 {
14800 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14801 }
14802 temp1 = args(0).matrix_value();
14803 arg1 = &temp1( 0, 0 );
14804 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14805 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14806 }
14807 {
14808 if ( _n_dims( args(1) ) > 2 )
14809 {
14810 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14811 }
14812 if ( _dim( args(1), 0 ) != Xlen )
14813 {
14814 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14815 }
14816 if ( _dim( args(1), 1 ) != Ylen )
14817 {
14818 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14819 }
14820 temp2 = args(1).matrix_value();
14821 arg2 = &temp2( 0, 0 );
14822 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14823 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14824 }
14825 ecode5 = SWIG_AsVal_double(args(2), &val5);
14826 if (!SWIG_IsOK(ecode5)) {
14827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14828 }
14829 arg5 = static_cast< PLFLT >(val5);
14830 {
14831 if ( _n_dims( args(3) ) > 1 )
14832 {
14833 error( "argument must be a scalar or vector" ); SWIG_fail;
14834 }
14835 if ( _dim( args(3), 0 ) != Xlen )
14836 {
14837 error( "argument vectors must be same length" ); SWIG_fail;
14838 }
14839 temp6 = args(3).matrix_value();
14840 arg6 = &temp6( 0, 0 );
14841 }
14842 {
14843 if ( _n_dims( args(4) ) > 1 )
14844 {
14845 error( "argument must be a scalar or vector" ); SWIG_fail;
14846 }
14847 if ( _dim( args(4), 0 ) != Ylen )
14848 {
14849 error( "argument vectors must be same length" ); SWIG_fail;
14850 }
14851 temp7 = args(4).matrix_value();
14852 arg7 = &temp7( 0, 0 );
14853 }
14854 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14855 _outv = octave_value();
14856 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14857 {
14858
14859 }
14860 {
14861
14862 }
14863 {
14864
14865 }
14866 {
14867
14868 }
14869 return _out;
14870 fail:
14871 {
14872
14873 }
14874 {
14875
14876 }
14877 {
14878
14879 }
14880 {
14881
14882 }
14883 return octave_value_list();
14884 }
14885 catch(...) {
14886 {
14887
14888 }
14889 {
14890
14891 }
14892 {
14893
14894 }
14895 {
14896
14897 }
14898 throw;
14899 }
14900}
14901
14902
14903SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14904 PLFLT *arg1 = (PLFLT *) 0 ;
14905 PLFLT *arg2 = (PLFLT *) 0 ;
14906 PLINT arg3 ;
14907 PLINT arg4 ;
14908 PLFLT arg5 ;
14909 PLFLT *arg6 = (PLFLT *) 0 ;
14910 PLFLT *arg7 = (PLFLT *) 0 ;
14911 Matrix temp1 ;
14912 Matrix temp2 ;
14913 double val5 ;
14914 int ecode5 = 0 ;
14915 Matrix temp6 ;
14916 Matrix temp7 ;
14917 octave_value_list _out;
14918 octave_value_list *_outp=&_out;
14919 octave_value _outv;
14920
14921 try {
14922 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14923 SWIG_fail;
14924 }
14925 {
14926 if ( _n_dims( args(0) ) > 2 )
14927 {
14928 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14929 }
14930 temp1 = args(0).matrix_value();
14931 arg1 = &temp1( 0, 0 );
14932 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14933 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14934 }
14935 {
14936 if ( _n_dims( args(1) ) > 2 )
14937 {
14938 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14939 }
14940 if ( _dim( args(1), 0 ) != Xlen )
14941 {
14942 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14943 }
14944 if ( _dim( args(1), 1 ) != Ylen )
14945 {
14946 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14947 }
14948 temp2 = args(1).matrix_value();
14949 arg2 = &temp2( 0, 0 );
14950 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14951 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14952 }
14953 ecode5 = SWIG_AsVal_double(args(2), &val5);
14954 if (!SWIG_IsOK(ecode5)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14956 }
14957 arg5 = static_cast< PLFLT >(val5);
14958 {
14959 if ( _n_dims( args(3) ) > 2 )
14960 {
14961 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14962 }
14963 temp6 = args(3).matrix_value();
14964 arg6 = &temp6( 0, 0 );
14965 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14966 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14967 }
14968 {
14969 if ( _n_dims( args(4) ) > 2 )
14970 {
14971 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14972 }
14973 temp7 = args(4).matrix_value();
14974 arg7 = &temp7( 0, 0 );
14975 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14976 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14977 }
14978 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14979 _outv = octave_value();
14980 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14981 {
14982
14983 }
14984 {
14985
14986 }
14987 {
14988
14989 }
14990 {
14991
14992 }
14993 return _out;
14994 fail:
14995 {
14996
14997 }
14998 {
14999
15000 }
15001 {
15002
15003 }
15004 {
15005
15006 }
15007 return octave_value_list();
15008 }
15009 catch(...) {
15010 {
15011
15012 }
15013 {
15014
15015 }
15016 {
15017
15018 }
15019 {
15020
15021 }
15022 throw;
15023 }
15024}
15025
15026
15027SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
15028 PLFLT *arg1 = (PLFLT *) 0 ;
15029 PLINT arg2 ;
15030 PLINT arg3 ;
15031 PLFLT arg4 ;
15032 PLFLT arg5 ;
15033 PLFLT arg6 ;
15034 PLFLT arg7 ;
15035 PLFLT arg8 ;
15036 PLFLT arg9 ;
15037 PLFLT arg10 ;
15038 PLFLT arg11 ;
15039 PLFLT arg12 ;
15040 PLFLT arg13 ;
15041 Matrix temp1 ;
15042 double val4 ;
15043 int ecode4 = 0 ;
15044 double val5 ;
15045 int ecode5 = 0 ;
15046 double val6 ;
15047 int ecode6 = 0 ;
15048 double val7 ;
15049 int ecode7 = 0 ;
15050 double val8 ;
15051 int ecode8 = 0 ;
15052 double val9 ;
15053 int ecode9 = 0 ;
15054 double val10 ;
15055 int ecode10 = 0 ;
15056 double val11 ;
15057 int ecode11 = 0 ;
15058 double val12 ;
15059 int ecode12 = 0 ;
15060 double val13 ;
15061 int ecode13 = 0 ;
15062 octave_value_list _out;
15063 octave_value_list *_outp=&_out;
15064 octave_value _outv;
15065
15066 try {
15067 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
15068 SWIG_fail;
15069 }
15070 {
15071 if ( _n_dims( args(0) ) > 2 )
15072 {
15073 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15074 }
15075 temp1 = args(0).matrix_value();
15076 arg1 = &temp1( 0, 0 );
15077 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15078 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15079 }
15080 ecode4 = SWIG_AsVal_double(args(1), &val4);
15081 if (!SWIG_IsOK(ecode4)) {
15082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15083 }
15084 arg4 = static_cast< PLFLT >(val4);
15085 ecode5 = SWIG_AsVal_double(args(2), &val5);
15086 if (!SWIG_IsOK(ecode5)) {
15087 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15088 }
15089 arg5 = static_cast< PLFLT >(val5);
15090 ecode6 = SWIG_AsVal_double(args(3), &val6);
15091 if (!SWIG_IsOK(ecode6)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15093 }
15094 arg6 = static_cast< PLFLT >(val6);
15095 ecode7 = SWIG_AsVal_double(args(4), &val7);
15096 if (!SWIG_IsOK(ecode7)) {
15097 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15098 }
15099 arg7 = static_cast< PLFLT >(val7);
15100 ecode8 = SWIG_AsVal_double(args(5), &val8);
15101 if (!SWIG_IsOK(ecode8)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15103 }
15104 arg8 = static_cast< PLFLT >(val8);
15105 ecode9 = SWIG_AsVal_double(args(6), &val9);
15106 if (!SWIG_IsOK(ecode9)) {
15107 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15108 }
15109 arg9 = static_cast< PLFLT >(val9);
15110 ecode10 = SWIG_AsVal_double(args(7), &val10);
15111 if (!SWIG_IsOK(ecode10)) {
15112 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15113 }
15114 arg10 = static_cast< PLFLT >(val10);
15115 ecode11 = SWIG_AsVal_double(args(8), &val11);
15116 if (!SWIG_IsOK(ecode11)) {
15117 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15118 }
15119 arg11 = static_cast< PLFLT >(val11);
15120 ecode12 = SWIG_AsVal_double(args(9), &val12);
15121 if (!SWIG_IsOK(ecode12)) {
15122 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15123 }
15124 arg12 = static_cast< PLFLT >(val12);
15125 ecode13 = SWIG_AsVal_double(args(10), &val13);
15126 if (!SWIG_IsOK(ecode13)) {
15127 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15128 }
15129 arg13 = static_cast< PLFLT >(val13);
15130 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15131 _outv = octave_value();
15132 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15133 {
15134
15135 }
15136 return _out;
15137 fail:
15138 {
15139
15140 }
15141 return octave_value_list();
15142 }
15143 catch(...) {
15144 {
15145
15146 }
15147 throw;
15148 }
15149}
15150
15151
15153 PLFLT *arg1 = (PLFLT *) 0 ;
15154 PLINT arg2 ;
15155 PLINT arg3 ;
15156 PLFLT arg4 ;
15157 PLFLT arg5 ;
15158 PLFLT arg6 ;
15159 PLFLT arg7 ;
15160 PLFLT arg8 ;
15161 PLFLT arg9 ;
15162 PLFLT arg10 ;
15163 PLFLT arg11 ;
15164 Matrix temp1 ;
15165 double val4 ;
15166 int ecode4 = 0 ;
15167 double val5 ;
15168 int ecode5 = 0 ;
15169 double val6 ;
15170 int ecode6 = 0 ;
15171 double val7 ;
15172 int ecode7 = 0 ;
15173 double val8 ;
15174 int ecode8 = 0 ;
15175 double val9 ;
15176 int ecode9 = 0 ;
15177 double val10 ;
15178 int ecode10 = 0 ;
15179 double val11 ;
15180 int ecode11 = 0 ;
15181 octave_value_list _out;
15182 octave_value_list *_outp=&_out;
15183 octave_value _outv;
15184
15185 try {
15186 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15187 SWIG_fail;
15188 }
15189 {
15190 if ( _n_dims( args(0) ) > 2 )
15191 {
15192 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15193 }
15194 temp1 = args(0).matrix_value();
15195 arg1 = &temp1( 0, 0 );
15196 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15197 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15198 }
15199 ecode4 = SWIG_AsVal_double(args(1), &val4);
15200 if (!SWIG_IsOK(ecode4)) {
15201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15202 }
15203 arg4 = static_cast< PLFLT >(val4);
15204 ecode5 = SWIG_AsVal_double(args(2), &val5);
15205 if (!SWIG_IsOK(ecode5)) {
15206 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15207 }
15208 arg5 = static_cast< PLFLT >(val5);
15209 ecode6 = SWIG_AsVal_double(args(3), &val6);
15210 if (!SWIG_IsOK(ecode6)) {
15211 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15212 }
15213 arg6 = static_cast< PLFLT >(val6);
15214 ecode7 = SWIG_AsVal_double(args(4), &val7);
15215 if (!SWIG_IsOK(ecode7)) {
15216 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15217 }
15218 arg7 = static_cast< PLFLT >(val7);
15219 ecode8 = SWIG_AsVal_double(args(5), &val8);
15220 if (!SWIG_IsOK(ecode8)) {
15221 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15222 }
15223 arg8 = static_cast< PLFLT >(val8);
15224 ecode9 = SWIG_AsVal_double(args(6), &val9);
15225 if (!SWIG_IsOK(ecode9)) {
15226 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15227 }
15228 arg9 = static_cast< PLFLT >(val9);
15229 ecode10 = SWIG_AsVal_double(args(7), &val10);
15230 if (!SWIG_IsOK(ecode10)) {
15231 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15232 }
15233 arg10 = static_cast< PLFLT >(val10);
15234 ecode11 = SWIG_AsVal_double(args(8), &val11);
15235 if (!SWIG_IsOK(ecode11)) {
15236 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15237 }
15238 arg11 = static_cast< PLFLT >(val11);
15239 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15240 _outv = octave_value();
15241 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15242 {
15243
15244 }
15245 return _out;
15246 fail:
15247 {
15248
15249 }
15250 return octave_value_list();
15251 }
15252 catch(...) {
15253 {
15254
15255 }
15256 throw;
15257 }
15258}
15259
15260
15261SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15262 PLFLT *arg1 = (PLFLT *) 0 ;
15263 PLINT arg2 ;
15264 PLINT arg3 ;
15265 PLFLT arg4 ;
15266 PLFLT arg5 ;
15267 PLFLT arg6 ;
15268 PLFLT arg7 ;
15269 PLFLT arg8 ;
15270 PLFLT arg9 ;
15271 PLFLT arg10 ;
15272 PLFLT arg11 ;
15273 PLFLT *arg12 = (PLFLT *) 0 ;
15274 Matrix temp1 ;
15275 double val4 ;
15276 int ecode4 = 0 ;
15277 double val5 ;
15278 int ecode5 = 0 ;
15279 double val6 ;
15280 int ecode6 = 0 ;
15281 double val7 ;
15282 int ecode7 = 0 ;
15283 double val8 ;
15284 int ecode8 = 0 ;
15285 double val9 ;
15286 int ecode9 = 0 ;
15287 double val10 ;
15288 int ecode10 = 0 ;
15289 double val11 ;
15290 int ecode11 = 0 ;
15291 Matrix temp12 ;
15292 octave_value_list _out;
15293 octave_value_list *_outp=&_out;
15294 octave_value _outv;
15295
15296 try {
15297 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15298 SWIG_fail;
15299 }
15300 {
15301 if ( _n_dims( args(0) ) > 2 )
15302 {
15303 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15304 }
15305 temp1 = args(0).matrix_value();
15306 arg1 = &temp1( 0, 0 );
15307 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15308 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15309 }
15310 ecode4 = SWIG_AsVal_double(args(1), &val4);
15311 if (!SWIG_IsOK(ecode4)) {
15312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15313 }
15314 arg4 = static_cast< PLFLT >(val4);
15315 ecode5 = SWIG_AsVal_double(args(2), &val5);
15316 if (!SWIG_IsOK(ecode5)) {
15317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15318 }
15319 arg5 = static_cast< PLFLT >(val5);
15320 ecode6 = SWIG_AsVal_double(args(3), &val6);
15321 if (!SWIG_IsOK(ecode6)) {
15322 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15323 }
15324 arg6 = static_cast< PLFLT >(val6);
15325 ecode7 = SWIG_AsVal_double(args(4), &val7);
15326 if (!SWIG_IsOK(ecode7)) {
15327 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15328 }
15329 arg7 = static_cast< PLFLT >(val7);
15330 ecode8 = SWIG_AsVal_double(args(5), &val8);
15331 if (!SWIG_IsOK(ecode8)) {
15332 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15333 }
15334 arg8 = static_cast< PLFLT >(val8);
15335 ecode9 = SWIG_AsVal_double(args(6), &val9);
15336 if (!SWIG_IsOK(ecode9)) {
15337 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15338 }
15339 arg9 = static_cast< PLFLT >(val9);
15340 ecode10 = SWIG_AsVal_double(args(7), &val10);
15341 if (!SWIG_IsOK(ecode10)) {
15342 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15343 }
15344 arg10 = static_cast< PLFLT >(val10);
15345 ecode11 = SWIG_AsVal_double(args(8), &val11);
15346 if (!SWIG_IsOK(ecode11)) {
15347 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15348 }
15349 arg11 = static_cast< PLFLT >(val11);
15350 {
15351 if ( _n_dims( args(9) ) > 1 )
15352 {
15353 error( "argument must be a scalar or vector" ); SWIG_fail;
15354 }
15355 if ( _dim( args(9), 0 ) != 6 )
15356 {
15357 error( "argument vectors must have length of 6" ); SWIG_fail;
15358 }
15359 temp12 = args(9).matrix_value();
15360 arg12 = &temp12( 0, 0 );
15361 }
15362 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15363 _outv = octave_value();
15364 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15365 {
15366
15367 }
15368 {
15369
15370 }
15371 return _out;
15372 fail:
15373 {
15374
15375 }
15376 {
15377
15378 }
15379 return octave_value_list();
15380 }
15381 catch(...) {
15382 {
15383
15384 }
15385 {
15386
15387 }
15388 throw;
15389 }
15390}
15391
15392
15393SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15394 PLFLT *arg1 = (PLFLT *) 0 ;
15395 PLINT arg2 ;
15396 PLINT arg3 ;
15397 PLFLT arg4 ;
15398 PLFLT arg5 ;
15399 PLFLT arg6 ;
15400 PLFLT arg7 ;
15401 PLFLT arg8 ;
15402 PLFLT arg9 ;
15403 PLFLT arg10 ;
15404 PLFLT arg11 ;
15405 PLFLT *arg12 = (PLFLT *) 0 ;
15406 PLFLT *arg13 = (PLFLT *) 0 ;
15407 Matrix temp1 ;
15408 double val4 ;
15409 int ecode4 = 0 ;
15410 double val5 ;
15411 int ecode5 = 0 ;
15412 double val6 ;
15413 int ecode6 = 0 ;
15414 double val7 ;
15415 int ecode7 = 0 ;
15416 double val8 ;
15417 int ecode8 = 0 ;
15418 double val9 ;
15419 int ecode9 = 0 ;
15420 double val10 ;
15421 int ecode10 = 0 ;
15422 double val11 ;
15423 int ecode11 = 0 ;
15424 Matrix temp12 ;
15425 Matrix temp13 ;
15426 octave_value_list _out;
15427 octave_value_list *_outp=&_out;
15428 octave_value _outv;
15429
15430 try {
15431 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15432 SWIG_fail;
15433 }
15434 {
15435 if ( _n_dims( args(0) ) > 2 )
15436 {
15437 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15438 }
15439 temp1 = args(0).matrix_value();
15440 arg1 = &temp1( 0, 0 );
15441 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15442 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15443 }
15444 ecode4 = SWIG_AsVal_double(args(1), &val4);
15445 if (!SWIG_IsOK(ecode4)) {
15446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15447 }
15448 arg4 = static_cast< PLFLT >(val4);
15449 ecode5 = SWIG_AsVal_double(args(2), &val5);
15450 if (!SWIG_IsOK(ecode5)) {
15451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15452 }
15453 arg5 = static_cast< PLFLT >(val5);
15454 ecode6 = SWIG_AsVal_double(args(3), &val6);
15455 if (!SWIG_IsOK(ecode6)) {
15456 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15457 }
15458 arg6 = static_cast< PLFLT >(val6);
15459 ecode7 = SWIG_AsVal_double(args(4), &val7);
15460 if (!SWIG_IsOK(ecode7)) {
15461 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15462 }
15463 arg7 = static_cast< PLFLT >(val7);
15464 ecode8 = SWIG_AsVal_double(args(5), &val8);
15465 if (!SWIG_IsOK(ecode8)) {
15466 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15467 }
15468 arg8 = static_cast< PLFLT >(val8);
15469 ecode9 = SWIG_AsVal_double(args(6), &val9);
15470 if (!SWIG_IsOK(ecode9)) {
15471 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15472 }
15473 arg9 = static_cast< PLFLT >(val9);
15474 ecode10 = SWIG_AsVal_double(args(7), &val10);
15475 if (!SWIG_IsOK(ecode10)) {
15476 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15477 }
15478 arg10 = static_cast< PLFLT >(val10);
15479 ecode11 = SWIG_AsVal_double(args(8), &val11);
15480 if (!SWIG_IsOK(ecode11)) {
15481 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15482 }
15483 arg11 = static_cast< PLFLT >(val11);
15484 {
15485 if ( _n_dims( args(9) ) > 1 )
15486 {
15487 error( "argument must be a scalar or vector" ); SWIG_fail;
15488 }
15489 if ( _dim( args(9), 0 ) != Xlen )
15490 {
15491 error( "argument vectors must be same length" ); SWIG_fail;
15492 }
15493 temp12 = args(9).matrix_value();
15494 arg12 = &temp12( 0, 0 );
15495 }
15496 {
15497 if ( _n_dims( args(10) ) > 1 )
15498 {
15499 error( "argument must be a scalar or vector" ); SWIG_fail;
15500 }
15501 if ( _dim( args(10), 0 ) != Ylen )
15502 {
15503 error( "argument vectors must be same length" ); SWIG_fail;
15504 }
15505 temp13 = args(10).matrix_value();
15506 arg13 = &temp13( 0, 0 );
15507 }
15508 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15509 _outv = octave_value();
15510 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15511 {
15512
15513 }
15514 {
15515
15516 }
15517 {
15518
15519 }
15520 return _out;
15521 fail:
15522 {
15523
15524 }
15525 {
15526
15527 }
15528 {
15529
15530 }
15531 return octave_value_list();
15532 }
15533 catch(...) {
15534 {
15535
15536 }
15537 {
15538
15539 }
15540 {
15541
15542 }
15543 throw;
15544 }
15545}
15546
15547
15548SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15549 PLFLT *arg1 = (PLFLT *) 0 ;
15550 PLINT arg2 ;
15551 PLINT arg3 ;
15552 PLFLT arg4 ;
15553 PLFLT arg5 ;
15554 PLFLT arg6 ;
15555 PLFLT arg7 ;
15556 PLFLT arg8 ;
15557 PLFLT arg9 ;
15558 PLFLT arg10 ;
15559 PLFLT arg11 ;
15560 PLFLT *arg12 = (PLFLT *) 0 ;
15561 PLFLT *arg13 = (PLFLT *) 0 ;
15562 Matrix temp1 ;
15563 double val4 ;
15564 int ecode4 = 0 ;
15565 double val5 ;
15566 int ecode5 = 0 ;
15567 double val6 ;
15568 int ecode6 = 0 ;
15569 double val7 ;
15570 int ecode7 = 0 ;
15571 double val8 ;
15572 int ecode8 = 0 ;
15573 double val9 ;
15574 int ecode9 = 0 ;
15575 double val10 ;
15576 int ecode10 = 0 ;
15577 double val11 ;
15578 int ecode11 = 0 ;
15579 Matrix temp12 ;
15580 Matrix temp13 ;
15581 octave_value_list _out;
15582 octave_value_list *_outp=&_out;
15583 octave_value _outv;
15584
15585 try {
15586 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15587 SWIG_fail;
15588 }
15589 {
15590 if ( _n_dims( args(0) ) > 2 )
15591 {
15592 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15593 }
15594 temp1 = args(0).matrix_value();
15595 arg1 = &temp1( 0, 0 );
15596 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15597 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15598 }
15599 ecode4 = SWIG_AsVal_double(args(1), &val4);
15600 if (!SWIG_IsOK(ecode4)) {
15601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15602 }
15603 arg4 = static_cast< PLFLT >(val4);
15604 ecode5 = SWIG_AsVal_double(args(2), &val5);
15605 if (!SWIG_IsOK(ecode5)) {
15606 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15607 }
15608 arg5 = static_cast< PLFLT >(val5);
15609 ecode6 = SWIG_AsVal_double(args(3), &val6);
15610 if (!SWIG_IsOK(ecode6)) {
15611 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15612 }
15613 arg6 = static_cast< PLFLT >(val6);
15614 ecode7 = SWIG_AsVal_double(args(4), &val7);
15615 if (!SWIG_IsOK(ecode7)) {
15616 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15617 }
15618 arg7 = static_cast< PLFLT >(val7);
15619 ecode8 = SWIG_AsVal_double(args(5), &val8);
15620 if (!SWIG_IsOK(ecode8)) {
15621 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15622 }
15623 arg8 = static_cast< PLFLT >(val8);
15624 ecode9 = SWIG_AsVal_double(args(6), &val9);
15625 if (!SWIG_IsOK(ecode9)) {
15626 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15627 }
15628 arg9 = static_cast< PLFLT >(val9);
15629 ecode10 = SWIG_AsVal_double(args(7), &val10);
15630 if (!SWIG_IsOK(ecode10)) {
15631 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15632 }
15633 arg10 = static_cast< PLFLT >(val10);
15634 ecode11 = SWIG_AsVal_double(args(8), &val11);
15635 if (!SWIG_IsOK(ecode11)) {
15636 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15637 }
15638 arg11 = static_cast< PLFLT >(val11);
15639 {
15640 if ( _n_dims( args(9) ) > 2 )
15641 {
15642 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15643 }
15644 temp12 = args(9).matrix_value();
15645 arg12 = &temp12( 0, 0 );
15646 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15647 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15648 }
15649 {
15650 if ( _n_dims( args(10) ) > 2 )
15651 {
15652 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15653 }
15654 temp13 = args(10).matrix_value();
15655 arg13 = &temp13( 0, 0 );
15656 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15657 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15658 }
15659 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15660 _outv = octave_value();
15661 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15662 {
15663
15664 }
15665 {
15666
15667 }
15668 {
15669
15670 }
15671 return _out;
15672 fail:
15673 {
15674
15675 }
15676 {
15677
15678 }
15679 {
15680
15681 }
15682 return octave_value_list();
15683 }
15684 catch(...) {
15685 {
15686
15687 }
15688 {
15689
15690 }
15691 {
15692
15693 }
15694 throw;
15695 }
15696}
15697
15698
15699SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15700 PLFLT *arg1 = (PLFLT *) 0 ;
15701 PLFLT *arg2 = (PLFLT *) 0 ;
15702 PLINT arg3 ;
15703 PLINT arg4 ;
15704 PLFLT arg5 ;
15705 PLFLT arg6 ;
15706 PLFLT arg7 ;
15707 PLFLT arg8 ;
15708 PLINT arg9 ;
15709 PLINT arg10 ;
15710 PLINT arg11 ;
15711 PLFLT arg12 ;
15712 PLFLT arg13 ;
15713 PLINT arg14 ;
15714 PLFLT arg15 ;
15715 PLINT arg16 ;
15716 PLINT *arg17 = (PLINT *) 0 ;
15717 char **arg18 = (char **) 0 ;
15718 PLINT arg19 ;
15719 char **arg20 = (char **) 0 ;
15720 PLFLT *arg21 = (PLFLT *) 0 ;
15721 PLINT *arg22 = (PLINT *) 0 ;
15722 PLINT *arg23 = (PLINT *) 0 ;
15723 PLFLT *arg24 = (PLFLT *) 0 ;
15724 PLFLT temp1 ;
15725 int res1 = SWIG_TMPOBJ ;
15726 PLFLT temp2 ;
15727 int res2 = SWIG_TMPOBJ ;
15728 int val3 ;
15729 int ecode3 = 0 ;
15730 int val4 ;
15731 int ecode4 = 0 ;
15732 double val5 ;
15733 int ecode5 = 0 ;
15734 double val6 ;
15735 int ecode6 = 0 ;
15736 double val7 ;
15737 int ecode7 = 0 ;
15738 double val8 ;
15739 int ecode8 = 0 ;
15740 int val9 ;
15741 int ecode9 = 0 ;
15742 int val10 ;
15743 int ecode10 = 0 ;
15744 int val11 ;
15745 int ecode11 = 0 ;
15746 double val12 ;
15747 int ecode12 = 0 ;
15748 double val13 ;
15749 int ecode13 = 0 ;
15750 int val14 ;
15751 int ecode14 = 0 ;
15752 double val15 ;
15753 int ecode15 = 0 ;
15754 Matrix temp16 ;
15755 Matrix temp21 ;
15756 Matrix temp22 ;
15757 Matrix temp23 ;
15758 Matrix temp24 ;
15759 octave_value_list _out;
15760 octave_value_list *_outp=&_out;
15761 octave_value _outv;
15762
15763 try {
15764 arg1 = &temp1;
15765 arg2 = &temp2;
15766 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15767 SWIG_fail;
15768 }
15769 ecode3 = SWIG_AsVal_int(args(0), &val3);
15770 if (!SWIG_IsOK(ecode3)) {
15771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15772 }
15773 arg3 = static_cast< PLINT >(val3);
15774 ecode4 = SWIG_AsVal_int(args(1), &val4);
15775 if (!SWIG_IsOK(ecode4)) {
15776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15777 }
15778 arg4 = static_cast< PLINT >(val4);
15779 ecode5 = SWIG_AsVal_double(args(2), &val5);
15780 if (!SWIG_IsOK(ecode5)) {
15781 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15782 }
15783 arg5 = static_cast< PLFLT >(val5);
15784 ecode6 = SWIG_AsVal_double(args(3), &val6);
15785 if (!SWIG_IsOK(ecode6)) {
15786 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15787 }
15788 arg6 = static_cast< PLFLT >(val6);
15789 ecode7 = SWIG_AsVal_double(args(4), &val7);
15790 if (!SWIG_IsOK(ecode7)) {
15791 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15792 }
15793 arg7 = static_cast< PLFLT >(val7);
15794 ecode8 = SWIG_AsVal_double(args(5), &val8);
15795 if (!SWIG_IsOK(ecode8)) {
15796 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15797 }
15798 arg8 = static_cast< PLFLT >(val8);
15799 ecode9 = SWIG_AsVal_int(args(6), &val9);
15800 if (!SWIG_IsOK(ecode9)) {
15801 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15802 }
15803 arg9 = static_cast< PLINT >(val9);
15804 ecode10 = SWIG_AsVal_int(args(7), &val10);
15805 if (!SWIG_IsOK(ecode10)) {
15806 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15807 }
15808 arg10 = static_cast< PLINT >(val10);
15809 ecode11 = SWIG_AsVal_int(args(8), &val11);
15810 if (!SWIG_IsOK(ecode11)) {
15811 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15812 }
15813 arg11 = static_cast< PLINT >(val11);
15814 ecode12 = SWIG_AsVal_double(args(9), &val12);
15815 if (!SWIG_IsOK(ecode12)) {
15816 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15817 }
15818 arg12 = static_cast< PLFLT >(val12);
15819 ecode13 = SWIG_AsVal_double(args(10), &val13);
15820 if (!SWIG_IsOK(ecode13)) {
15821 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15822 }
15823 arg13 = static_cast< PLFLT >(val13);
15824 ecode14 = SWIG_AsVal_int(args(11), &val14);
15825 if (!SWIG_IsOK(ecode14)) {
15826 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15827 }
15828 arg14 = static_cast< PLINT >(val14);
15829 ecode15 = SWIG_AsVal_double(args(12), &val15);
15830 if (!SWIG_IsOK(ecode15)) {
15831 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15832 }
15833 arg15 = static_cast< PLFLT >(val15);
15834 {
15835 if ( _n_dims( args(13) ) > 1 )
15836 {
15837 error( "argument must be a scalar or vector" ); SWIG_fail;
15838 }
15839 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15840 arg17 = new PLINT[Alen];
15841 temp16 = args(13).matrix_value();
15842 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15843 }
15844 {
15845 charMatrix temp_matrix;
15846 Cell temp_cell;
15847 char *tmp_cstring;
15848 std::string str;
15849 size_t max_length = 0, non_blank_length;
15850 int i, ifcell;
15851 if ( _n_dims( args(14) ) > 2 )
15852 {
15853 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15854 }
15855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15856 if ( !args(14).isempty() )
15857#else
15858 if ( !args(14).is_empty() )
15859#endif
15860 {
15861 if ( _dim( args(14), 0 ) != Alen )
15862 {
15863 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15864 }
15865 arg18 = new char*[Alen];
15866#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15867 ifcell = args(14).iscell();
15868#else
15869 ifcell = args(14).is_cell();
15870#endif
15871 if ( ifcell )
15872 {
15873 temp_cell = args(14).cell_value();
15874 }
15875 else
15876 {
15877 temp_matrix = args(14).char_matrix_value();
15878 // Allow one extra space for null termination.
15879 max_length = _dim( args(14), 1 ) + 1;
15880 }
15881
15882 for ( i = 0; i < Alen; i++ )
15883 {
15884 // Must copy string to "permanent" location because the string
15885 // location corresponding to tmp_cstring gets
15886 // overwritten for each iteration of loop.
15887 if ( ifcell )
15888 {
15889 if ( temp_cell.elem( i ).is_string() )
15890 {
15891 str = temp_cell.elem( i ).string_value();
15892 // leave room for null termination.
15893 max_length = str.size() + 1;
15894 tmp_cstring = (char *) str.c_str();
15895 }
15896 else
15897 {
15898 // Use null string if user attempts to pass a cell array
15899 // with a non-string element (likely an empty element
15900 // since that should be allowed by the PLplot interface
15901 // if that element is going to be unused).
15902 // leave room for null termination.
15903 max_length = 1;
15904 tmp_cstring = (char *) "";
15905 }
15906 }
15907 else
15908 {
15909 str = temp_matrix.row_as_string( i );
15910 tmp_cstring = (char *) str.c_str();
15911 }
15912 arg18[i] = new char[max_length];
15913 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15914 arg18[i][max_length - 1] = '\0';
15915 // All the trailing blank crapola should not be needed for
15916 // string cell arrays.
15917 if ( !ifcell )
15918 {
15919 // remove trailing-blank padding that is used by the
15920 // charMatrix class to insure all strings in a given
15921 // charMatrix instance have the same length.
15922 // This transformation also removes legitimate trailing
15923 // blanks but there is nothing we can do about that
15924 // for the charMatrix class.
15925
15926 // Look for trailing nulls first (just in case, although that
15927 // shouldn't happen if charMatrix implemented as documented)
15928 // before looking for trailing blanks.
15929 non_blank_length = max_length - 2;
15930 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15931 {
15932 non_blank_length--;
15933 }
15934 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15935 {
15936 non_blank_length--;
15937 }
15938 arg18[i][non_blank_length + 1] = '\0';
15939 }
15940 }
15941 }
15942 else
15943 {
15944 arg18 = NULL;
15945 }
15946 }
15947 {
15948 charMatrix temp_matrix;
15949 Cell temp_cell;
15950 char *tmp_cstring;
15951 std::string str;
15952 size_t max_length = 0, non_blank_length;
15953 int i, ifcell;
15954 if ( _n_dims( args(15) ) > 2 )
15955 {
15956 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15957 }
15958#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15959 if ( !args(15).isempty() )
15960#else
15961 if ( !args(15).is_empty() )
15962#endif
15963 {
15964 Alen = _dim( args(15), 0 );
15965 arg19 = Alen;
15966 arg20 = new char*[Alen];
15967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15968 ifcell = args(15).iscell();
15969#else
15970 ifcell = args(15).is_cell();
15971#endif
15972 if ( ifcell )
15973 {
15974 temp_cell = args(15).cell_value();
15975 }
15976 else
15977 {
15978 temp_matrix = args(15).char_matrix_value();
15979 // Allow one extra space for null termination.
15980 max_length = _dim( args(15), 1 ) + 1;
15981 }
15982
15983 for ( i = 0; i < Alen; i++ )
15984 {
15985 // Must copy string to "permanent" location because the string
15986 // location corresponding to tmp_cstring gets
15987 // overwritten for each iteration of loop.
15988 if ( ifcell )
15989 {
15990 if ( temp_cell.elem( i ).is_string() )
15991 {
15992 str = temp_cell.elem( i ).string_value();
15993 // leave room for null termination.
15994 max_length = str.size() + 1;
15995 tmp_cstring = (char *) str.c_str();
15996 }
15997 else
15998 {
15999 // Use null string if user attempts to pass a cell array
16000 // with a non-string element (likely an empty element
16001 // since that should be allowed by the PLplot interface
16002 // if that element is going to be unused).
16003 // leave room for null termination.
16004 max_length = 1;
16005 tmp_cstring = (char *) "";
16006 }
16007 }
16008 else
16009 {
16010 str = temp_matrix.row_as_string( i );
16011 tmp_cstring = (char *) str.c_str();
16012 }
16013 arg20[i] = new char[max_length];
16014 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16015 arg20[i][max_length - 1] = '\0';
16016 // All the trailing blank crapola should not be needed for
16017 // string cell arrays.
16018 if ( !ifcell )
16019 {
16020 // remove trailing-blank padding that is used by the
16021 // charMatrix class to insure all strings in a given
16022 // charMatrix instance have the same length.
16023 // This transformation also removes legitimate trailing
16024 // blanks but there is nothing we can do about that
16025 // for the charMatrix class.
16026
16027 // Look for trailing nulls first (just in case, although that
16028 // shouldn't happen if charMatrix implemented as documented)
16029 // before looking for trailing blanks.
16030 non_blank_length = max_length - 2;
16031 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16032 {
16033 non_blank_length--;
16034 }
16035 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16036 {
16037 non_blank_length--;
16038 }
16039 arg20[i][non_blank_length + 1] = '\0';
16040 }
16041 }
16042 }
16043 else
16044 {
16045 arg19 = 0;
16046 arg20 = NULL;
16047 }
16048 }
16049 {
16050 if ( _n_dims( args(16) ) > 1 )
16051 {
16052 error( "argument must be a scalar or vector" ); SWIG_fail;
16053 }
16054 if ( _dim( args(16), 0 ) != Alen )
16055 {
16056 error( "argument vectors must be same length" ); SWIG_fail;
16057 }
16058 temp21 = args(16).matrix_value();
16059 arg21 = &temp21( 0, 0 );
16060 }
16061 {
16062 if ( _n_dims( args(17) ) > 1 )
16063 {
16064 error( "argument must be a scalar or vector" ); SWIG_fail;
16065 }
16066 if ( _dim( args(17), 0 ) != Alen )
16067 {
16068 error( "argument vectors must be same length" ); SWIG_fail;
16069 }
16070 temp22 = args(17).matrix_value();
16071 arg22 = new PLINT[Alen];
16072 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16073 }
16074 {
16075 int i;
16076 if ( _n_dims( args(18) ) > 1 )
16077 {
16078 error( "argument must be a scalar or vector" ); SWIG_fail;
16079 }
16080 if ( _dim( args(18), 0 ) != Alen )
16081 {
16082 error( "argument vectors must be same length" ); SWIG_fail;
16083 }
16084 Xlen = Alen;
16085 temp23 = args(18).matrix_value();
16086 arg23 = new PLINT[Alen];
16087 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16088 Ylen = -1;
16089 for ( i = 0; i < Xlen; i++ )
16090 if ( arg23[i] > Ylen )
16091 Ylen = arg23[i];
16092 }
16093 {
16094 if ( _n_dims( args(19) ) > 2 )
16095 {
16096 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16097 }
16098 if ( _dim( args(19), 0 ) != Xlen )
16099 {
16100 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16101 }
16102 if ( _dim( args(19), 1 ) != Ylen )
16103 {
16104 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16105 }
16106 temp24 = args(19).matrix_value();
16107 arg24 = &temp24( 0, 0 );
16108 }
16109 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);
16110 _outv = octave_value();
16111 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16112 if (SWIG_IsTmpObj(res1)) {
16113 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16114 } else {
16115 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16116 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16117 }
16118 if (SWIG_IsTmpObj(res2)) {
16119 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16120 } else {
16121 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16122 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16123 }
16124 {
16125 delete [] arg17;
16126 }
16127 {
16128 int i;
16129 if ( arg18 != NULL )
16130 {
16131 for ( i = 0; i < Alen; i++ )
16132 {
16133 delete[] arg18[i];
16134 }
16135 delete[] arg18;
16136 }
16137 }
16138 {
16139 int i;
16140 if ( arg20 != NULL )
16141 {
16142 for ( i = 0; i < Alen; i++ )
16143 {
16144 delete[] arg20[i];
16145 }
16146 delete[] arg20;
16147 }
16148 }
16149 {
16150
16151 }
16152 {
16153 delete [] arg22;
16154 }
16155 {
16156 delete [] arg23;
16157 }
16158 {
16159
16160 }
16161 return _out;
16162 fail:
16163 {
16164 delete [] arg17;
16165 }
16166 {
16167 int i;
16168 if ( arg18 != NULL )
16169 {
16170 for ( i = 0; i < Alen; i++ )
16171 {
16172 delete[] arg18[i];
16173 }
16174 delete[] arg18;
16175 }
16176 }
16177 {
16178 int i;
16179 if ( arg20 != NULL )
16180 {
16181 for ( i = 0; i < Alen; i++ )
16182 {
16183 delete[] arg20[i];
16184 }
16185 delete[] arg20;
16186 }
16187 }
16188 {
16189
16190 }
16191 {
16192 delete [] arg22;
16193 }
16194 {
16195 delete [] arg23;
16196 }
16197 {
16198
16199 }
16200 return octave_value_list();
16201 }
16202 catch(...) {
16203 {
16204 delete [] arg17;
16205 }
16206 {
16207 int i;
16208 if ( arg18 != NULL )
16209 {
16210 for ( i = 0; i < Alen; i++ )
16211 {
16212 delete[] arg18[i];
16213 }
16214 delete[] arg18;
16215 }
16216 }
16217 {
16218 int i;
16219 if ( arg20 != NULL )
16220 {
16221 for ( i = 0; i < Alen; i++ )
16222 {
16223 delete[] arg20[i];
16224 }
16225 delete[] arg20;
16226 }
16227 }
16228 {
16229
16230 }
16231 {
16232 delete [] arg22;
16233 }
16234 {
16235 delete [] arg23;
16236 }
16237 {
16238
16239 }
16240 throw;
16241 }
16242}
16243
16244
16245SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16246 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16247 int arg2 ;
16248 void *argp1 = 0 ;
16249 int res1 = 0 ;
16250 int val2 ;
16251 int ecode2 = 0 ;
16252 octave_value_list _out;
16253 octave_value_list *_outp=&_out;
16254 octave_value _outv;
16255
16256 try {
16257 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16258 SWIG_fail;
16259 }
16260 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16261 if (!SWIG_IsOK(res1)) {
16262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16263 }
16264 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16265 ecode2 = SWIG_AsVal_int(args(1), &val2);
16266 if (!SWIG_IsOK(ecode2)) {
16267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16268 }
16269 arg2 = static_cast< int >(val2);
16270 if (arg1) (arg1)->type = arg2;
16271 _outv = octave_value();
16272 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16273 return _out;
16274 fail:
16275 return octave_value_list();
16276 }
16277 catch(...) {
16278 throw;
16279 }
16280}
16281
16282
16283SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16284 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 octave_value_list _out;
16288 octave_value_list *_outp=&_out;
16289 octave_value _outv;
16290 int result;
16291
16292 try {
16293 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16294 SWIG_fail;
16295 }
16296 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16299 }
16300 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16301 result = (int) ((arg1)->type);
16302 _outv = SWIG_From_int(static_cast< int >(result));
16303 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16304 return _out;
16305 fail:
16306 return octave_value_list();
16307 }
16308 catch(...) {
16309 throw;
16310 }
16311}
16312
16313
16314SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16315 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16316 unsigned int arg2 ;
16317 void *argp1 = 0 ;
16318 int res1 = 0 ;
16319 unsigned int val2 ;
16320 int ecode2 = 0 ;
16321 octave_value_list _out;
16322 octave_value_list *_outp=&_out;
16323 octave_value _outv;
16324
16325 try {
16326 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16327 SWIG_fail;
16328 }
16329 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16332 }
16333 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16334 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16335 if (!SWIG_IsOK(ecode2)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16337 }
16338 arg2 = static_cast< unsigned int >(val2);
16339 if (arg1) (arg1)->state = arg2;
16340 _outv = octave_value();
16341 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16342 return _out;
16343 fail:
16344 return octave_value_list();
16345 }
16346 catch(...) {
16347 throw;
16348 }
16349}
16350
16351
16352SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16353 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16354 void *argp1 = 0 ;
16355 int res1 = 0 ;
16356 octave_value_list _out;
16357 octave_value_list *_outp=&_out;
16358 octave_value _outv;
16359 unsigned int result;
16360
16361 try {
16362 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16363 SWIG_fail;
16364 }
16365 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16366 if (!SWIG_IsOK(res1)) {
16367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16368 }
16369 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16370 result = (unsigned int) ((arg1)->state);
16371 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16373 return _out;
16374 fail:
16375 return octave_value_list();
16376 }
16377 catch(...) {
16378 throw;
16379 }
16380}
16381
16382
16383SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16384 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16385 unsigned int arg2 ;
16386 void *argp1 = 0 ;
16387 int res1 = 0 ;
16388 unsigned int val2 ;
16389 int ecode2 = 0 ;
16390 octave_value_list _out;
16391 octave_value_list *_outp=&_out;
16392 octave_value _outv;
16393
16394 try {
16395 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16396 SWIG_fail;
16397 }
16398 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16399 if (!SWIG_IsOK(res1)) {
16400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16401 }
16402 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16403 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16404 if (!SWIG_IsOK(ecode2)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16406 }
16407 arg2 = static_cast< unsigned int >(val2);
16408 if (arg1) (arg1)->keysym = arg2;
16409 _outv = octave_value();
16410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16411 return _out;
16412 fail:
16413 return octave_value_list();
16414 }
16415 catch(...) {
16416 throw;
16417 }
16418}
16419
16420
16421SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16422 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16423 void *argp1 = 0 ;
16424 int res1 = 0 ;
16425 octave_value_list _out;
16426 octave_value_list *_outp=&_out;
16427 octave_value _outv;
16428 unsigned int result;
16429
16430 try {
16431 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16432 SWIG_fail;
16433 }
16434 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16435 if (!SWIG_IsOK(res1)) {
16436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16437 }
16438 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16439 result = (unsigned int) ((arg1)->keysym);
16440 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16441 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16442 return _out;
16443 fail:
16444 return octave_value_list();
16445 }
16446 catch(...) {
16447 throw;
16448 }
16449}
16450
16451
16452SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16453 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16454 unsigned int arg2 ;
16455 void *argp1 = 0 ;
16456 int res1 = 0 ;
16457 unsigned int val2 ;
16458 int ecode2 = 0 ;
16459 octave_value_list _out;
16460 octave_value_list *_outp=&_out;
16461 octave_value _outv;
16462
16463 try {
16464 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16465 SWIG_fail;
16466 }
16467 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16468 if (!SWIG_IsOK(res1)) {
16469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16470 }
16471 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16472 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16473 if (!SWIG_IsOK(ecode2)) {
16474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16475 }
16476 arg2 = static_cast< unsigned int >(val2);
16477 if (arg1) (arg1)->button = arg2;
16478 _outv = octave_value();
16479 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16480 return _out;
16481 fail:
16482 return octave_value_list();
16483 }
16484 catch(...) {
16485 throw;
16486 }
16487}
16488
16489
16490SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16491 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16492 void *argp1 = 0 ;
16493 int res1 = 0 ;
16494 octave_value_list _out;
16495 octave_value_list *_outp=&_out;
16496 octave_value _outv;
16497 unsigned int result;
16498
16499 try {
16500 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16501 SWIG_fail;
16502 }
16503 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16504 if (!SWIG_IsOK(res1)) {
16505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16506 }
16507 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16508 result = (unsigned int) ((arg1)->button);
16509 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16510 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16511 return _out;
16512 fail:
16513 return octave_value_list();
16514 }
16515 catch(...) {
16516 throw;
16517 }
16518}
16519
16520
16521SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16522 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16523 PLINT arg2 ;
16524 void *argp1 = 0 ;
16525 int res1 = 0 ;
16526 int val2 ;
16527 int ecode2 = 0 ;
16528 octave_value_list _out;
16529 octave_value_list *_outp=&_out;
16530 octave_value _outv;
16531
16532 try {
16533 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16534 SWIG_fail;
16535 }
16536 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16539 }
16540 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16541 ecode2 = SWIG_AsVal_int(args(1), &val2);
16542 if (!SWIG_IsOK(ecode2)) {
16543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16544 }
16545 arg2 = static_cast< PLINT >(val2);
16546 if (arg1) (arg1)->subwindow = arg2;
16547 _outv = octave_value();
16548 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16549 return _out;
16550 fail:
16551 return octave_value_list();
16552 }
16553 catch(...) {
16554 throw;
16555 }
16556}
16557
16558
16559SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16560 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16561 void *argp1 = 0 ;
16562 int res1 = 0 ;
16563 octave_value_list _out;
16564 octave_value_list *_outp=&_out;
16565 octave_value _outv;
16566 PLINT result;
16567
16568 try {
16569 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16570 SWIG_fail;
16571 }
16572 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16573 if (!SWIG_IsOK(res1)) {
16574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16575 }
16576 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16577 result = (PLINT) ((arg1)->subwindow);
16578 _outv = SWIG_From_int(static_cast< int >(result));
16579 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16580 return _out;
16581 fail:
16582 return octave_value_list();
16583 }
16584 catch(...) {
16585 throw;
16586 }
16587}
16588
16589
16590SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16591 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16592 char *arg2 = (char *) (char *)0 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 char temp2[16] ;
16596 int res2 ;
16597 octave_value_list _out;
16598 octave_value_list *_outp=&_out;
16599 octave_value _outv;
16600
16601 try {
16602 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16603 SWIG_fail;
16604 }
16605 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16606 if (!SWIG_IsOK(res1)) {
16607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16608 }
16609 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16610 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16611 if (!SWIG_IsOK(res2)) {
16612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16613 }
16614 arg2 = reinterpret_cast< char * >(temp2);
16615 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16616 else memset(arg1->string,0,16*sizeof(char));
16617 _outv = octave_value();
16618 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16619 return _out;
16620 fail:
16621 return octave_value_list();
16622 }
16623 catch(...) {
16624 throw;
16625 }
16626}
16627
16628
16629SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16630 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16631 void *argp1 = 0 ;
16632 int res1 = 0 ;
16633 octave_value_list _out;
16634 octave_value_list *_outp=&_out;
16635 octave_value _outv;
16636 char *result = 0 ;
16637
16638 try {
16639 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16640 SWIG_fail;
16641 }
16642 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16643 if (!SWIG_IsOK(res1)) {
16644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16645 }
16646 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16647 result = (char *)(char *) ((arg1)->string);
16648 {
16649 size_t size = SWIG_strnlen(result, 16);
16650
16651
16652
16653 _outv = SWIG_FromCharPtrAndSize(result, size);
16654 }
16655 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16656 return _out;
16657 fail:
16658 return octave_value_list();
16659 }
16660 catch(...) {
16661 throw;
16662 }
16663}
16664
16665
16666SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16667 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16668 int arg2 ;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 int val2 ;
16672 int ecode2 = 0 ;
16673 octave_value_list _out;
16674 octave_value_list *_outp=&_out;
16675 octave_value _outv;
16676
16677 try {
16678 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16679 SWIG_fail;
16680 }
16681 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16684 }
16685 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16686 ecode2 = SWIG_AsVal_int(args(1), &val2);
16687 if (!SWIG_IsOK(ecode2)) {
16688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16689 }
16690 arg2 = static_cast< int >(val2);
16691 if (arg1) (arg1)->pX = arg2;
16692 _outv = octave_value();
16693 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16694 return _out;
16695 fail:
16696 return octave_value_list();
16697 }
16698 catch(...) {
16699 throw;
16700 }
16701}
16702
16703
16704SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16705 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 octave_value_list _out;
16709 octave_value_list *_outp=&_out;
16710 octave_value _outv;
16711 int result;
16712
16713 try {
16714 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16715 SWIG_fail;
16716 }
16717 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16718 if (!SWIG_IsOK(res1)) {
16719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16720 }
16721 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16722 result = (int) ((arg1)->pX);
16723 _outv = SWIG_From_int(static_cast< int >(result));
16724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16725 return _out;
16726 fail:
16727 return octave_value_list();
16728 }
16729 catch(...) {
16730 throw;
16731 }
16732}
16733
16734
16735SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16736 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16737 int arg2 ;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 int val2 ;
16741 int ecode2 = 0 ;
16742 octave_value_list _out;
16743 octave_value_list *_outp=&_out;
16744 octave_value _outv;
16745
16746 try {
16747 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16748 SWIG_fail;
16749 }
16750 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16751 if (!SWIG_IsOK(res1)) {
16752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16753 }
16754 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16755 ecode2 = SWIG_AsVal_int(args(1), &val2);
16756 if (!SWIG_IsOK(ecode2)) {
16757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16758 }
16759 arg2 = static_cast< int >(val2);
16760 if (arg1) (arg1)->pY = arg2;
16761 _outv = octave_value();
16762 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16763 return _out;
16764 fail:
16765 return octave_value_list();
16766 }
16767 catch(...) {
16768 throw;
16769 }
16770}
16771
16772
16773SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16774 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16775 void *argp1 = 0 ;
16776 int res1 = 0 ;
16777 octave_value_list _out;
16778 octave_value_list *_outp=&_out;
16779 octave_value _outv;
16780 int result;
16781
16782 try {
16783 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16784 SWIG_fail;
16785 }
16786 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16787 if (!SWIG_IsOK(res1)) {
16788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16789 }
16790 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16791 result = (int) ((arg1)->pY);
16792 _outv = SWIG_From_int(static_cast< int >(result));
16793 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16794 return _out;
16795 fail:
16796 return octave_value_list();
16797 }
16798 catch(...) {
16799 throw;
16800 }
16801}
16802
16803
16804SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16805 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16806 PLFLT arg2 ;
16807 void *argp1 = 0 ;
16808 int res1 = 0 ;
16809 double val2 ;
16810 int ecode2 = 0 ;
16811 octave_value_list _out;
16812 octave_value_list *_outp=&_out;
16813 octave_value _outv;
16814
16815 try {
16816 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16817 SWIG_fail;
16818 }
16819 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16822 }
16823 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16824 ecode2 = SWIG_AsVal_double(args(1), &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16827 }
16828 arg2 = static_cast< PLFLT >(val2);
16829 if (arg1) (arg1)->dX = arg2;
16830 _outv = octave_value();
16831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16832 return _out;
16833 fail:
16834 return octave_value_list();
16835 }
16836 catch(...) {
16837 throw;
16838 }
16839}
16840
16841
16842SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16843 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 octave_value_list _out;
16847 octave_value_list *_outp=&_out;
16848 octave_value _outv;
16849 PLFLT result;
16850
16851 try {
16852 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16853 SWIG_fail;
16854 }
16855 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16856 if (!SWIG_IsOK(res1)) {
16857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16858 }
16859 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16860 result = (PLFLT) ((arg1)->dX);
16861 _outv = SWIG_From_double(static_cast< double >(result));
16862 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16863 return _out;
16864 fail:
16865 return octave_value_list();
16866 }
16867 catch(...) {
16868 throw;
16869 }
16870}
16871
16872
16873SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16874 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16875 PLFLT arg2 ;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 double val2 ;
16879 int ecode2 = 0 ;
16880 octave_value_list _out;
16881 octave_value_list *_outp=&_out;
16882 octave_value _outv;
16883
16884 try {
16885 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16886 SWIG_fail;
16887 }
16888 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16889 if (!SWIG_IsOK(res1)) {
16890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16891 }
16892 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16893 ecode2 = SWIG_AsVal_double(args(1), &val2);
16894 if (!SWIG_IsOK(ecode2)) {
16895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16896 }
16897 arg2 = static_cast< PLFLT >(val2);
16898 if (arg1) (arg1)->dY = arg2;
16899 _outv = octave_value();
16900 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16901 return _out;
16902 fail:
16903 return octave_value_list();
16904 }
16905 catch(...) {
16906 throw;
16907 }
16908}
16909
16910
16911SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16912 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 octave_value_list _out;
16916 octave_value_list *_outp=&_out;
16917 octave_value _outv;
16918 PLFLT result;
16919
16920 try {
16921 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16922 SWIG_fail;
16923 }
16924 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16925 if (!SWIG_IsOK(res1)) {
16926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16927 }
16928 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16929 result = (PLFLT) ((arg1)->dY);
16930 _outv = SWIG_From_double(static_cast< double >(result));
16931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16932 return _out;
16933 fail:
16934 return octave_value_list();
16935 }
16936 catch(...) {
16937 throw;
16938 }
16939}
16940
16941
16942SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16943 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16944 PLFLT arg2 ;
16945 void *argp1 = 0 ;
16946 int res1 = 0 ;
16947 double val2 ;
16948 int ecode2 = 0 ;
16949 octave_value_list _out;
16950 octave_value_list *_outp=&_out;
16951 octave_value _outv;
16952
16953 try {
16954 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16955 SWIG_fail;
16956 }
16957 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16960 }
16961 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16962 ecode2 = SWIG_AsVal_double(args(1), &val2);
16963 if (!SWIG_IsOK(ecode2)) {
16964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16965 }
16966 arg2 = static_cast< PLFLT >(val2);
16967 if (arg1) (arg1)->wX = arg2;
16968 _outv = octave_value();
16969 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16970 return _out;
16971 fail:
16972 return octave_value_list();
16973 }
16974 catch(...) {
16975 throw;
16976 }
16977}
16978
16979
16980SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16981 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16982 void *argp1 = 0 ;
16983 int res1 = 0 ;
16984 octave_value_list _out;
16985 octave_value_list *_outp=&_out;
16986 octave_value _outv;
16987 PLFLT result;
16988
16989 try {
16990 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16991 SWIG_fail;
16992 }
16993 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16994 if (!SWIG_IsOK(res1)) {
16995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16996 }
16997 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16998 result = (PLFLT) ((arg1)->wX);
16999 _outv = SWIG_From_double(static_cast< double >(result));
17000 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17001 return _out;
17002 fail:
17003 return octave_value_list();
17004 }
17005 catch(...) {
17006 throw;
17007 }
17008}
17009
17010
17011SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
17012 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17013 PLFLT arg2 ;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 double val2 ;
17017 int ecode2 = 0 ;
17018 octave_value_list _out;
17019 octave_value_list *_outp=&_out;
17020 octave_value _outv;
17021
17022 try {
17023 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
17024 SWIG_fail;
17025 }
17026 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17029 }
17030 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17031 ecode2 = SWIG_AsVal_double(args(1), &val2);
17032 if (!SWIG_IsOK(ecode2)) {
17033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
17034 }
17035 arg2 = static_cast< PLFLT >(val2);
17036 if (arg1) (arg1)->wY = arg2;
17037 _outv = octave_value();
17038 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17039 return _out;
17040 fail:
17041 return octave_value_list();
17042 }
17043 catch(...) {
17044 throw;
17045 }
17046}
17047
17048
17049SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
17050 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17051 void *argp1 = 0 ;
17052 int res1 = 0 ;
17053 octave_value_list _out;
17054 octave_value_list *_outp=&_out;
17055 octave_value _outv;
17056 PLFLT result;
17057
17058 try {
17059 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
17060 SWIG_fail;
17061 }
17062 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17063 if (!SWIG_IsOK(res1)) {
17064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17065 }
17066 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17067 result = (PLFLT) ((arg1)->wY);
17068 _outv = SWIG_From_double(static_cast< double >(result));
17069 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17070 return _out;
17071 fail:
17072 return octave_value_list();
17073 }
17074 catch(...) {
17075 throw;
17076 }
17077}
17078
17079
17080SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
17081 octave_value_list _out;
17082 octave_value_list *_outp=&_out;
17083 octave_value _outv;
17084 PLGraphicsIn *result = 0 ;
17085
17086 try {
17087 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17088 SWIG_fail;
17089 }
17090 result = (PLGraphicsIn *)new PLGraphicsIn();
17092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17093 return _out;
17094 fail:
17095 return octave_value_list();
17096 }
17097 catch(...) {
17098 throw;
17099 }
17100}
17101
17102
17103SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17104 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17105 void *argp1 = 0 ;
17106 int res1 = 0 ;
17107 octave_value_list _out;
17108 octave_value_list *_outp=&_out;
17109 octave_value _outv;
17110
17111 try {
17112 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17113 SWIG_fail;
17114 }
17115 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17116 if (!SWIG_IsOK(res1)) {
17117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17118 }
17119 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17120 delete arg1;
17121 _outv = octave_value();
17122 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17123 return _out;
17124 fail:
17125 return octave_value_list();
17126 }
17127 catch(...) {
17128 throw;
17129 }
17130}
17131
17132
17148static const char *swig_PLGraphicsIn_base_names[] = {0};
17151
17153 PLINT arg1 ;
17154 PLINT arg2 ;
17155 int val1 ;
17156 int ecode1 = 0 ;
17157 int val2 ;
17158 int ecode2 = 0 ;
17159 octave_value_list _out;
17160 octave_value_list *_outp=&_out;
17161 octave_value _outv;
17162
17163 try {
17164 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17165 SWIG_fail;
17166 }
17167 ecode1 = SWIG_AsVal_int(args(0), &val1);
17168 if (!SWIG_IsOK(ecode1)) {
17169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17170 }
17171 arg1 = static_cast< PLINT >(val1);
17172 ecode2 = SWIG_AsVal_int(args(1), &val2);
17173 if (!SWIG_IsOK(ecode2)) {
17174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17175 }
17176 arg2 = static_cast< PLINT >(val2);
17177 pl_setcontlabelformat(arg1,arg2);
17178 _outv = octave_value();
17179 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17180 return _out;
17181 fail:
17182 return octave_value_list();
17183 }
17184 catch(...) {
17185 throw;
17186 }
17187}
17188
17189
17191 PLFLT arg1 ;
17192 PLFLT arg2 ;
17193 PLFLT arg3 ;
17194 PLINT arg4 ;
17195 double val1 ;
17196 int ecode1 = 0 ;
17197 double val2 ;
17198 int ecode2 = 0 ;
17199 double val3 ;
17200 int ecode3 = 0 ;
17201 int val4 ;
17202 int ecode4 = 0 ;
17203 octave_value_list _out;
17204 octave_value_list *_outp=&_out;
17205 octave_value _outv;
17206
17207 try {
17208 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17209 SWIG_fail;
17210 }
17211 ecode1 = SWIG_AsVal_double(args(0), &val1);
17212 if (!SWIG_IsOK(ecode1)) {
17213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17214 }
17215 arg1 = static_cast< PLFLT >(val1);
17216 ecode2 = SWIG_AsVal_double(args(1), &val2);
17217 if (!SWIG_IsOK(ecode2)) {
17218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17219 }
17220 arg2 = static_cast< PLFLT >(val2);
17221 ecode3 = SWIG_AsVal_double(args(2), &val3);
17222 if (!SWIG_IsOK(ecode3)) {
17223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17224 }
17225 arg3 = static_cast< PLFLT >(val3);
17226 ecode4 = SWIG_AsVal_int(args(3), &val4);
17227 if (!SWIG_IsOK(ecode4)) {
17228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17229 }
17230 arg4 = static_cast< PLINT >(val4);
17231 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17232 _outv = octave_value();
17233 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17234 return _out;
17235 fail:
17236 return octave_value_list();
17237 }
17238 catch(...) {
17239 throw;
17240 }
17241}
17242
17243
17245 PLINT arg1 ;
17246 int val1 ;
17247 int ecode1 = 0 ;
17248 octave_value_list _out;
17249 octave_value_list *_outp=&_out;
17250 octave_value _outv;
17251
17252 try {
17253 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17254 SWIG_fail;
17255 }
17256 ecode1 = SWIG_AsVal_int(args(0), &val1);
17257 if (!SWIG_IsOK(ecode1)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17259 }
17260 arg1 = static_cast< PLINT >(val1);
17261 pladv(arg1);
17262 _outv = octave_value();
17263 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17264 return _out;
17265 fail:
17266 return octave_value_list();
17267 }
17268 catch(...) {
17269 throw;
17270 }
17271}
17272
17273
17275 PLFLT arg1 ;
17276 PLFLT arg2 ;
17277 PLFLT arg3 ;
17278 PLFLT arg4 ;
17279 PLFLT arg5 ;
17280 PLFLT arg6 ;
17281 PLFLT arg7 ;
17282 PLBOOL arg8 ;
17283 double val1 ;
17284 int ecode1 = 0 ;
17285 double val2 ;
17286 int ecode2 = 0 ;
17287 double val3 ;
17288 int ecode3 = 0 ;
17289 double val4 ;
17290 int ecode4 = 0 ;
17291 double val5 ;
17292 int ecode5 = 0 ;
17293 double val6 ;
17294 int ecode6 = 0 ;
17295 double val7 ;
17296 int ecode7 = 0 ;
17297 int val8 ;
17298 int ecode8 = 0 ;
17299 octave_value_list _out;
17300 octave_value_list *_outp=&_out;
17301 octave_value _outv;
17302
17303 try {
17304 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17305 SWIG_fail;
17306 }
17307 ecode1 = SWIG_AsVal_double(args(0), &val1);
17308 if (!SWIG_IsOK(ecode1)) {
17309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17310 }
17311 arg1 = static_cast< PLFLT >(val1);
17312 ecode2 = SWIG_AsVal_double(args(1), &val2);
17313 if (!SWIG_IsOK(ecode2)) {
17314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17315 }
17316 arg2 = static_cast< PLFLT >(val2);
17317 ecode3 = SWIG_AsVal_double(args(2), &val3);
17318 if (!SWIG_IsOK(ecode3)) {
17319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17320 }
17321 arg3 = static_cast< PLFLT >(val3);
17322 ecode4 = SWIG_AsVal_double(args(3), &val4);
17323 if (!SWIG_IsOK(ecode4)) {
17324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17325 }
17326 arg4 = static_cast< PLFLT >(val4);
17327 ecode5 = SWIG_AsVal_double(args(4), &val5);
17328 if (!SWIG_IsOK(ecode5)) {
17329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17330 }
17331 arg5 = static_cast< PLFLT >(val5);
17332 ecode6 = SWIG_AsVal_double(args(5), &val6);
17333 if (!SWIG_IsOK(ecode6)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17335 }
17336 arg6 = static_cast< PLFLT >(val6);
17337 ecode7 = SWIG_AsVal_double(args(6), &val7);
17338 if (!SWIG_IsOK(ecode7)) {
17339 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17340 }
17341 arg7 = static_cast< PLFLT >(val7);
17342 ecode8 = SWIG_AsVal_int(args(7), &val8);
17343 if (!SWIG_IsOK(ecode8)) {
17344 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17345 }
17346 arg8 = static_cast< PLBOOL >(val8);
17347 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17348 _outv = octave_value();
17349 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17350 return _out;
17351 fail:
17352 return octave_value_list();
17353 }
17354 catch(...) {
17355 throw;
17356 }
17357}
17358
17359
17361 PLFLT arg1 ;
17362 PLFLT arg2 ;
17363 char *arg3 = (char *) 0 ;
17364 PLFLT arg4 ;
17365 PLINT arg5 ;
17366 char *arg6 = (char *) 0 ;
17367 PLFLT arg7 ;
17368 PLINT arg8 ;
17369 double val1 ;
17370 int ecode1 = 0 ;
17371 double val2 ;
17372 int ecode2 = 0 ;
17373 int res3 ;
17374 char *buf3 = 0 ;
17375 int alloc3 = 0 ;
17376 double val4 ;
17377 int ecode4 = 0 ;
17378 int val5 ;
17379 int ecode5 = 0 ;
17380 int res6 ;
17381 char *buf6 = 0 ;
17382 int alloc6 = 0 ;
17383 double val7 ;
17384 int ecode7 = 0 ;
17385 int val8 ;
17386 int ecode8 = 0 ;
17387 octave_value_list _out;
17388 octave_value_list *_outp=&_out;
17389 octave_value _outv;
17390
17391 try {
17392 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17393 SWIG_fail;
17394 }
17395 ecode1 = SWIG_AsVal_double(args(0), &val1);
17396 if (!SWIG_IsOK(ecode1)) {
17397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17398 }
17399 arg1 = static_cast< PLFLT >(val1);
17400 ecode2 = SWIG_AsVal_double(args(1), &val2);
17401 if (!SWIG_IsOK(ecode2)) {
17402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17403 }
17404 arg2 = static_cast< PLFLT >(val2);
17405 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17406 if (!SWIG_IsOK(res3)) {
17407 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17408 }
17409 arg3 = reinterpret_cast< char * >(buf3);
17410 ecode4 = SWIG_AsVal_double(args(3), &val4);
17411 if (!SWIG_IsOK(ecode4)) {
17412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17413 }
17414 arg4 = static_cast< PLFLT >(val4);
17415 ecode5 = SWIG_AsVal_int(args(4), &val5);
17416 if (!SWIG_IsOK(ecode5)) {
17417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17418 }
17419 arg5 = static_cast< PLINT >(val5);
17420 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17421 if (!SWIG_IsOK(res6)) {
17422 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17423 }
17424 arg6 = reinterpret_cast< char * >(buf6);
17425 ecode7 = SWIG_AsVal_double(args(6), &val7);
17426 if (!SWIG_IsOK(ecode7)) {
17427 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17428 }
17429 arg7 = static_cast< PLFLT >(val7);
17430 ecode8 = SWIG_AsVal_int(args(7), &val8);
17431 if (!SWIG_IsOK(ecode8)) {
17432 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17433 }
17434 arg8 = static_cast< PLINT >(val8);
17435 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17436 _outv = octave_value();
17437 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17438 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17439 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17440 return _out;
17441 fail:
17442 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17443 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17444 return octave_value_list();
17445 }
17446 catch(...) {
17447 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17448 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17449 throw;
17450 }
17451}
17452
17453
17455 PLINT arg1 ;
17456 PLFLT *arg2 = (PLFLT *) 0 ;
17457 PLFLT *arg3 = (PLFLT *) 0 ;
17458 PLINT arg4 ;
17459 Matrix temp1 ;
17460 Matrix temp3 ;
17461 int val4 ;
17462 int ecode4 = 0 ;
17463 octave_value_list _out;
17464 octave_value_list *_outp=&_out;
17465 octave_value _outv;
17466
17467 try {
17468 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17469 SWIG_fail;
17470 }
17471 {
17472 if ( _n_dims( args(0) ) > 1 )
17473 {
17474 error( "argument must be a scalar or vector" ); SWIG_fail;
17475 }
17476 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17477 temp1 = args(0).matrix_value();
17478 arg2 = &temp1( 0, 0 );
17479 }
17480 {
17481 if ( _n_dims( args(1) ) > 1 )
17482 {
17483 error( "argument must be a scalar or vector" ); SWIG_fail;
17484 }
17485 if ( _dim( args(1), 0 ) != Alen )
17486 {
17487 error( "argument vectors must be same length" ); SWIG_fail;
17488 }
17489 temp3 = args(1).matrix_value();
17490 arg3 = &temp3( 0, 0 );
17491 }
17492 ecode4 = SWIG_AsVal_int(args(2), &val4);
17493 if (!SWIG_IsOK(ecode4)) {
17494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17495 }
17496 arg4 = static_cast< PLINT >(val4);
17497 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17498 _outv = octave_value();
17499 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17500 {
17501
17502 }
17503 {
17504
17505 }
17506 return _out;
17507 fail:
17508 {
17509
17510 }
17511 {
17512
17513 }
17514 return octave_value_list();
17515 }
17516 catch(...) {
17517 {
17518
17519 }
17520 {
17521
17522 }
17523 throw;
17524 }
17525}
17526
17527
17529 PLINT *arg1 = (PLINT *) 0 ;
17530 PLINT *arg2 = (PLINT *) 0 ;
17531 PLINT *arg3 = (PLINT *) 0 ;
17532 PLINT *arg4 = (PLINT *) 0 ;
17533 PLINT *arg5 = (PLINT *) 0 ;
17534 PLFLT *arg6 = (PLFLT *) 0 ;
17535 PLFLT arg7 ;
17536 PLINT temp1 ;
17537 int res1 = SWIG_TMPOBJ ;
17538 PLINT temp2 ;
17539 int res2 = SWIG_TMPOBJ ;
17540 PLINT temp3 ;
17541 int res3 = SWIG_TMPOBJ ;
17542 PLINT temp4 ;
17543 int res4 = SWIG_TMPOBJ ;
17544 PLINT temp5 ;
17545 int res5 = SWIG_TMPOBJ ;
17546 PLFLT temp6 ;
17547 int res6 = SWIG_TMPOBJ ;
17548 double val7 ;
17549 int ecode7 = 0 ;
17550 octave_value_list _out;
17551 octave_value_list *_outp=&_out;
17552 octave_value _outv;
17553
17554 try {
17555 arg1 = &temp1;
17556 arg2 = &temp2;
17557 arg3 = &temp3;
17558 arg4 = &temp4;
17559 arg5 = &temp5;
17560 arg6 = &temp6;
17561 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17562 SWIG_fail;
17563 }
17564 ecode7 = SWIG_AsVal_double(args(0), &val7);
17565 if (!SWIG_IsOK(ecode7)) {
17566 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17567 }
17568 arg7 = static_cast< PLFLT >(val7);
17569 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17570 _outv = octave_value();
17571 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17572 if (SWIG_IsTmpObj(res1)) {
17573 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17574 } else {
17575 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17576 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17577 }
17578 if (SWIG_IsTmpObj(res2)) {
17579 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17580 } else {
17581 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17582 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17583 }
17584 if (SWIG_IsTmpObj(res3)) {
17585 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17586 } else {
17587 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17588 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17589 }
17590 if (SWIG_IsTmpObj(res4)) {
17591 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17592 } else {
17593 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17594 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17595 }
17596 if (SWIG_IsTmpObj(res5)) {
17597 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17598 } else {
17599 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17600 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17601 }
17602 if (SWIG_IsTmpObj(res6)) {
17603 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17604 } else {
17605 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17606 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17607 }
17608 return _out;
17609 fail:
17610 return octave_value_list();
17611 }
17612 catch(...) {
17613 throw;
17614 }
17615}
17616
17617
17619 octave_value_list _out;
17620 octave_value_list *_outp=&_out;
17621 octave_value _outv;
17622
17623 try {
17624 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17625 SWIG_fail;
17626 }
17627 plbop();
17628 _outv = octave_value();
17629 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17630 return _out;
17631 fail:
17632 return octave_value_list();
17633 }
17634 catch(...) {
17635 throw;
17636 }
17637}
17638
17639
17641 char *arg1 = (char *) 0 ;
17642 PLFLT arg2 ;
17643 PLINT arg3 ;
17644 char *arg4 = (char *) 0 ;
17645 PLFLT arg5 ;
17646 PLINT arg6 ;
17647 int res1 ;
17648 char *buf1 = 0 ;
17649 int alloc1 = 0 ;
17650 double val2 ;
17651 int ecode2 = 0 ;
17652 int val3 ;
17653 int ecode3 = 0 ;
17654 int res4 ;
17655 char *buf4 = 0 ;
17656 int alloc4 = 0 ;
17657 double val5 ;
17658 int ecode5 = 0 ;
17659 int val6 ;
17660 int ecode6 = 0 ;
17661 octave_value_list _out;
17662 octave_value_list *_outp=&_out;
17663 octave_value _outv;
17664
17665 try {
17666 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17667 SWIG_fail;
17668 }
17669 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17672 }
17673 arg1 = reinterpret_cast< char * >(buf1);
17674 ecode2 = SWIG_AsVal_double(args(1), &val2);
17675 if (!SWIG_IsOK(ecode2)) {
17676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17677 }
17678 arg2 = static_cast< PLFLT >(val2);
17679 ecode3 = SWIG_AsVal_int(args(2), &val3);
17680 if (!SWIG_IsOK(ecode3)) {
17681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17682 }
17683 arg3 = static_cast< PLINT >(val3);
17684 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17685 if (!SWIG_IsOK(res4)) {
17686 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17687 }
17688 arg4 = reinterpret_cast< char * >(buf4);
17689 ecode5 = SWIG_AsVal_double(args(4), &val5);
17690 if (!SWIG_IsOK(ecode5)) {
17691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17692 }
17693 arg5 = static_cast< PLFLT >(val5);
17694 ecode6 = SWIG_AsVal_int(args(5), &val6);
17695 if (!SWIG_IsOK(ecode6)) {
17696 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17697 }
17698 arg6 = static_cast< PLINT >(val6);
17699 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17700 _outv = octave_value();
17701 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17702 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17703 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17704 return _out;
17705 fail:
17706 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17707 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17708 return octave_value_list();
17709 }
17710 catch(...) {
17711 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17712 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17713 throw;
17714 }
17715}
17716
17717
17719 char *arg1 = (char *) 0 ;
17720 char *arg2 = (char *) 0 ;
17721 PLFLT arg3 ;
17722 PLINT arg4 ;
17723 char *arg5 = (char *) 0 ;
17724 char *arg6 = (char *) 0 ;
17725 PLFLT arg7 ;
17726 PLINT arg8 ;
17727 char *arg9 = (char *) 0 ;
17728 char *arg10 = (char *) 0 ;
17729 PLFLT arg11 ;
17730 PLINT arg12 ;
17731 int res1 ;
17732 char *buf1 = 0 ;
17733 int alloc1 = 0 ;
17734 int res2 ;
17735 char *buf2 = 0 ;
17736 int alloc2 = 0 ;
17737 double val3 ;
17738 int ecode3 = 0 ;
17739 int val4 ;
17740 int ecode4 = 0 ;
17741 int res5 ;
17742 char *buf5 = 0 ;
17743 int alloc5 = 0 ;
17744 int res6 ;
17745 char *buf6 = 0 ;
17746 int alloc6 = 0 ;
17747 double val7 ;
17748 int ecode7 = 0 ;
17749 int val8 ;
17750 int ecode8 = 0 ;
17751 int res9 ;
17752 char *buf9 = 0 ;
17753 int alloc9 = 0 ;
17754 int res10 ;
17755 char *buf10 = 0 ;
17756 int alloc10 = 0 ;
17757 double val11 ;
17758 int ecode11 = 0 ;
17759 int val12 ;
17760 int ecode12 = 0 ;
17761 octave_value_list _out;
17762 octave_value_list *_outp=&_out;
17763 octave_value _outv;
17764
17765 try {
17766 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17767 SWIG_fail;
17768 }
17769 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17770 if (!SWIG_IsOK(res1)) {
17771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17772 }
17773 arg1 = reinterpret_cast< char * >(buf1);
17774 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17775 if (!SWIG_IsOK(res2)) {
17776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17777 }
17778 arg2 = reinterpret_cast< char * >(buf2);
17779 ecode3 = SWIG_AsVal_double(args(2), &val3);
17780 if (!SWIG_IsOK(ecode3)) {
17781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17782 }
17783 arg3 = static_cast< PLFLT >(val3);
17784 ecode4 = SWIG_AsVal_int(args(3), &val4);
17785 if (!SWIG_IsOK(ecode4)) {
17786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17787 }
17788 arg4 = static_cast< PLINT >(val4);
17789 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17790 if (!SWIG_IsOK(res5)) {
17791 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17792 }
17793 arg5 = reinterpret_cast< char * >(buf5);
17794 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17795 if (!SWIG_IsOK(res6)) {
17796 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17797 }
17798 arg6 = reinterpret_cast< char * >(buf6);
17799 ecode7 = SWIG_AsVal_double(args(6), &val7);
17800 if (!SWIG_IsOK(ecode7)) {
17801 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17802 }
17803 arg7 = static_cast< PLFLT >(val7);
17804 ecode8 = SWIG_AsVal_int(args(7), &val8);
17805 if (!SWIG_IsOK(ecode8)) {
17806 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17807 }
17808 arg8 = static_cast< PLINT >(val8);
17809 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17810 if (!SWIG_IsOK(res9)) {
17811 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17812 }
17813 arg9 = reinterpret_cast< char * >(buf9);
17814 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17815 if (!SWIG_IsOK(res10)) {
17816 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17817 }
17818 arg10 = reinterpret_cast< char * >(buf10);
17819 ecode11 = SWIG_AsVal_double(args(10), &val11);
17820 if (!SWIG_IsOK(ecode11)) {
17821 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17822 }
17823 arg11 = static_cast< PLFLT >(val11);
17824 ecode12 = SWIG_AsVal_int(args(11), &val12);
17825 if (!SWIG_IsOK(ecode12)) {
17826 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17827 }
17828 arg12 = static_cast< PLINT >(val12);
17829 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);
17830 _outv = octave_value();
17831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17832 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17833 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17834 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17835 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17836 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17837 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17838 return _out;
17839 fail:
17840 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17841 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17842 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17843 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17844 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17845 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17846 return octave_value_list();
17847 }
17848 catch(...) {
17849 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17850 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17851 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17852 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17853 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17854 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17855 throw;
17856 }
17857}
17858
17859
17861 PLFLT arg1 ;
17862 PLFLT arg2 ;
17863 PLFLT *arg3 = (PLFLT *) 0 ;
17864 PLFLT *arg4 = (PLFLT *) 0 ;
17865 PLINT *arg5 = (PLINT *) 0 ;
17866 double val1 ;
17867 int ecode1 = 0 ;
17868 double val2 ;
17869 int ecode2 = 0 ;
17870 PLFLT temp3 ;
17871 int res3 = SWIG_TMPOBJ ;
17872 PLFLT temp4 ;
17873 int res4 = SWIG_TMPOBJ ;
17874 PLINT temp5 ;
17875 int res5 = SWIG_TMPOBJ ;
17876 octave_value_list _out;
17877 octave_value_list *_outp=&_out;
17878 octave_value _outv;
17879
17880 try {
17881 arg3 = &temp3;
17882 arg4 = &temp4;
17883 arg5 = &temp5;
17884 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17885 SWIG_fail;
17886 }
17887 ecode1 = SWIG_AsVal_double(args(0), &val1);
17888 if (!SWIG_IsOK(ecode1)) {
17889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17890 }
17891 arg1 = static_cast< PLFLT >(val1);
17892 ecode2 = SWIG_AsVal_double(args(1), &val2);
17893 if (!SWIG_IsOK(ecode2)) {
17894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17895 }
17896 arg2 = static_cast< PLFLT >(val2);
17897 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17898 _outv = octave_value();
17899 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17900 if (SWIG_IsTmpObj(res3)) {
17901 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17902 } else {
17903 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17904 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17905 }
17906 if (SWIG_IsTmpObj(res4)) {
17907 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17908 } else {
17909 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17910 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17911 }
17912 if (SWIG_IsTmpObj(res5)) {
17913 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17914 } else {
17915 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17916 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17917 }
17918 return _out;
17919 fail:
17920 return octave_value_list();
17921 }
17922 catch(...) {
17923 throw;
17924 }
17925}
17926
17927
17929 octave_value_list _out;
17930 octave_value_list *_outp=&_out;
17931 octave_value _outv;
17932
17933 try {
17934 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17935 SWIG_fail;
17936 }
17937 plclear();
17938 _outv = octave_value();
17939 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17940 return _out;
17941 fail:
17942 return octave_value_list();
17943 }
17944 catch(...) {
17945 throw;
17946 }
17947}
17948
17949
17951 PLINT arg1 ;
17952 int val1 ;
17953 int ecode1 = 0 ;
17954 octave_value_list _out;
17955 octave_value_list *_outp=&_out;
17956 octave_value _outv;
17957
17958 try {
17959 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17960 SWIG_fail;
17961 }
17962 ecode1 = SWIG_AsVal_int(args(0), &val1);
17963 if (!SWIG_IsOK(ecode1)) {
17964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17965 }
17966 arg1 = static_cast< PLINT >(val1);
17967 plcol0(arg1);
17968 _outv = octave_value();
17969 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17970 return _out;
17971 fail:
17972 return octave_value_list();
17973 }
17974 catch(...) {
17975 throw;
17976 }
17977}
17978
17979
17981 PLFLT arg1 ;
17982 double val1 ;
17983 int ecode1 = 0 ;
17984 octave_value_list _out;
17985 octave_value_list *_outp=&_out;
17986 octave_value _outv;
17987
17988 try {
17989 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17990 SWIG_fail;
17991 }
17992 ecode1 = SWIG_AsVal_double(args(0), &val1);
17993 if (!SWIG_IsOK(ecode1)) {
17994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17995 }
17996 arg1 = static_cast< PLFLT >(val1);
17997 plcol1(arg1);
17998 _outv = octave_value();
17999 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18000 return _out;
18001 fail:
18002 return octave_value_list();
18003 }
18004 catch(...) {
18005 throw;
18006 }
18007}
18008
18009
18011 PLFLT arg1 ;
18012 PLFLT arg2 ;
18013 PLFLT arg3 ;
18014 PLINT arg4 ;
18015 PLBOOL arg5 ;
18016 PLINT arg6 ;
18017 PLINT arg7 ;
18018 PLINT arg8 ;
18019 PLINT arg9 ;
18020 PLINT arg10 ;
18021 PLFLT arg11 ;
18022 double val1 ;
18023 int ecode1 = 0 ;
18024 double val2 ;
18025 int ecode2 = 0 ;
18026 double val3 ;
18027 int ecode3 = 0 ;
18028 int val4 ;
18029 int ecode4 = 0 ;
18030 int val5 ;
18031 int ecode5 = 0 ;
18032 int val6 ;
18033 int ecode6 = 0 ;
18034 int val7 ;
18035 int ecode7 = 0 ;
18036 int val8 ;
18037 int ecode8 = 0 ;
18038 int val9 ;
18039 int ecode9 = 0 ;
18040 int val10 ;
18041 int ecode10 = 0 ;
18042 double val11 ;
18043 int ecode11 = 0 ;
18044 octave_value_list _out;
18045 octave_value_list *_outp=&_out;
18046 octave_value _outv;
18047
18048 try {
18049 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
18050 SWIG_fail;
18051 }
18052 ecode1 = SWIG_AsVal_double(args(0), &val1);
18053 if (!SWIG_IsOK(ecode1)) {
18054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
18055 }
18056 arg1 = static_cast< PLFLT >(val1);
18057 ecode2 = SWIG_AsVal_double(args(1), &val2);
18058 if (!SWIG_IsOK(ecode2)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
18060 }
18061 arg2 = static_cast< PLFLT >(val2);
18062 ecode3 = SWIG_AsVal_double(args(2), &val3);
18063 if (!SWIG_IsOK(ecode3)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
18065 }
18066 arg3 = static_cast< PLFLT >(val3);
18067 ecode4 = SWIG_AsVal_int(args(3), &val4);
18068 if (!SWIG_IsOK(ecode4)) {
18069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
18070 }
18071 arg4 = static_cast< PLINT >(val4);
18072 ecode5 = SWIG_AsVal_int(args(4), &val5);
18073 if (!SWIG_IsOK(ecode5)) {
18074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
18075 }
18076 arg5 = static_cast< PLBOOL >(val5);
18077 ecode6 = SWIG_AsVal_int(args(5), &val6);
18078 if (!SWIG_IsOK(ecode6)) {
18079 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
18080 }
18081 arg6 = static_cast< PLINT >(val6);
18082 ecode7 = SWIG_AsVal_int(args(6), &val7);
18083 if (!SWIG_IsOK(ecode7)) {
18084 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18085 }
18086 arg7 = static_cast< PLINT >(val7);
18087 ecode8 = SWIG_AsVal_int(args(7), &val8);
18088 if (!SWIG_IsOK(ecode8)) {
18089 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18090 }
18091 arg8 = static_cast< PLINT >(val8);
18092 ecode9 = SWIG_AsVal_int(args(8), &val9);
18093 if (!SWIG_IsOK(ecode9)) {
18094 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18095 }
18096 arg9 = static_cast< PLINT >(val9);
18097 ecode10 = SWIG_AsVal_int(args(9), &val10);
18098 if (!SWIG_IsOK(ecode10)) {
18099 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18100 }
18101 arg10 = static_cast< PLINT >(val10);
18102 ecode11 = SWIG_AsVal_double(args(10), &val11);
18103 if (!SWIG_IsOK(ecode11)) {
18104 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18105 }
18106 arg11 = static_cast< PLFLT >(val11);
18107 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18108 _outv = octave_value();
18109 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18110 return _out;
18111 fail:
18112 return octave_value_list();
18113 }
18114 catch(...) {
18115 throw;
18116 }
18117}
18118
18119
18121 PLINT arg1 ;
18122 PLINT arg2 ;
18123 PLINT arg3 ;
18124 PLINT arg4 ;
18125 PLINT arg5 ;
18126 PLFLT arg6 ;
18127 PLFLT *arg7 = (PLFLT *) 0 ;
18128 int val1 ;
18129 int ecode1 = 0 ;
18130 int val2 ;
18131 int ecode2 = 0 ;
18132 int val3 ;
18133 int ecode3 = 0 ;
18134 int val4 ;
18135 int ecode4 = 0 ;
18136 int val5 ;
18137 int ecode5 = 0 ;
18138 double val6 ;
18139 int ecode6 = 0 ;
18140 PLFLT temp7 ;
18141 int res7 = SWIG_TMPOBJ ;
18142 octave_value_list _out;
18143 octave_value_list *_outp=&_out;
18144 octave_value _outv;
18145
18146 try {
18147 arg7 = &temp7;
18148 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18149 SWIG_fail;
18150 }
18151 ecode1 = SWIG_AsVal_int(args(0), &val1);
18152 if (!SWIG_IsOK(ecode1)) {
18153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18154 }
18155 arg1 = static_cast< PLINT >(val1);
18156 ecode2 = SWIG_AsVal_int(args(1), &val2);
18157 if (!SWIG_IsOK(ecode2)) {
18158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18159 }
18160 arg2 = static_cast< PLINT >(val2);
18161 ecode3 = SWIG_AsVal_int(args(2), &val3);
18162 if (!SWIG_IsOK(ecode3)) {
18163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18164 }
18165 arg3 = static_cast< PLINT >(val3);
18166 ecode4 = SWIG_AsVal_int(args(3), &val4);
18167 if (!SWIG_IsOK(ecode4)) {
18168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18169 }
18170 arg4 = static_cast< PLINT >(val4);
18171 ecode5 = SWIG_AsVal_int(args(4), &val5);
18172 if (!SWIG_IsOK(ecode5)) {
18173 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18174 }
18175 arg5 = static_cast< PLINT >(val5);
18176 ecode6 = SWIG_AsVal_double(args(5), &val6);
18177 if (!SWIG_IsOK(ecode6)) {
18178 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18179 }
18180 arg6 = static_cast< PLFLT >(val6);
18181 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18182 _outv = octave_value();
18183 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18184 if (SWIG_IsTmpObj(res7)) {
18185 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18186 } else {
18187 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18188 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18189 }
18190 return _out;
18191 fail:
18192 return octave_value_list();
18193 }
18194 catch(...) {
18195 throw;
18196 }
18197}
18198
18199
18201 PLINT arg1 ;
18202 PLBOOL arg2 ;
18203 int val1 ;
18204 int ecode1 = 0 ;
18205 int val2 ;
18206 int ecode2 = 0 ;
18207 octave_value_list _out;
18208 octave_value_list *_outp=&_out;
18209 octave_value _outv;
18210
18211 try {
18212 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18213 SWIG_fail;
18214 }
18215 ecode1 = SWIG_AsVal_int(args(0), &val1);
18216 if (!SWIG_IsOK(ecode1)) {
18217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18218 }
18219 arg1 = static_cast< PLINT >(val1);
18220 ecode2 = SWIG_AsVal_int(args(1), &val2);
18221 if (!SWIG_IsOK(ecode2)) {
18222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18223 }
18224 arg2 = static_cast< PLBOOL >(val2);
18225 plcpstrm(arg1,arg2);
18226 _outv = octave_value();
18227 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18228 return _out;
18229 fail:
18230 return octave_value_list();
18231 }
18232 catch(...) {
18233 throw;
18234 }
18235}
18236
18237
18239 octave_value_list _out;
18240 octave_value_list *_outp=&_out;
18241 octave_value _outv;
18242
18243 try {
18244 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18245 SWIG_fail;
18246 }
18247 plend();
18248 _outv = octave_value();
18249 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18250 return _out;
18251 fail:
18252 return octave_value_list();
18253 }
18254 catch(...) {
18255 throw;
18256 }
18257}
18258
18259
18261 octave_value_list _out;
18262 octave_value_list *_outp=&_out;
18263 octave_value _outv;
18264
18265 try {
18266 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18267 SWIG_fail;
18268 }
18269 plend1();
18270 _outv = octave_value();
18271 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18272 return _out;
18273 fail:
18274 return octave_value_list();
18275 }
18276 catch(...) {
18277 throw;
18278 }
18279}
18280
18281
18283 PLFLT arg1 ;
18284 PLFLT arg2 ;
18285 PLFLT arg3 ;
18286 PLFLT arg4 ;
18287 PLINT arg5 ;
18288 PLINT arg6 ;
18289 double val1 ;
18290 int ecode1 = 0 ;
18291 double val2 ;
18292 int ecode2 = 0 ;
18293 double val3 ;
18294 int ecode3 = 0 ;
18295 double val4 ;
18296 int ecode4 = 0 ;
18297 int val5 ;
18298 int ecode5 = 0 ;
18299 int val6 ;
18300 int ecode6 = 0 ;
18301 octave_value_list _out;
18302 octave_value_list *_outp=&_out;
18303 octave_value _outv;
18304
18305 try {
18306 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18307 SWIG_fail;
18308 }
18309 ecode1 = SWIG_AsVal_double(args(0), &val1);
18310 if (!SWIG_IsOK(ecode1)) {
18311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18312 }
18313 arg1 = static_cast< PLFLT >(val1);
18314 ecode2 = SWIG_AsVal_double(args(1), &val2);
18315 if (!SWIG_IsOK(ecode2)) {
18316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18317 }
18318 arg2 = static_cast< PLFLT >(val2);
18319 ecode3 = SWIG_AsVal_double(args(2), &val3);
18320 if (!SWIG_IsOK(ecode3)) {
18321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18322 }
18323 arg3 = static_cast< PLFLT >(val3);
18324 ecode4 = SWIG_AsVal_double(args(3), &val4);
18325 if (!SWIG_IsOK(ecode4)) {
18326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18327 }
18328 arg4 = static_cast< PLFLT >(val4);
18329 ecode5 = SWIG_AsVal_int(args(4), &val5);
18330 if (!SWIG_IsOK(ecode5)) {
18331 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18332 }
18333 arg5 = static_cast< PLINT >(val5);
18334 ecode6 = SWIG_AsVal_int(args(5), &val6);
18335 if (!SWIG_IsOK(ecode6)) {
18336 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18337 }
18338 arg6 = static_cast< PLINT >(val6);
18339 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18340 _outv = octave_value();
18341 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18342 return _out;
18343 fail:
18344 return octave_value_list();
18345 }
18346 catch(...) {
18347 throw;
18348 }
18349}
18350
18351
18353 PLFLT arg1 ;
18354 PLFLT arg2 ;
18355 PLFLT arg3 ;
18356 PLFLT arg4 ;
18357 PLINT arg5 ;
18358 PLINT arg6 ;
18359 double val1 ;
18360 int ecode1 = 0 ;
18361 double val2 ;
18362 int ecode2 = 0 ;
18363 double val3 ;
18364 int ecode3 = 0 ;
18365 double val4 ;
18366 int ecode4 = 0 ;
18367 int val5 ;
18368 int ecode5 = 0 ;
18369 int val6 ;
18370 int ecode6 = 0 ;
18371 octave_value_list _out;
18372 octave_value_list *_outp=&_out;
18373 octave_value _outv;
18374
18375 try {
18376 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18377 SWIG_fail;
18378 }
18379 ecode1 = SWIG_AsVal_double(args(0), &val1);
18380 if (!SWIG_IsOK(ecode1)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18382 }
18383 arg1 = static_cast< PLFLT >(val1);
18384 ecode2 = SWIG_AsVal_double(args(1), &val2);
18385 if (!SWIG_IsOK(ecode2)) {
18386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18387 }
18388 arg2 = static_cast< PLFLT >(val2);
18389 ecode3 = SWIG_AsVal_double(args(2), &val3);
18390 if (!SWIG_IsOK(ecode3)) {
18391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18392 }
18393 arg3 = static_cast< PLFLT >(val3);
18394 ecode4 = SWIG_AsVal_double(args(3), &val4);
18395 if (!SWIG_IsOK(ecode4)) {
18396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18397 }
18398 arg4 = static_cast< PLFLT >(val4);
18399 ecode5 = SWIG_AsVal_int(args(4), &val5);
18400 if (!SWIG_IsOK(ecode5)) {
18401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18402 }
18403 arg5 = static_cast< PLINT >(val5);
18404 ecode6 = SWIG_AsVal_int(args(5), &val6);
18405 if (!SWIG_IsOK(ecode6)) {
18406 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18407 }
18408 arg6 = static_cast< PLINT >(val6);
18409 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18410 _outv = octave_value();
18411 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18412 return _out;
18413 fail:
18414 return octave_value_list();
18415 }
18416 catch(...) {
18417 throw;
18418 }
18419}
18420
18421
18423 octave_value_list _out;
18424 octave_value_list *_outp=&_out;
18425 octave_value _outv;
18426
18427 try {
18428 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18429 SWIG_fail;
18430 }
18431 pleop();
18432 _outv = octave_value();
18433 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18434 return _out;
18435 fail:
18436 return octave_value_list();
18437 }
18438 catch(...) {
18439 throw;
18440 }
18441}
18442
18443
18445 PLINT arg1 ;
18446 PLFLT *arg2 = (PLFLT *) 0 ;
18447 PLFLT *arg3 = (PLFLT *) 0 ;
18448 PLFLT *arg4 = (PLFLT *) 0 ;
18449 Matrix temp1 ;
18450 Matrix temp3 ;
18451 Matrix temp4 ;
18452 octave_value_list _out;
18453 octave_value_list *_outp=&_out;
18454 octave_value _outv;
18455
18456 try {
18457 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18458 SWIG_fail;
18459 }
18460 {
18461 if ( _n_dims( args(0) ) > 1 )
18462 {
18463 error( "argument must be a scalar or vector" ); SWIG_fail;
18464 }
18465 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18466 temp1 = args(0).matrix_value();
18467 arg2 = &temp1( 0, 0 );
18468 }
18469 {
18470 if ( _n_dims( args(1) ) > 1 )
18471 {
18472 error( "argument must be a scalar or vector" ); SWIG_fail;
18473 }
18474 if ( _dim( args(1), 0 ) != Alen )
18475 {
18476 error( "argument vectors must be same length" ); SWIG_fail;
18477 }
18478 temp3 = args(1).matrix_value();
18479 arg3 = &temp3( 0, 0 );
18480 }
18481 {
18482 if ( _n_dims( args(2) ) > 1 )
18483 {
18484 error( "argument must be a scalar or vector" ); SWIG_fail;
18485 }
18486 if ( _dim( args(2), 0 ) != Alen )
18487 {
18488 error( "argument vectors must be same length" ); SWIG_fail;
18489 }
18490 temp4 = args(2).matrix_value();
18491 arg4 = &temp4( 0, 0 );
18492 }
18493 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18494 _outv = octave_value();
18495 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18496 {
18497
18498 }
18499 {
18500
18501 }
18502 {
18503
18504 }
18505 return _out;
18506 fail:
18507 {
18508
18509 }
18510 {
18511
18512 }
18513 {
18514
18515 }
18516 return octave_value_list();
18517 }
18518 catch(...) {
18519 {
18520
18521 }
18522 {
18523
18524 }
18525 {
18526
18527 }
18528 throw;
18529 }
18530}
18531
18532
18534 PLINT arg1 ;
18535 PLFLT *arg2 = (PLFLT *) 0 ;
18536 PLFLT *arg3 = (PLFLT *) 0 ;
18537 PLFLT *arg4 = (PLFLT *) 0 ;
18538 Matrix temp1 ;
18539 Matrix temp3 ;
18540 Matrix temp4 ;
18541 octave_value_list _out;
18542 octave_value_list *_outp=&_out;
18543 octave_value _outv;
18544
18545 try {
18546 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18547 SWIG_fail;
18548 }
18549 {
18550 if ( _n_dims( args(0) ) > 1 )
18551 {
18552 error( "argument must be a scalar or vector" ); SWIG_fail;
18553 }
18554 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18555 temp1 = args(0).matrix_value();
18556 arg2 = &temp1( 0, 0 );
18557 }
18558 {
18559 if ( _n_dims( args(1) ) > 1 )
18560 {
18561 error( "argument must be a scalar or vector" ); SWIG_fail;
18562 }
18563 if ( _dim( args(1), 0 ) != Alen )
18564 {
18565 error( "argument vectors must be same length" ); SWIG_fail;
18566 }
18567 temp3 = args(1).matrix_value();
18568 arg3 = &temp3( 0, 0 );
18569 }
18570 {
18571 if ( _n_dims( args(2) ) > 1 )
18572 {
18573 error( "argument must be a scalar or vector" ); SWIG_fail;
18574 }
18575 if ( _dim( args(2), 0 ) != Alen )
18576 {
18577 error( "argument vectors must be same length" ); SWIG_fail;
18578 }
18579 temp4 = args(2).matrix_value();
18580 arg4 = &temp4( 0, 0 );
18581 }
18582 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18583 _outv = octave_value();
18584 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18585 {
18586
18587 }
18588 {
18589
18590 }
18591 {
18592
18593 }
18594 return _out;
18595 fail:
18596 {
18597
18598 }
18599 {
18600
18601 }
18602 {
18603
18604 }
18605 return octave_value_list();
18606 }
18607 catch(...) {
18608 {
18609
18610 }
18611 {
18612
18613 }
18614 {
18615
18616 }
18617 throw;
18618 }
18619}
18620
18621
18623 octave_value_list _out;
18624 octave_value_list *_outp=&_out;
18625 octave_value _outv;
18626
18627 try {
18628 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18629 SWIG_fail;
18630 }
18631 plfamadv();
18632 _outv = octave_value();
18633 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18634 return _out;
18635 fail:
18636 return octave_value_list();
18637 }
18638 catch(...) {
18639 throw;
18640 }
18641}
18642
18643
18645 PLINT arg1 ;
18646 PLFLT *arg2 = (PLFLT *) 0 ;
18647 PLFLT *arg3 = (PLFLT *) 0 ;
18648 Matrix temp1 ;
18649 Matrix temp3 ;
18650 octave_value_list _out;
18651 octave_value_list *_outp=&_out;
18652 octave_value _outv;
18653
18654 try {
18655 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18656 SWIG_fail;
18657 }
18658 {
18659 if ( _n_dims( args(0) ) > 1 )
18660 {
18661 error( "argument must be a scalar or vector" ); SWIG_fail;
18662 }
18663 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18664 temp1 = args(0).matrix_value();
18665 arg2 = &temp1( 0, 0 );
18666 }
18667 {
18668 if ( _n_dims( args(1) ) > 1 )
18669 {
18670 error( "argument must be a scalar or vector" ); SWIG_fail;
18671 }
18672 if ( _dim( args(1), 0 ) != Alen )
18673 {
18674 error( "argument vectors must be same length" ); SWIG_fail;
18675 }
18676 temp3 = args(1).matrix_value();
18677 arg3 = &temp3( 0, 0 );
18678 }
18679 plfill(arg1,(double const *)arg2,(double const *)arg3);
18680 _outv = octave_value();
18681 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18682 {
18683
18684 }
18685 {
18686
18687 }
18688 return _out;
18689 fail:
18690 {
18691
18692 }
18693 {
18694
18695 }
18696 return octave_value_list();
18697 }
18698 catch(...) {
18699 {
18700
18701 }
18702 {
18703
18704 }
18705 throw;
18706 }
18707}
18708
18709
18711 PLINT arg1 ;
18712 PLFLT *arg2 = (PLFLT *) 0 ;
18713 PLFLT *arg3 = (PLFLT *) 0 ;
18714 PLFLT *arg4 = (PLFLT *) 0 ;
18715 Matrix temp1 ;
18716 Matrix temp3 ;
18717 Matrix temp4 ;
18718 octave_value_list _out;
18719 octave_value_list *_outp=&_out;
18720 octave_value _outv;
18721
18722 try {
18723 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18724 SWIG_fail;
18725 }
18726 {
18727 if ( _n_dims( args(0) ) > 1 )
18728 {
18729 error( "argument must be a scalar or vector" ); SWIG_fail;
18730 }
18731 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18732 temp1 = args(0).matrix_value();
18733 arg2 = &temp1( 0, 0 );
18734 }
18735 {
18736 if ( _n_dims( args(1) ) > 1 )
18737 {
18738 error( "argument must be a scalar or vector" ); SWIG_fail;
18739 }
18740 if ( _dim( args(1), 0 ) != Alen )
18741 {
18742 error( "argument vectors must be same length" ); SWIG_fail;
18743 }
18744 temp3 = args(1).matrix_value();
18745 arg3 = &temp3( 0, 0 );
18746 }
18747 {
18748 if ( _n_dims( args(2) ) > 1 )
18749 {
18750 error( "argument must be a scalar or vector" ); SWIG_fail;
18751 }
18752 if ( _dim( args(2), 0 ) != Alen )
18753 {
18754 error( "argument vectors must be same length" ); SWIG_fail;
18755 }
18756 temp4 = args(2).matrix_value();
18757 arg4 = &temp4( 0, 0 );
18758 }
18759 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18760 _outv = octave_value();
18761 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18762 {
18763
18764 }
18765 {
18766
18767 }
18768 {
18769
18770 }
18771 return _out;
18772 fail:
18773 {
18774
18775 }
18776 {
18777
18778 }
18779 {
18780
18781 }
18782 return octave_value_list();
18783 }
18784 catch(...) {
18785 {
18786
18787 }
18788 {
18789
18790 }
18791 {
18792
18793 }
18794 throw;
18795 }
18796}
18797
18798
18800 PLINT arg1 ;
18801 PLFLT *arg2 = (PLFLT *) 0 ;
18802 PLFLT *arg3 = (PLFLT *) 0 ;
18803 PLFLT arg4 ;
18804 Matrix temp1 ;
18805 Matrix temp3 ;
18806 double val4 ;
18807 int ecode4 = 0 ;
18808 octave_value_list _out;
18809 octave_value_list *_outp=&_out;
18810 octave_value _outv;
18811
18812 try {
18813 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18814 SWIG_fail;
18815 }
18816 {
18817 if ( _n_dims( args(0) ) > 1 )
18818 {
18819 error( "argument must be a scalar or vector" ); SWIG_fail;
18820 }
18821 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18822 temp1 = args(0).matrix_value();
18823 arg2 = &temp1( 0, 0 );
18824 }
18825 {
18826 if ( _n_dims( args(1) ) > 1 )
18827 {
18828 error( "argument must be a scalar or vector" ); SWIG_fail;
18829 }
18830 if ( _dim( args(1), 0 ) != Alen )
18831 {
18832 error( "argument vectors must be same length" ); SWIG_fail;
18833 }
18834 temp3 = args(1).matrix_value();
18835 arg3 = &temp3( 0, 0 );
18836 }
18837 ecode4 = SWIG_AsVal_double(args(2), &val4);
18838 if (!SWIG_IsOK(ecode4)) {
18839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18840 }
18841 arg4 = static_cast< PLFLT >(val4);
18842 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18843 _outv = octave_value();
18844 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18845 {
18846
18847 }
18848 {
18849
18850 }
18851 return _out;
18852 fail:
18853 {
18854
18855 }
18856 {
18857
18858 }
18859 return octave_value_list();
18860 }
18861 catch(...) {
18862 {
18863
18864 }
18865 {
18866
18867 }
18868 throw;
18869 }
18870}
18871
18872
18874 octave_value_list _out;
18875 octave_value_list *_outp=&_out;
18876 octave_value _outv;
18877
18878 try {
18879 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18880 SWIG_fail;
18881 }
18882 plflush();
18883 _outv = octave_value();
18884 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18885 return _out;
18886 fail:
18887 return octave_value_list();
18888 }
18889 catch(...) {
18890 throw;
18891 }
18892}
18893
18894
18896 PLINT arg1 ;
18897 int val1 ;
18898 int ecode1 = 0 ;
18899 octave_value_list _out;
18900 octave_value_list *_outp=&_out;
18901 octave_value _outv;
18902
18903 try {
18904 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18905 SWIG_fail;
18906 }
18907 ecode1 = SWIG_AsVal_int(args(0), &val1);
18908 if (!SWIG_IsOK(ecode1)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18910 }
18911 arg1 = static_cast< PLINT >(val1);
18912 plfont(arg1);
18913 _outv = octave_value();
18914 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18915 return _out;
18916 fail:
18917 return octave_value_list();
18918 }
18919 catch(...) {
18920 throw;
18921 }
18922}
18923
18924
18926 PLINT arg1 ;
18927 int val1 ;
18928 int ecode1 = 0 ;
18929 octave_value_list _out;
18930 octave_value_list *_outp=&_out;
18931 octave_value _outv;
18932
18933 try {
18934 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18935 SWIG_fail;
18936 }
18937 ecode1 = SWIG_AsVal_int(args(0), &val1);
18938 if (!SWIG_IsOK(ecode1)) {
18939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18940 }
18941 arg1 = static_cast< PLINT >(val1);
18942 plfontld(arg1);
18943 _outv = octave_value();
18944 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18945 return _out;
18946 fail:
18947 return octave_value_list();
18948 }
18949 catch(...) {
18950 throw;
18951 }
18952}
18953
18954
18956 PLFLT *arg1 = (PLFLT *) 0 ;
18957 PLFLT *arg2 = (PLFLT *) 0 ;
18958 PLFLT temp1 ;
18959 int res1 = SWIG_TMPOBJ ;
18960 PLFLT temp2 ;
18961 int res2 = SWIG_TMPOBJ ;
18962 octave_value_list _out;
18963 octave_value_list *_outp=&_out;
18964 octave_value _outv;
18965
18966 try {
18967 arg1 = &temp1;
18968 arg2 = &temp2;
18969 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18970 SWIG_fail;
18971 }
18972 plgchr(arg1,arg2);
18973 _outv = octave_value();
18974 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18975 if (SWIG_IsTmpObj(res1)) {
18976 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18977 } else {
18978 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18979 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18980 }
18981 if (SWIG_IsTmpObj(res2)) {
18982 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18983 } else {
18984 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18985 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18986 }
18987 return _out;
18988 fail:
18989 return octave_value_list();
18990 }
18991 catch(...) {
18992 throw;
18993 }
18994}
18995
18996
18998 PLINT arg1 ;
18999 PLINT *arg2 = (PLINT *) 0 ;
19000 PLINT *arg3 = (PLINT *) 0 ;
19001 PLINT *arg4 = (PLINT *) 0 ;
19002 int val1 ;
19003 int ecode1 = 0 ;
19004 PLINT temp2 ;
19005 int res2 = SWIG_TMPOBJ ;
19006 PLINT temp3 ;
19007 int res3 = SWIG_TMPOBJ ;
19008 PLINT temp4 ;
19009 int res4 = SWIG_TMPOBJ ;
19010 octave_value_list _out;
19011 octave_value_list *_outp=&_out;
19012 octave_value _outv;
19013
19014 try {
19015 arg2 = &temp2;
19016 arg3 = &temp3;
19017 arg4 = &temp4;
19018 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
19019 SWIG_fail;
19020 }
19021 ecode1 = SWIG_AsVal_int(args(0), &val1);
19022 if (!SWIG_IsOK(ecode1)) {
19023 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
19024 }
19025 arg1 = static_cast< PLINT >(val1);
19026 plgcol0(arg1,arg2,arg3,arg4);
19027 _outv = octave_value();
19028 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19029 if (SWIG_IsTmpObj(res2)) {
19030 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19031 } else {
19032 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19033 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19034 }
19035 if (SWIG_IsTmpObj(res3)) {
19036 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19037 } else {
19038 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19039 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19040 }
19041 if (SWIG_IsTmpObj(res4)) {
19042 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19043 } else {
19044 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19045 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19046 }
19047 return _out;
19048 fail:
19049 return octave_value_list();
19050 }
19051 catch(...) {
19052 throw;
19053 }
19054}
19055
19056
19058 PLINT arg1 ;
19059 PLINT *arg2 = (PLINT *) 0 ;
19060 PLINT *arg3 = (PLINT *) 0 ;
19061 PLINT *arg4 = (PLINT *) 0 ;
19062 PLFLT *arg5 = (PLFLT *) 0 ;
19063 int val1 ;
19064 int ecode1 = 0 ;
19065 PLINT temp2 ;
19066 int res2 = SWIG_TMPOBJ ;
19067 PLINT temp3 ;
19068 int res3 = SWIG_TMPOBJ ;
19069 PLINT temp4 ;
19070 int res4 = SWIG_TMPOBJ ;
19071 PLFLT temp5 ;
19072 int res5 = SWIG_TMPOBJ ;
19073 octave_value_list _out;
19074 octave_value_list *_outp=&_out;
19075 octave_value _outv;
19076
19077 try {
19078 arg2 = &temp2;
19079 arg3 = &temp3;
19080 arg4 = &temp4;
19081 arg5 = &temp5;
19082 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19083 SWIG_fail;
19084 }
19085 ecode1 = SWIG_AsVal_int(args(0), &val1);
19086 if (!SWIG_IsOK(ecode1)) {
19087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19088 }
19089 arg1 = static_cast< PLINT >(val1);
19090 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19091 _outv = octave_value();
19092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19093 if (SWIG_IsTmpObj(res2)) {
19094 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19095 } else {
19096 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19097 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19098 }
19099 if (SWIG_IsTmpObj(res3)) {
19100 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19101 } else {
19102 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19103 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19104 }
19105 if (SWIG_IsTmpObj(res4)) {
19106 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19107 } else {
19108 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19109 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19110 }
19111 if (SWIG_IsTmpObj(res5)) {
19112 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19113 } else {
19114 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19115 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19116 }
19117 return _out;
19118 fail:
19119 return octave_value_list();
19120 }
19121 catch(...) {
19122 throw;
19123 }
19124}
19125
19126
19128 PLINT *arg1 = (PLINT *) 0 ;
19129 PLINT *arg2 = (PLINT *) 0 ;
19130 PLINT *arg3 = (PLINT *) 0 ;
19131 PLINT temp1 ;
19132 int res1 = SWIG_TMPOBJ ;
19133 PLINT temp2 ;
19134 int res2 = SWIG_TMPOBJ ;
19135 PLINT temp3 ;
19136 int res3 = SWIG_TMPOBJ ;
19137 octave_value_list _out;
19138 octave_value_list *_outp=&_out;
19139 octave_value _outv;
19140
19141 try {
19142 arg1 = &temp1;
19143 arg2 = &temp2;
19144 arg3 = &temp3;
19145 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19146 SWIG_fail;
19147 }
19148 plgcolbg(arg1,arg2,arg3);
19149 _outv = octave_value();
19150 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19151 if (SWIG_IsTmpObj(res1)) {
19152 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19153 } else {
19154 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19155 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19156 }
19157 if (SWIG_IsTmpObj(res2)) {
19158 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19159 } else {
19160 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19161 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19162 }
19163 if (SWIG_IsTmpObj(res3)) {
19164 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19165 } else {
19166 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19167 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19168 }
19169 return _out;
19170 fail:
19171 return octave_value_list();
19172 }
19173 catch(...) {
19174 throw;
19175 }
19176}
19177
19178
19180 PLINT *arg1 = (PLINT *) 0 ;
19181 PLINT *arg2 = (PLINT *) 0 ;
19182 PLINT *arg3 = (PLINT *) 0 ;
19183 PLFLT *arg4 = (PLFLT *) 0 ;
19184 PLINT temp1 ;
19185 int res1 = SWIG_TMPOBJ ;
19186 PLINT temp2 ;
19187 int res2 = SWIG_TMPOBJ ;
19188 PLINT temp3 ;
19189 int res3 = SWIG_TMPOBJ ;
19190 PLFLT temp4 ;
19191 int res4 = SWIG_TMPOBJ ;
19192 octave_value_list _out;
19193 octave_value_list *_outp=&_out;
19194 octave_value _outv;
19195
19196 try {
19197 arg1 = &temp1;
19198 arg2 = &temp2;
19199 arg3 = &temp3;
19200 arg4 = &temp4;
19201 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19202 SWIG_fail;
19203 }
19204 plgcolbga(arg1,arg2,arg3,arg4);
19205 _outv = octave_value();
19206 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19207 if (SWIG_IsTmpObj(res1)) {
19208 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19209 } else {
19210 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19211 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19212 }
19213 if (SWIG_IsTmpObj(res2)) {
19214 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19215 } else {
19216 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19217 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19218 }
19219 if (SWIG_IsTmpObj(res3)) {
19220 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19221 } else {
19222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19223 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19224 }
19225 if (SWIG_IsTmpObj(res4)) {
19226 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19227 } else {
19228 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19229 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19230 }
19231 return _out;
19232 fail:
19233 return octave_value_list();
19234 }
19235 catch(...) {
19236 throw;
19237 }
19238}
19239
19240
19241SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19242 PLINT *arg1 = (PLINT *) 0 ;
19243 PLINT temp1 ;
19244 int res1 = SWIG_TMPOBJ ;
19245 octave_value_list _out;
19246 octave_value_list *_outp=&_out;
19247 octave_value _outv;
19248
19249 try {
19250 arg1 = &temp1;
19251 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19252 SWIG_fail;
19253 }
19254 plgcompression(arg1);
19255 _outv = octave_value();
19256 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19257 if (SWIG_IsTmpObj(res1)) {
19258 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19259 } else {
19260 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19261 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19262 }
19263 return _out;
19264 fail:
19265 return octave_value_list();
19266 }
19267 catch(...) {
19268 throw;
19269 }
19270}
19271
19272
19274 char *arg1 = (char *) 0 ;
19275 char local_string1[80] ;
19276 size_t local_string_length1 ;
19277 charMatrix local_charMatrix1 ;
19278 octave_value_list retval1 ;
19279 octave_value_list _out;
19280 octave_value_list *_outp=&_out;
19281 octave_value _outv;
19282
19283 try {
19284 {
19285 arg1 = local_string1;
19286 }
19287 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19288 SWIG_fail;
19289 }
19290 plgdev(arg1);
19291 _outv = octave_value();
19292 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19293 {
19294 local_string_length1 = strlen( local_string1 );
19295 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19296 local_charMatrix1.insert( local_string1, 0, 0 );
19297 retval1( 0 ) = octave_value( local_charMatrix1 );
19298 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19299 }
19300 return _out;
19301 fail:
19302 return octave_value_list();
19303 }
19304 catch(...) {
19305 throw;
19306 }
19307}
19308
19309
19311 PLFLT *arg1 = (PLFLT *) 0 ;
19312 PLFLT *arg2 = (PLFLT *) 0 ;
19313 PLFLT *arg3 = (PLFLT *) 0 ;
19314 PLFLT *arg4 = (PLFLT *) 0 ;
19315 PLFLT temp1 ;
19316 int res1 = SWIG_TMPOBJ ;
19317 PLFLT temp2 ;
19318 int res2 = SWIG_TMPOBJ ;
19319 PLFLT temp3 ;
19320 int res3 = SWIG_TMPOBJ ;
19321 PLFLT temp4 ;
19322 int res4 = SWIG_TMPOBJ ;
19323 octave_value_list _out;
19324 octave_value_list *_outp=&_out;
19325 octave_value _outv;
19326
19327 try {
19328 arg1 = &temp1;
19329 arg2 = &temp2;
19330 arg3 = &temp3;
19331 arg4 = &temp4;
19332 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19333 SWIG_fail;
19334 }
19335 plgdidev(arg1,arg2,arg3,arg4);
19336 _outv = octave_value();
19337 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19338 if (SWIG_IsTmpObj(res1)) {
19339 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19340 } else {
19341 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19342 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19343 }
19344 if (SWIG_IsTmpObj(res2)) {
19345 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19346 } else {
19347 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19348 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19349 }
19350 if (SWIG_IsTmpObj(res3)) {
19351 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19352 } else {
19353 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19354 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19355 }
19356 if (SWIG_IsTmpObj(res4)) {
19357 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19358 } else {
19359 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19360 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19361 }
19362 return _out;
19363 fail:
19364 return octave_value_list();
19365 }
19366 catch(...) {
19367 throw;
19368 }
19369}
19370
19371
19373 PLFLT *arg1 = (PLFLT *) 0 ;
19374 PLFLT temp1 ;
19375 int res1 = SWIG_TMPOBJ ;
19376 octave_value_list _out;
19377 octave_value_list *_outp=&_out;
19378 octave_value _outv;
19379
19380 try {
19381 arg1 = &temp1;
19382 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19383 SWIG_fail;
19384 }
19385 plgdiori(arg1);
19386 _outv = octave_value();
19387 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19388 if (SWIG_IsTmpObj(res1)) {
19389 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19390 } else {
19391 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19392 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19393 }
19394 return _out;
19395 fail:
19396 return octave_value_list();
19397 }
19398 catch(...) {
19399 throw;
19400 }
19401}
19402
19403
19405 PLFLT *arg1 = (PLFLT *) 0 ;
19406 PLFLT *arg2 = (PLFLT *) 0 ;
19407 PLFLT *arg3 = (PLFLT *) 0 ;
19408 PLFLT *arg4 = (PLFLT *) 0 ;
19409 PLFLT temp1 ;
19410 int res1 = SWIG_TMPOBJ ;
19411 PLFLT temp2 ;
19412 int res2 = SWIG_TMPOBJ ;
19413 PLFLT temp3 ;
19414 int res3 = SWIG_TMPOBJ ;
19415 PLFLT temp4 ;
19416 int res4 = SWIG_TMPOBJ ;
19417 octave_value_list _out;
19418 octave_value_list *_outp=&_out;
19419 octave_value _outv;
19420
19421 try {
19422 arg1 = &temp1;
19423 arg2 = &temp2;
19424 arg3 = &temp3;
19425 arg4 = &temp4;
19426 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19427 SWIG_fail;
19428 }
19429 plgdiplt(arg1,arg2,arg3,arg4);
19430 _outv = octave_value();
19431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19432 if (SWIG_IsTmpObj(res1)) {
19433 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19434 } else {
19435 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19436 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19437 }
19438 if (SWIG_IsTmpObj(res2)) {
19439 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19440 } else {
19441 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19442 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19443 }
19444 if (SWIG_IsTmpObj(res3)) {
19445 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19446 } else {
19447 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19448 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19449 }
19450 if (SWIG_IsTmpObj(res4)) {
19451 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19452 } else {
19453 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19454 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19455 }
19456 return _out;
19457 fail:
19458 return octave_value_list();
19459 }
19460 catch(...) {
19461 throw;
19462 }
19463}
19464
19465
19467 PLINT *arg1 = (PLINT *) 0 ;
19468 PLINT *arg2 = (PLINT *) 0 ;
19469 PLINT *arg3 = (PLINT *) 0 ;
19470 PLINT temp1 ;
19471 int res1 = SWIG_TMPOBJ ;
19472 PLINT temp2 ;
19473 int res2 = SWIG_TMPOBJ ;
19474 PLINT temp3 ;
19475 int res3 = SWIG_TMPOBJ ;
19476 octave_value_list _out;
19477 octave_value_list *_outp=&_out;
19478 octave_value _outv;
19479
19480 try {
19481 arg1 = &temp1;
19482 arg2 = &temp2;
19483 arg3 = &temp3;
19484 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19485 SWIG_fail;
19486 }
19487 plgfam(arg1,arg2,arg3);
19488 _outv = octave_value();
19489 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19490 if (SWIG_IsTmpObj(res1)) {
19491 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19492 } else {
19493 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19494 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19495 }
19496 if (SWIG_IsTmpObj(res2)) {
19497 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19498 } else {
19499 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19500 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19501 }
19502 if (SWIG_IsTmpObj(res3)) {
19503 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19504 } else {
19505 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19506 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19507 }
19508 return _out;
19509 fail:
19510 return octave_value_list();
19511 }
19512 catch(...) {
19513 throw;
19514 }
19515}
19516
19517
19519 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19520 PLUNICODE temp1 ;
19521 int res1 = SWIG_TMPOBJ ;
19522 octave_value_list _out;
19523 octave_value_list *_outp=&_out;
19524 octave_value _outv;
19525
19526 try {
19527 arg1 = &temp1;
19528 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19529 SWIG_fail;
19530 }
19531 plgfci(arg1);
19532 _outv = octave_value();
19533 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19534 if (SWIG_IsTmpObj(res1)) {
19535 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19536 } else {
19537 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19538 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19539 }
19540 return _out;
19541 fail:
19542 return octave_value_list();
19543 }
19544 catch(...) {
19545 throw;
19546 }
19547}
19548
19549
19551 char *arg1 = (char *) 0 ;
19552 char local_string1[80] ;
19553 size_t local_string_length1 ;
19554 charMatrix local_charMatrix1 ;
19555 octave_value_list retval1 ;
19556 octave_value_list _out;
19557 octave_value_list *_outp=&_out;
19558 octave_value _outv;
19559
19560 try {
19561 {
19562 arg1 = local_string1;
19563 }
19564 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19565 SWIG_fail;
19566 }
19567 plgfnam(arg1);
19568 _outv = octave_value();
19569 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19570 {
19571 local_string_length1 = strlen( local_string1 );
19572 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19573 local_charMatrix1.insert( local_string1, 0, 0 );
19574 retval1( 0 ) = octave_value( local_charMatrix1 );
19575 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19576 }
19577 return _out;
19578 fail:
19579 return octave_value_list();
19580 }
19581 catch(...) {
19582 throw;
19583 }
19584}
19585
19586
19588 PLINT *arg1 = (PLINT *) 0 ;
19589 PLINT *arg2 = (PLINT *) 0 ;
19590 PLINT *arg3 = (PLINT *) 0 ;
19591 PLINT temp1 ;
19592 int res1 = SWIG_TMPOBJ ;
19593 PLINT temp2 ;
19594 int res2 = SWIG_TMPOBJ ;
19595 PLINT temp3 ;
19596 int res3 = SWIG_TMPOBJ ;
19597 octave_value_list _out;
19598 octave_value_list *_outp=&_out;
19599 octave_value _outv;
19600
19601 try {
19602 arg1 = &temp1;
19603 arg2 = &temp2;
19604 arg3 = &temp3;
19605 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19606 SWIG_fail;
19607 }
19608 plgfont(arg1,arg2,arg3);
19609 _outv = octave_value();
19610 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19611 if (SWIG_IsTmpObj(res1)) {
19612 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19613 } else {
19614 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19615 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19616 }
19617 if (SWIG_IsTmpObj(res2)) {
19618 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19619 } else {
19620 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19621 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19622 }
19623 if (SWIG_IsTmpObj(res3)) {
19624 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19625 } else {
19626 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19627 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19628 }
19629 return _out;
19630 fail:
19631 return octave_value_list();
19632 }
19633 catch(...) {
19634 throw;
19635 }
19636}
19637
19638
19640 PLINT *arg1 = (PLINT *) 0 ;
19641 PLINT temp1 ;
19642 int res1 = SWIG_TMPOBJ ;
19643 octave_value_list _out;
19644 octave_value_list *_outp=&_out;
19645 octave_value _outv;
19646
19647 try {
19648 arg1 = &temp1;
19649 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19650 SWIG_fail;
19651 }
19652 plglevel(arg1);
19653 _outv = octave_value();
19654 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19655 if (SWIG_IsTmpObj(res1)) {
19656 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19657 } else {
19658 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19659 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19660 }
19661 return _out;
19662 fail:
19663 return octave_value_list();
19664 }
19665 catch(...) {
19666 throw;
19667 }
19668}
19669
19670
19672 PLFLT *arg1 = (PLFLT *) 0 ;
19673 PLFLT *arg2 = (PLFLT *) 0 ;
19674 PLINT *arg3 = (PLINT *) 0 ;
19675 PLINT *arg4 = (PLINT *) 0 ;
19676 PLINT *arg5 = (PLINT *) 0 ;
19677 PLINT *arg6 = (PLINT *) 0 ;
19678 PLFLT temp1 ;
19679 int res1 = SWIG_TMPOBJ ;
19680 PLFLT temp2 ;
19681 int res2 = SWIG_TMPOBJ ;
19682 PLINT temp3 ;
19683 int res3 = SWIG_TMPOBJ ;
19684 PLINT temp4 ;
19685 int res4 = SWIG_TMPOBJ ;
19686 PLINT temp5 ;
19687 int res5 = SWIG_TMPOBJ ;
19688 PLINT temp6 ;
19689 int res6 = SWIG_TMPOBJ ;
19690 octave_value_list _out;
19691 octave_value_list *_outp=&_out;
19692 octave_value _outv;
19693
19694 try {
19695 arg1 = &temp1;
19696 arg2 = &temp2;
19697 arg3 = &temp3;
19698 arg4 = &temp4;
19699 arg5 = &temp5;
19700 arg6 = &temp6;
19701 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19702 SWIG_fail;
19703 }
19704 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19705 _outv = octave_value();
19706 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19707 if (SWIG_IsTmpObj(res1)) {
19708 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19709 } else {
19710 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19711 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19712 }
19713 if (SWIG_IsTmpObj(res2)) {
19714 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19715 } else {
19716 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19717 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19718 }
19719 if (SWIG_IsTmpObj(res3)) {
19720 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19721 } else {
19722 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19723 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19724 }
19725 if (SWIG_IsTmpObj(res4)) {
19726 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19727 } else {
19728 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19729 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19730 }
19731 if (SWIG_IsTmpObj(res5)) {
19732 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19733 } else {
19734 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19735 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19736 }
19737 if (SWIG_IsTmpObj(res6)) {
19738 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19739 } else {
19740 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19741 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19742 }
19743 return _out;
19744 fail:
19745 return octave_value_list();
19746 }
19747 catch(...) {
19748 throw;
19749 }
19750}
19751
19752
19754 octave_value_list _out;
19755 octave_value_list *_outp=&_out;
19756 octave_value _outv;
19757
19758 try {
19759 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19760 SWIG_fail;
19761 }
19762 plgra();
19763 _outv = octave_value();
19764 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19765 return _out;
19766 fail:
19767 return octave_value_list();
19768 }
19769 catch(...) {
19770 throw;
19771 }
19772}
19773
19774
19776 PLFLT *arg1 = (PLFLT *) 0 ;
19777 PLFLT *arg2 = (PLFLT *) 0 ;
19778 PLFLT *arg3 = (PLFLT *) 0 ;
19779 PLFLT *arg4 = (PLFLT *) 0 ;
19780 PLFLT temp1 ;
19781 int res1 = SWIG_TMPOBJ ;
19782 PLFLT temp2 ;
19783 int res2 = SWIG_TMPOBJ ;
19784 PLFLT temp3 ;
19785 int res3 = SWIG_TMPOBJ ;
19786 PLFLT temp4 ;
19787 int res4 = SWIG_TMPOBJ ;
19788 octave_value_list _out;
19789 octave_value_list *_outp=&_out;
19790 octave_value _outv;
19791
19792 try {
19793 arg1 = &temp1;
19794 arg2 = &temp2;
19795 arg3 = &temp3;
19796 arg4 = &temp4;
19797 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19798 SWIG_fail;
19799 }
19800 plgspa(arg1,arg2,arg3,arg4);
19801 _outv = octave_value();
19802 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19803 if (SWIG_IsTmpObj(res1)) {
19804 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19805 } else {
19806 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19807 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19808 }
19809 if (SWIG_IsTmpObj(res2)) {
19810 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19811 } else {
19812 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19813 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19814 }
19815 if (SWIG_IsTmpObj(res3)) {
19816 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19817 } else {
19818 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19819 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19820 }
19821 if (SWIG_IsTmpObj(res4)) {
19822 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19823 } else {
19824 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19825 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19826 }
19827 return _out;
19828 fail:
19829 return octave_value_list();
19830 }
19831 catch(...) {
19832 throw;
19833 }
19834}
19835
19836
19838 PLINT *arg1 = (PLINT *) 0 ;
19839 PLINT temp1 ;
19840 int res1 = SWIG_TMPOBJ ;
19841 octave_value_list _out;
19842 octave_value_list *_outp=&_out;
19843 octave_value _outv;
19844
19845 try {
19846 arg1 = &temp1;
19847 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19848 SWIG_fail;
19849 }
19850 plgstrm(arg1);
19851 _outv = octave_value();
19852 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19853 if (SWIG_IsTmpObj(res1)) {
19854 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19855 } else {
19856 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19857 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19858 }
19859 return _out;
19860 fail:
19861 return octave_value_list();
19862 }
19863 catch(...) {
19864 throw;
19865 }
19866}
19867
19868
19870 char *arg1 = (char *) 0 ;
19871 char local_string1[80] ;
19872 size_t local_string_length1 ;
19873 charMatrix local_charMatrix1 ;
19874 octave_value_list retval1 ;
19875 octave_value_list _out;
19876 octave_value_list *_outp=&_out;
19877 octave_value _outv;
19878
19879 try {
19880 {
19881 arg1 = local_string1;
19882 }
19883 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19884 SWIG_fail;
19885 }
19886 plgver(arg1);
19887 _outv = octave_value();
19888 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19889 {
19890 local_string_length1 = strlen( local_string1 );
19891 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19892 local_charMatrix1.insert( local_string1, 0, 0 );
19893 retval1( 0 ) = octave_value( local_charMatrix1 );
19894 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19895 }
19896 return _out;
19897 fail:
19898 return octave_value_list();
19899 }
19900 catch(...) {
19901 throw;
19902 }
19903}
19904
19905
19907 PLFLT *arg1 = (PLFLT *) 0 ;
19908 PLFLT *arg2 = (PLFLT *) 0 ;
19909 PLFLT *arg3 = (PLFLT *) 0 ;
19910 PLFLT *arg4 = (PLFLT *) 0 ;
19911 PLFLT temp1 ;
19912 int res1 = SWIG_TMPOBJ ;
19913 PLFLT temp2 ;
19914 int res2 = SWIG_TMPOBJ ;
19915 PLFLT temp3 ;
19916 int res3 = SWIG_TMPOBJ ;
19917 PLFLT temp4 ;
19918 int res4 = SWIG_TMPOBJ ;
19919 octave_value_list _out;
19920 octave_value_list *_outp=&_out;
19921 octave_value _outv;
19922
19923 try {
19924 arg1 = &temp1;
19925 arg2 = &temp2;
19926 arg3 = &temp3;
19927 arg4 = &temp4;
19928 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19929 SWIG_fail;
19930 }
19931 plgvpd(arg1,arg2,arg3,arg4);
19932 _outv = octave_value();
19933 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19934 if (SWIG_IsTmpObj(res1)) {
19935 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19936 } else {
19937 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19938 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19939 }
19940 if (SWIG_IsTmpObj(res2)) {
19941 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19942 } else {
19943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19944 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19945 }
19946 if (SWIG_IsTmpObj(res3)) {
19947 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19948 } else {
19949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19950 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19951 }
19952 if (SWIG_IsTmpObj(res4)) {
19953 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19954 } else {
19955 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19956 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19957 }
19958 return _out;
19959 fail:
19960 return octave_value_list();
19961 }
19962 catch(...) {
19963 throw;
19964 }
19965}
19966
19967
19969 PLFLT *arg1 = (PLFLT *) 0 ;
19970 PLFLT *arg2 = (PLFLT *) 0 ;
19971 PLFLT *arg3 = (PLFLT *) 0 ;
19972 PLFLT *arg4 = (PLFLT *) 0 ;
19973 PLFLT temp1 ;
19974 int res1 = SWIG_TMPOBJ ;
19975 PLFLT temp2 ;
19976 int res2 = SWIG_TMPOBJ ;
19977 PLFLT temp3 ;
19978 int res3 = SWIG_TMPOBJ ;
19979 PLFLT temp4 ;
19980 int res4 = SWIG_TMPOBJ ;
19981 octave_value_list _out;
19982 octave_value_list *_outp=&_out;
19983 octave_value _outv;
19984
19985 try {
19986 arg1 = &temp1;
19987 arg2 = &temp2;
19988 arg3 = &temp3;
19989 arg4 = &temp4;
19990 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19991 SWIG_fail;
19992 }
19993 plgvpw(arg1,arg2,arg3,arg4);
19994 _outv = octave_value();
19995 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19996 if (SWIG_IsTmpObj(res1)) {
19997 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19998 } else {
19999 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20000 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20001 }
20002 if (SWIG_IsTmpObj(res2)) {
20003 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20004 } else {
20005 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20006 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20007 }
20008 if (SWIG_IsTmpObj(res3)) {
20009 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
20010 } else {
20011 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20012 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
20013 }
20014 if (SWIG_IsTmpObj(res4)) {
20015 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20016 } else {
20017 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20018 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20019 }
20020 return _out;
20021 fail:
20022 return octave_value_list();
20023 }
20024 catch(...) {
20025 throw;
20026 }
20027}
20028
20029
20031 PLINT *arg1 = (PLINT *) 0 ;
20032 PLINT *arg2 = (PLINT *) 0 ;
20033 PLINT temp1 ;
20034 int res1 = SWIG_TMPOBJ ;
20035 PLINT temp2 ;
20036 int res2 = SWIG_TMPOBJ ;
20037 octave_value_list _out;
20038 octave_value_list *_outp=&_out;
20039 octave_value _outv;
20040
20041 try {
20042 arg1 = &temp1;
20043 arg2 = &temp2;
20044 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
20045 SWIG_fail;
20046 }
20047 plgxax(arg1,arg2);
20048 _outv = octave_value();
20049 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20050 if (SWIG_IsTmpObj(res1)) {
20051 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20052 } else {
20053 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20054 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20055 }
20056 if (SWIG_IsTmpObj(res2)) {
20057 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20058 } else {
20059 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20060 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20061 }
20062 return _out;
20063 fail:
20064 return octave_value_list();
20065 }
20066 catch(...) {
20067 throw;
20068 }
20069}
20070
20071
20073 PLINT *arg1 = (PLINT *) 0 ;
20074 PLINT *arg2 = (PLINT *) 0 ;
20075 PLINT temp1 ;
20076 int res1 = SWIG_TMPOBJ ;
20077 PLINT temp2 ;
20078 int res2 = SWIG_TMPOBJ ;
20079 octave_value_list _out;
20080 octave_value_list *_outp=&_out;
20081 octave_value _outv;
20082
20083 try {
20084 arg1 = &temp1;
20085 arg2 = &temp2;
20086 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20087 SWIG_fail;
20088 }
20089 plgyax(arg1,arg2);
20090 _outv = octave_value();
20091 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20092 if (SWIG_IsTmpObj(res1)) {
20093 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20094 } else {
20095 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20096 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20097 }
20098 if (SWIG_IsTmpObj(res2)) {
20099 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20100 } else {
20101 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20102 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20103 }
20104 return _out;
20105 fail:
20106 return octave_value_list();
20107 }
20108 catch(...) {
20109 throw;
20110 }
20111}
20112
20113
20115 PLINT *arg1 = (PLINT *) 0 ;
20116 PLINT *arg2 = (PLINT *) 0 ;
20117 PLINT temp1 ;
20118 int res1 = SWIG_TMPOBJ ;
20119 PLINT temp2 ;
20120 int res2 = SWIG_TMPOBJ ;
20121 octave_value_list _out;
20122 octave_value_list *_outp=&_out;
20123 octave_value _outv;
20124
20125 try {
20126 arg1 = &temp1;
20127 arg2 = &temp2;
20128 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20129 SWIG_fail;
20130 }
20131 plgzax(arg1,arg2);
20132 _outv = octave_value();
20133 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20134 if (SWIG_IsTmpObj(res1)) {
20135 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20136 } else {
20137 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20138 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20139 }
20140 if (SWIG_IsTmpObj(res2)) {
20141 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20142 } else {
20143 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20144 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20145 }
20146 return _out;
20147 fail:
20148 return octave_value_list();
20149 }
20150 catch(...) {
20151 throw;
20152 }
20153}
20154
20155
20157 PLINT arg1 ;
20158 PLFLT *arg2 = (PLFLT *) 0 ;
20159 PLFLT arg3 ;
20160 PLFLT arg4 ;
20161 PLINT arg5 ;
20162 PLINT arg6 ;
20163 Matrix temp1 ;
20164 double val3 ;
20165 int ecode3 = 0 ;
20166 double val4 ;
20167 int ecode4 = 0 ;
20168 int val5 ;
20169 int ecode5 = 0 ;
20170 int val6 ;
20171 int ecode6 = 0 ;
20172 octave_value_list _out;
20173 octave_value_list *_outp=&_out;
20174 octave_value _outv;
20175
20176 try {
20177 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20178 SWIG_fail;
20179 }
20180 {
20181 if ( _n_dims( args(0) ) > 1 )
20182 {
20183 error( "argument must be a scalar or vector" ); SWIG_fail;
20184 }
20185 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20186 temp1 = args(0).matrix_value();
20187 arg2 = &temp1( 0, 0 );
20188 }
20189 ecode3 = SWIG_AsVal_double(args(1), &val3);
20190 if (!SWIG_IsOK(ecode3)) {
20191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20192 }
20193 arg3 = static_cast< PLFLT >(val3);
20194 ecode4 = SWIG_AsVal_double(args(2), &val4);
20195 if (!SWIG_IsOK(ecode4)) {
20196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20197 }
20198 arg4 = static_cast< PLFLT >(val4);
20199 ecode5 = SWIG_AsVal_int(args(3), &val5);
20200 if (!SWIG_IsOK(ecode5)) {
20201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20202 }
20203 arg5 = static_cast< PLINT >(val5);
20204 ecode6 = SWIG_AsVal_int(args(4), &val6);
20205 if (!SWIG_IsOK(ecode6)) {
20206 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20207 }
20208 arg6 = static_cast< PLINT >(val6);
20209 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20210 _outv = octave_value();
20211 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20212 {
20213
20214 }
20215 return _out;
20216 fail:
20217 {
20218
20219 }
20220 return octave_value_list();
20221 }
20222 catch(...) {
20223 {
20224
20225 }
20226 throw;
20227 }
20228}
20229
20230
20232 PLFLT arg1 ;
20233 PLFLT arg2 ;
20234 PLFLT arg3 ;
20235 PLFLT *arg4 = (PLFLT *) 0 ;
20236 PLFLT *arg5 = (PLFLT *) 0 ;
20237 PLFLT *arg6 = (PLFLT *) 0 ;
20238 double val1 ;
20239 int ecode1 = 0 ;
20240 double val2 ;
20241 int ecode2 = 0 ;
20242 double val3 ;
20243 int ecode3 = 0 ;
20244 PLFLT temp4 ;
20245 int res4 = SWIG_TMPOBJ ;
20246 PLFLT temp5 ;
20247 int res5 = SWIG_TMPOBJ ;
20248 PLFLT temp6 ;
20249 int res6 = SWIG_TMPOBJ ;
20250 octave_value_list _out;
20251 octave_value_list *_outp=&_out;
20252 octave_value _outv;
20253
20254 try {
20255 arg4 = &temp4;
20256 arg5 = &temp5;
20257 arg6 = &temp6;
20258 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20259 SWIG_fail;
20260 }
20261 ecode1 = SWIG_AsVal_double(args(0), &val1);
20262 if (!SWIG_IsOK(ecode1)) {
20263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20264 }
20265 arg1 = static_cast< PLFLT >(val1);
20266 ecode2 = SWIG_AsVal_double(args(1), &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20269 }
20270 arg2 = static_cast< PLFLT >(val2);
20271 ecode3 = SWIG_AsVal_double(args(2), &val3);
20272 if (!SWIG_IsOK(ecode3)) {
20273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20274 }
20275 arg3 = static_cast< PLFLT >(val3);
20276 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20277 _outv = octave_value();
20278 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20279 if (SWIG_IsTmpObj(res4)) {
20280 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20281 } else {
20282 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20283 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20284 }
20285 if (SWIG_IsTmpObj(res5)) {
20286 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20287 } else {
20288 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20289 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20290 }
20291 if (SWIG_IsTmpObj(res6)) {
20292 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20293 } else {
20294 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20295 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20296 }
20297 return _out;
20298 fail:
20299 return octave_value_list();
20300 }
20301 catch(...) {
20302 throw;
20303 }
20304}
20305
20306
20308 octave_value_list _out;
20309 octave_value_list *_outp=&_out;
20310 octave_value _outv;
20311
20312 try {
20313 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20314 SWIG_fail;
20315 }
20316 plinit();
20317 _outv = octave_value();
20318 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20319 return _out;
20320 fail:
20321 return octave_value_list();
20322 }
20323 catch(...) {
20324 throw;
20325 }
20326}
20327
20328
20330 PLFLT arg1 ;
20331 PLFLT arg2 ;
20332 PLFLT arg3 ;
20333 PLFLT arg4 ;
20334 double val1 ;
20335 int ecode1 = 0 ;
20336 double val2 ;
20337 int ecode2 = 0 ;
20338 double val3 ;
20339 int ecode3 = 0 ;
20340 double val4 ;
20341 int ecode4 = 0 ;
20342 octave_value_list _out;
20343 octave_value_list *_outp=&_out;
20344 octave_value _outv;
20345
20346 try {
20347 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20348 SWIG_fail;
20349 }
20350 ecode1 = SWIG_AsVal_double(args(0), &val1);
20351 if (!SWIG_IsOK(ecode1)) {
20352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20353 }
20354 arg1 = static_cast< PLFLT >(val1);
20355 ecode2 = SWIG_AsVal_double(args(1), &val2);
20356 if (!SWIG_IsOK(ecode2)) {
20357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20358 }
20359 arg2 = static_cast< PLFLT >(val2);
20360 ecode3 = SWIG_AsVal_double(args(2), &val3);
20361 if (!SWIG_IsOK(ecode3)) {
20362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20363 }
20364 arg3 = static_cast< PLFLT >(val3);
20365 ecode4 = SWIG_AsVal_double(args(3), &val4);
20366 if (!SWIG_IsOK(ecode4)) {
20367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20368 }
20369 arg4 = static_cast< PLFLT >(val4);
20370 pljoin(arg1,arg2,arg3,arg4);
20371 _outv = octave_value();
20372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20373 return _out;
20374 fail:
20375 return octave_value_list();
20376 }
20377 catch(...) {
20378 throw;
20379 }
20380}
20381
20382
20384 char *arg1 = (char *) 0 ;
20385 char *arg2 = (char *) 0 ;
20386 char *arg3 = (char *) 0 ;
20387 int res1 ;
20388 char *buf1 = 0 ;
20389 int alloc1 = 0 ;
20390 int res2 ;
20391 char *buf2 = 0 ;
20392 int alloc2 = 0 ;
20393 int res3 ;
20394 char *buf3 = 0 ;
20395 int alloc3 = 0 ;
20396 octave_value_list _out;
20397 octave_value_list *_outp=&_out;
20398 octave_value _outv;
20399
20400 try {
20401 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20402 SWIG_fail;
20403 }
20404 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20405 if (!SWIG_IsOK(res1)) {
20406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20407 }
20408 arg1 = reinterpret_cast< char * >(buf1);
20409 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20410 if (!SWIG_IsOK(res2)) {
20411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20412 }
20413 arg2 = reinterpret_cast< char * >(buf2);
20414 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20415 if (!SWIG_IsOK(res3)) {
20416 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20417 }
20418 arg3 = reinterpret_cast< char * >(buf3);
20419 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20420 _outv = octave_value();
20421 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20422 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20423 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20424 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20425 return _out;
20426 fail:
20427 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20428 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20429 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20430 return octave_value_list();
20431 }
20432 catch(...) {
20433 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20434 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20435 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20436 throw;
20437 }
20438}
20439
20440
20442 PLFLT *arg1 = (PLFLT *) 0 ;
20443 PLFLT *arg2 = (PLFLT *) 0 ;
20444 PLINT arg3 ;
20445 PLINT arg4 ;
20446 PLFLT arg5 ;
20447 PLFLT arg6 ;
20448 PLFLT arg7 ;
20449 PLINT arg8 ;
20450 PLINT arg9 ;
20451 PLINT arg10 ;
20452 PLINT arg11 ;
20453 PLINT arg12 ;
20454 PLINT arg13 ;
20455 PLINT *arg14 = (PLINT *) 0 ;
20456 PLFLT arg15 ;
20457 PLFLT arg16 ;
20458 PLFLT arg17 ;
20459 PLFLT arg18 ;
20460 PLINT *arg19 = (PLINT *) 0 ;
20461 char **arg20 = (char **) 0 ;
20462 PLINT *arg21 = (PLINT *) 0 ;
20463 PLINT *arg22 = (PLINT *) 0 ;
20464 PLFLT *arg23 = (PLFLT *) 0 ;
20465 PLFLT *arg24 = (PLFLT *) 0 ;
20466 PLINT *arg25 = (PLINT *) 0 ;
20467 PLINT *arg26 = (PLINT *) 0 ;
20468 PLFLT *arg27 = (PLFLT *) 0 ;
20469 PLINT *arg28 = (PLINT *) 0 ;
20470 PLFLT *arg29 = (PLFLT *) 0 ;
20471 PLINT *arg30 = (PLINT *) 0 ;
20472 char **arg31 = (char **) 0 ;
20473 PLFLT temp1 ;
20474 int res1 = SWIG_TMPOBJ ;
20475 PLFLT temp2 ;
20476 int res2 = SWIG_TMPOBJ ;
20477 int val3 ;
20478 int ecode3 = 0 ;
20479 int val4 ;
20480 int ecode4 = 0 ;
20481 double val5 ;
20482 int ecode5 = 0 ;
20483 double val6 ;
20484 int ecode6 = 0 ;
20485 double val7 ;
20486 int ecode7 = 0 ;
20487 int val8 ;
20488 int ecode8 = 0 ;
20489 int val9 ;
20490 int ecode9 = 0 ;
20491 int val10 ;
20492 int ecode10 = 0 ;
20493 int val11 ;
20494 int ecode11 = 0 ;
20495 int val12 ;
20496 int ecode12 = 0 ;
20497 Matrix temp13 ;
20498 double val15 ;
20499 int ecode15 = 0 ;
20500 double val16 ;
20501 int ecode16 = 0 ;
20502 double val17 ;
20503 int ecode17 = 0 ;
20504 double val18 ;
20505 int ecode18 = 0 ;
20506 Matrix temp19 ;
20507 Matrix temp21 ;
20508 Matrix temp22 ;
20509 Matrix temp23 ;
20510 Matrix temp24 ;
20511 Matrix temp25 ;
20512 Matrix temp26 ;
20513 Matrix temp27 ;
20514 Matrix temp28 ;
20515 Matrix temp29 ;
20516 Matrix temp30 ;
20517 octave_value_list _out;
20518 octave_value_list *_outp=&_out;
20519 octave_value _outv;
20520
20521 try {
20522 arg1 = &temp1;
20523 arg2 = &temp2;
20524 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20525 SWIG_fail;
20526 }
20527 ecode3 = SWIG_AsVal_int(args(0), &val3);
20528 if (!SWIG_IsOK(ecode3)) {
20529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20530 }
20531 arg3 = static_cast< PLINT >(val3);
20532 ecode4 = SWIG_AsVal_int(args(1), &val4);
20533 if (!SWIG_IsOK(ecode4)) {
20534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20535 }
20536 arg4 = static_cast< PLINT >(val4);
20537 ecode5 = SWIG_AsVal_double(args(2), &val5);
20538 if (!SWIG_IsOK(ecode5)) {
20539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20540 }
20541 arg5 = static_cast< PLFLT >(val5);
20542 ecode6 = SWIG_AsVal_double(args(3), &val6);
20543 if (!SWIG_IsOK(ecode6)) {
20544 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20545 }
20546 arg6 = static_cast< PLFLT >(val6);
20547 ecode7 = SWIG_AsVal_double(args(4), &val7);
20548 if (!SWIG_IsOK(ecode7)) {
20549 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20550 }
20551 arg7 = static_cast< PLFLT >(val7);
20552 ecode8 = SWIG_AsVal_int(args(5), &val8);
20553 if (!SWIG_IsOK(ecode8)) {
20554 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20555 }
20556 arg8 = static_cast< PLINT >(val8);
20557 ecode9 = SWIG_AsVal_int(args(6), &val9);
20558 if (!SWIG_IsOK(ecode9)) {
20559 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20560 }
20561 arg9 = static_cast< PLINT >(val9);
20562 ecode10 = SWIG_AsVal_int(args(7), &val10);
20563 if (!SWIG_IsOK(ecode10)) {
20564 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20565 }
20566 arg10 = static_cast< PLINT >(val10);
20567 ecode11 = SWIG_AsVal_int(args(8), &val11);
20568 if (!SWIG_IsOK(ecode11)) {
20569 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20570 }
20571 arg11 = static_cast< PLINT >(val11);
20572 ecode12 = SWIG_AsVal_int(args(9), &val12);
20573 if (!SWIG_IsOK(ecode12)) {
20574 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20575 }
20576 arg12 = static_cast< PLINT >(val12);
20577 {
20578 if ( _n_dims( args(10) ) > 1 )
20579 {
20580 error( "argument must be a scalar or vector" ); SWIG_fail;
20581 }
20582 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20583 arg14 = new PLINT[Alen];
20584 temp13 = args(10).matrix_value();
20585 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20586 }
20587 ecode15 = SWIG_AsVal_double(args(11), &val15);
20588 if (!SWIG_IsOK(ecode15)) {
20589 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20590 }
20591 arg15 = static_cast< PLFLT >(val15);
20592 ecode16 = SWIG_AsVal_double(args(12), &val16);
20593 if (!SWIG_IsOK(ecode16)) {
20594 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20595 }
20596 arg16 = static_cast< PLFLT >(val16);
20597 ecode17 = SWIG_AsVal_double(args(13), &val17);
20598 if (!SWIG_IsOK(ecode17)) {
20599 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20600 }
20601 arg17 = static_cast< PLFLT >(val17);
20602 ecode18 = SWIG_AsVal_double(args(14), &val18);
20603 if (!SWIG_IsOK(ecode18)) {
20604 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20605 }
20606 arg18 = static_cast< PLFLT >(val18);
20607 {
20608 if ( _n_dims( args(15) ) > 1 )
20609 {
20610 error( "argument must be a scalar or vector" ); SWIG_fail;
20611 }
20612 if ( _dim( args(15), 0 ) != Alen )
20613 {
20614 error( "argument vectors must be same length" ); SWIG_fail;
20615 }
20616 temp19 = args(15).matrix_value();
20617 arg19 = new PLINT[Alen];
20618 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20619 }
20620 {
20621 charMatrix temp_matrix;
20622 Cell temp_cell;
20623 char *tmp_cstring;
20624 std::string str;
20625 size_t max_length = 0, non_blank_length;
20626 int i, ifcell;
20627 if ( _n_dims( args(16) ) > 2 )
20628 {
20629 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20630 }
20631#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20632 if ( !args(16).isempty() )
20633#else
20634 if ( !args(16).is_empty() )
20635#endif
20636 {
20637 if ( _dim( args(16), 0 ) != Alen )
20638 {
20639 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20640 }
20641 arg20 = new char*[Alen];
20642#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20643 ifcell = args(16).iscell();
20644#else
20645 ifcell = args(16).is_cell();
20646#endif
20647 if ( ifcell )
20648 {
20649 temp_cell = args(16).cell_value();
20650 }
20651 else
20652 {
20653 temp_matrix = args(16).char_matrix_value();
20654 // Allow one extra space for null termination.
20655 max_length = _dim( args(16), 1 ) + 1;
20656 }
20657
20658 for ( i = 0; i < Alen; i++ )
20659 {
20660 // Must copy string to "permanent" location because the string
20661 // location corresponding to tmp_cstring gets
20662 // overwritten for each iteration of loop.
20663 if ( ifcell )
20664 {
20665 if ( temp_cell.elem( i ).is_string() )
20666 {
20667 str = temp_cell.elem( i ).string_value();
20668 // leave room for null termination.
20669 max_length = str.size() + 1;
20670 tmp_cstring = (char *) str.c_str();
20671 }
20672 else
20673 {
20674 // Use null string if user attempts to pass a cell array
20675 // with a non-string element (likely an empty element
20676 // since that should be allowed by the PLplot interface
20677 // if that element is going to be unused).
20678 // leave room for null termination.
20679 max_length = 1;
20680 tmp_cstring = (char *) "";
20681 }
20682 }
20683 else
20684 {
20685 str = temp_matrix.row_as_string( i );
20686 tmp_cstring = (char *) str.c_str();
20687 }
20688 arg20[i] = new char[max_length];
20689 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20690 arg20[i][max_length - 1] = '\0';
20691 // All the trailing blank crapola should not be needed for
20692 // string cell arrays.
20693 if ( !ifcell )
20694 {
20695 // remove trailing-blank padding that is used by the
20696 // charMatrix class to insure all strings in a given
20697 // charMatrix instance have the same length.
20698 // This transformation also removes legitimate trailing
20699 // blanks but there is nothing we can do about that
20700 // for the charMatrix class.
20701
20702 // Look for trailing nulls first (just in case, although that
20703 // shouldn't happen if charMatrix implemented as documented)
20704 // before looking for trailing blanks.
20705 non_blank_length = max_length - 2;
20706 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20707 {
20708 non_blank_length--;
20709 }
20710 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20711 {
20712 non_blank_length--;
20713 }
20714 arg20[i][non_blank_length + 1] = '\0';
20715 }
20716 }
20717 }
20718 else
20719 {
20720 arg20 = NULL;
20721 }
20722 }
20723 {
20724 if ( _n_dims( args(17) ) > 1 )
20725 {
20726 error( "argument must be a scalar or vector" ); SWIG_fail;
20727 }
20728#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20729 if ( !args(17).isempty() )
20730#else
20731 if ( !args(17).is_empty() )
20732#endif
20733 {
20734 if ( _dim( args(17), 0 ) != Alen )
20735 {
20736 error( "argument vectors must be same length" ); SWIG_fail;
20737 }
20738 temp21 = args(17).matrix_value();
20739 arg21 = new PLINT[Alen];
20740 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20741 }
20742 else
20743 {
20744 arg21 = NULL;
20745 }
20746 }
20747 {
20748 if ( _n_dims( args(18) ) > 1 )
20749 {
20750 error( "argument must be a scalar or vector" ); SWIG_fail;
20751 }
20752#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20753 if ( !args(18).isempty() )
20754#else
20755 if ( !args(18).is_empty() )
20756#endif
20757 {
20758 if ( _dim( args(18), 0 ) != Alen )
20759 {
20760 error( "argument vectors must be same length" ); SWIG_fail;
20761 }
20762 temp22 = args(18).matrix_value();
20763 arg22 = new PLINT[Alen];
20764 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20765 }
20766 else
20767 {
20768 arg22 = NULL;
20769 }
20770 }
20771 {
20772 if ( _n_dims( args(19) ) > 1 )
20773 {
20774 error( "argument must be a scalar or vector" ); SWIG_fail;
20775 }
20776#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20777 if ( !args(19).isempty() )
20778#else
20779 if ( !args(19).is_empty() )
20780#endif
20781 {
20782 if ( _dim( args(19), 0 ) != Alen )
20783 {
20784 error( "argument vectors must be same length" ); SWIG_fail;
20785 }
20786 temp23 = args(19).matrix_value();
20787 arg23 = &temp23( 0, 0 );
20788 }
20789 else
20790 {
20791 arg23 = NULL;
20792 }
20793 }
20794 {
20795 if ( _n_dims( args(20) ) > 1 )
20796 {
20797 error( "argument must be a scalar or vector" ); SWIG_fail;
20798 }
20799#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20800 if ( !args(20).isempty() )
20801#else
20802 if ( !args(20).is_empty() )
20803#endif
20804 {
20805 if ( _dim( args(20), 0 ) != Alen )
20806 {
20807 error( "argument vectors must be same length" ); SWIG_fail;
20808 }
20809 temp24 = args(20).matrix_value();
20810 arg24 = &temp24( 0, 0 );
20811 }
20812 else
20813 {
20814 arg24 = NULL;
20815 }
20816 }
20817 {
20818 if ( _n_dims( args(21) ) > 1 )
20819 {
20820 error( "argument must be a scalar or vector" ); SWIG_fail;
20821 }
20822#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20823 if ( !args(21).isempty() )
20824#else
20825 if ( !args(21).is_empty() )
20826#endif
20827 {
20828 if ( _dim( args(21), 0 ) != Alen )
20829 {
20830 error( "argument vectors must be same length" ); SWIG_fail;
20831 }
20832 temp25 = args(21).matrix_value();
20833 arg25 = new PLINT[Alen];
20834 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20835 }
20836 else
20837 {
20838 arg25 = NULL;
20839 }
20840 }
20841 {
20842 if ( _n_dims( args(22) ) > 1 )
20843 {
20844 error( "argument must be a scalar or vector" ); SWIG_fail;
20845 }
20846#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20847 if ( !args(22).isempty() )
20848#else
20849 if ( !args(22).is_empty() )
20850#endif
20851 {
20852 if ( _dim( args(22), 0 ) != Alen )
20853 {
20854 error( "argument vectors must be same length" ); SWIG_fail;
20855 }
20856 temp26 = args(22).matrix_value();
20857 arg26 = new PLINT[Alen];
20858 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20859 }
20860 else
20861 {
20862 arg26 = NULL;
20863 }
20864 }
20865 {
20866 if ( _n_dims( args(23) ) > 1 )
20867 {
20868 error( "argument must be a scalar or vector" ); SWIG_fail;
20869 }
20870#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20871 if ( !args(23).isempty() )
20872#else
20873 if ( !args(23).is_empty() )
20874#endif
20875 {
20876 if ( _dim( args(23), 0 ) != Alen )
20877 {
20878 error( "argument vectors must be same length" ); SWIG_fail;
20879 }
20880 temp27 = args(23).matrix_value();
20881 arg27 = &temp27( 0, 0 );
20882 }
20883 else
20884 {
20885 arg27 = NULL;
20886 }
20887 }
20888 {
20889 if ( _n_dims( args(24) ) > 1 )
20890 {
20891 error( "argument must be a scalar or vector" ); SWIG_fail;
20892 }
20893#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20894 if ( !args(24).isempty() )
20895#else
20896 if ( !args(24).is_empty() )
20897#endif
20898 {
20899 if ( _dim( args(24), 0 ) != Alen )
20900 {
20901 error( "argument vectors must be same length" ); SWIG_fail;
20902 }
20903 temp28 = args(24).matrix_value();
20904 arg28 = new PLINT[Alen];
20905 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20906 }
20907 else
20908 {
20909 arg28 = NULL;
20910 }
20911 }
20912 {
20913 if ( _n_dims( args(25) ) > 1 )
20914 {
20915 error( "argument must be a scalar or vector" ); SWIG_fail;
20916 }
20917#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20918 if ( !args(25).isempty() )
20919#else
20920 if ( !args(25).is_empty() )
20921#endif
20922 {
20923 if ( _dim( args(25), 0 ) != Alen )
20924 {
20925 error( "argument vectors must be same length" ); SWIG_fail;
20926 }
20927 temp29 = args(25).matrix_value();
20928 arg29 = &temp29( 0, 0 );
20929 }
20930 else
20931 {
20932 arg29 = NULL;
20933 }
20934 }
20935 {
20936 if ( _n_dims( args(26) ) > 1 )
20937 {
20938 error( "argument must be a scalar or vector" ); SWIG_fail;
20939 }
20940#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20941 if ( !args(26).isempty() )
20942#else
20943 if ( !args(26).is_empty() )
20944#endif
20945 {
20946 if ( _dim( args(26), 0 ) != Alen )
20947 {
20948 error( "argument vectors must be same length" ); SWIG_fail;
20949 }
20950 temp30 = args(26).matrix_value();
20951 arg30 = new PLINT[Alen];
20952 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20953 }
20954 else
20955 {
20956 arg30 = NULL;
20957 }
20958 }
20959 {
20960 charMatrix temp_matrix;
20961 Cell temp_cell;
20962 char *tmp_cstring;
20963 std::string str;
20964 size_t max_length = 0, non_blank_length;
20965 int i, ifcell;
20966 if ( _n_dims( args(27) ) > 2 )
20967 {
20968 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20969 }
20970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20971 if ( !args(27).isempty() )
20972#else
20973 if ( !args(27).is_empty() )
20974#endif
20975 {
20976 if ( _dim( args(27), 0 ) != Alen )
20977 {
20978 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20979 }
20980 arg31 = new char*[Alen];
20981#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20982 ifcell = args(27).iscell();
20983#else
20984 ifcell = args(27).is_cell();
20985#endif
20986 if ( ifcell )
20987 {
20988 temp_cell = args(27).cell_value();
20989 }
20990 else
20991 {
20992 temp_matrix = args(27).char_matrix_value();
20993 // Allow one extra space for null termination.
20994 max_length = _dim( args(27), 1 ) + 1;
20995 }
20996
20997 for ( i = 0; i < Alen; i++ )
20998 {
20999 // Must copy string to "permanent" location because the string
21000 // location corresponding to tmp_cstring gets
21001 // overwritten for each iteration of loop.
21002 if ( ifcell )
21003 {
21004 if ( temp_cell.elem( i ).is_string() )
21005 {
21006 str = temp_cell.elem( i ).string_value();
21007 // leave room for null termination.
21008 max_length = str.size() + 1;
21009 tmp_cstring = (char *) str.c_str();
21010 }
21011 else
21012 {
21013 // Use null string if user attempts to pass a cell array
21014 // with a non-string element (likely an empty element
21015 // since that should be allowed by the PLplot interface
21016 // if that element is going to be unused).
21017 // leave room for null termination.
21018 max_length = 1;
21019 tmp_cstring = (char *) "";
21020 }
21021 }
21022 else
21023 {
21024 str = temp_matrix.row_as_string( i );
21025 tmp_cstring = (char *) str.c_str();
21026 }
21027 arg31[i] = new char[max_length];
21028 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21029 arg31[i][max_length - 1] = '\0';
21030 // All the trailing blank crapola should not be needed for
21031 // string cell arrays.
21032 if ( !ifcell )
21033 {
21034 // remove trailing-blank padding that is used by the
21035 // charMatrix class to insure all strings in a given
21036 // charMatrix instance have the same length.
21037 // This transformation also removes legitimate trailing
21038 // blanks but there is nothing we can do about that
21039 // for the charMatrix class.
21040
21041 // Look for trailing nulls first (just in case, although that
21042 // shouldn't happen if charMatrix implemented as documented)
21043 // before looking for trailing blanks.
21044 non_blank_length = max_length - 2;
21045 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
21046 {
21047 non_blank_length--;
21048 }
21049 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
21050 {
21051 non_blank_length--;
21052 }
21053 arg31[i][non_blank_length + 1] = '\0';
21054 }
21055 }
21056 }
21057 else
21058 {
21059 arg31 = NULL;
21060 }
21061 }
21062 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);
21063 _outv = octave_value();
21064 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21065 if (SWIG_IsTmpObj(res1)) {
21066 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21067 } else {
21068 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21069 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21070 }
21071 if (SWIG_IsTmpObj(res2)) {
21072 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21073 } else {
21074 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21075 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21076 }
21077 {
21078 delete [] arg14;
21079 }
21080 {
21081 delete [] arg19;
21082 }
21083 {
21084 int i;
21085 if ( arg20 != NULL )
21086 {
21087 for ( i = 0; i < Alen; i++ )
21088 {
21089 delete[] arg20[i];
21090 }
21091 delete[] arg20;
21092 }
21093 }
21094 {
21095 if ( arg21 != NULL )
21096 delete [] arg21;
21097 }
21098 {
21099 if ( arg22 != NULL )
21100 delete [] arg22;
21101 }
21102 {
21103
21104 }
21105 {
21106
21107 }
21108 {
21109 if ( arg25 != NULL )
21110 delete [] arg25;
21111 }
21112 {
21113 if ( arg26 != NULL )
21114 delete [] arg26;
21115 }
21116 {
21117
21118 }
21119 {
21120 if ( arg28 != NULL )
21121 delete [] arg28;
21122 }
21123 {
21124
21125 }
21126 {
21127 if ( arg30 != NULL )
21128 delete [] arg30;
21129 }
21130 {
21131 int i;
21132 if ( arg31 != NULL )
21133 {
21134 for ( i = 0; i < Alen; i++ )
21135 {
21136 delete[] arg31[i];
21137 }
21138 delete[] arg31;
21139 }
21140 }
21141 return _out;
21142 fail:
21143 {
21144 delete [] arg14;
21145 }
21146 {
21147 delete [] arg19;
21148 }
21149 {
21150 int i;
21151 if ( arg20 != NULL )
21152 {
21153 for ( i = 0; i < Alen; i++ )
21154 {
21155 delete[] arg20[i];
21156 }
21157 delete[] arg20;
21158 }
21159 }
21160 {
21161 if ( arg21 != NULL )
21162 delete [] arg21;
21163 }
21164 {
21165 if ( arg22 != NULL )
21166 delete [] arg22;
21167 }
21168 {
21169
21170 }
21171 {
21172
21173 }
21174 {
21175 if ( arg25 != NULL )
21176 delete [] arg25;
21177 }
21178 {
21179 if ( arg26 != NULL )
21180 delete [] arg26;
21181 }
21182 {
21183
21184 }
21185 {
21186 if ( arg28 != NULL )
21187 delete [] arg28;
21188 }
21189 {
21190
21191 }
21192 {
21193 if ( arg30 != NULL )
21194 delete [] arg30;
21195 }
21196 {
21197 int i;
21198 if ( arg31 != NULL )
21199 {
21200 for ( i = 0; i < Alen; i++ )
21201 {
21202 delete[] arg31[i];
21203 }
21204 delete[] arg31;
21205 }
21206 }
21207 return octave_value_list();
21208 }
21209 catch(...) {
21210 {
21211 delete [] arg14;
21212 }
21213 {
21214 delete [] arg19;
21215 }
21216 {
21217 int i;
21218 if ( arg20 != NULL )
21219 {
21220 for ( i = 0; i < Alen; i++ )
21221 {
21222 delete[] arg20[i];
21223 }
21224 delete[] arg20;
21225 }
21226 }
21227 {
21228 if ( arg21 != NULL )
21229 delete [] arg21;
21230 }
21231 {
21232 if ( arg22 != NULL )
21233 delete [] arg22;
21234 }
21235 {
21236
21237 }
21238 {
21239
21240 }
21241 {
21242 if ( arg25 != NULL )
21243 delete [] arg25;
21244 }
21245 {
21246 if ( arg26 != NULL )
21247 delete [] arg26;
21248 }
21249 {
21250
21251 }
21252 {
21253 if ( arg28 != NULL )
21254 delete [] arg28;
21255 }
21256 {
21257
21258 }
21259 {
21260 if ( arg30 != NULL )
21261 delete [] arg30;
21262 }
21263 {
21264 int i;
21265 if ( arg31 != NULL )
21266 {
21267 for ( i = 0; i < Alen; i++ )
21268 {
21269 delete[] arg31[i];
21270 }
21271 delete[] arg31;
21272 }
21273 }
21274 throw;
21275 }
21276}
21277
21278
21280 PLFLT arg1 ;
21281 PLFLT arg2 ;
21282 PLFLT arg3 ;
21283 double val1 ;
21284 int ecode1 = 0 ;
21285 double val2 ;
21286 int ecode2 = 0 ;
21287 double val3 ;
21288 int ecode3 = 0 ;
21289 octave_value_list _out;
21290 octave_value_list *_outp=&_out;
21291 octave_value _outv;
21292
21293 try {
21294 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21295 SWIG_fail;
21296 }
21297 ecode1 = SWIG_AsVal_double(args(0), &val1);
21298 if (!SWIG_IsOK(ecode1)) {
21299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21300 }
21301 arg1 = static_cast< PLFLT >(val1);
21302 ecode2 = SWIG_AsVal_double(args(1), &val2);
21303 if (!SWIG_IsOK(ecode2)) {
21304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21305 }
21306 arg2 = static_cast< PLFLT >(val2);
21307 ecode3 = SWIG_AsVal_double(args(2), &val3);
21308 if (!SWIG_IsOK(ecode3)) {
21309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21310 }
21311 arg3 = static_cast< PLFLT >(val3);
21312 pllightsource(arg1,arg2,arg3);
21313 _outv = octave_value();
21314 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21315 return _out;
21316 fail:
21317 return octave_value_list();
21318 }
21319 catch(...) {
21320 throw;
21321 }
21322}
21323
21324
21326 PLINT arg1 ;
21327 PLFLT *arg2 = (PLFLT *) 0 ;
21328 PLFLT *arg3 = (PLFLT *) 0 ;
21329 Matrix temp1 ;
21330 Matrix temp3 ;
21331 octave_value_list _out;
21332 octave_value_list *_outp=&_out;
21333 octave_value _outv;
21334
21335 try {
21336 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21337 SWIG_fail;
21338 }
21339 {
21340 if ( _n_dims( args(0) ) > 1 )
21341 {
21342 error( "argument must be a scalar or vector" ); SWIG_fail;
21343 }
21344 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21345 temp1 = args(0).matrix_value();
21346 arg2 = &temp1( 0, 0 );
21347 }
21348 {
21349 if ( _n_dims( args(1) ) > 1 )
21350 {
21351 error( "argument must be a scalar or vector" ); SWIG_fail;
21352 }
21353 if ( _dim( args(1), 0 ) != Alen )
21354 {
21355 error( "argument vectors must be same length" ); SWIG_fail;
21356 }
21357 temp3 = args(1).matrix_value();
21358 arg3 = &temp3( 0, 0 );
21359 }
21360 plline(arg1,(double const *)arg2,(double const *)arg3);
21361 _outv = octave_value();
21362 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21363 {
21364
21365 }
21366 {
21367
21368 }
21369 return _out;
21370 fail:
21371 {
21372
21373 }
21374 {
21375
21376 }
21377 return octave_value_list();
21378 }
21379 catch(...) {
21380 {
21381
21382 }
21383 {
21384
21385 }
21386 throw;
21387 }
21388}
21389
21390
21392 PLINT arg1 ;
21393 PLFLT *arg2 = (PLFLT *) 0 ;
21394 PLFLT *arg3 = (PLFLT *) 0 ;
21395 PLFLT *arg4 = (PLFLT *) 0 ;
21396 Matrix temp1 ;
21397 Matrix temp3 ;
21398 Matrix temp4 ;
21399 octave_value_list _out;
21400 octave_value_list *_outp=&_out;
21401 octave_value _outv;
21402
21403 try {
21404 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21405 SWIG_fail;
21406 }
21407 {
21408 if ( _n_dims( args(0) ) > 1 )
21409 {
21410 error( "argument must be a scalar or vector" ); SWIG_fail;
21411 }
21412 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21413 temp1 = args(0).matrix_value();
21414 arg2 = &temp1( 0, 0 );
21415 }
21416 {
21417 if ( _n_dims( args(1) ) > 1 )
21418 {
21419 error( "argument must be a scalar or vector" ); SWIG_fail;
21420 }
21421 if ( _dim( args(1), 0 ) != Alen )
21422 {
21423 error( "argument vectors must be same length" ); SWIG_fail;
21424 }
21425 temp3 = args(1).matrix_value();
21426 arg3 = &temp3( 0, 0 );
21427 }
21428 {
21429 if ( _n_dims( args(2) ) > 1 )
21430 {
21431 error( "argument must be a scalar or vector" ); SWIG_fail;
21432 }
21433 if ( _dim( args(2), 0 ) != Alen )
21434 {
21435 error( "argument vectors must be same length" ); SWIG_fail;
21436 }
21437 temp4 = args(2).matrix_value();
21438 arg4 = &temp4( 0, 0 );
21439 }
21440 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21441 _outv = octave_value();
21442 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21443 {
21444
21445 }
21446 {
21447
21448 }
21449 {
21450
21451 }
21452 return _out;
21453 fail:
21454 {
21455
21456 }
21457 {
21458
21459 }
21460 {
21461
21462 }
21463 return octave_value_list();
21464 }
21465 catch(...) {
21466 {
21467
21468 }
21469 {
21470
21471 }
21472 {
21473
21474 }
21475 throw;
21476 }
21477}
21478
21479
21481 PLINT arg1 ;
21482 int val1 ;
21483 int ecode1 = 0 ;
21484 octave_value_list _out;
21485 octave_value_list *_outp=&_out;
21486 octave_value _outv;
21487
21488 try {
21489 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21490 SWIG_fail;
21491 }
21492 ecode1 = SWIG_AsVal_int(args(0), &val1);
21493 if (!SWIG_IsOK(ecode1)) {
21494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21495 }
21496 arg1 = static_cast< PLINT >(val1);
21497 pllsty(arg1);
21498 _outv = octave_value();
21499 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21500 return _out;
21501 fail:
21502 return octave_value_list();
21503 }
21504 catch(...) {
21505 throw;
21506 }
21507}
21508
21509
21511 PLINT *arg1 = (PLINT *) 0 ;
21512 PLINT temp1 ;
21513 int res1 = SWIG_TMPOBJ ;
21514 octave_value_list _out;
21515 octave_value_list *_outp=&_out;
21516 octave_value _outv;
21517
21518 try {
21519 arg1 = &temp1;
21520 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21521 SWIG_fail;
21522 }
21523 plmkstrm(arg1);
21524 _outv = octave_value();
21525 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21526 if (SWIG_IsTmpObj(res1)) {
21527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21528 } else {
21529 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21530 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21531 }
21532 return _out;
21533 fail:
21534 return octave_value_list();
21535 }
21536 catch(...) {
21537 throw;
21538 }
21539}
21540
21541
21543 char *arg1 = (char *) 0 ;
21544 PLFLT arg2 ;
21545 PLFLT arg3 ;
21546 PLFLT arg4 ;
21547 char *arg5 = (char *) 0 ;
21548 int res1 ;
21549 char *buf1 = 0 ;
21550 int alloc1 = 0 ;
21551 double val2 ;
21552 int ecode2 = 0 ;
21553 double val3 ;
21554 int ecode3 = 0 ;
21555 double val4 ;
21556 int ecode4 = 0 ;
21557 int res5 ;
21558 char *buf5 = 0 ;
21559 int alloc5 = 0 ;
21560 octave_value_list _out;
21561 octave_value_list *_outp=&_out;
21562 octave_value _outv;
21563
21564 try {
21565 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21566 SWIG_fail;
21567 }
21568 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21571 }
21572 arg1 = reinterpret_cast< char * >(buf1);
21573 ecode2 = SWIG_AsVal_double(args(1), &val2);
21574 if (!SWIG_IsOK(ecode2)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21576 }
21577 arg2 = static_cast< PLFLT >(val2);
21578 ecode3 = SWIG_AsVal_double(args(2), &val3);
21579 if (!SWIG_IsOK(ecode3)) {
21580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21581 }
21582 arg3 = static_cast< PLFLT >(val3);
21583 ecode4 = SWIG_AsVal_double(args(3), &val4);
21584 if (!SWIG_IsOK(ecode4)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21586 }
21587 arg4 = static_cast< PLFLT >(val4);
21588 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21589 if (!SWIG_IsOK(res5)) {
21590 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21591 }
21592 arg5 = reinterpret_cast< char * >(buf5);
21593 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21594 _outv = octave_value();
21595 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21596 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21597 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21598 return _out;
21599 fail:
21600 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21601 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21602 return octave_value_list();
21603 }
21604 catch(...) {
21605 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21606 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21607 throw;
21608 }
21609}
21610
21611
21613 char *arg1 = (char *) 0 ;
21614 PLFLT arg2 ;
21615 PLFLT arg3 ;
21616 PLFLT arg4 ;
21617 char *arg5 = (char *) 0 ;
21618 int res1 ;
21619 char *buf1 = 0 ;
21620 int alloc1 = 0 ;
21621 double val2 ;
21622 int ecode2 = 0 ;
21623 double val3 ;
21624 int ecode3 = 0 ;
21625 double val4 ;
21626 int ecode4 = 0 ;
21627 int res5 ;
21628 char *buf5 = 0 ;
21629 int alloc5 = 0 ;
21630 octave_value_list _out;
21631 octave_value_list *_outp=&_out;
21632 octave_value _outv;
21633
21634 try {
21635 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21636 SWIG_fail;
21637 }
21638 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21641 }
21642 arg1 = reinterpret_cast< char * >(buf1);
21643 ecode2 = SWIG_AsVal_double(args(1), &val2);
21644 if (!SWIG_IsOK(ecode2)) {
21645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21646 }
21647 arg2 = static_cast< PLFLT >(val2);
21648 ecode3 = SWIG_AsVal_double(args(2), &val3);
21649 if (!SWIG_IsOK(ecode3)) {
21650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21651 }
21652 arg3 = static_cast< PLFLT >(val3);
21653 ecode4 = SWIG_AsVal_double(args(3), &val4);
21654 if (!SWIG_IsOK(ecode4)) {
21655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21656 }
21657 arg4 = static_cast< PLFLT >(val4);
21658 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21659 if (!SWIG_IsOK(res5)) {
21660 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21661 }
21662 arg5 = reinterpret_cast< char * >(buf5);
21663 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21664 _outv = octave_value();
21665 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21666 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21667 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21668 return _out;
21669 fail:
21670 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21671 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21672 return octave_value_list();
21673 }
21674 catch(...) {
21675 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21676 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21677 throw;
21678 }
21679}
21680
21681
21683 int *arg1 = (int *) 0 ;
21684 char **arg2 = (char **) 0 ;
21685 PLINT arg3 ;
21686 void *argp1 = 0 ;
21687 int res1 = 0 ;
21688 void *argp2 = 0 ;
21689 int res2 = 0 ;
21690 int val3 ;
21691 int ecode3 = 0 ;
21692 octave_value_list _out;
21693 octave_value_list *_outp=&_out;
21694 octave_value _outv;
21695 PLINT result;
21696
21697 try {
21698 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21699 SWIG_fail;
21700 }
21701 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21702 if (!SWIG_IsOK(res1)) {
21703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21704 }
21705 arg1 = reinterpret_cast< int * >(argp1);
21706 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21707 if (!SWIG_IsOK(res2)) {
21708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21709 }
21710 arg2 = reinterpret_cast< char ** >(argp2);
21711 ecode3 = SWIG_AsVal_int(args(2), &val3);
21712 if (!SWIG_IsOK(ecode3)) {
21713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21714 }
21715 arg3 = static_cast< PLINT >(val3);
21716 result = (PLINT)plparseopts(arg1,arg2,arg3);
21717 _outv = SWIG_From_int(static_cast< int >(result));
21718 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21719 return _out;
21720 fail:
21721 return octave_value_list();
21722 }
21723 catch(...) {
21724 throw;
21725 }
21726}
21727
21728
21730 PLINT arg1 ;
21731 PLINT *arg2 = (PLINT *) 0 ;
21732 PLINT *arg3 = (PLINT *) 0 ;
21733 Matrix temp1 ;
21734 Matrix temp3 ;
21735 octave_value_list _out;
21736 octave_value_list *_outp=&_out;
21737 octave_value _outv;
21738
21739 try {
21740 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21741 SWIG_fail;
21742 }
21743 {
21744 if ( _n_dims( args(0) ) > 1 )
21745 {
21746 error( "argument must be a scalar or vector" ); SWIG_fail;
21747 }
21748 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21749 arg2 = new PLINT[Alen];
21750 temp1 = args(0).matrix_value();
21751 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21752 }
21753 {
21754 if ( _n_dims( args(1) ) > 1 )
21755 {
21756 error( "argument must be a scalar or vector" ); SWIG_fail;
21757 }
21758 if ( _dim( args(1), 0 ) != Alen )
21759 {
21760 error( "argument vectors must be same length" ); SWIG_fail;
21761 }
21762 temp3 = args(1).matrix_value();
21763 arg3 = new PLINT[Alen];
21764 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21765 }
21766 plpat(arg1,(int const *)arg2,(int const *)arg3);
21767 _outv = octave_value();
21768 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21769 {
21770 delete [] arg2;
21771 }
21772 {
21773 delete [] arg3;
21774 }
21775 return _out;
21776 fail:
21777 {
21778 delete [] arg2;
21779 }
21780 {
21781 delete [] arg3;
21782 }
21783 return octave_value_list();
21784 }
21785 catch(...) {
21786 {
21787 delete [] arg2;
21788 }
21789 {
21790 delete [] arg3;
21791 }
21792 throw;
21793 }
21794}
21795
21796
21798 PLINT arg1 ;
21799 PLFLT arg2 ;
21800 PLFLT arg3 ;
21801 PLFLT arg4 ;
21802 PLFLT arg5 ;
21803 int val1 ;
21804 int ecode1 = 0 ;
21805 double val2 ;
21806 int ecode2 = 0 ;
21807 double val3 ;
21808 int ecode3 = 0 ;
21809 double val4 ;
21810 int ecode4 = 0 ;
21811 double val5 ;
21812 int ecode5 = 0 ;
21813 octave_value_list _out;
21814 octave_value_list *_outp=&_out;
21815 octave_value _outv;
21816
21817 try {
21818 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21819 SWIG_fail;
21820 }
21821 ecode1 = SWIG_AsVal_int(args(0), &val1);
21822 if (!SWIG_IsOK(ecode1)) {
21823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21824 }
21825 arg1 = static_cast< PLINT >(val1);
21826 ecode2 = SWIG_AsVal_double(args(1), &val2);
21827 if (!SWIG_IsOK(ecode2)) {
21828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21829 }
21830 arg2 = static_cast< PLFLT >(val2);
21831 ecode3 = SWIG_AsVal_double(args(2), &val3);
21832 if (!SWIG_IsOK(ecode3)) {
21833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21834 }
21835 arg3 = static_cast< PLFLT >(val3);
21836 ecode4 = SWIG_AsVal_double(args(3), &val4);
21837 if (!SWIG_IsOK(ecode4)) {
21838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21839 }
21840 arg4 = static_cast< PLFLT >(val4);
21841 ecode5 = SWIG_AsVal_double(args(4), &val5);
21842 if (!SWIG_IsOK(ecode5)) {
21843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21844 }
21845 arg5 = static_cast< PLFLT >(val5);
21846 plpath(arg1,arg2,arg3,arg4,arg5);
21847 _outv = octave_value();
21848 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21849 return _out;
21850 fail:
21851 return octave_value_list();
21852 }
21853 catch(...) {
21854 throw;
21855 }
21856}
21857
21858
21860 PLINT arg1 ;
21861 PLFLT *arg2 = (PLFLT *) 0 ;
21862 PLFLT *arg3 = (PLFLT *) 0 ;
21863 PLINT arg4 ;
21864 Matrix temp1 ;
21865 Matrix temp3 ;
21866 int val4 ;
21867 int ecode4 = 0 ;
21868 octave_value_list _out;
21869 octave_value_list *_outp=&_out;
21870 octave_value _outv;
21871
21872 try {
21873 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21874 SWIG_fail;
21875 }
21876 {
21877 if ( _n_dims( args(0) ) > 1 )
21878 {
21879 error( "argument must be a scalar or vector" ); SWIG_fail;
21880 }
21881 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21882 temp1 = args(0).matrix_value();
21883 arg2 = &temp1( 0, 0 );
21884 }
21885 {
21886 if ( _n_dims( args(1) ) > 1 )
21887 {
21888 error( "argument must be a scalar or vector" ); SWIG_fail;
21889 }
21890 if ( _dim( args(1), 0 ) != Alen )
21891 {
21892 error( "argument vectors must be same length" ); SWIG_fail;
21893 }
21894 temp3 = args(1).matrix_value();
21895 arg3 = &temp3( 0, 0 );
21896 }
21897 ecode4 = SWIG_AsVal_int(args(2), &val4);
21898 if (!SWIG_IsOK(ecode4)) {
21899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21900 }
21901 arg4 = static_cast< PLINT >(val4);
21902 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21903 _outv = octave_value();
21904 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21905 {
21906
21907 }
21908 {
21909
21910 }
21911 return _out;
21912 fail:
21913 {
21914
21915 }
21916 {
21917
21918 }
21919 return octave_value_list();
21920 }
21921 catch(...) {
21922 {
21923
21924 }
21925 {
21926
21927 }
21928 throw;
21929 }
21930}
21931
21932
21934 PLINT arg1 ;
21935 PLFLT *arg2 = (PLFLT *) 0 ;
21936 PLFLT *arg3 = (PLFLT *) 0 ;
21937 PLFLT *arg4 = (PLFLT *) 0 ;
21938 PLINT arg5 ;
21939 Matrix temp1 ;
21940 Matrix temp3 ;
21941 Matrix temp4 ;
21942 int val5 ;
21943 int ecode5 = 0 ;
21944 octave_value_list _out;
21945 octave_value_list *_outp=&_out;
21946 octave_value _outv;
21947
21948 try {
21949 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21950 SWIG_fail;
21951 }
21952 {
21953 if ( _n_dims( args(0) ) > 1 )
21954 {
21955 error( "argument must be a scalar or vector" ); SWIG_fail;
21956 }
21957 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21958 temp1 = args(0).matrix_value();
21959 arg2 = &temp1( 0, 0 );
21960 }
21961 {
21962 if ( _n_dims( args(1) ) > 1 )
21963 {
21964 error( "argument must be a scalar or vector" ); SWIG_fail;
21965 }
21966 if ( _dim( args(1), 0 ) != Alen )
21967 {
21968 error( "argument vectors must be same length" ); SWIG_fail;
21969 }
21970 temp3 = args(1).matrix_value();
21971 arg3 = &temp3( 0, 0 );
21972 }
21973 {
21974 if ( _n_dims( args(2) ) > 1 )
21975 {
21976 error( "argument must be a scalar or vector" ); SWIG_fail;
21977 }
21978 if ( _dim( args(2), 0 ) != Alen )
21979 {
21980 error( "argument vectors must be same length" ); SWIG_fail;
21981 }
21982 temp4 = args(2).matrix_value();
21983 arg4 = &temp4( 0, 0 );
21984 }
21985 ecode5 = SWIG_AsVal_int(args(3), &val5);
21986 if (!SWIG_IsOK(ecode5)) {
21987 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21988 }
21989 arg5 = static_cast< PLINT >(val5);
21990 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21991 _outv = octave_value();
21992 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21993 {
21994
21995 }
21996 {
21997
21998 }
21999 {
22000
22001 }
22002 return _out;
22003 fail:
22004 {
22005
22006 }
22007 {
22008
22009 }
22010 {
22011
22012 }
22013 return octave_value_list();
22014 }
22015 catch(...) {
22016 {
22017
22018 }
22019 {
22020
22021 }
22022 {
22023
22024 }
22025 throw;
22026 }
22027}
22028
22029
22031 PLINT arg1 ;
22032 PLFLT *arg2 = (PLFLT *) 0 ;
22033 PLFLT *arg3 = (PLFLT *) 0 ;
22034 PLFLT *arg4 = (PLFLT *) 0 ;
22035 PLBOOL *arg5 = (PLBOOL *) 0 ;
22036 PLBOOL arg6 ;
22037 Matrix temp1 ;
22038 Matrix temp3 ;
22039 Matrix temp4 ;
22040 Matrix temp5 ;
22041 int val6 ;
22042 int ecode6 = 0 ;
22043 octave_value_list _out;
22044 octave_value_list *_outp=&_out;
22045 octave_value _outv;
22046
22047 try {
22048 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
22049 SWIG_fail;
22050 }
22051 {
22052 if ( _n_dims( args(0) ) > 1 )
22053 {
22054 error( "argument must be a scalar or vector" ); SWIG_fail;
22055 }
22056 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22057 temp1 = args(0).matrix_value();
22058 arg2 = &temp1( 0, 0 );
22059 }
22060 {
22061 if ( _n_dims( args(1) ) > 1 )
22062 {
22063 error( "argument must be a scalar or vector" ); SWIG_fail;
22064 }
22065 if ( _dim( args(1), 0 ) != Alen )
22066 {
22067 error( "argument vectors must be same length" ); SWIG_fail;
22068 }
22069 temp3 = args(1).matrix_value();
22070 arg3 = &temp3( 0, 0 );
22071 }
22072 {
22073 if ( _n_dims( args(2) ) > 1 )
22074 {
22075 error( "argument must be a scalar or vector" ); SWIG_fail;
22076 }
22077 if ( _dim( args(2), 0 ) != Alen )
22078 {
22079 error( "argument vectors must be same length" ); SWIG_fail;
22080 }
22081 temp4 = args(2).matrix_value();
22082 arg4 = &temp4( 0, 0 );
22083 }
22084 {
22085 if ( _n_dims( args(3) ) > 1 )
22086 {
22087 error( "argument must be a scalar or vector" ); SWIG_fail;
22088 }
22089 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22090 {
22091 error( "argument vector must be same length or one less" ); SWIG_fail;
22092 }
22093 temp5 = args(3).matrix_value();
22094 arg5 = new PLINT[Alen];
22095 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22096 }
22097 ecode6 = SWIG_AsVal_int(args(4), &val6);
22098 if (!SWIG_IsOK(ecode6)) {
22099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22100 }
22101 arg6 = static_cast< PLBOOL >(val6);
22102 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22103 _outv = octave_value();
22104 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22105 {
22106
22107 }
22108 {
22109
22110 }
22111 {
22112
22113 }
22114 {
22115 delete [] arg5;
22116 }
22117 return _out;
22118 fail:
22119 {
22120
22121 }
22122 {
22123
22124 }
22125 {
22126
22127 }
22128 {
22129 delete [] arg5;
22130 }
22131 return octave_value_list();
22132 }
22133 catch(...) {
22134 {
22135
22136 }
22137 {
22138
22139 }
22140 {
22141
22142 }
22143 {
22144 delete [] arg5;
22145 }
22146 throw;
22147 }
22148}
22149
22150
22152 PLINT arg1 ;
22153 PLINT arg2 ;
22154 int val1 ;
22155 int ecode1 = 0 ;
22156 int val2 ;
22157 int ecode2 = 0 ;
22158 octave_value_list _out;
22159 octave_value_list *_outp=&_out;
22160 octave_value _outv;
22161
22162 try {
22163 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22164 SWIG_fail;
22165 }
22166 ecode1 = SWIG_AsVal_int(args(0), &val1);
22167 if (!SWIG_IsOK(ecode1)) {
22168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22169 }
22170 arg1 = static_cast< PLINT >(val1);
22171 ecode2 = SWIG_AsVal_int(args(1), &val2);
22172 if (!SWIG_IsOK(ecode2)) {
22173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22174 }
22175 arg2 = static_cast< PLINT >(val2);
22176 plprec(arg1,arg2);
22177 _outv = octave_value();
22178 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22179 return _out;
22180 fail:
22181 return octave_value_list();
22182 }
22183 catch(...) {
22184 throw;
22185 }
22186}
22187
22188
22190 PLINT arg1 ;
22191 int val1 ;
22192 int ecode1 = 0 ;
22193 octave_value_list _out;
22194 octave_value_list *_outp=&_out;
22195 octave_value _outv;
22196
22197 try {
22198 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22199 SWIG_fail;
22200 }
22201 ecode1 = SWIG_AsVal_int(args(0), &val1);
22202 if (!SWIG_IsOK(ecode1)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22204 }
22205 arg1 = static_cast< PLINT >(val1);
22206 plpsty(arg1);
22207 _outv = octave_value();
22208 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22209 return _out;
22210 fail:
22211 return octave_value_list();
22212 }
22213 catch(...) {
22214 throw;
22215 }
22216}
22217
22218
22220 PLFLT arg1 ;
22221 PLFLT arg2 ;
22222 PLFLT arg3 ;
22223 PLFLT arg4 ;
22224 PLFLT arg5 ;
22225 char *arg6 = (char *) 0 ;
22226 double val1 ;
22227 int ecode1 = 0 ;
22228 double val2 ;
22229 int ecode2 = 0 ;
22230 double val3 ;
22231 int ecode3 = 0 ;
22232 double val4 ;
22233 int ecode4 = 0 ;
22234 double val5 ;
22235 int ecode5 = 0 ;
22236 int res6 ;
22237 char *buf6 = 0 ;
22238 int alloc6 = 0 ;
22239 octave_value_list _out;
22240 octave_value_list *_outp=&_out;
22241 octave_value _outv;
22242
22243 try {
22244 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22245 SWIG_fail;
22246 }
22247 ecode1 = SWIG_AsVal_double(args(0), &val1);
22248 if (!SWIG_IsOK(ecode1)) {
22249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22250 }
22251 arg1 = static_cast< PLFLT >(val1);
22252 ecode2 = SWIG_AsVal_double(args(1), &val2);
22253 if (!SWIG_IsOK(ecode2)) {
22254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22255 }
22256 arg2 = static_cast< PLFLT >(val2);
22257 ecode3 = SWIG_AsVal_double(args(2), &val3);
22258 if (!SWIG_IsOK(ecode3)) {
22259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22260 }
22261 arg3 = static_cast< PLFLT >(val3);
22262 ecode4 = SWIG_AsVal_double(args(3), &val4);
22263 if (!SWIG_IsOK(ecode4)) {
22264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22265 }
22266 arg4 = static_cast< PLFLT >(val4);
22267 ecode5 = SWIG_AsVal_double(args(4), &val5);
22268 if (!SWIG_IsOK(ecode5)) {
22269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22270 }
22271 arg5 = static_cast< PLFLT >(val5);
22272 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22273 if (!SWIG_IsOK(res6)) {
22274 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22275 }
22276 arg6 = reinterpret_cast< char * >(buf6);
22277 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22278 _outv = octave_value();
22279 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22280 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22281 return _out;
22282 fail:
22283 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22284 return octave_value_list();
22285 }
22286 catch(...) {
22287 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22288 throw;
22289 }
22290}
22291
22292
22294 PLFLT arg1 ;
22295 PLFLT arg2 ;
22296 PLFLT arg3 ;
22297 PLFLT arg4 ;
22298 PLFLT arg5 ;
22299 PLFLT arg6 ;
22300 PLFLT arg7 ;
22301 PLFLT arg8 ;
22302 PLFLT arg9 ;
22303 PLFLT arg10 ;
22304 char *arg11 = (char *) 0 ;
22305 double val1 ;
22306 int ecode1 = 0 ;
22307 double val2 ;
22308 int ecode2 = 0 ;
22309 double val3 ;
22310 int ecode3 = 0 ;
22311 double val4 ;
22312 int ecode4 = 0 ;
22313 double val5 ;
22314 int ecode5 = 0 ;
22315 double val6 ;
22316 int ecode6 = 0 ;
22317 double val7 ;
22318 int ecode7 = 0 ;
22319 double val8 ;
22320 int ecode8 = 0 ;
22321 double val9 ;
22322 int ecode9 = 0 ;
22323 double val10 ;
22324 int ecode10 = 0 ;
22325 int res11 ;
22326 char *buf11 = 0 ;
22327 int alloc11 = 0 ;
22328 octave_value_list _out;
22329 octave_value_list *_outp=&_out;
22330 octave_value _outv;
22331
22332 try {
22333 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22334 SWIG_fail;
22335 }
22336 ecode1 = SWIG_AsVal_double(args(0), &val1);
22337 if (!SWIG_IsOK(ecode1)) {
22338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22339 }
22340 arg1 = static_cast< PLFLT >(val1);
22341 ecode2 = SWIG_AsVal_double(args(1), &val2);
22342 if (!SWIG_IsOK(ecode2)) {
22343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22344 }
22345 arg2 = static_cast< PLFLT >(val2);
22346 ecode3 = SWIG_AsVal_double(args(2), &val3);
22347 if (!SWIG_IsOK(ecode3)) {
22348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22349 }
22350 arg3 = static_cast< PLFLT >(val3);
22351 ecode4 = SWIG_AsVal_double(args(3), &val4);
22352 if (!SWIG_IsOK(ecode4)) {
22353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22354 }
22355 arg4 = static_cast< PLFLT >(val4);
22356 ecode5 = SWIG_AsVal_double(args(4), &val5);
22357 if (!SWIG_IsOK(ecode5)) {
22358 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22359 }
22360 arg5 = static_cast< PLFLT >(val5);
22361 ecode6 = SWIG_AsVal_double(args(5), &val6);
22362 if (!SWIG_IsOK(ecode6)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22364 }
22365 arg6 = static_cast< PLFLT >(val6);
22366 ecode7 = SWIG_AsVal_double(args(6), &val7);
22367 if (!SWIG_IsOK(ecode7)) {
22368 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22369 }
22370 arg7 = static_cast< PLFLT >(val7);
22371 ecode8 = SWIG_AsVal_double(args(7), &val8);
22372 if (!SWIG_IsOK(ecode8)) {
22373 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22374 }
22375 arg8 = static_cast< PLFLT >(val8);
22376 ecode9 = SWIG_AsVal_double(args(8), &val9);
22377 if (!SWIG_IsOK(ecode9)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22379 }
22380 arg9 = static_cast< PLFLT >(val9);
22381 ecode10 = SWIG_AsVal_double(args(9), &val10);
22382 if (!SWIG_IsOK(ecode10)) {
22383 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22384 }
22385 arg10 = static_cast< PLFLT >(val10);
22386 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22387 if (!SWIG_IsOK(res11)) {
22388 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22389 }
22390 arg11 = reinterpret_cast< char * >(buf11);
22391 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22392 _outv = octave_value();
22393 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22394 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22395 return _out;
22396 fail:
22397 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22398 return octave_value_list();
22399 }
22400 catch(...) {
22401 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22402 throw;
22403 }
22404}
22405
22406
22408 octave_value_list _out;
22409 octave_value_list *_outp=&_out;
22410 octave_value _outv;
22411 PLFLT result;
22412
22413 try {
22414 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22415 SWIG_fail;
22416 }
22417 result = (PLFLT)plrandd();
22418 _outv = SWIG_From_double(static_cast< double >(result));
22419 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22420 return _out;
22421 fail:
22422 return octave_value_list();
22423 }
22424 catch(...) {
22425 throw;
22426 }
22427}
22428
22429
22431 octave_value_list _out;
22432 octave_value_list *_outp=&_out;
22433 octave_value _outv;
22434
22435 try {
22436 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22437 SWIG_fail;
22438 }
22439 plreplot();
22440 _outv = octave_value();
22441 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22442 return _out;
22443 fail:
22444 return octave_value_list();
22445 }
22446 catch(...) {
22447 throw;
22448 }
22449}
22450
22451
22453 PLFLT arg1 ;
22454 PLFLT arg2 ;
22455 PLFLT arg3 ;
22456 PLFLT *arg4 = (PLFLT *) 0 ;
22457 PLFLT *arg5 = (PLFLT *) 0 ;
22458 PLFLT *arg6 = (PLFLT *) 0 ;
22459 double val1 ;
22460 int ecode1 = 0 ;
22461 double val2 ;
22462 int ecode2 = 0 ;
22463 double val3 ;
22464 int ecode3 = 0 ;
22465 PLFLT temp4 ;
22466 int res4 = SWIG_TMPOBJ ;
22467 PLFLT temp5 ;
22468 int res5 = SWIG_TMPOBJ ;
22469 PLFLT temp6 ;
22470 int res6 = SWIG_TMPOBJ ;
22471 octave_value_list _out;
22472 octave_value_list *_outp=&_out;
22473 octave_value _outv;
22474
22475 try {
22476 arg4 = &temp4;
22477 arg5 = &temp5;
22478 arg6 = &temp6;
22479 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22480 SWIG_fail;
22481 }
22482 ecode1 = SWIG_AsVal_double(args(0), &val1);
22483 if (!SWIG_IsOK(ecode1)) {
22484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22485 }
22486 arg1 = static_cast< PLFLT >(val1);
22487 ecode2 = SWIG_AsVal_double(args(1), &val2);
22488 if (!SWIG_IsOK(ecode2)) {
22489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22490 }
22491 arg2 = static_cast< PLFLT >(val2);
22492 ecode3 = SWIG_AsVal_double(args(2), &val3);
22493 if (!SWIG_IsOK(ecode3)) {
22494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22495 }
22496 arg3 = static_cast< PLFLT >(val3);
22497 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22498 _outv = octave_value();
22499 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22500 if (SWIG_IsTmpObj(res4)) {
22501 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22502 } else {
22503 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22504 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22505 }
22506 if (SWIG_IsTmpObj(res5)) {
22507 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22508 } else {
22509 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22510 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22511 }
22512 if (SWIG_IsTmpObj(res6)) {
22513 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22514 } else {
22515 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22516 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22517 }
22518 return _out;
22519 fail:
22520 return octave_value_list();
22521 }
22522 catch(...) {
22523 throw;
22524 }
22525}
22526
22527
22529 PLFLT arg1 ;
22530 PLFLT arg2 ;
22531 double val1 ;
22532 int ecode1 = 0 ;
22533 double val2 ;
22534 int ecode2 = 0 ;
22535 octave_value_list _out;
22536 octave_value_list *_outp=&_out;
22537 octave_value _outv;
22538
22539 try {
22540 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22541 SWIG_fail;
22542 }
22543 ecode1 = SWIG_AsVal_double(args(0), &val1);
22544 if (!SWIG_IsOK(ecode1)) {
22545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22546 }
22547 arg1 = static_cast< PLFLT >(val1);
22548 ecode2 = SWIG_AsVal_double(args(1), &val2);
22549 if (!SWIG_IsOK(ecode2)) {
22550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22551 }
22552 arg2 = static_cast< PLFLT >(val2);
22553 plschr(arg1,arg2);
22554 _outv = octave_value();
22555 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22556 return _out;
22557 fail:
22558 return octave_value_list();
22559 }
22560 catch(...) {
22561 throw;
22562 }
22563}
22564
22565
22567 PLINT *arg1 = (PLINT *) 0 ;
22568 PLINT *arg2 = (PLINT *) 0 ;
22569 PLINT *arg3 = (PLINT *) 0 ;
22570 PLINT arg4 ;
22571 Matrix temp1 ;
22572 Matrix temp2 ;
22573 Matrix temp3 ;
22574 octave_value_list _out;
22575 octave_value_list *_outp=&_out;
22576 octave_value _outv;
22577
22578 try {
22579 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22580 SWIG_fail;
22581 }
22582 {
22583 if ( _n_dims( args(0) ) > 1 )
22584 {
22585 error( "argument must be a scalar or vector" ); SWIG_fail;
22586 }
22587 Alen = (PLINT) ( _dim( args(0), 0 ) );
22588 temp1 = args(0).matrix_value();
22589 arg1 = new PLINT[Alen];
22590 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22591 }
22592 {
22593 if ( _n_dims( args(1) ) > 1 )
22594 {
22595 error( "argument must be a scalar or vector" ); SWIG_fail;
22596 }
22597 if ( _dim( args(1), 0 ) != Alen )
22598 {
22599 error( "argument vectors must be same length" ); SWIG_fail;
22600 }
22601 temp2 = args(1).matrix_value();
22602 arg2 = new PLINT[Alen];
22603 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22604 }
22605 {
22606 if ( _n_dims( args(2) ) > 1 )
22607 {
22608 error( "argument must be a scalar or vector" ); SWIG_fail;
22609 }
22610 if ( _dim( args(2), 0 ) != Alen )
22611 {
22612 error( "argument vectors must be same length" ); SWIG_fail;
22613 }
22614 temp3 = args(2).matrix_value();
22615 arg3 = new PLINT[Alen];
22616 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22617 arg4 = Alen;
22618 }
22619 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22620 _outv = octave_value();
22621 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22622 {
22623 delete [] arg1;
22624 }
22625 {
22626 delete [] arg2;
22627 }
22628 {
22629 delete [] arg3;
22630 }
22631 return _out;
22632 fail:
22633 {
22634 delete [] arg1;
22635 }
22636 {
22637 delete [] arg2;
22638 }
22639 {
22640 delete [] arg3;
22641 }
22642 return octave_value_list();
22643 }
22644 catch(...) {
22645 {
22646 delete [] arg1;
22647 }
22648 {
22649 delete [] arg2;
22650 }
22651 {
22652 delete [] arg3;
22653 }
22654 throw;
22655 }
22656}
22657
22658
22660 PLINT *arg1 = (PLINT *) 0 ;
22661 PLINT *arg2 = (PLINT *) 0 ;
22662 PLINT *arg3 = (PLINT *) 0 ;
22663 PLFLT *arg4 = (PLFLT *) 0 ;
22664 PLINT arg5 ;
22665 Matrix temp1 ;
22666 Matrix temp2 ;
22667 Matrix temp3 ;
22668 Matrix temp4 ;
22669 octave_value_list _out;
22670 octave_value_list *_outp=&_out;
22671 octave_value _outv;
22672
22673 try {
22674 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22675 SWIG_fail;
22676 }
22677 {
22678 if ( _n_dims( args(0) ) > 1 )
22679 {
22680 error( "argument must be a scalar or vector" ); SWIG_fail;
22681 }
22682 Alen = (PLINT) ( _dim( args(0), 0 ) );
22683 temp1 = args(0).matrix_value();
22684 arg1 = new PLINT[Alen];
22685 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22686 }
22687 {
22688 if ( _n_dims( args(1) ) > 1 )
22689 {
22690 error( "argument must be a scalar or vector" ); SWIG_fail;
22691 }
22692 if ( _dim( args(1), 0 ) != Alen )
22693 {
22694 error( "argument vectors must be same length" ); SWIG_fail;
22695 }
22696 temp2 = args(1).matrix_value();
22697 arg2 = new PLINT[Alen];
22698 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22699 }
22700 {
22701 if ( _n_dims( args(2) ) > 1 )
22702 {
22703 error( "argument must be a scalar or vector" ); SWIG_fail;
22704 }
22705 if ( _dim( args(2), 0 ) != Alen )
22706 {
22707 error( "argument vectors must be same length" ); SWIG_fail;
22708 }
22709 temp3 = args(2).matrix_value();
22710 arg3 = new PLINT[Alen];
22711 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22712 }
22713 {
22714 if ( _n_dims( args(3) ) > 1 )
22715 {
22716 error( "argument must be a scalar or vector" ); SWIG_fail;
22717 }
22718 if ( _dim( args(3), 0 ) != Alen )
22719 {
22720 error( "argument vectors must be same length" ); SWIG_fail;
22721 }
22722 temp4 = args(3).matrix_value();
22723 arg4 = &temp4( 0, 0 );
22724 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22725 }
22726 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22727 _outv = octave_value();
22728 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22729 {
22730 delete [] arg1;
22731 }
22732 {
22733 delete [] arg2;
22734 }
22735 {
22736 delete [] arg3;
22737 }
22738 {
22739
22740 }
22741 return _out;
22742 fail:
22743 {
22744 delete [] arg1;
22745 }
22746 {
22747 delete [] arg2;
22748 }
22749 {
22750 delete [] arg3;
22751 }
22752 {
22753
22754 }
22755 return octave_value_list();
22756 }
22757 catch(...) {
22758 {
22759 delete [] arg1;
22760 }
22761 {
22762 delete [] arg2;
22763 }
22764 {
22765 delete [] arg3;
22766 }
22767 {
22768
22769 }
22770 throw;
22771 }
22772}
22773
22774
22776 PLINT arg1 ;
22777 int val1 ;
22778 int ecode1 = 0 ;
22779 octave_value_list _out;
22780 octave_value_list *_outp=&_out;
22781 octave_value _outv;
22782
22783 try {
22784 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22785 SWIG_fail;
22786 }
22787 ecode1 = SWIG_AsVal_int(args(0), &val1);
22788 if (!SWIG_IsOK(ecode1)) {
22789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22790 }
22791 arg1 = static_cast< PLINT >(val1);
22792 plscmap0n(arg1);
22793 _outv = octave_value();
22794 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22795 return _out;
22796 fail:
22797 return octave_value_list();
22798 }
22799 catch(...) {
22800 throw;
22801 }
22802}
22803
22804
22806 PLINT *arg1 = (PLINT *) 0 ;
22807 PLINT *arg2 = (PLINT *) 0 ;
22808 PLINT *arg3 = (PLINT *) 0 ;
22809 PLINT arg4 ;
22810 Matrix temp1 ;
22811 Matrix temp2 ;
22812 Matrix temp3 ;
22813 octave_value_list _out;
22814 octave_value_list *_outp=&_out;
22815 octave_value _outv;
22816
22817 try {
22818 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22819 SWIG_fail;
22820 }
22821 {
22822 if ( _n_dims( args(0) ) > 1 )
22823 {
22824 error( "argument must be a scalar or vector" ); SWIG_fail;
22825 }
22826 Alen = (PLINT) ( _dim( args(0), 0 ) );
22827 temp1 = args(0).matrix_value();
22828 arg1 = new PLINT[Alen];
22829 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22830 }
22831 {
22832 if ( _n_dims( args(1) ) > 1 )
22833 {
22834 error( "argument must be a scalar or vector" ); SWIG_fail;
22835 }
22836 if ( _dim( args(1), 0 ) != Alen )
22837 {
22838 error( "argument vectors must be same length" ); SWIG_fail;
22839 }
22840 temp2 = args(1).matrix_value();
22841 arg2 = new PLINT[Alen];
22842 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22843 }
22844 {
22845 if ( _n_dims( args(2) ) > 1 )
22846 {
22847 error( "argument must be a scalar or vector" ); SWIG_fail;
22848 }
22849 if ( _dim( args(2), 0 ) != Alen )
22850 {
22851 error( "argument vectors must be same length" ); SWIG_fail;
22852 }
22853 temp3 = args(2).matrix_value();
22854 arg3 = new PLINT[Alen];
22855 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22856 arg4 = Alen;
22857 }
22858 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22859 _outv = octave_value();
22860 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22861 {
22862 delete [] arg1;
22863 }
22864 {
22865 delete [] arg2;
22866 }
22867 {
22868 delete [] arg3;
22869 }
22870 return _out;
22871 fail:
22872 {
22873 delete [] arg1;
22874 }
22875 {
22876 delete [] arg2;
22877 }
22878 {
22879 delete [] arg3;
22880 }
22881 return octave_value_list();
22882 }
22883 catch(...) {
22884 {
22885 delete [] arg1;
22886 }
22887 {
22888 delete [] arg2;
22889 }
22890 {
22891 delete [] arg3;
22892 }
22893 throw;
22894 }
22895}
22896
22897
22899 PLINT *arg1 = (PLINT *) 0 ;
22900 PLINT *arg2 = (PLINT *) 0 ;
22901 PLINT *arg3 = (PLINT *) 0 ;
22902 PLFLT *arg4 = (PLFLT *) 0 ;
22903 PLINT arg5 ;
22904 Matrix temp1 ;
22905 Matrix temp2 ;
22906 Matrix temp3 ;
22907 Matrix temp4 ;
22908 octave_value_list _out;
22909 octave_value_list *_outp=&_out;
22910 octave_value _outv;
22911
22912 try {
22913 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22914 SWIG_fail;
22915 }
22916 {
22917 if ( _n_dims( args(0) ) > 1 )
22918 {
22919 error( "argument must be a scalar or vector" ); SWIG_fail;
22920 }
22921 Alen = (PLINT) ( _dim( args(0), 0 ) );
22922 temp1 = args(0).matrix_value();
22923 arg1 = new PLINT[Alen];
22924 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22925 }
22926 {
22927 if ( _n_dims( args(1) ) > 1 )
22928 {
22929 error( "argument must be a scalar or vector" ); SWIG_fail;
22930 }
22931 if ( _dim( args(1), 0 ) != Alen )
22932 {
22933 error( "argument vectors must be same length" ); SWIG_fail;
22934 }
22935 temp2 = args(1).matrix_value();
22936 arg2 = new PLINT[Alen];
22937 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22938 }
22939 {
22940 if ( _n_dims( args(2) ) > 1 )
22941 {
22942 error( "argument must be a scalar or vector" ); SWIG_fail;
22943 }
22944 if ( _dim( args(2), 0 ) != Alen )
22945 {
22946 error( "argument vectors must be same length" ); SWIG_fail;
22947 }
22948 temp3 = args(2).matrix_value();
22949 arg3 = new PLINT[Alen];
22950 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22951 }
22952 {
22953 if ( _n_dims( args(3) ) > 1 )
22954 {
22955 error( "argument must be a scalar or vector" ); SWIG_fail;
22956 }
22957 if ( _dim( args(3), 0 ) != Alen )
22958 {
22959 error( "argument vectors must be same length" ); SWIG_fail;
22960 }
22961 temp4 = args(3).matrix_value();
22962 arg4 = &temp4( 0, 0 );
22963 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22964 }
22965 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22966 _outv = octave_value();
22967 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22968 {
22969 delete [] arg1;
22970 }
22971 {
22972 delete [] arg2;
22973 }
22974 {
22975 delete [] arg3;
22976 }
22977 {
22978
22979 }
22980 return _out;
22981 fail:
22982 {
22983 delete [] arg1;
22984 }
22985 {
22986 delete [] arg2;
22987 }
22988 {
22989 delete [] arg3;
22990 }
22991 {
22992
22993 }
22994 return octave_value_list();
22995 }
22996 catch(...) {
22997 {
22998 delete [] arg1;
22999 }
23000 {
23001 delete [] arg2;
23002 }
23003 {
23004 delete [] arg3;
23005 }
23006 {
23007
23008 }
23009 throw;
23010 }
23011}
23012
23013
23015 PLBOOL arg1 ;
23016 PLINT arg2 ;
23017 PLFLT *arg3 = (PLFLT *) 0 ;
23018 PLFLT *arg4 = (PLFLT *) 0 ;
23019 PLFLT *arg5 = (PLFLT *) 0 ;
23020 PLFLT *arg6 = (PLFLT *) 0 ;
23021 PLBOOL *arg7 = (PLBOOL *) 0 ;
23022 int val1 ;
23023 int ecode1 = 0 ;
23024 Matrix temp2 ;
23025 Matrix temp4 ;
23026 Matrix temp5 ;
23027 Matrix temp6 ;
23028 Matrix temp7 ;
23029 octave_value_list _out;
23030 octave_value_list *_outp=&_out;
23031 octave_value _outv;
23032
23033 try {
23034 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
23035 SWIG_fail;
23036 }
23037 ecode1 = SWIG_AsVal_int(args(0), &val1);
23038 if (!SWIG_IsOK(ecode1)) {
23039 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
23040 }
23041 arg1 = static_cast< PLBOOL >(val1);
23042 {
23043 if ( _n_dims( args(1) ) > 1 )
23044 {
23045 error( "argument must be a scalar or vector" ); SWIG_fail;
23046 }
23047 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23048 temp2 = args(1).matrix_value();
23049 arg3 = &temp2( 0, 0 );
23050 }
23051 {
23052 if ( _n_dims( args(2) ) > 1 )
23053 {
23054 error( "argument must be a scalar or vector" ); SWIG_fail;
23055 }
23056 if ( _dim( args(2), 0 ) != Alen )
23057 {
23058 error( "argument vectors must be same length" ); SWIG_fail;
23059 }
23060 temp4 = args(2).matrix_value();
23061 arg4 = &temp4( 0, 0 );
23062 }
23063 {
23064 if ( _n_dims( args(3) ) > 1 )
23065 {
23066 error( "argument must be a scalar or vector" ); SWIG_fail;
23067 }
23068 if ( _dim( args(3), 0 ) != Alen )
23069 {
23070 error( "argument vectors must be same length" ); SWIG_fail;
23071 }
23072 temp5 = args(3).matrix_value();
23073 arg5 = &temp5( 0, 0 );
23074 }
23075 {
23076 if ( _n_dims( args(4) ) > 1 )
23077 {
23078 error( "argument must be a scalar or vector" ); SWIG_fail;
23079 }
23080 if ( _dim( args(4), 0 ) != Alen )
23081 {
23082 error( "argument vectors must be same length" ); SWIG_fail;
23083 }
23084 temp6 = args(4).matrix_value();
23085 arg6 = &temp6( 0, 0 );
23086 }
23087 {
23088 if ( _n_dims( args(5) ) > 1 )
23089 {
23090 error( "argument must be a scalar or vector" ); SWIG_fail;
23091 }
23092 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23093 {
23094 error( "argument vector must be same length or one less" ); SWIG_fail;
23095 }
23096 temp7 = args(5).matrix_value();
23097 arg7 = new PLINT[Alen];
23098 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23099 }
23100 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23101 _outv = octave_value();
23102 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23103 {
23104
23105 }
23106 {
23107
23108 }
23109 {
23110
23111 }
23112 {
23113
23114 }
23115 {
23116 delete [] arg7;
23117 }
23118 return _out;
23119 fail:
23120 {
23121
23122 }
23123 {
23124
23125 }
23126 {
23127
23128 }
23129 {
23130
23131 }
23132 {
23133 delete [] arg7;
23134 }
23135 return octave_value_list();
23136 }
23137 catch(...) {
23138 {
23139
23140 }
23141 {
23142
23143 }
23144 {
23145
23146 }
23147 {
23148
23149 }
23150 {
23151 delete [] arg7;
23152 }
23153 throw;
23154 }
23155}
23156
23157
23159 PLBOOL arg1 ;
23160 PLINT arg2 ;
23161 PLFLT *arg3 = (PLFLT *) 0 ;
23162 PLFLT *arg4 = (PLFLT *) 0 ;
23163 PLFLT *arg5 = (PLFLT *) 0 ;
23164 PLFLT *arg6 = (PLFLT *) 0 ;
23165 PLFLT *arg7 = (PLFLT *) 0 ;
23166 PLBOOL *arg8 = (PLBOOL *) 0 ;
23167 int val1 ;
23168 int ecode1 = 0 ;
23169 Matrix temp2 ;
23170 Matrix temp4 ;
23171 Matrix temp5 ;
23172 Matrix temp6 ;
23173 Matrix temp7 ;
23174 Matrix temp8 ;
23175 octave_value_list _out;
23176 octave_value_list *_outp=&_out;
23177 octave_value _outv;
23178
23179 try {
23180 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23181 SWIG_fail;
23182 }
23183 ecode1 = SWIG_AsVal_int(args(0), &val1);
23184 if (!SWIG_IsOK(ecode1)) {
23185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23186 }
23187 arg1 = static_cast< PLBOOL >(val1);
23188 {
23189 if ( _n_dims( args(1) ) > 1 )
23190 {
23191 error( "argument must be a scalar or vector" ); SWIG_fail;
23192 }
23193 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23194 temp2 = args(1).matrix_value();
23195 arg3 = &temp2( 0, 0 );
23196 }
23197 {
23198 if ( _n_dims( args(2) ) > 1 )
23199 {
23200 error( "argument must be a scalar or vector" ); SWIG_fail;
23201 }
23202 if ( _dim( args(2), 0 ) != Alen )
23203 {
23204 error( "argument vectors must be same length" ); SWIG_fail;
23205 }
23206 temp4 = args(2).matrix_value();
23207 arg4 = &temp4( 0, 0 );
23208 }
23209 {
23210 if ( _n_dims( args(3) ) > 1 )
23211 {
23212 error( "argument must be a scalar or vector" ); SWIG_fail;
23213 }
23214 if ( _dim( args(3), 0 ) != Alen )
23215 {
23216 error( "argument vectors must be same length" ); SWIG_fail;
23217 }
23218 temp5 = args(3).matrix_value();
23219 arg5 = &temp5( 0, 0 );
23220 }
23221 {
23222 if ( _n_dims( args(4) ) > 1 )
23223 {
23224 error( "argument must be a scalar or vector" ); SWIG_fail;
23225 }
23226 if ( _dim( args(4), 0 ) != Alen )
23227 {
23228 error( "argument vectors must be same length" ); SWIG_fail;
23229 }
23230 temp6 = args(4).matrix_value();
23231 arg6 = &temp6( 0, 0 );
23232 }
23233 {
23234 if ( _n_dims( args(5) ) > 1 )
23235 {
23236 error( "argument must be a scalar or vector" ); SWIG_fail;
23237 }
23238 if ( _dim( args(5), 0 ) != Alen )
23239 {
23240 error( "argument vectors must be same length" ); SWIG_fail;
23241 }
23242 temp7 = args(5).matrix_value();
23243 arg7 = &temp7( 0, 0 );
23244 }
23245 {
23246 if ( _n_dims( args(6) ) > 1 )
23247 {
23248 error( "argument must be a scalar or vector" ); SWIG_fail;
23249 }
23250 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23251 {
23252 error( "argument vector must be same length or one less" ); SWIG_fail;
23253 }
23254 temp8 = args(6).matrix_value();
23255 arg8 = new PLINT[Alen];
23256 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23257 }
23258 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23259 _outv = octave_value();
23260 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23261 {
23262
23263 }
23264 {
23265
23266 }
23267 {
23268
23269 }
23270 {
23271
23272 }
23273 {
23274
23275 }
23276 {
23277 delete [] arg8;
23278 }
23279 return _out;
23280 fail:
23281 {
23282
23283 }
23284 {
23285
23286 }
23287 {
23288
23289 }
23290 {
23291
23292 }
23293 {
23294
23295 }
23296 {
23297 delete [] arg8;
23298 }
23299 return octave_value_list();
23300 }
23301 catch(...) {
23302 {
23303
23304 }
23305 {
23306
23307 }
23308 {
23309
23310 }
23311 {
23312
23313 }
23314 {
23315
23316 }
23317 {
23318 delete [] arg8;
23319 }
23320 throw;
23321 }
23322}
23323
23324
23326 PLINT arg1 ;
23327 int val1 ;
23328 int ecode1 = 0 ;
23329 octave_value_list _out;
23330 octave_value_list *_outp=&_out;
23331 octave_value _outv;
23332
23333 try {
23334 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23335 SWIG_fail;
23336 }
23337 ecode1 = SWIG_AsVal_int(args(0), &val1);
23338 if (!SWIG_IsOK(ecode1)) {
23339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23340 }
23341 arg1 = static_cast< PLINT >(val1);
23342 plscmap1n(arg1);
23343 _outv = octave_value();
23344 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23345 return _out;
23346 fail:
23347 return octave_value_list();
23348 }
23349 catch(...) {
23350 throw;
23351 }
23352}
23353
23354
23356 PLFLT arg1 ;
23357 PLFLT arg2 ;
23358 double val1 ;
23359 int ecode1 = 0 ;
23360 double val2 ;
23361 int ecode2 = 0 ;
23362 octave_value_list _out;
23363 octave_value_list *_outp=&_out;
23364 octave_value _outv;
23365
23366 try {
23367 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23368 SWIG_fail;
23369 }
23370 ecode1 = SWIG_AsVal_double(args(0), &val1);
23371 if (!SWIG_IsOK(ecode1)) {
23372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23373 }
23374 arg1 = static_cast< PLFLT >(val1);
23375 ecode2 = SWIG_AsVal_double(args(1), &val2);
23376 if (!SWIG_IsOK(ecode2)) {
23377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23378 }
23379 arg2 = static_cast< PLFLT >(val2);
23380 plscmap1_range(arg1,arg2);
23381 _outv = octave_value();
23382 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23383 return _out;
23384 fail:
23385 return octave_value_list();
23386 }
23387 catch(...) {
23388 throw;
23389 }
23390}
23391
23392
23394 PLFLT *arg1 = (PLFLT *) 0 ;
23395 PLFLT *arg2 = (PLFLT *) 0 ;
23396 PLFLT temp1 ;
23397 int res1 = SWIG_TMPOBJ ;
23398 PLFLT temp2 ;
23399 int res2 = SWIG_TMPOBJ ;
23400 octave_value_list _out;
23401 octave_value_list *_outp=&_out;
23402 octave_value _outv;
23403
23404 try {
23405 arg1 = &temp1;
23406 arg2 = &temp2;
23407 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23408 SWIG_fail;
23409 }
23410 plgcmap1_range(arg1,arg2);
23411 _outv = octave_value();
23412 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23413 if (SWIG_IsTmpObj(res1)) {
23414 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23415 } else {
23416 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23417 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23418 }
23419 if (SWIG_IsTmpObj(res2)) {
23420 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23421 } else {
23422 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23423 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23424 }
23425 return _out;
23426 fail:
23427 return octave_value_list();
23428 }
23429 catch(...) {
23430 throw;
23431 }
23432}
23433
23434
23436 PLINT arg1 ;
23437 PLINT arg2 ;
23438 PLINT arg3 ;
23439 PLINT arg4 ;
23440 int val1 ;
23441 int ecode1 = 0 ;
23442 int val2 ;
23443 int ecode2 = 0 ;
23444 int val3 ;
23445 int ecode3 = 0 ;
23446 int val4 ;
23447 int ecode4 = 0 ;
23448 octave_value_list _out;
23449 octave_value_list *_outp=&_out;
23450 octave_value _outv;
23451
23452 try {
23453 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23454 SWIG_fail;
23455 }
23456 ecode1 = SWIG_AsVal_int(args(0), &val1);
23457 if (!SWIG_IsOK(ecode1)) {
23458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23459 }
23460 arg1 = static_cast< PLINT >(val1);
23461 ecode2 = SWIG_AsVal_int(args(1), &val2);
23462 if (!SWIG_IsOK(ecode2)) {
23463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23464 }
23465 arg2 = static_cast< PLINT >(val2);
23466 ecode3 = SWIG_AsVal_int(args(2), &val3);
23467 if (!SWIG_IsOK(ecode3)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23469 }
23470 arg3 = static_cast< PLINT >(val3);
23471 ecode4 = SWIG_AsVal_int(args(3), &val4);
23472 if (!SWIG_IsOK(ecode4)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23474 }
23475 arg4 = static_cast< PLINT >(val4);
23476 plscol0(arg1,arg2,arg3,arg4);
23477 _outv = octave_value();
23478 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23479 return _out;
23480 fail:
23481 return octave_value_list();
23482 }
23483 catch(...) {
23484 throw;
23485 }
23486}
23487
23488
23490 PLINT arg1 ;
23491 PLINT arg2 ;
23492 PLINT arg3 ;
23493 PLINT arg4 ;
23494 PLFLT arg5 ;
23495 int val1 ;
23496 int ecode1 = 0 ;
23497 int val2 ;
23498 int ecode2 = 0 ;
23499 int val3 ;
23500 int ecode3 = 0 ;
23501 int val4 ;
23502 int ecode4 = 0 ;
23503 double val5 ;
23504 int ecode5 = 0 ;
23505 octave_value_list _out;
23506 octave_value_list *_outp=&_out;
23507 octave_value _outv;
23508
23509 try {
23510 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23511 SWIG_fail;
23512 }
23513 ecode1 = SWIG_AsVal_int(args(0), &val1);
23514 if (!SWIG_IsOK(ecode1)) {
23515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23516 }
23517 arg1 = static_cast< PLINT >(val1);
23518 ecode2 = SWIG_AsVal_int(args(1), &val2);
23519 if (!SWIG_IsOK(ecode2)) {
23520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23521 }
23522 arg2 = static_cast< PLINT >(val2);
23523 ecode3 = SWIG_AsVal_int(args(2), &val3);
23524 if (!SWIG_IsOK(ecode3)) {
23525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23526 }
23527 arg3 = static_cast< PLINT >(val3);
23528 ecode4 = SWIG_AsVal_int(args(3), &val4);
23529 if (!SWIG_IsOK(ecode4)) {
23530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23531 }
23532 arg4 = static_cast< PLINT >(val4);
23533 ecode5 = SWIG_AsVal_double(args(4), &val5);
23534 if (!SWIG_IsOK(ecode5)) {
23535 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23536 }
23537 arg5 = static_cast< PLFLT >(val5);
23538 plscol0a(arg1,arg2,arg3,arg4,arg5);
23539 _outv = octave_value();
23540 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23541 return _out;
23542 fail:
23543 return octave_value_list();
23544 }
23545 catch(...) {
23546 throw;
23547 }
23548}
23549
23550
23552 PLINT arg1 ;
23553 PLINT arg2 ;
23554 PLINT arg3 ;
23555 int val1 ;
23556 int ecode1 = 0 ;
23557 int val2 ;
23558 int ecode2 = 0 ;
23559 int val3 ;
23560 int ecode3 = 0 ;
23561 octave_value_list _out;
23562 octave_value_list *_outp=&_out;
23563 octave_value _outv;
23564
23565 try {
23566 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23567 SWIG_fail;
23568 }
23569 ecode1 = SWIG_AsVal_int(args(0), &val1);
23570 if (!SWIG_IsOK(ecode1)) {
23571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23572 }
23573 arg1 = static_cast< PLINT >(val1);
23574 ecode2 = SWIG_AsVal_int(args(1), &val2);
23575 if (!SWIG_IsOK(ecode2)) {
23576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23577 }
23578 arg2 = static_cast< PLINT >(val2);
23579 ecode3 = SWIG_AsVal_int(args(2), &val3);
23580 if (!SWIG_IsOK(ecode3)) {
23581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23582 }
23583 arg3 = static_cast< PLINT >(val3);
23584 plscolbg(arg1,arg2,arg3);
23585 _outv = octave_value();
23586 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23587 return _out;
23588 fail:
23589 return octave_value_list();
23590 }
23591 catch(...) {
23592 throw;
23593 }
23594}
23595
23596
23598 PLINT arg1 ;
23599 PLINT arg2 ;
23600 PLINT arg3 ;
23601 PLFLT arg4 ;
23602 int val1 ;
23603 int ecode1 = 0 ;
23604 int val2 ;
23605 int ecode2 = 0 ;
23606 int val3 ;
23607 int ecode3 = 0 ;
23608 double val4 ;
23609 int ecode4 = 0 ;
23610 octave_value_list _out;
23611 octave_value_list *_outp=&_out;
23612 octave_value _outv;
23613
23614 try {
23615 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23616 SWIG_fail;
23617 }
23618 ecode1 = SWIG_AsVal_int(args(0), &val1);
23619 if (!SWIG_IsOK(ecode1)) {
23620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23621 }
23622 arg1 = static_cast< PLINT >(val1);
23623 ecode2 = SWIG_AsVal_int(args(1), &val2);
23624 if (!SWIG_IsOK(ecode2)) {
23625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23626 }
23627 arg2 = static_cast< PLINT >(val2);
23628 ecode3 = SWIG_AsVal_int(args(2), &val3);
23629 if (!SWIG_IsOK(ecode3)) {
23630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23631 }
23632 arg3 = static_cast< PLINT >(val3);
23633 ecode4 = SWIG_AsVal_double(args(3), &val4);
23634 if (!SWIG_IsOK(ecode4)) {
23635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23636 }
23637 arg4 = static_cast< PLFLT >(val4);
23638 plscolbga(arg1,arg2,arg3,arg4);
23639 _outv = octave_value();
23640 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23641 return _out;
23642 fail:
23643 return octave_value_list();
23644 }
23645 catch(...) {
23646 throw;
23647 }
23648}
23649
23650
23652 PLINT arg1 ;
23653 int val1 ;
23654 int ecode1 = 0 ;
23655 octave_value_list _out;
23656 octave_value_list *_outp=&_out;
23657 octave_value _outv;
23658
23659 try {
23660 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23661 SWIG_fail;
23662 }
23663 ecode1 = SWIG_AsVal_int(args(0), &val1);
23664 if (!SWIG_IsOK(ecode1)) {
23665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23666 }
23667 arg1 = static_cast< PLINT >(val1);
23668 plscolor(arg1);
23669 _outv = octave_value();
23670 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23671 return _out;
23672 fail:
23673 return octave_value_list();
23674 }
23675 catch(...) {
23676 throw;
23677 }
23678}
23679
23680
23682 PLINT arg1 ;
23683 int val1 ;
23684 int ecode1 = 0 ;
23685 octave_value_list _out;
23686 octave_value_list *_outp=&_out;
23687 octave_value _outv;
23688
23689 try {
23690 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23691 SWIG_fail;
23692 }
23693 ecode1 = SWIG_AsVal_int(args(0), &val1);
23694 if (!SWIG_IsOK(ecode1)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23696 }
23697 arg1 = static_cast< PLINT >(val1);
23698 plscompression(arg1);
23699 _outv = octave_value();
23700 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23701 return _out;
23702 fail:
23703 return octave_value_list();
23704 }
23705 catch(...) {
23706 throw;
23707 }
23708}
23709
23710
23712 char *arg1 = (char *) 0 ;
23713 int res1 ;
23714 char *buf1 = 0 ;
23715 int alloc1 = 0 ;
23716 octave_value_list _out;
23717 octave_value_list *_outp=&_out;
23718 octave_value _outv;
23719
23720 try {
23721 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23722 SWIG_fail;
23723 }
23724 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23725 if (!SWIG_IsOK(res1)) {
23726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23727 }
23728 arg1 = reinterpret_cast< char * >(buf1);
23729 plsdev((char const *)arg1);
23730 _outv = octave_value();
23731 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23732 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23733 return _out;
23734 fail:
23735 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23736 return octave_value_list();
23737 }
23738 catch(...) {
23739 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23740 throw;
23741 }
23742}
23743
23744
23746 PLFLT arg1 ;
23747 PLFLT arg2 ;
23748 PLFLT arg3 ;
23749 PLFLT arg4 ;
23750 double val1 ;
23751 int ecode1 = 0 ;
23752 double val2 ;
23753 int ecode2 = 0 ;
23754 double val3 ;
23755 int ecode3 = 0 ;
23756 double val4 ;
23757 int ecode4 = 0 ;
23758 octave_value_list _out;
23759 octave_value_list *_outp=&_out;
23760 octave_value _outv;
23761
23762 try {
23763 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23764 SWIG_fail;
23765 }
23766 ecode1 = SWIG_AsVal_double(args(0), &val1);
23767 if (!SWIG_IsOK(ecode1)) {
23768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23769 }
23770 arg1 = static_cast< PLFLT >(val1);
23771 ecode2 = SWIG_AsVal_double(args(1), &val2);
23772 if (!SWIG_IsOK(ecode2)) {
23773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23774 }
23775 arg2 = static_cast< PLFLT >(val2);
23776 ecode3 = SWIG_AsVal_double(args(2), &val3);
23777 if (!SWIG_IsOK(ecode3)) {
23778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23779 }
23780 arg3 = static_cast< PLFLT >(val3);
23781 ecode4 = SWIG_AsVal_double(args(3), &val4);
23782 if (!SWIG_IsOK(ecode4)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23784 }
23785 arg4 = static_cast< PLFLT >(val4);
23786 plsdidev(arg1,arg2,arg3,arg4);
23787 _outv = octave_value();
23788 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23789 return _out;
23790 fail:
23791 return octave_value_list();
23792 }
23793 catch(...) {
23794 throw;
23795 }
23796}
23797
23798
23800 PLINT arg1 ;
23801 PLINT arg2 ;
23802 PLINT arg3 ;
23803 PLINT arg4 ;
23804 PLFLT arg5 ;
23805 PLFLT arg6 ;
23806 int val1 ;
23807 int ecode1 = 0 ;
23808 int val2 ;
23809 int ecode2 = 0 ;
23810 int val3 ;
23811 int ecode3 = 0 ;
23812 int val4 ;
23813 int ecode4 = 0 ;
23814 double val5 ;
23815 int ecode5 = 0 ;
23816 double val6 ;
23817 int ecode6 = 0 ;
23818 octave_value_list _out;
23819 octave_value_list *_outp=&_out;
23820 octave_value _outv;
23821
23822 try {
23823 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23824 SWIG_fail;
23825 }
23826 ecode1 = SWIG_AsVal_int(args(0), &val1);
23827 if (!SWIG_IsOK(ecode1)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23829 }
23830 arg1 = static_cast< PLINT >(val1);
23831 ecode2 = SWIG_AsVal_int(args(1), &val2);
23832 if (!SWIG_IsOK(ecode2)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23834 }
23835 arg2 = static_cast< PLINT >(val2);
23836 ecode3 = SWIG_AsVal_int(args(2), &val3);
23837 if (!SWIG_IsOK(ecode3)) {
23838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23839 }
23840 arg3 = static_cast< PLINT >(val3);
23841 ecode4 = SWIG_AsVal_int(args(3), &val4);
23842 if (!SWIG_IsOK(ecode4)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23844 }
23845 arg4 = static_cast< PLINT >(val4);
23846 ecode5 = SWIG_AsVal_double(args(4), &val5);
23847 if (!SWIG_IsOK(ecode5)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23849 }
23850 arg5 = static_cast< PLFLT >(val5);
23851 ecode6 = SWIG_AsVal_double(args(5), &val6);
23852 if (!SWIG_IsOK(ecode6)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23854 }
23855 arg6 = static_cast< PLFLT >(val6);
23856 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23857 _outv = octave_value();
23858 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23859 return _out;
23860 fail:
23861 return octave_value_list();
23862 }
23863 catch(...) {
23864 throw;
23865 }
23866}
23867
23868
23870 PLFLT arg1 ;
23871 double val1 ;
23872 int ecode1 = 0 ;
23873 octave_value_list _out;
23874 octave_value_list *_outp=&_out;
23875 octave_value _outv;
23876
23877 try {
23878 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23879 SWIG_fail;
23880 }
23881 ecode1 = SWIG_AsVal_double(args(0), &val1);
23882 if (!SWIG_IsOK(ecode1)) {
23883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23884 }
23885 arg1 = static_cast< PLFLT >(val1);
23886 plsdiori(arg1);
23887 _outv = octave_value();
23888 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23889 return _out;
23890 fail:
23891 return octave_value_list();
23892 }
23893 catch(...) {
23894 throw;
23895 }
23896}
23897
23898
23900 PLFLT arg1 ;
23901 PLFLT arg2 ;
23902 PLFLT arg3 ;
23903 PLFLT arg4 ;
23904 double val1 ;
23905 int ecode1 = 0 ;
23906 double val2 ;
23907 int ecode2 = 0 ;
23908 double val3 ;
23909 int ecode3 = 0 ;
23910 double val4 ;
23911 int ecode4 = 0 ;
23912 octave_value_list _out;
23913 octave_value_list *_outp=&_out;
23914 octave_value _outv;
23915
23916 try {
23917 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23918 SWIG_fail;
23919 }
23920 ecode1 = SWIG_AsVal_double(args(0), &val1);
23921 if (!SWIG_IsOK(ecode1)) {
23922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23923 }
23924 arg1 = static_cast< PLFLT >(val1);
23925 ecode2 = SWIG_AsVal_double(args(1), &val2);
23926 if (!SWIG_IsOK(ecode2)) {
23927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23928 }
23929 arg2 = static_cast< PLFLT >(val2);
23930 ecode3 = SWIG_AsVal_double(args(2), &val3);
23931 if (!SWIG_IsOK(ecode3)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23933 }
23934 arg3 = static_cast< PLFLT >(val3);
23935 ecode4 = SWIG_AsVal_double(args(3), &val4);
23936 if (!SWIG_IsOK(ecode4)) {
23937 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23938 }
23939 arg4 = static_cast< PLFLT >(val4);
23940 plsdiplt(arg1,arg2,arg3,arg4);
23941 _outv = octave_value();
23942 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23943 return _out;
23944 fail:
23945 return octave_value_list();
23946 }
23947 catch(...) {
23948 throw;
23949 }
23950}
23951
23952
23954 PLFLT arg1 ;
23955 PLFLT arg2 ;
23956 PLFLT arg3 ;
23957 PLFLT arg4 ;
23958 double val1 ;
23959 int ecode1 = 0 ;
23960 double val2 ;
23961 int ecode2 = 0 ;
23962 double val3 ;
23963 int ecode3 = 0 ;
23964 double val4 ;
23965 int ecode4 = 0 ;
23966 octave_value_list _out;
23967 octave_value_list *_outp=&_out;
23968 octave_value _outv;
23969
23970 try {
23971 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23972 SWIG_fail;
23973 }
23974 ecode1 = SWIG_AsVal_double(args(0), &val1);
23975 if (!SWIG_IsOK(ecode1)) {
23976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23977 }
23978 arg1 = static_cast< PLFLT >(val1);
23979 ecode2 = SWIG_AsVal_double(args(1), &val2);
23980 if (!SWIG_IsOK(ecode2)) {
23981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23982 }
23983 arg2 = static_cast< PLFLT >(val2);
23984 ecode3 = SWIG_AsVal_double(args(2), &val3);
23985 if (!SWIG_IsOK(ecode3)) {
23986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23987 }
23988 arg3 = static_cast< PLFLT >(val3);
23989 ecode4 = SWIG_AsVal_double(args(3), &val4);
23990 if (!SWIG_IsOK(ecode4)) {
23991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23992 }
23993 arg4 = static_cast< PLFLT >(val4);
23994 plsdiplz(arg1,arg2,arg3,arg4);
23995 _outv = octave_value();
23996 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23997 return _out;
23998 fail:
23999 return octave_value_list();
24000 }
24001 catch(...) {
24002 throw;
24003 }
24004}
24005
24006
24008 unsigned int arg1 ;
24009 unsigned int val1 ;
24010 int ecode1 = 0 ;
24011 octave_value_list _out;
24012 octave_value_list *_outp=&_out;
24013 octave_value _outv;
24014
24015 try {
24016 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
24017 SWIG_fail;
24018 }
24019 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24020 if (!SWIG_IsOK(ecode1)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
24022 }
24023 arg1 = static_cast< unsigned int >(val1);
24024 plseed(arg1);
24025 _outv = octave_value();
24026 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24027 return _out;
24028 fail:
24029 return octave_value_list();
24030 }
24031 catch(...) {
24032 throw;
24033 }
24034}
24035
24036
24038 char arg1 ;
24039 char val1 ;
24040 int ecode1 = 0 ;
24041 octave_value_list _out;
24042 octave_value_list *_outp=&_out;
24043 octave_value _outv;
24044
24045 try {
24046 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
24047 SWIG_fail;
24048 }
24049 ecode1 = SWIG_AsVal_char(args(0), &val1);
24050 if (!SWIG_IsOK(ecode1)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
24052 }
24053 arg1 = static_cast< char >(val1);
24054 plsesc(arg1);
24055 _outv = octave_value();
24056 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24057 return _out;
24058 fail:
24059 return octave_value_list();
24060 }
24061 catch(...) {
24062 throw;
24063 }
24064}
24065
24066
24067SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
24068 char *arg1 = (char *) 0 ;
24069 char *arg2 = (char *) 0 ;
24070 int res1 ;
24071 char *buf1 = 0 ;
24072 int alloc1 = 0 ;
24073 int res2 ;
24074 char *buf2 = 0 ;
24075 int alloc2 = 0 ;
24076 octave_value_list _out;
24077 octave_value_list *_outp=&_out;
24078 octave_value _outv;
24079 PLINT result;
24080
24081 try {
24082 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24083 SWIG_fail;
24084 }
24085 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24086 if (!SWIG_IsOK(res1)) {
24087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24088 }
24089 arg1 = reinterpret_cast< char * >(buf1);
24090 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24091 if (!SWIG_IsOK(res2)) {
24092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24093 }
24094 arg2 = reinterpret_cast< char * >(buf2);
24095 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24096 _outv = SWIG_From_int(static_cast< int >(result));
24097 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24098 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24099 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24100 return _out;
24101 fail:
24102 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24103 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24104 return octave_value_list();
24105 }
24106 catch(...) {
24107 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24108 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24109 throw;
24110 }
24111}
24112
24113
24115 PLINT arg1 ;
24116 PLINT arg2 ;
24117 PLINT arg3 ;
24118 int val1 ;
24119 int ecode1 = 0 ;
24120 int val2 ;
24121 int ecode2 = 0 ;
24122 int val3 ;
24123 int ecode3 = 0 ;
24124 octave_value_list _out;
24125 octave_value_list *_outp=&_out;
24126 octave_value _outv;
24127
24128 try {
24129 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24130 SWIG_fail;
24131 }
24132 ecode1 = SWIG_AsVal_int(args(0), &val1);
24133 if (!SWIG_IsOK(ecode1)) {
24134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24135 }
24136 arg1 = static_cast< PLINT >(val1);
24137 ecode2 = SWIG_AsVal_int(args(1), &val2);
24138 if (!SWIG_IsOK(ecode2)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24140 }
24141 arg2 = static_cast< PLINT >(val2);
24142 ecode3 = SWIG_AsVal_int(args(2), &val3);
24143 if (!SWIG_IsOK(ecode3)) {
24144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24145 }
24146 arg3 = static_cast< PLINT >(val3);
24147 plsfam(arg1,arg2,arg3);
24148 _outv = octave_value();
24149 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24150 return _out;
24151 fail:
24152 return octave_value_list();
24153 }
24154 catch(...) {
24155 throw;
24156 }
24157}
24158
24159
24161 PLUNICODE arg1 ;
24162 unsigned int val1 ;
24163 int ecode1 = 0 ;
24164 octave_value_list _out;
24165 octave_value_list *_outp=&_out;
24166 octave_value _outv;
24167
24168 try {
24169 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24170 SWIG_fail;
24171 }
24172 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24173 if (!SWIG_IsOK(ecode1)) {
24174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24175 }
24176 arg1 = static_cast< PLUNICODE >(val1);
24177 plsfci(arg1);
24178 _outv = octave_value();
24179 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24180 return _out;
24181 fail:
24182 return octave_value_list();
24183 }
24184 catch(...) {
24185 throw;
24186 }
24187}
24188
24189
24191 char *arg1 = (char *) 0 ;
24192 int res1 ;
24193 char *buf1 = 0 ;
24194 int alloc1 = 0 ;
24195 octave_value_list _out;
24196 octave_value_list *_outp=&_out;
24197 octave_value _outv;
24198
24199 try {
24200 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24201 SWIG_fail;
24202 }
24203 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24204 if (!SWIG_IsOK(res1)) {
24205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24206 }
24207 arg1 = reinterpret_cast< char * >(buf1);
24208 plsfnam((char const *)arg1);
24209 _outv = octave_value();
24210 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24211 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24212 return _out;
24213 fail:
24214 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24215 return octave_value_list();
24216 }
24217 catch(...) {
24218 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24219 throw;
24220 }
24221}
24222
24223
24225 PLINT arg1 ;
24226 PLINT arg2 ;
24227 PLINT arg3 ;
24228 int val1 ;
24229 int ecode1 = 0 ;
24230 int val2 ;
24231 int ecode2 = 0 ;
24232 int val3 ;
24233 int ecode3 = 0 ;
24234 octave_value_list _out;
24235 octave_value_list *_outp=&_out;
24236 octave_value _outv;
24237
24238 try {
24239 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24240 SWIG_fail;
24241 }
24242 ecode1 = SWIG_AsVal_int(args(0), &val1);
24243 if (!SWIG_IsOK(ecode1)) {
24244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24245 }
24246 arg1 = static_cast< PLINT >(val1);
24247 ecode2 = SWIG_AsVal_int(args(1), &val2);
24248 if (!SWIG_IsOK(ecode2)) {
24249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24250 }
24251 arg2 = static_cast< PLINT >(val2);
24252 ecode3 = SWIG_AsVal_int(args(2), &val3);
24253 if (!SWIG_IsOK(ecode3)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24255 }
24256 arg3 = static_cast< PLINT >(val3);
24257 plsfont(arg1,arg2,arg3);
24258 _outv = octave_value();
24259 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24260 return _out;
24261 fail:
24262 return octave_value_list();
24263 }
24264 catch(...) {
24265 throw;
24266 }
24267}
24268
24269
24271 label_func arg1 = (label_func) 0 ;
24272 PLPointer arg2 = (PLPointer) 0 ;
24273 int res2 ;
24274 octave_value_list _out;
24275 octave_value_list *_outp=&_out;
24276 octave_value _outv;
24277
24278 try {
24279 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24280 SWIG_fail;
24281 }
24282 {
24283 octave_value obj = args(0);
24284#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24285 if ( !obj.isempty() )
24286#else
24287 if ( !obj.is_empty() )
24288#endif
24289 {
24290 if ( obj.is_function_handle() || obj.is_inline_function() )
24291 {
24292 fcnLabelFunc = obj.function_value();
24293 }
24294 else if ( obj.is_string() )
24295 {
24296 nameLabelFunc = obj.string_value();
24297 fcnLabelFunc = NULL;
24298 }
24299 arg1 = labelfunc_octave;
24300 }
24301 else
24302 {
24303 arg1 = NULL;
24304 }
24305 }
24306 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24307 if (!SWIG_IsOK(res2)) {
24308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24309 }
24310 plslabelfunc(arg1,arg2);
24311 _outv = octave_value();
24312 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24313 return _out;
24314 fail:
24315 return octave_value_list();
24316 }
24317 catch(...) {
24318 throw;
24319 }
24320}
24321
24322
24324 PLFLT arg1 ;
24325 PLFLT arg2 ;
24326 double val1 ;
24327 int ecode1 = 0 ;
24328 double val2 ;
24329 int ecode2 = 0 ;
24330 octave_value_list _out;
24331 octave_value_list *_outp=&_out;
24332 octave_value _outv;
24333
24334 try {
24335 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24336 SWIG_fail;
24337 }
24338 ecode1 = SWIG_AsVal_double(args(0), &val1);
24339 if (!SWIG_IsOK(ecode1)) {
24340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24341 }
24342 arg1 = static_cast< PLFLT >(val1);
24343 ecode2 = SWIG_AsVal_double(args(1), &val2);
24344 if (!SWIG_IsOK(ecode2)) {
24345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24346 }
24347 arg2 = static_cast< PLFLT >(val2);
24348 plsmaj(arg1,arg2);
24349 _outv = octave_value();
24350 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24351 return _out;
24352 fail:
24353 return octave_value_list();
24354 }
24355 catch(...) {
24356 throw;
24357 }
24358}
24359
24360
24362 PLFLT arg1 ;
24363 PLFLT arg2 ;
24364 double val1 ;
24365 int ecode1 = 0 ;
24366 double val2 ;
24367 int ecode2 = 0 ;
24368 octave_value_list _out;
24369 octave_value_list *_outp=&_out;
24370 octave_value _outv;
24371
24372 try {
24373 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24374 SWIG_fail;
24375 }
24376 ecode1 = SWIG_AsVal_double(args(0), &val1);
24377 if (!SWIG_IsOK(ecode1)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24379 }
24380 arg1 = static_cast< PLFLT >(val1);
24381 ecode2 = SWIG_AsVal_double(args(1), &val2);
24382 if (!SWIG_IsOK(ecode2)) {
24383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24384 }
24385 arg2 = static_cast< PLFLT >(val2);
24386 plsmin(arg1,arg2);
24387 _outv = octave_value();
24388 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24389 return _out;
24390 fail:
24391 return octave_value_list();
24392 }
24393 catch(...) {
24394 throw;
24395 }
24396}
24397
24398
24400 PLINT arg1 ;
24401 int val1 ;
24402 int ecode1 = 0 ;
24403 octave_value_list _out;
24404 octave_value_list *_outp=&_out;
24405 octave_value _outv;
24406
24407 try {
24408 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24409 SWIG_fail;
24410 }
24411 ecode1 = SWIG_AsVal_int(args(0), &val1);
24412 if (!SWIG_IsOK(ecode1)) {
24413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24414 }
24415 arg1 = static_cast< PLINT >(val1);
24416 plsori(arg1);
24417 _outv = octave_value();
24418 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24419 return _out;
24420 fail:
24421 return octave_value_list();
24422 }
24423 catch(...) {
24424 throw;
24425 }
24426}
24427
24428
24430 PLFLT arg1 ;
24431 PLFLT arg2 ;
24432 PLINT arg3 ;
24433 PLINT arg4 ;
24434 PLINT arg5 ;
24435 PLINT arg6 ;
24436 double val1 ;
24437 int ecode1 = 0 ;
24438 double val2 ;
24439 int ecode2 = 0 ;
24440 int val3 ;
24441 int ecode3 = 0 ;
24442 int val4 ;
24443 int ecode4 = 0 ;
24444 int val5 ;
24445 int ecode5 = 0 ;
24446 int val6 ;
24447 int ecode6 = 0 ;
24448 octave_value_list _out;
24449 octave_value_list *_outp=&_out;
24450 octave_value _outv;
24451
24452 try {
24453 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24454 SWIG_fail;
24455 }
24456 ecode1 = SWIG_AsVal_double(args(0), &val1);
24457 if (!SWIG_IsOK(ecode1)) {
24458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24459 }
24460 arg1 = static_cast< PLFLT >(val1);
24461 ecode2 = SWIG_AsVal_double(args(1), &val2);
24462 if (!SWIG_IsOK(ecode2)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24464 }
24465 arg2 = static_cast< PLFLT >(val2);
24466 ecode3 = SWIG_AsVal_int(args(2), &val3);
24467 if (!SWIG_IsOK(ecode3)) {
24468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24469 }
24470 arg3 = static_cast< PLINT >(val3);
24471 ecode4 = SWIG_AsVal_int(args(3), &val4);
24472 if (!SWIG_IsOK(ecode4)) {
24473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24474 }
24475 arg4 = static_cast< PLINT >(val4);
24476 ecode5 = SWIG_AsVal_int(args(4), &val5);
24477 if (!SWIG_IsOK(ecode5)) {
24478 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24479 }
24480 arg5 = static_cast< PLINT >(val5);
24481 ecode6 = SWIG_AsVal_int(args(5), &val6);
24482 if (!SWIG_IsOK(ecode6)) {
24483 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24484 }
24485 arg6 = static_cast< PLINT >(val6);
24486 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24487 _outv = octave_value();
24488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24489 return _out;
24490 fail:
24491 return octave_value_list();
24492 }
24493 catch(...) {
24494 throw;
24495 }
24496}
24497
24498
24500 char *arg1 = (char *) 0 ;
24501 int res1 ;
24502 char *buf1 = 0 ;
24503 int alloc1 = 0 ;
24504 octave_value_list _out;
24505 octave_value_list *_outp=&_out;
24506 octave_value _outv;
24507
24508 try {
24509 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24510 SWIG_fail;
24511 }
24512 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24513 if (!SWIG_IsOK(res1)) {
24514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24515 }
24516 arg1 = reinterpret_cast< char * >(buf1);
24517 plspal0((char const *)arg1);
24518 _outv = octave_value();
24519 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24520 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24521 return _out;
24522 fail:
24523 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24524 return octave_value_list();
24525 }
24526 catch(...) {
24527 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24528 throw;
24529 }
24530}
24531
24532
24534 char *arg1 = (char *) 0 ;
24535 PLBOOL arg2 ;
24536 int res1 ;
24537 char *buf1 = 0 ;
24538 int alloc1 = 0 ;
24539 int val2 ;
24540 int ecode2 = 0 ;
24541 octave_value_list _out;
24542 octave_value_list *_outp=&_out;
24543 octave_value _outv;
24544
24545 try {
24546 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24547 SWIG_fail;
24548 }
24549 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24550 if (!SWIG_IsOK(res1)) {
24551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24552 }
24553 arg1 = reinterpret_cast< char * >(buf1);
24554 ecode2 = SWIG_AsVal_int(args(1), &val2);
24555 if (!SWIG_IsOK(ecode2)) {
24556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24557 }
24558 arg2 = static_cast< PLBOOL >(val2);
24559 plspal1((char const *)arg1,arg2);
24560 _outv = octave_value();
24561 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24562 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24563 return _out;
24564 fail:
24565 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24566 return octave_value_list();
24567 }
24568 catch(...) {
24569 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24570 throw;
24571 }
24572}
24573
24574
24576 PLBOOL arg1 ;
24577 int val1 ;
24578 int ecode1 = 0 ;
24579 octave_value_list _out;
24580 octave_value_list *_outp=&_out;
24581 octave_value _outv;
24582
24583 try {
24584 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24585 SWIG_fail;
24586 }
24587 ecode1 = SWIG_AsVal_int(args(0), &val1);
24588 if (!SWIG_IsOK(ecode1)) {
24589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24590 }
24591 arg1 = static_cast< PLBOOL >(val1);
24592 plspause(arg1);
24593 _outv = octave_value();
24594 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24595 return _out;
24596 fail:
24597 return octave_value_list();
24598 }
24599 catch(...) {
24600 throw;
24601 }
24602}
24603
24604
24605SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24606 PLINT arg1 ;
24607 int val1 ;
24608 int ecode1 = 0 ;
24609 octave_value_list _out;
24610 octave_value_list *_outp=&_out;
24611 octave_value _outv;
24612
24613 try {
24614 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24615 SWIG_fail;
24616 }
24617 ecode1 = SWIG_AsVal_int(args(0), &val1);
24618 if (!SWIG_IsOK(ecode1)) {
24619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24620 }
24621 arg1 = static_cast< PLINT >(val1);
24622 plsstrm(arg1);
24623 _outv = octave_value();
24624 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24625 return _out;
24626 fail:
24627 return octave_value_list();
24628 }
24629 catch(...) {
24630 throw;
24631 }
24632}
24633
24634
24636 PLINT arg1 ;
24637 PLINT arg2 ;
24638 int val1 ;
24639 int ecode1 = 0 ;
24640 int val2 ;
24641 int ecode2 = 0 ;
24642 octave_value_list _out;
24643 octave_value_list *_outp=&_out;
24644 octave_value _outv;
24645
24646 try {
24647 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24648 SWIG_fail;
24649 }
24650 ecode1 = SWIG_AsVal_int(args(0), &val1);
24651 if (!SWIG_IsOK(ecode1)) {
24652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24653 }
24654 arg1 = static_cast< PLINT >(val1);
24655 ecode2 = SWIG_AsVal_int(args(1), &val2);
24656 if (!SWIG_IsOK(ecode2)) {
24657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24658 }
24659 arg2 = static_cast< PLINT >(val2);
24660 plssub(arg1,arg2);
24661 _outv = octave_value();
24662 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24663 return _out;
24664 fail:
24665 return octave_value_list();
24666 }
24667 catch(...) {
24668 throw;
24669 }
24670}
24671
24672
24674 PLFLT arg1 ;
24675 PLFLT arg2 ;
24676 double val1 ;
24677 int ecode1 = 0 ;
24678 double val2 ;
24679 int ecode2 = 0 ;
24680 octave_value_list _out;
24681 octave_value_list *_outp=&_out;
24682 octave_value _outv;
24683
24684 try {
24685 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24686 SWIG_fail;
24687 }
24688 ecode1 = SWIG_AsVal_double(args(0), &val1);
24689 if (!SWIG_IsOK(ecode1)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24691 }
24692 arg1 = static_cast< PLFLT >(val1);
24693 ecode2 = SWIG_AsVal_double(args(1), &val2);
24694 if (!SWIG_IsOK(ecode2)) {
24695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24696 }
24697 arg2 = static_cast< PLFLT >(val2);
24698 plssym(arg1,arg2);
24699 _outv = octave_value();
24700 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24701 return _out;
24702 fail:
24703 return octave_value_list();
24704 }
24705 catch(...) {
24706 throw;
24707 }
24708}
24709
24710
24712 PLINT arg1 ;
24713 PLINT arg2 ;
24714 int val1 ;
24715 int ecode1 = 0 ;
24716 int val2 ;
24717 int ecode2 = 0 ;
24718 octave_value_list _out;
24719 octave_value_list *_outp=&_out;
24720 octave_value _outv;
24721
24722 try {
24723 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24724 SWIG_fail;
24725 }
24726 ecode1 = SWIG_AsVal_int(args(0), &val1);
24727 if (!SWIG_IsOK(ecode1)) {
24728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24729 }
24730 arg1 = static_cast< PLINT >(val1);
24731 ecode2 = SWIG_AsVal_int(args(1), &val2);
24732 if (!SWIG_IsOK(ecode2)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24734 }
24735 arg2 = static_cast< PLINT >(val2);
24736 plstar(arg1,arg2);
24737 _outv = octave_value();
24738 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24739 return _out;
24740 fail:
24741 return octave_value_list();
24742 }
24743 catch(...) {
24744 throw;
24745 }
24746}
24747
24748
24750 char *arg1 = (char *) 0 ;
24751 PLINT arg2 ;
24752 PLINT arg3 ;
24753 int res1 ;
24754 char *buf1 = 0 ;
24755 int alloc1 = 0 ;
24756 int val2 ;
24757 int ecode2 = 0 ;
24758 int val3 ;
24759 int ecode3 = 0 ;
24760 octave_value_list _out;
24761 octave_value_list *_outp=&_out;
24762 octave_value _outv;
24763
24764 try {
24765 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24766 SWIG_fail;
24767 }
24768 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24769 if (!SWIG_IsOK(res1)) {
24770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24771 }
24772 arg1 = reinterpret_cast< char * >(buf1);
24773 ecode2 = SWIG_AsVal_int(args(1), &val2);
24774 if (!SWIG_IsOK(ecode2)) {
24775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24776 }
24777 arg2 = static_cast< PLINT >(val2);
24778 ecode3 = SWIG_AsVal_int(args(2), &val3);
24779 if (!SWIG_IsOK(ecode3)) {
24780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24781 }
24782 arg3 = static_cast< PLINT >(val3);
24783 plstart((char const *)arg1,arg2,arg3);
24784 _outv = octave_value();
24785 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24786 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24787 return _out;
24788 fail:
24789 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24790 return octave_value_list();
24791 }
24792 catch(...) {
24793 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24794 throw;
24795 }
24796}
24797
24798
24800 ct_func arg1 = (ct_func) 0 ;
24801 PLPointer arg2 = (PLPointer) 0 ;
24802 int res2 ;
24803 octave_value_list _out;
24804 octave_value_list *_outp=&_out;
24805 octave_value _outv;
24806
24807 try {
24808 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24809 SWIG_fail;
24810 }
24811 {
24812 octave_value obj = args(0);
24813#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24814 if ( !obj.isempty() )
24815#else
24816 if ( !obj.is_empty() )
24817#endif
24818 {
24819 if ( obj.is_function_handle() || obj.is_inline_function() )
24820 {
24821 fcnCoordTrans = obj.function_value();
24822 }
24823 else if ( obj.is_string() )
24824 {
24825 nameCoordTrans = obj.string_value();
24826 fcnCoordTrans = NULL;
24827 }
24828 arg1 = ct_octave;
24829 }
24830 else
24831 {
24832 arg1 = NULL;
24833 }
24834 }
24835 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24836 if (!SWIG_IsOK(res2)) {
24837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24838 }
24839 plstransform(arg1,arg2);
24840 _outv = octave_value();
24841 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24842 return _out;
24843 fail:
24844 return octave_value_list();
24845 }
24846 catch(...) {
24847 throw;
24848 }
24849}
24850
24851
24853 PLINT arg1 ;
24854 PLFLT *arg2 = (PLFLT *) 0 ;
24855 PLFLT *arg3 = (PLFLT *) 0 ;
24856 char *arg4 = (char *) 0 ;
24857 Matrix temp1 ;
24858 Matrix temp3 ;
24859 int res4 ;
24860 char *buf4 = 0 ;
24861 int alloc4 = 0 ;
24862 octave_value_list _out;
24863 octave_value_list *_outp=&_out;
24864 octave_value _outv;
24865
24866 try {
24867 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24868 SWIG_fail;
24869 }
24870 {
24871 if ( _n_dims( args(0) ) > 1 )
24872 {
24873 error( "argument must be a scalar or vector" ); SWIG_fail;
24874 }
24875 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24876 temp1 = args(0).matrix_value();
24877 arg2 = &temp1( 0, 0 );
24878 }
24879 {
24880 if ( _n_dims( args(1) ) > 1 )
24881 {
24882 error( "argument must be a scalar or vector" ); SWIG_fail;
24883 }
24884 if ( _dim( args(1), 0 ) != Alen )
24885 {
24886 error( "argument vectors must be same length" ); SWIG_fail;
24887 }
24888 temp3 = args(1).matrix_value();
24889 arg3 = &temp3( 0, 0 );
24890 }
24891 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24892 if (!SWIG_IsOK(res4)) {
24893 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24894 }
24895 arg4 = reinterpret_cast< char * >(buf4);
24896 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24897 _outv = octave_value();
24898 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24899 {
24900
24901 }
24902 {
24903
24904 }
24905 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24906 return _out;
24907 fail:
24908 {
24909
24910 }
24911 {
24912
24913 }
24914 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24915 return octave_value_list();
24916 }
24917 catch(...) {
24918 {
24919
24920 }
24921 {
24922
24923 }
24924 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24925 throw;
24926 }
24927}
24928
24929
24931 PLINT arg1 ;
24932 PLFLT *arg2 = (PLFLT *) 0 ;
24933 PLFLT *arg3 = (PLFLT *) 0 ;
24934 PLFLT *arg4 = (PLFLT *) 0 ;
24935 char *arg5 = (char *) 0 ;
24936 Matrix temp1 ;
24937 Matrix temp3 ;
24938 Matrix temp4 ;
24939 int res5 ;
24940 char *buf5 = 0 ;
24941 int alloc5 = 0 ;
24942 octave_value_list _out;
24943 octave_value_list *_outp=&_out;
24944 octave_value _outv;
24945
24946 try {
24947 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24948 SWIG_fail;
24949 }
24950 {
24951 if ( _n_dims( args(0) ) > 1 )
24952 {
24953 error( "argument must be a scalar or vector" ); SWIG_fail;
24954 }
24955 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24956 temp1 = args(0).matrix_value();
24957 arg2 = &temp1( 0, 0 );
24958 }
24959 {
24960 if ( _n_dims( args(1) ) > 1 )
24961 {
24962 error( "argument must be a scalar or vector" ); SWIG_fail;
24963 }
24964 if ( _dim( args(1), 0 ) != Alen )
24965 {
24966 error( "argument vectors must be same length" ); SWIG_fail;
24967 }
24968 temp3 = args(1).matrix_value();
24969 arg3 = &temp3( 0, 0 );
24970 }
24971 {
24972 if ( _n_dims( args(2) ) > 1 )
24973 {
24974 error( "argument must be a scalar or vector" ); SWIG_fail;
24975 }
24976 if ( _dim( args(2), 0 ) != Alen )
24977 {
24978 error( "argument vectors must be same length" ); SWIG_fail;
24979 }
24980 temp4 = args(2).matrix_value();
24981 arg4 = &temp4( 0, 0 );
24982 }
24983 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24984 if (!SWIG_IsOK(res5)) {
24985 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24986 }
24987 arg5 = reinterpret_cast< char * >(buf5);
24988 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24989 _outv = octave_value();
24990 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24991 {
24992
24993 }
24994 {
24995
24996 }
24997 {
24998
24999 }
25000 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25001 return _out;
25002 fail:
25003 {
25004
25005 }
25006 {
25007
25008 }
25009 {
25010
25011 }
25012 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25013 return octave_value_list();
25014 }
25015 catch(...) {
25016 {
25017
25018 }
25019 {
25020
25021 }
25022 {
25023
25024 }
25025 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25026 throw;
25027 }
25028}
25029
25030
25032 PLINT arg1 ;
25033 PLINT arg2 ;
25034 PLFLT arg3 ;
25035 PLFLT arg4 ;
25036 int val1 ;
25037 int ecode1 = 0 ;
25038 int val2 ;
25039 int ecode2 = 0 ;
25040 double val3 ;
25041 int ecode3 = 0 ;
25042 double val4 ;
25043 int ecode4 = 0 ;
25044 octave_value_list _out;
25045 octave_value_list *_outp=&_out;
25046 octave_value _outv;
25047
25048 try {
25049 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
25050 SWIG_fail;
25051 }
25052 ecode1 = SWIG_AsVal_int(args(0), &val1);
25053 if (!SWIG_IsOK(ecode1)) {
25054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
25055 }
25056 arg1 = static_cast< PLINT >(val1);
25057 ecode2 = SWIG_AsVal_int(args(1), &val2);
25058 if (!SWIG_IsOK(ecode2)) {
25059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
25060 }
25061 arg2 = static_cast< PLINT >(val2);
25062 ecode3 = SWIG_AsVal_double(args(2), &val3);
25063 if (!SWIG_IsOK(ecode3)) {
25064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
25065 }
25066 arg3 = static_cast< PLFLT >(val3);
25067 ecode4 = SWIG_AsVal_double(args(3), &val4);
25068 if (!SWIG_IsOK(ecode4)) {
25069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
25070 }
25071 arg4 = static_cast< PLFLT >(val4);
25072 plstripa(arg1,arg2,arg3,arg4);
25073 _outv = octave_value();
25074 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25075 return _out;
25076 fail:
25077 return octave_value_list();
25078 }
25079 catch(...) {
25080 throw;
25081 }
25082}
25083
25084
25086 PLINT arg1 ;
25087 int val1 ;
25088 int ecode1 = 0 ;
25089 octave_value_list _out;
25090 octave_value_list *_outp=&_out;
25091 octave_value _outv;
25092
25093 try {
25094 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25095 SWIG_fail;
25096 }
25097 ecode1 = SWIG_AsVal_int(args(0), &val1);
25098 if (!SWIG_IsOK(ecode1)) {
25099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25100 }
25101 arg1 = static_cast< PLINT >(val1);
25102 plstripd(arg1);
25103 _outv = octave_value();
25104 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25105 return _out;
25106 fail:
25107 return octave_value_list();
25108 }
25109 catch(...) {
25110 throw;
25111 }
25112}
25113
25114
25116 PLINT arg1 ;
25117 PLINT *arg2 = (PLINT *) 0 ;
25118 PLINT *arg3 = (PLINT *) 0 ;
25119 Matrix temp1 ;
25120 Matrix temp3 ;
25121 octave_value_list _out;
25122 octave_value_list *_outp=&_out;
25123 octave_value _outv;
25124
25125 try {
25126 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25127 SWIG_fail;
25128 }
25129 {
25130 if ( _n_dims( args(0) ) > 1 )
25131 {
25132 error( "argument must be a scalar or vector" ); SWIG_fail;
25133 }
25134 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25135 arg2 = new PLINT[Alen];
25136 temp1 = args(0).matrix_value();
25137 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25138 }
25139 {
25140 if ( _n_dims( args(1) ) > 1 )
25141 {
25142 error( "argument must be a scalar or vector" ); SWIG_fail;
25143 }
25144 if ( _dim( args(1), 0 ) != Alen )
25145 {
25146 error( "argument vectors must be same length" ); SWIG_fail;
25147 }
25148 temp3 = args(1).matrix_value();
25149 arg3 = new PLINT[Alen];
25150 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25151 }
25152 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25153 _outv = octave_value();
25154 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25155 {
25156 delete [] arg2;
25157 }
25158 {
25159 delete [] arg3;
25160 }
25161 return _out;
25162 fail:
25163 {
25164 delete [] arg2;
25165 }
25166 {
25167 delete [] arg3;
25168 }
25169 return octave_value_list();
25170 }
25171 catch(...) {
25172 {
25173 delete [] arg2;
25174 }
25175 {
25176 delete [] arg3;
25177 }
25178 throw;
25179 }
25180}
25181
25182
25184 PLFLT *arg1 = (PLFLT *) 0 ;
25185 PLFLT *arg2 = (PLFLT *) 0 ;
25186 PLINT arg3 ;
25187 PLBOOL arg4 ;
25188 Matrix temp1 ;
25189 Matrix temp2 ;
25190 int val4 ;
25191 int ecode4 = 0 ;
25192 octave_value_list _out;
25193 octave_value_list *_outp=&_out;
25194 octave_value _outv;
25195
25196 try {
25197 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25198 SWIG_fail;
25199 }
25200 {
25201 if ( _n_dims( args(0) ) > 1 )
25202 {
25203 error( "argument must be a scalar or vector" ); SWIG_fail;
25204 }
25205#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25206 if ( !args(0).isempty() )
25207#else
25208 if ( !args(0).is_empty() )
25209#endif
25210 {
25211 Alen = (PLINT) ( _dim( args(0), 0 ) );
25212 temp1 = args(0).matrix_value();
25213 arg1 = &temp1( 0, 0 );
25214 }
25215 else
25216 {
25217 arg1 = NULL;
25218 Alen = 0;
25219 }
25220 }
25221 {
25222 if ( _n_dims( args(1) ) > 1 )
25223 {
25224 error( "argument must be a scalar or vector" ); SWIG_fail;
25225 }
25226#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25227 if ( !args(1).isempty() )
25228#else
25229 if ( !args(1).is_empty() )
25230#endif
25231 {
25232 if ( _dim( args(1), 0 ) != Alen )
25233 {
25234 error( "argument vectors must be same length" ); SWIG_fail;
25235 }
25236 temp2 = args(1).matrix_value();
25237 arg2 = &temp2( 0, 0 );
25238 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25239 }
25240 else
25241 {
25242 arg2 = NULL;
25243 arg3 = 0;
25244 }
25245 }
25246 ecode4 = SWIG_AsVal_int(args(2), &val4);
25247 if (!SWIG_IsOK(ecode4)) {
25248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25249 }
25250 arg4 = static_cast< PLBOOL >(val4);
25251 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25252 _outv = octave_value();
25253 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25254 {
25255
25256 }
25257 {
25258
25259 }
25260 return _out;
25261 fail:
25262 {
25263
25264 }
25265 {
25266
25267 }
25268 return octave_value_list();
25269 }
25270 catch(...) {
25271 {
25272
25273 }
25274 {
25275
25276 }
25277 throw;
25278 }
25279}
25280
25281
25283 PLFLT arg1 ;
25284 PLFLT arg2 ;
25285 PLFLT arg3 ;
25286 PLFLT arg4 ;
25287 double val1 ;
25288 int ecode1 = 0 ;
25289 double val2 ;
25290 int ecode2 = 0 ;
25291 double val3 ;
25292 int ecode3 = 0 ;
25293 double val4 ;
25294 int ecode4 = 0 ;
25295 octave_value_list _out;
25296 octave_value_list *_outp=&_out;
25297 octave_value _outv;
25298
25299 try {
25300 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25301 SWIG_fail;
25302 }
25303 ecode1 = SWIG_AsVal_double(args(0), &val1);
25304 if (!SWIG_IsOK(ecode1)) {
25305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25306 }
25307 arg1 = static_cast< PLFLT >(val1);
25308 ecode2 = SWIG_AsVal_double(args(1), &val2);
25309 if (!SWIG_IsOK(ecode2)) {
25310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25311 }
25312 arg2 = static_cast< PLFLT >(val2);
25313 ecode3 = SWIG_AsVal_double(args(2), &val3);
25314 if (!SWIG_IsOK(ecode3)) {
25315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25316 }
25317 arg3 = static_cast< PLFLT >(val3);
25318 ecode4 = SWIG_AsVal_double(args(3), &val4);
25319 if (!SWIG_IsOK(ecode4)) {
25320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25321 }
25322 arg4 = static_cast< PLFLT >(val4);
25323 plsvpa(arg1,arg2,arg3,arg4);
25324 _outv = octave_value();
25325 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25326 return _out;
25327 fail:
25328 return octave_value_list();
25329 }
25330 catch(...) {
25331 throw;
25332 }
25333}
25334
25335
25337 PLINT arg1 ;
25338 PLINT arg2 ;
25339 int val1 ;
25340 int ecode1 = 0 ;
25341 int val2 ;
25342 int ecode2 = 0 ;
25343 octave_value_list _out;
25344 octave_value_list *_outp=&_out;
25345 octave_value _outv;
25346
25347 try {
25348 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25349 SWIG_fail;
25350 }
25351 ecode1 = SWIG_AsVal_int(args(0), &val1);
25352 if (!SWIG_IsOK(ecode1)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25354 }
25355 arg1 = static_cast< PLINT >(val1);
25356 ecode2 = SWIG_AsVal_int(args(1), &val2);
25357 if (!SWIG_IsOK(ecode2)) {
25358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25359 }
25360 arg2 = static_cast< PLINT >(val2);
25361 plsxax(arg1,arg2);
25362 _outv = octave_value();
25363 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25364 return _out;
25365 fail:
25366 return octave_value_list();
25367 }
25368 catch(...) {
25369 throw;
25370 }
25371}
25372
25373
25375 PLINT arg1 ;
25376 PLINT arg2 ;
25377 int val1 ;
25378 int ecode1 = 0 ;
25379 int val2 ;
25380 int ecode2 = 0 ;
25381 octave_value_list _out;
25382 octave_value_list *_outp=&_out;
25383 octave_value _outv;
25384
25385 try {
25386 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25387 SWIG_fail;
25388 }
25389 ecode1 = SWIG_AsVal_int(args(0), &val1);
25390 if (!SWIG_IsOK(ecode1)) {
25391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25392 }
25393 arg1 = static_cast< PLINT >(val1);
25394 ecode2 = SWIG_AsVal_int(args(1), &val2);
25395 if (!SWIG_IsOK(ecode2)) {
25396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25397 }
25398 arg2 = static_cast< PLINT >(val2);
25399 plsyax(arg1,arg2);
25400 _outv = octave_value();
25401 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25402 return _out;
25403 fail:
25404 return octave_value_list();
25405 }
25406 catch(...) {
25407 throw;
25408 }
25409}
25410
25411
25413 PLINT arg1 ;
25414 PLFLT *arg2 = (PLFLT *) 0 ;
25415 PLFLT *arg3 = (PLFLT *) 0 ;
25416 PLINT arg4 ;
25417 Matrix temp1 ;
25418 Matrix temp3 ;
25419 int val4 ;
25420 int ecode4 = 0 ;
25421 octave_value_list _out;
25422 octave_value_list *_outp=&_out;
25423 octave_value _outv;
25424
25425 try {
25426 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25427 SWIG_fail;
25428 }
25429 {
25430 if ( _n_dims( args(0) ) > 1 )
25431 {
25432 error( "argument must be a scalar or vector" ); SWIG_fail;
25433 }
25434 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25435 temp1 = args(0).matrix_value();
25436 arg2 = &temp1( 0, 0 );
25437 }
25438 {
25439 if ( _n_dims( args(1) ) > 1 )
25440 {
25441 error( "argument must be a scalar or vector" ); SWIG_fail;
25442 }
25443 if ( _dim( args(1), 0 ) != Alen )
25444 {
25445 error( "argument vectors must be same length" ); SWIG_fail;
25446 }
25447 temp3 = args(1).matrix_value();
25448 arg3 = &temp3( 0, 0 );
25449 }
25450 ecode4 = SWIG_AsVal_int(args(2), &val4);
25451 if (!SWIG_IsOK(ecode4)) {
25452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25453 }
25454 arg4 = static_cast< PLINT >(val4);
25455 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25456 _outv = octave_value();
25457 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25458 {
25459
25460 }
25461 {
25462
25463 }
25464 return _out;
25465 fail:
25466 {
25467
25468 }
25469 {
25470
25471 }
25472 return octave_value_list();
25473 }
25474 catch(...) {
25475 {
25476
25477 }
25478 {
25479
25480 }
25481 throw;
25482 }
25483}
25484
25485
25487 PLINT arg1 ;
25488 PLINT arg2 ;
25489 int val1 ;
25490 int ecode1 = 0 ;
25491 int val2 ;
25492 int ecode2 = 0 ;
25493 octave_value_list _out;
25494 octave_value_list *_outp=&_out;
25495 octave_value _outv;
25496
25497 try {
25498 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25499 SWIG_fail;
25500 }
25501 ecode1 = SWIG_AsVal_int(args(0), &val1);
25502 if (!SWIG_IsOK(ecode1)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25504 }
25505 arg1 = static_cast< PLINT >(val1);
25506 ecode2 = SWIG_AsVal_int(args(1), &val2);
25507 if (!SWIG_IsOK(ecode2)) {
25508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25509 }
25510 arg2 = static_cast< PLINT >(val2);
25511 plszax(arg1,arg2);
25512 _outv = octave_value();
25513 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25514 return _out;
25515 fail:
25516 return octave_value_list();
25517 }
25518 catch(...) {
25519 throw;
25520 }
25521}
25522
25523
25525 octave_value_list _out;
25526 octave_value_list *_outp=&_out;
25527 octave_value _outv;
25528
25529 try {
25530 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25531 SWIG_fail;
25532 }
25533 pltext();
25534 _outv = octave_value();
25535 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25536 return _out;
25537 fail:
25538 return octave_value_list();
25539 }
25540 catch(...) {
25541 throw;
25542 }
25543}
25544
25545
25547 char *arg1 = (char *) 0 ;
25548 int res1 ;
25549 char *buf1 = 0 ;
25550 int alloc1 = 0 ;
25551 octave_value_list _out;
25552 octave_value_list *_outp=&_out;
25553 octave_value _outv;
25554
25555 try {
25556 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25557 SWIG_fail;
25558 }
25559 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25560 if (!SWIG_IsOK(res1)) {
25561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25562 }
25563 arg1 = reinterpret_cast< char * >(buf1);
25564 pltimefmt((char const *)arg1);
25565 _outv = octave_value();
25566 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25567 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25568 return _out;
25569 fail:
25570 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25571 return octave_value_list();
25572 }
25573 catch(...) {
25574 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25575 throw;
25576 }
25577}
25578
25579
25581 PLFLT arg1 ;
25582 double val1 ;
25583 int ecode1 = 0 ;
25584 octave_value_list _out;
25585 octave_value_list *_outp=&_out;
25586 octave_value _outv;
25587
25588 try {
25589 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25590 SWIG_fail;
25591 }
25592 ecode1 = SWIG_AsVal_double(args(0), &val1);
25593 if (!SWIG_IsOK(ecode1)) {
25594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25595 }
25596 arg1 = static_cast< PLFLT >(val1);
25597 plvasp(arg1);
25598 _outv = octave_value();
25599 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25600 return _out;
25601 fail:
25602 return octave_value_list();
25603 }
25604 catch(...) {
25605 throw;
25606 }
25607}
25608
25609
25611 PLFLT arg1 ;
25612 PLFLT arg2 ;
25613 PLFLT arg3 ;
25614 PLFLT arg4 ;
25615 PLFLT arg5 ;
25616 double val1 ;
25617 int ecode1 = 0 ;
25618 double val2 ;
25619 int ecode2 = 0 ;
25620 double val3 ;
25621 int ecode3 = 0 ;
25622 double val4 ;
25623 int ecode4 = 0 ;
25624 double val5 ;
25625 int ecode5 = 0 ;
25626 octave_value_list _out;
25627 octave_value_list *_outp=&_out;
25628 octave_value _outv;
25629
25630 try {
25631 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25632 SWIG_fail;
25633 }
25634 ecode1 = SWIG_AsVal_double(args(0), &val1);
25635 if (!SWIG_IsOK(ecode1)) {
25636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25637 }
25638 arg1 = static_cast< PLFLT >(val1);
25639 ecode2 = SWIG_AsVal_double(args(1), &val2);
25640 if (!SWIG_IsOK(ecode2)) {
25641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25642 }
25643 arg2 = static_cast< PLFLT >(val2);
25644 ecode3 = SWIG_AsVal_double(args(2), &val3);
25645 if (!SWIG_IsOK(ecode3)) {
25646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25647 }
25648 arg3 = static_cast< PLFLT >(val3);
25649 ecode4 = SWIG_AsVal_double(args(3), &val4);
25650 if (!SWIG_IsOK(ecode4)) {
25651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25652 }
25653 arg4 = static_cast< PLFLT >(val4);
25654 ecode5 = SWIG_AsVal_double(args(4), &val5);
25655 if (!SWIG_IsOK(ecode5)) {
25656 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25657 }
25658 arg5 = static_cast< PLFLT >(val5);
25659 plvpas(arg1,arg2,arg3,arg4,arg5);
25660 _outv = octave_value();
25661 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25662 return _out;
25663 fail:
25664 return octave_value_list();
25665 }
25666 catch(...) {
25667 throw;
25668 }
25669}
25670
25671
25673 PLFLT arg1 ;
25674 PLFLT arg2 ;
25675 PLFLT arg3 ;
25676 PLFLT arg4 ;
25677 double val1 ;
25678 int ecode1 = 0 ;
25679 double val2 ;
25680 int ecode2 = 0 ;
25681 double val3 ;
25682 int ecode3 = 0 ;
25683 double val4 ;
25684 int ecode4 = 0 ;
25685 octave_value_list _out;
25686 octave_value_list *_outp=&_out;
25687 octave_value _outv;
25688
25689 try {
25690 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25691 SWIG_fail;
25692 }
25693 ecode1 = SWIG_AsVal_double(args(0), &val1);
25694 if (!SWIG_IsOK(ecode1)) {
25695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25696 }
25697 arg1 = static_cast< PLFLT >(val1);
25698 ecode2 = SWIG_AsVal_double(args(1), &val2);
25699 if (!SWIG_IsOK(ecode2)) {
25700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25701 }
25702 arg2 = static_cast< PLFLT >(val2);
25703 ecode3 = SWIG_AsVal_double(args(2), &val3);
25704 if (!SWIG_IsOK(ecode3)) {
25705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25706 }
25707 arg3 = static_cast< PLFLT >(val3);
25708 ecode4 = SWIG_AsVal_double(args(3), &val4);
25709 if (!SWIG_IsOK(ecode4)) {
25710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25711 }
25712 arg4 = static_cast< PLFLT >(val4);
25713 plvpor(arg1,arg2,arg3,arg4);
25714 _outv = octave_value();
25715 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25716 return _out;
25717 fail:
25718 return octave_value_list();
25719 }
25720 catch(...) {
25721 throw;
25722 }
25723}
25724
25725
25727 octave_value_list _out;
25728 octave_value_list *_outp=&_out;
25729 octave_value _outv;
25730
25731 try {
25732 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25733 SWIG_fail;
25734 }
25735 plvsta();
25736 _outv = octave_value();
25737 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25738 return _out;
25739 fail:
25740 return octave_value_list();
25741 }
25742 catch(...) {
25743 throw;
25744 }
25745}
25746
25747
25749 PLFLT arg1 ;
25750 PLFLT arg2 ;
25751 PLFLT arg3 ;
25752 PLFLT arg4 ;
25753 PLFLT arg5 ;
25754 PLFLT arg6 ;
25755 PLFLT arg7 ;
25756 PLFLT arg8 ;
25757 PLFLT arg9 ;
25758 PLFLT arg10 ;
25759 PLFLT arg11 ;
25760 double val1 ;
25761 int ecode1 = 0 ;
25762 double val2 ;
25763 int ecode2 = 0 ;
25764 double val3 ;
25765 int ecode3 = 0 ;
25766 double val4 ;
25767 int ecode4 = 0 ;
25768 double val5 ;
25769 int ecode5 = 0 ;
25770 double val6 ;
25771 int ecode6 = 0 ;
25772 double val7 ;
25773 int ecode7 = 0 ;
25774 double val8 ;
25775 int ecode8 = 0 ;
25776 double val9 ;
25777 int ecode9 = 0 ;
25778 double val10 ;
25779 int ecode10 = 0 ;
25780 double val11 ;
25781 int ecode11 = 0 ;
25782 octave_value_list _out;
25783 octave_value_list *_outp=&_out;
25784 octave_value _outv;
25785
25786 try {
25787 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25788 SWIG_fail;
25789 }
25790 ecode1 = SWIG_AsVal_double(args(0), &val1);
25791 if (!SWIG_IsOK(ecode1)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25793 }
25794 arg1 = static_cast< PLFLT >(val1);
25795 ecode2 = SWIG_AsVal_double(args(1), &val2);
25796 if (!SWIG_IsOK(ecode2)) {
25797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25798 }
25799 arg2 = static_cast< PLFLT >(val2);
25800 ecode3 = SWIG_AsVal_double(args(2), &val3);
25801 if (!SWIG_IsOK(ecode3)) {
25802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25803 }
25804 arg3 = static_cast< PLFLT >(val3);
25805 ecode4 = SWIG_AsVal_double(args(3), &val4);
25806 if (!SWIG_IsOK(ecode4)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25808 }
25809 arg4 = static_cast< PLFLT >(val4);
25810 ecode5 = SWIG_AsVal_double(args(4), &val5);
25811 if (!SWIG_IsOK(ecode5)) {
25812 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25813 }
25814 arg5 = static_cast< PLFLT >(val5);
25815 ecode6 = SWIG_AsVal_double(args(5), &val6);
25816 if (!SWIG_IsOK(ecode6)) {
25817 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25818 }
25819 arg6 = static_cast< PLFLT >(val6);
25820 ecode7 = SWIG_AsVal_double(args(6), &val7);
25821 if (!SWIG_IsOK(ecode7)) {
25822 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25823 }
25824 arg7 = static_cast< PLFLT >(val7);
25825 ecode8 = SWIG_AsVal_double(args(7), &val8);
25826 if (!SWIG_IsOK(ecode8)) {
25827 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25828 }
25829 arg8 = static_cast< PLFLT >(val8);
25830 ecode9 = SWIG_AsVal_double(args(8), &val9);
25831 if (!SWIG_IsOK(ecode9)) {
25832 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25833 }
25834 arg9 = static_cast< PLFLT >(val9);
25835 ecode10 = SWIG_AsVal_double(args(9), &val10);
25836 if (!SWIG_IsOK(ecode10)) {
25837 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25838 }
25839 arg10 = static_cast< PLFLT >(val10);
25840 ecode11 = SWIG_AsVal_double(args(10), &val11);
25841 if (!SWIG_IsOK(ecode11)) {
25842 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25843 }
25844 arg11 = static_cast< PLFLT >(val11);
25845 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25846 _outv = octave_value();
25847 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25848 return _out;
25849 fail:
25850 return octave_value_list();
25851 }
25852 catch(...) {
25853 throw;
25854 }
25855}
25856
25857
25859 PLFLT arg1 ;
25860 double val1 ;
25861 int ecode1 = 0 ;
25862 octave_value_list _out;
25863 octave_value_list *_outp=&_out;
25864 octave_value _outv;
25865
25866 try {
25867 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25868 SWIG_fail;
25869 }
25870 ecode1 = SWIG_AsVal_double(args(0), &val1);
25871 if (!SWIG_IsOK(ecode1)) {
25872 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25873 }
25874 arg1 = static_cast< PLFLT >(val1);
25875 plwidth(arg1);
25876 _outv = octave_value();
25877 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25878 return _out;
25879 fail:
25880 return octave_value_list();
25881 }
25882 catch(...) {
25883 throw;
25884 }
25885}
25886
25887
25889 PLFLT arg1 ;
25890 PLFLT arg2 ;
25891 PLFLT arg3 ;
25892 PLFLT arg4 ;
25893 double val1 ;
25894 int ecode1 = 0 ;
25895 double val2 ;
25896 int ecode2 = 0 ;
25897 double val3 ;
25898 int ecode3 = 0 ;
25899 double val4 ;
25900 int ecode4 = 0 ;
25901 octave_value_list _out;
25902 octave_value_list *_outp=&_out;
25903 octave_value _outv;
25904
25905 try {
25906 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25907 SWIG_fail;
25908 }
25909 ecode1 = SWIG_AsVal_double(args(0), &val1);
25910 if (!SWIG_IsOK(ecode1)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25912 }
25913 arg1 = static_cast< PLFLT >(val1);
25914 ecode2 = SWIG_AsVal_double(args(1), &val2);
25915 if (!SWIG_IsOK(ecode2)) {
25916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25917 }
25918 arg2 = static_cast< PLFLT >(val2);
25919 ecode3 = SWIG_AsVal_double(args(2), &val3);
25920 if (!SWIG_IsOK(ecode3)) {
25921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25922 }
25923 arg3 = static_cast< PLFLT >(val3);
25924 ecode4 = SWIG_AsVal_double(args(3), &val4);
25925 if (!SWIG_IsOK(ecode4)) {
25926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25927 }
25928 arg4 = static_cast< PLFLT >(val4);
25929 plwind(arg1,arg2,arg3,arg4);
25930 _outv = octave_value();
25931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25932 return _out;
25933 fail:
25934 return octave_value_list();
25935 }
25936 catch(...) {
25937 throw;
25938 }
25939}
25940
25941
25943 PLBOOL arg1 ;
25944 PLBOOL *arg2 = (PLBOOL *) 0 ;
25945 int val1 ;
25946 int ecode1 = 0 ;
25947 PLBOOL temp2 ;
25948 int res2 = SWIG_TMPOBJ ;
25949 octave_value_list _out;
25950 octave_value_list *_outp=&_out;
25951 octave_value _outv;
25952
25953 try {
25954 arg2 = &temp2;
25955 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25956 SWIG_fail;
25957 }
25958 ecode1 = SWIG_AsVal_int(args(0), &val1);
25959 if (!SWIG_IsOK(ecode1)) {
25960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25961 }
25962 arg1 = static_cast< PLBOOL >(val1);
25963 plxormod(arg1,arg2);
25964 _outv = octave_value();
25965 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25966 if (SWIG_IsTmpObj(res2)) {
25967 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25968 } else {
25969 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25970 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25971 }
25972 return _out;
25973 fail:
25974 return octave_value_list();
25975 }
25976 catch(...) {
25977 throw;
25978 }
25979}
25980
25981
25983 mapform_func arg1 = (mapform_func) 0 ;
25984 char *arg2 = (char *) 0 ;
25985 PLFLT arg3 ;
25986 PLFLT arg4 ;
25987 PLFLT arg5 ;
25988 PLFLT arg6 ;
25989 int res2 ;
25990 char *buf2 = 0 ;
25991 int alloc2 = 0 ;
25992 double val3 ;
25993 int ecode3 = 0 ;
25994 double val4 ;
25995 int ecode4 = 0 ;
25996 double val5 ;
25997 int ecode5 = 0 ;
25998 double val6 ;
25999 int ecode6 = 0 ;
26000 octave_value_list _out;
26001 octave_value_list *_outp=&_out;
26002 octave_value _outv;
26003
26004 try {
26005 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
26006 SWIG_fail;
26007 }
26008 {
26009 octave_value obj = args(0);
26010#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26011 if ( !obj.isempty() )
26012#else
26013 if ( !obj.is_empty() )
26014#endif
26015 {
26016 if ( obj.is_function_handle() || obj.is_inline_function() )
26017 {
26018 fcnMapForm = obj.function_value();
26019 }
26020 else if ( obj.is_string() )
26021 {
26022 nameMapForm = obj.string_value();
26023 fcnMapForm = NULL;
26024 }
26025 arg1 = mapform_octave;
26026 }
26027 else
26028 {
26029 arg1 = NULL;
26030 }
26031 }
26032 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26033 if (!SWIG_IsOK(res2)) {
26034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
26035 }
26036 arg2 = reinterpret_cast< char * >(buf2);
26037 ecode3 = SWIG_AsVal_double(args(2), &val3);
26038 if (!SWIG_IsOK(ecode3)) {
26039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
26040 }
26041 arg3 = static_cast< PLFLT >(val3);
26042 ecode4 = SWIG_AsVal_double(args(3), &val4);
26043 if (!SWIG_IsOK(ecode4)) {
26044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
26045 }
26046 arg4 = static_cast< PLFLT >(val4);
26047 ecode5 = SWIG_AsVal_double(args(4), &val5);
26048 if (!SWIG_IsOK(ecode5)) {
26049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
26050 }
26051 arg5 = static_cast< PLFLT >(val5);
26052 ecode6 = SWIG_AsVal_double(args(5), &val6);
26053 if (!SWIG_IsOK(ecode6)) {
26054 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
26055 }
26056 arg6 = static_cast< PLFLT >(val6);
26057 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
26058 _outv = octave_value();
26059 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26060 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26061 return _out;
26062 fail:
26063 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26064 return octave_value_list();
26065 }
26066 catch(...) {
26067 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26068 throw;
26069 }
26070}
26071
26072
26074 mapform_func arg1 = (mapform_func) 0 ;
26075 char *arg2 = (char *) 0 ;
26076 PLFLT arg3 ;
26077 PLFLT arg4 ;
26078 PLFLT arg5 ;
26079 PLFLT arg6 ;
26080 PLINT *arg7 = (PLINT *) 0 ;
26081 PLINT arg8 ;
26082 int res2 ;
26083 char *buf2 = 0 ;
26084 int alloc2 = 0 ;
26085 double val3 ;
26086 int ecode3 = 0 ;
26087 double val4 ;
26088 int ecode4 = 0 ;
26089 double val5 ;
26090 int ecode5 = 0 ;
26091 double val6 ;
26092 int ecode6 = 0 ;
26093 Matrix temp7 ;
26094 octave_value_list _out;
26095 octave_value_list *_outp=&_out;
26096 octave_value _outv;
26097
26098 try {
26099 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26100 SWIG_fail;
26101 }
26102 {
26103 octave_value obj = args(0);
26104#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26105 if ( !obj.isempty() )
26106#else
26107 if ( !obj.is_empty() )
26108#endif
26109 {
26110 if ( obj.is_function_handle() || obj.is_inline_function() )
26111 {
26112 fcnMapForm = obj.function_value();
26113 }
26114 else if ( obj.is_string() )
26115 {
26116 nameMapForm = obj.string_value();
26117 fcnMapForm = NULL;
26118 }
26119 arg1 = mapform_octave;
26120 }
26121 else
26122 {
26123 arg1 = NULL;
26124 }
26125 }
26126 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26127 if (!SWIG_IsOK(res2)) {
26128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26129 }
26130 arg2 = reinterpret_cast< char * >(buf2);
26131 ecode3 = SWIG_AsVal_double(args(2), &val3);
26132 if (!SWIG_IsOK(ecode3)) {
26133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26134 }
26135 arg3 = static_cast< PLFLT >(val3);
26136 ecode4 = SWIG_AsVal_double(args(3), &val4);
26137 if (!SWIG_IsOK(ecode4)) {
26138 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26139 }
26140 arg4 = static_cast< PLFLT >(val4);
26141 ecode5 = SWIG_AsVal_double(args(4), &val5);
26142 if (!SWIG_IsOK(ecode5)) {
26143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26144 }
26145 arg5 = static_cast< PLFLT >(val5);
26146 ecode6 = SWIG_AsVal_double(args(5), &val6);
26147 if (!SWIG_IsOK(ecode6)) {
26148 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26149 }
26150 arg6 = static_cast< PLFLT >(val6);
26151 {
26152 if ( _n_dims( args(6) ) > 1 )
26153 {
26154 error( "argument must be a scalar or vector" ); SWIG_fail;
26155 }
26156#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26157 if ( !args(6).isempty() )
26158#else
26159 if ( !args(6).is_empty() )
26160#endif
26161 {
26162 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26163 temp7 = args(6).matrix_value();
26164 arg7 = new PLINT[arg8];
26165 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26166 }
26167 else
26168 {
26169 arg7 = NULL;
26170 arg8 = 0;
26171 }
26172 }
26173 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26174 _outv = octave_value();
26175 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26176 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26177 {
26178 delete [] arg7;
26179 }
26180 return _out;
26181 fail:
26182 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26183 {
26184 delete [] arg7;
26185 }
26186 return octave_value_list();
26187 }
26188 catch(...) {
26189 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26190 {
26191 delete [] arg7;
26192 }
26193 throw;
26194 }
26195}
26196
26197
26199 mapform_func arg1 = (mapform_func) 0 ;
26200 char *arg2 = (char *) 0 ;
26201 char *arg3 = (char *) 0 ;
26202 PLFLT arg4 ;
26203 PLFLT arg5 ;
26204 PLFLT arg6 ;
26205 PLFLT arg7 ;
26206 PLINT *arg8 = (PLINT *) 0 ;
26207 PLINT arg9 ;
26208 int res2 ;
26209 char *buf2 = 0 ;
26210 int alloc2 = 0 ;
26211 int res3 ;
26212 char *buf3 = 0 ;
26213 int alloc3 = 0 ;
26214 double val4 ;
26215 int ecode4 = 0 ;
26216 double val5 ;
26217 int ecode5 = 0 ;
26218 double val6 ;
26219 int ecode6 = 0 ;
26220 double val7 ;
26221 int ecode7 = 0 ;
26222 Matrix temp8 ;
26223 octave_value_list _out;
26224 octave_value_list *_outp=&_out;
26225 octave_value _outv;
26226
26227 try {
26228 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26229 SWIG_fail;
26230 }
26231 {
26232 octave_value obj = args(0);
26233#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26234 if ( !obj.isempty() )
26235#else
26236 if ( !obj.is_empty() )
26237#endif
26238 {
26239 if ( obj.is_function_handle() || obj.is_inline_function() )
26240 {
26241 fcnMapForm = obj.function_value();
26242 }
26243 else if ( obj.is_string() )
26244 {
26245 nameMapForm = obj.string_value();
26246 fcnMapForm = NULL;
26247 }
26248 arg1 = mapform_octave;
26249 }
26250 else
26251 {
26252 arg1 = NULL;
26253 }
26254 }
26255 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26256 if (!SWIG_IsOK(res2)) {
26257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26258 }
26259 arg2 = reinterpret_cast< char * >(buf2);
26260 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26261 if (!SWIG_IsOK(res3)) {
26262 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26263 }
26264 arg3 = reinterpret_cast< char * >(buf3);
26265 ecode4 = SWIG_AsVal_double(args(3), &val4);
26266 if (!SWIG_IsOK(ecode4)) {
26267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26268 }
26269 arg4 = static_cast< PLFLT >(val4);
26270 ecode5 = SWIG_AsVal_double(args(4), &val5);
26271 if (!SWIG_IsOK(ecode5)) {
26272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26273 }
26274 arg5 = static_cast< PLFLT >(val5);
26275 ecode6 = SWIG_AsVal_double(args(5), &val6);
26276 if (!SWIG_IsOK(ecode6)) {
26277 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26278 }
26279 arg6 = static_cast< PLFLT >(val6);
26280 ecode7 = SWIG_AsVal_double(args(6), &val7);
26281 if (!SWIG_IsOK(ecode7)) {
26282 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26283 }
26284 arg7 = static_cast< PLFLT >(val7);
26285 {
26286 if ( _n_dims( args(7) ) > 1 )
26287 {
26288 error( "argument must be a scalar or vector" ); SWIG_fail;
26289 }
26290#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26291 if ( !args(7).isempty() )
26292#else
26293 if ( !args(7).is_empty() )
26294#endif
26295 {
26296 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26297 temp8 = args(7).matrix_value();
26298 arg8 = new PLINT[arg9];
26299 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26300 }
26301 else
26302 {
26303 arg8 = NULL;
26304 arg9 = 0;
26305 }
26306 }
26307 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26308 _outv = octave_value();
26309 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26310 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26311 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26312 {
26313 delete [] arg8;
26314 }
26315 return _out;
26316 fail:
26317 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26318 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26319 {
26320 delete [] arg8;
26321 }
26322 return octave_value_list();
26323 }
26324 catch(...) {
26325 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26326 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26327 {
26328 delete [] arg8;
26329 }
26330 throw;
26331 }
26332}
26333
26334
26336 mapform_func arg1 = (mapform_func) 0 ;
26337 char *arg2 = (char *) 0 ;
26338 PLFLT arg3 ;
26339 PLFLT arg4 ;
26340 PLFLT arg5 ;
26341 char *arg6 = (char *) 0 ;
26342 PLFLT arg7 ;
26343 PLFLT arg8 ;
26344 PLFLT arg9 ;
26345 PLFLT arg10 ;
26346 PLINT arg11 ;
26347 int res2 ;
26348 char *buf2 = 0 ;
26349 int alloc2 = 0 ;
26350 double val3 ;
26351 int ecode3 = 0 ;
26352 double val4 ;
26353 int ecode4 = 0 ;
26354 double val5 ;
26355 int ecode5 = 0 ;
26356 int res6 ;
26357 char *buf6 = 0 ;
26358 int alloc6 = 0 ;
26359 double val7 ;
26360 int ecode7 = 0 ;
26361 double val8 ;
26362 int ecode8 = 0 ;
26363 double val9 ;
26364 int ecode9 = 0 ;
26365 double val10 ;
26366 int ecode10 = 0 ;
26367 int val11 ;
26368 int ecode11 = 0 ;
26369 octave_value_list _out;
26370 octave_value_list *_outp=&_out;
26371 octave_value _outv;
26372
26373 try {
26374 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26375 SWIG_fail;
26376 }
26377 {
26378 octave_value obj = args(0);
26379#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26380 if ( !obj.isempty() )
26381#else
26382 if ( !obj.is_empty() )
26383#endif
26384 {
26385 if ( obj.is_function_handle() || obj.is_inline_function() )
26386 {
26387 fcnMapForm = obj.function_value();
26388 }
26389 else if ( obj.is_string() )
26390 {
26391 nameMapForm = obj.string_value();
26392 fcnMapForm = NULL;
26393 }
26394 arg1 = mapform_octave;
26395 }
26396 else
26397 {
26398 arg1 = NULL;
26399 }
26400 }
26401 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26402 if (!SWIG_IsOK(res2)) {
26403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26404 }
26405 arg2 = reinterpret_cast< char * >(buf2);
26406 ecode3 = SWIG_AsVal_double(args(2), &val3);
26407 if (!SWIG_IsOK(ecode3)) {
26408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26409 }
26410 arg3 = static_cast< PLFLT >(val3);
26411 ecode4 = SWIG_AsVal_double(args(3), &val4);
26412 if (!SWIG_IsOK(ecode4)) {
26413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26414 }
26415 arg4 = static_cast< PLFLT >(val4);
26416 ecode5 = SWIG_AsVal_double(args(4), &val5);
26417 if (!SWIG_IsOK(ecode5)) {
26418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26419 }
26420 arg5 = static_cast< PLFLT >(val5);
26421 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26422 if (!SWIG_IsOK(res6)) {
26423 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26424 }
26425 arg6 = reinterpret_cast< char * >(buf6);
26426 ecode7 = SWIG_AsVal_double(args(6), &val7);
26427 if (!SWIG_IsOK(ecode7)) {
26428 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26429 }
26430 arg7 = static_cast< PLFLT >(val7);
26431 ecode8 = SWIG_AsVal_double(args(7), &val8);
26432 if (!SWIG_IsOK(ecode8)) {
26433 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26434 }
26435 arg8 = static_cast< PLFLT >(val8);
26436 ecode9 = SWIG_AsVal_double(args(8), &val9);
26437 if (!SWIG_IsOK(ecode9)) {
26438 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26439 }
26440 arg9 = static_cast< PLFLT >(val9);
26441 ecode10 = SWIG_AsVal_double(args(9), &val10);
26442 if (!SWIG_IsOK(ecode10)) {
26443 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26444 }
26445 arg10 = static_cast< PLFLT >(val10);
26446 ecode11 = SWIG_AsVal_int(args(10), &val11);
26447 if (!SWIG_IsOK(ecode11)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26449 }
26450 arg11 = static_cast< PLINT >(val11);
26451 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26452 _outv = octave_value();
26453 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26454 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26455 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26456 return _out;
26457 fail:
26458 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26459 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26460 return octave_value_list();
26461 }
26462 catch(...) {
26463 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26464 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26465 throw;
26466 }
26467}
26468
26469
26471 mapform_func arg1 = (mapform_func) 0 ;
26472 char *arg2 = (char *) 0 ;
26473 PLFLT arg3 ;
26474 PLFLT arg4 ;
26475 PLFLT arg5 ;
26476 PLFLT arg6 ;
26477 PLINT *arg7 = (PLINT *) 0 ;
26478 PLINT arg8 ;
26479 int res2 ;
26480 char *buf2 = 0 ;
26481 int alloc2 = 0 ;
26482 double val3 ;
26483 int ecode3 = 0 ;
26484 double val4 ;
26485 int ecode4 = 0 ;
26486 double val5 ;
26487 int ecode5 = 0 ;
26488 double val6 ;
26489 int ecode6 = 0 ;
26490 Matrix temp7 ;
26491 octave_value_list _out;
26492 octave_value_list *_outp=&_out;
26493 octave_value _outv;
26494
26495 try {
26496 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26497 SWIG_fail;
26498 }
26499 {
26500 octave_value obj = args(0);
26501#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26502 if ( !obj.isempty() )
26503#else
26504 if ( !obj.is_empty() )
26505#endif
26506 {
26507 if ( obj.is_function_handle() || obj.is_inline_function() )
26508 {
26509 fcnMapForm = obj.function_value();
26510 }
26511 else if ( obj.is_string() )
26512 {
26513 nameMapForm = obj.string_value();
26514 fcnMapForm = NULL;
26515 }
26516 arg1 = mapform_octave;
26517 }
26518 else
26519 {
26520 arg1 = NULL;
26521 }
26522 }
26523 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26524 if (!SWIG_IsOK(res2)) {
26525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26526 }
26527 arg2 = reinterpret_cast< char * >(buf2);
26528 ecode3 = SWIG_AsVal_double(args(2), &val3);
26529 if (!SWIG_IsOK(ecode3)) {
26530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26531 }
26532 arg3 = static_cast< PLFLT >(val3);
26533 ecode4 = SWIG_AsVal_double(args(3), &val4);
26534 if (!SWIG_IsOK(ecode4)) {
26535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26536 }
26537 arg4 = static_cast< PLFLT >(val4);
26538 ecode5 = SWIG_AsVal_double(args(4), &val5);
26539 if (!SWIG_IsOK(ecode5)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26541 }
26542 arg5 = static_cast< PLFLT >(val5);
26543 ecode6 = SWIG_AsVal_double(args(5), &val6);
26544 if (!SWIG_IsOK(ecode6)) {
26545 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26546 }
26547 arg6 = static_cast< PLFLT >(val6);
26548 {
26549 if ( _n_dims( args(6) ) > 1 )
26550 {
26551 error( "argument must be a scalar or vector" ); SWIG_fail;
26552 }
26553#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26554 if ( !args(6).isempty() )
26555#else
26556 if ( !args(6).is_empty() )
26557#endif
26558 {
26559 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26560 temp7 = args(6).matrix_value();
26561 arg7 = new PLINT[arg8];
26562 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26563 }
26564 else
26565 {
26566 arg7 = NULL;
26567 arg8 = 0;
26568 }
26569 }
26570 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26571 _outv = octave_value();
26572 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26573 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26574 {
26575 delete [] arg7;
26576 }
26577 return _out;
26578 fail:
26579 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26580 {
26581 delete [] arg7;
26582 }
26583 return octave_value_list();
26584 }
26585 catch(...) {
26586 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26587 {
26588 delete [] arg7;
26589 }
26590 throw;
26591 }
26592}
26593
26594
26596 mapform_func arg1 = (mapform_func) 0 ;
26597 PLFLT arg2 ;
26598 PLFLT arg3 ;
26599 PLFLT arg4 ;
26600 PLFLT arg5 ;
26601 PLFLT arg6 ;
26602 PLFLT arg7 ;
26603 double val2 ;
26604 int ecode2 = 0 ;
26605 double val3 ;
26606 int ecode3 = 0 ;
26607 double val4 ;
26608 int ecode4 = 0 ;
26609 double val5 ;
26610 int ecode5 = 0 ;
26611 double val6 ;
26612 int ecode6 = 0 ;
26613 double val7 ;
26614 int ecode7 = 0 ;
26615 octave_value_list _out;
26616 octave_value_list *_outp=&_out;
26617 octave_value _outv;
26618
26619 try {
26620 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26621 SWIG_fail;
26622 }
26623 {
26624 octave_value obj = args(0);
26625#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26626 if ( !obj.isempty() )
26627#else
26628 if ( !obj.is_empty() )
26629#endif
26630 {
26631 if ( obj.is_function_handle() || obj.is_inline_function() )
26632 {
26633 fcnMapForm = obj.function_value();
26634 }
26635 else if ( obj.is_string() )
26636 {
26637 nameMapForm = obj.string_value();
26638 fcnMapForm = NULL;
26639 }
26640 arg1 = mapform_octave;
26641 }
26642 else
26643 {
26644 arg1 = NULL;
26645 }
26646 }
26647 ecode2 = SWIG_AsVal_double(args(1), &val2);
26648 if (!SWIG_IsOK(ecode2)) {
26649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26650 }
26651 arg2 = static_cast< PLFLT >(val2);
26652 ecode3 = SWIG_AsVal_double(args(2), &val3);
26653 if (!SWIG_IsOK(ecode3)) {
26654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26655 }
26656 arg3 = static_cast< PLFLT >(val3);
26657 ecode4 = SWIG_AsVal_double(args(3), &val4);
26658 if (!SWIG_IsOK(ecode4)) {
26659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26660 }
26661 arg4 = static_cast< PLFLT >(val4);
26662 ecode5 = SWIG_AsVal_double(args(4), &val5);
26663 if (!SWIG_IsOK(ecode5)) {
26664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26665 }
26666 arg5 = static_cast< PLFLT >(val5);
26667 ecode6 = SWIG_AsVal_double(args(5), &val6);
26668 if (!SWIG_IsOK(ecode6)) {
26669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26670 }
26671 arg6 = static_cast< PLFLT >(val6);
26672 ecode7 = SWIG_AsVal_double(args(6), &val7);
26673 if (!SWIG_IsOK(ecode7)) {
26674 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26675 }
26676 arg7 = static_cast< PLFLT >(val7);
26677 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26678 _outv = octave_value();
26679 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26680 return _out;
26681 fail:
26682 return octave_value_list();
26683 }
26684 catch(...) {
26685 throw;
26686 }
26687}
26688
26689
26691 octave_value_list _out;
26692 octave_value_list *_outp=&_out;
26693 octave_value _outv;
26694
26695 try {
26696 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26697 SWIG_fail;
26698 }
26699 plClearOpts();
26700 _outv = octave_value();
26701 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26702 return _out;
26703 fail:
26704 return octave_value_list();
26705 }
26706 catch(...) {
26707 throw;
26708 }
26709}
26710
26711
26713 octave_value_list _out;
26714 octave_value_list *_outp=&_out;
26715 octave_value _outv;
26716
26717 try {
26718 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26719 SWIG_fail;
26720 }
26721 plResetOpts();
26722 _outv = octave_value();
26723 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26724 return _out;
26725 fail:
26726 return octave_value_list();
26727 }
26728 catch(...) {
26729 throw;
26730 }
26731}
26732
26733
26735 char *arg1 = (char *) 0 ;
26736 char *arg2 = (char *) 0 ;
26737 int res1 ;
26738 char *buf1 = 0 ;
26739 int alloc1 = 0 ;
26740 int res2 ;
26741 char *buf2 = 0 ;
26742 int alloc2 = 0 ;
26743 octave_value_list _out;
26744 octave_value_list *_outp=&_out;
26745 octave_value _outv;
26746
26747 try {
26748 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26749 SWIG_fail;
26750 }
26751 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26752 if (!SWIG_IsOK(res1)) {
26753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26754 }
26755 arg1 = reinterpret_cast< char * >(buf1);
26756 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26757 if (!SWIG_IsOK(res2)) {
26758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26759 }
26760 arg2 = reinterpret_cast< char * >(buf2);
26761 plSetUsage((char const *)arg1,(char const *)arg2);
26762 _outv = octave_value();
26763 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26764 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26765 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26766 return _out;
26767 fail:
26768 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26769 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26770 return octave_value_list();
26771 }
26772 catch(...) {
26773 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26774 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26775 throw;
26776 }
26777}
26778
26779
26781 octave_value_list _out;
26782 octave_value_list *_outp=&_out;
26783 octave_value _outv;
26784
26785 try {
26786 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26787 SWIG_fail;
26788 }
26789 plOptUsage();
26790 _outv = octave_value();
26791 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26792 return _out;
26793 fail:
26794 return octave_value_list();
26795 }
26796 catch(...) {
26797 throw;
26798 }
26799}
26800
26801
26802
26803static const struct swig_octave_member swig_globals[] = {
26804{"testppchar",_wrap_testppchar,0,0,2,0},
26805{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26806{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26807{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26808{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26809{"plcont0",_wrap_plcont0,0,0,2,0},
26810{"plcont1",_wrap_plcont1,0,0,2,0},
26811{"plcont2",_wrap_plcont2,0,0,2,0},
26812{"plcont2p",_wrap_plcont2p,0,0,2,0},
26813{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26814{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26815{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26816{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26817{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26818{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26819{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26820{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26821{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26822{"plshade1",_wrap_plshade1,0,0,2,0},
26823{"plshade2",_wrap_plshade2,0,0,2,0},
26824{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26825{"plshadesx",_wrap_plshadesx,0,0,2,0},
26826{"plshades1",_wrap_plshades1,0,0,2,0},
26827{"plshades2",_wrap_plshades2,0,0,2,0},
26828{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26829{"plvect1",_wrap_plvect1,0,0,2,0},
26830{"plvect2",_wrap_plvect2,0,0,2,0},
26831{"pplimage",_wrap_pplimage,0,0,2,0},
26832{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26833{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26834{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26835{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26836{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26837{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26838{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26839{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26840{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26841{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26842{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26843{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26844{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26845{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26846{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26847{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26848{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26849{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26850{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26851{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26852{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26853{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26854{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26855{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26856{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26857{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26858{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26859{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26860{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26861{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26862{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26865{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26866{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26867{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26868{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26869{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26870{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26871{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26872{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26873{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26874{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26875{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26876{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26877{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26878{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26879{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26880{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26881{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26882{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26883{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26884{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26885{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26886{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26887{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26888{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26889{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26890{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26891{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26892{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26893{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26894{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26895{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26896{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26897{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26898{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26899{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26900{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26901{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26902{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26903{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26904{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26905{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26906{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26907{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26908{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26909{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26910{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26911{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26912{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26913{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26914{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26915{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26916{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26917{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26918{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26919{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26920{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26921{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26922{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26923{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26924{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26925{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26926{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26927{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26928{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26929{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26930{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26931{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26932{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26933{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26934{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26935{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26936{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26937{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26938{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26939{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26940{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26941{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26942{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26943{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26944{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26945{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26946{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26947{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26948{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26949{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26950{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26951{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26952{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26953{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26954{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26955{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26956{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26957{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26958{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26959{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26960{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26961{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26962{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26963{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26964{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26965{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26966{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26967{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26968{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26969{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26970{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26971{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26972{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26973{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26974{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26975{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26976{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26977{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26978{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26979{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26980{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26981{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26982{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26983{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26984{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26985{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26986{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26987{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26988{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26989{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26990{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26991{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26992{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26993{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26994{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26995{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26996{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26997{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26998{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26999{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
27000{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
27001{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
27002{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
27003{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
27004{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
27005{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
27006{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
27007{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
27008{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
27009{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
27010{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
27011{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
27012{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
27013{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
27014{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
27015{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
27016{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
27017{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
27018{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
27019{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
27020{0,0,0,0,0,0}
27021};
27022
27023/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
27024
27025static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
27026static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
27027static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
27028static 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};
27029static 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};
27030static 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};
27031static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
27032static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
27033static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
27034
27046
27047static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
27048static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
27049static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
27053static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
27054static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
27055static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
27056
27068
27069
27070/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
27071
27072/* -----------------------------------------------------------------------------
27073 * Type initialization:
27074 * This problem is tough by the requirement that no dynamic
27075 * memory is used. Also, since swig_type_info structures store pointers to
27076 * swig_cast_info structures and swig_cast_info structures store pointers back
27077 * to swig_type_info structures, we need some lookup code at initialization.
27078 * The idea is that swig generates all the structures that are needed.
27079 * The runtime then collects these partially filled structures.
27080 * The SWIG_InitializeModule function takes these initial arrays out of
27081 * swig_module, and does all the lookup, filling in the swig_module.types
27082 * array with the correct data and linking the correct swig_cast_info
27083 * structures together.
27084 *
27085 * The generated swig_type_info structures are assigned statically to an initial
27086 * array. We just loop through that array, and handle each type individually.
27087 * First we lookup if this type has been already loaded, and if so, use the
27088 * loaded structure instead of the generated one. Then we have to fill in the
27089 * cast linked list. The cast data is initially stored in something like a
27090 * two-dimensional array. Each row corresponds to a type (there are the same
27091 * number of rows as there are in the swig_type_initial array). Each entry in
27092 * a column is one of the swig_cast_info structures for that type.
27093 * The cast_initial array is actually an array of arrays, because each row has
27094 * a variable number of columns. So to actually build the cast linked list,
27095 * we find the array of casts associated with the type, and loop through it
27096 * adding the casts to the list. The one last trick we need to do is making
27097 * sure the type pointer in the swig_cast_info struct is correct.
27098 *
27099 * First off, we lookup the cast->type name to see if it is already loaded.
27100 * There are three cases to handle:
27101 * 1) If the cast->type has already been loaded AND the type we are adding
27102 * casting info to has not been loaded (it is in this module), THEN we
27103 * replace the cast->type pointer with the type pointer that has already
27104 * been loaded.
27105 * 2) If BOTH types (the one we are adding casting info to, and the
27106 * cast->type) are loaded, THEN the cast info has already been loaded by
27107 * the previous module so we just ignore it.
27108 * 3) Finally, if cast->type has not already been loaded, then we add that
27109 * swig_cast_info to the linked list (because the cast->type) pointer will
27110 * be correct.
27111 * ----------------------------------------------------------------------------- */
27112
27113#ifdef __cplusplus
27114extern "C" {
27115#if 0
27116} /* c-mode */
27117#endif
27118#endif
27119
27120#if 0
27121#define SWIGRUNTIME_DEBUG
27122#endif
27123
27124#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27125#define SWIG_INIT_CLIENT_DATA_TYPE void *
27126#endif
27127
27128SWIGRUNTIME void
27130 size_t i;
27131 swig_module_info *module_head, *iter;
27132 int init;
27133
27134 /* check to see if the circular list has been setup, if not, set it up */
27135 if (swig_module.next==0) {
27136 /* Initialize the swig_module */
27140 init = 1;
27141 } else {
27142 init = 0;
27143 }
27144
27145 /* Try and load any already created modules */
27146 module_head = SWIG_GetModule(clientdata);
27147 if (!module_head) {
27148 /* This is the first module loaded for this interpreter */
27149 /* so set the swig module into the interpreter */
27150 SWIG_SetModule(clientdata, &swig_module);
27151 } else {
27152 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27153 iter=module_head;
27154 do {
27155 if (iter==&swig_module) {
27156 /* Our module is already in the list, so there's nothing more to do. */
27157 return;
27158 }
27159 iter=iter->next;
27160 } while (iter!= module_head);
27161
27162 /* otherwise we must add our module into the list */
27163 swig_module.next = module_head->next;
27164 module_head->next = &swig_module;
27165 }
27166
27167 /* When multiple interpreters are used, a module could have already been initialized in
27168 a different interpreter, but not yet have a pointer in this interpreter.
27169 In this case, we do not want to continue adding types... everything should be
27170 set up already */
27171 if (init == 0) return;
27172
27173 /* Now work on filling in swig_module.types */
27174#ifdef SWIGRUNTIME_DEBUG
27175 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27176#endif
27177 for (i = 0; i < swig_module.size; ++i) {
27178 swig_type_info *type = 0;
27179 swig_type_info *ret;
27180 swig_cast_info *cast;
27181
27182#ifdef SWIGRUNTIME_DEBUG
27183 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27184#endif
27185
27186 /* if there is another module already loaded */
27187 if (swig_module.next != &swig_module) {
27189 }
27190 if (type) {
27191 /* Overwrite clientdata field */
27192#ifdef SWIGRUNTIME_DEBUG
27193 printf("SWIG_InitializeModule: found type %s\n", type->name);
27194#endif
27196 type->clientdata = swig_module.type_initial[i]->clientdata;
27197#ifdef SWIGRUNTIME_DEBUG
27198 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27199#endif
27200 }
27201 } else {
27202 type = swig_module.type_initial[i];
27203 }
27204
27205 /* Insert casting types */
27206 cast = swig_module.cast_initial[i];
27207 while (cast->type) {
27208
27209 /* Don't need to add information already in the list */
27210 ret = 0;
27211#ifdef SWIGRUNTIME_DEBUG
27212 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27213#endif
27214 if (swig_module.next != &swig_module) {
27216#ifdef SWIGRUNTIME_DEBUG
27217 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27218#endif
27219 }
27220 if (ret) {
27221 if (type == swig_module.type_initial[i]) {
27222#ifdef SWIGRUNTIME_DEBUG
27223 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27224#endif
27225 cast->type = ret;
27226 ret = 0;
27227 } else {
27228 /* Check for casting already in the list */
27229 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27230#ifdef SWIGRUNTIME_DEBUG
27231 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27232#endif
27233 if (!ocast) ret = 0;
27234 }
27235 }
27236
27237 if (!ret) {
27238#ifdef SWIGRUNTIME_DEBUG
27239 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27240#endif
27241 if (type->cast) {
27242 type->cast->prev = cast;
27243 cast->next = type->cast;
27244 }
27245 type->cast = cast;
27246 }
27247 cast++;
27248 }
27249 /* Set entry in modules->types array equal to the type */
27250 swig_module.types[i] = type;
27251 }
27252 swig_module.types[i] = 0;
27253
27254#ifdef SWIGRUNTIME_DEBUG
27255 printf("**** SWIG_InitializeModule: Cast List ******\n");
27256 for (i = 0; i < swig_module.size; ++i) {
27257 int j = 0;
27259 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27260 while (cast->type) {
27261 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27262 cast++;
27263 ++j;
27264 }
27265 printf("---- Total casts: %d\n",j);
27266 }
27267 printf("**** SWIG_InitializeModule: Cast List ******\n");
27268#endif
27269}
27270
27271/* This function will propagate the clientdata field of type to
27272* any new swig_type_info structures that have been added into the list
27273* of equivalent types. It is like calling
27274* SWIG_TypeClientData(type, clientdata) a second time.
27275*/
27276SWIGRUNTIME void
27278 size_t i;
27279 swig_cast_info *equiv;
27280 static int init_run = 0;
27281
27282 if (init_run) return;
27283 init_run = 1;
27284
27285 for (i = 0; i < swig_module.size; i++) {
27286 if (swig_module.types[i]->clientdata) {
27287 equiv = swig_module.types[i]->cast;
27288 while (equiv) {
27289 if (!equiv->converter) {
27290 if (equiv->type && !equiv->type->clientdata)
27292 }
27293 equiv = equiv->next;
27294 }
27295 }
27296 }
27297}
27298
27299#ifdef __cplusplus
27300#if 0
27301{ /* c-mode */
27302#endif
27303}
27304#endif
27305
27306
27307
27308static bool SWIG_init_user(octave_swig_type* module_ns);
27309
27311 bool retn = false;
27312 {
27313#if SWIG_OCTAVE_PREREQ(6,0,0)
27314#elif SWIG_OCTAVE_PREREQ(4,2,0)
27315 octave::unwind_protect frame;
27316 frame.protect_var(discard_error_messages); discard_error_messages = true;
27317 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27318#elif SWIG_OCTAVE_PREREQ(3,3,50)
27319 unwind_protect frame;
27320 frame.protect_var(error_state); error_state = 0;
27321 frame.protect_var(warning_state); warning_state = 0;
27322 frame.protect_var(discard_error_messages); discard_error_messages = true;
27323 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27324#else
27325 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27326 unwind_protect_int(error_state); error_state = 0;
27327 unwind_protect_int(warning_state); warning_state = 0;
27328 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27329 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27330#endif
27331#if SWIG_OCTAVE_PREREQ(4,2,0)
27332 try {
27333#if SWIG_OCTAVE_PREREQ(4,4,0)
27334 octave::feval(name, octave_value_list(), 0);
27335#else
27336 feval(name, octave_value_list(), 0);
27337#endif
27338 retn = true;
27339 } catch (octave::execution_exception&) { }
27340#else
27341 feval(name, octave_value_list(), 0);
27342 retn = (error_state == 0);
27343#endif
27344#if !SWIG_OCTAVE_PREREQ(3,3,50)
27345 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27346#endif
27347 }
27348 if (!retn) {
27349 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27350 }
27351 return retn;
27352}
27353
27354SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27355 bool retn = false;
27356 {
27357#if SWIG_OCTAVE_PREREQ(6,0,0)
27358#elif SWIG_OCTAVE_PREREQ(4,2,0)
27359 octave::unwind_protect frame;
27360 frame.protect_var(discard_error_messages); discard_error_messages = true;
27361 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27362#elif SWIG_OCTAVE_PREREQ(3,3,50)
27363 unwind_protect frame;
27364 frame.protect_var(error_state); error_state = 0;
27365 frame.protect_var(warning_state); warning_state = 0;
27366 frame.protect_var(discard_error_messages); discard_error_messages = true;
27367 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27368#else
27369 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27370 unwind_protect_int(error_state); error_state = 0;
27371 unwind_protect_int(warning_state); warning_state = 0;
27372 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27373 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27374#endif
27375 octave_value_list args;
27376 args.append(name);
27377 args.append(octloadfcn->fcn_file_name());
27378#if SWIG_OCTAVE_PREREQ(4,2,0)
27379 try {
27380#if SWIG_OCTAVE_PREREQ(4,4,0)
27381 octave::feval("autoload", args, 0);
27382#else
27383 feval("autoload", args, 0);
27384#endif
27385 retn = true;
27386 } catch (octave::execution_exception&) { }
27387#else
27388 feval("autoload", args, 0);
27389 retn = (error_state == 0);
27390#endif
27391#if !SWIG_OCTAVE_PREREQ(3,3,50)
27392 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27393#endif
27394 }
27395 if (!retn) {
27396 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27397 }
27398 return retn;
27399}
27400
27401static const char *const subclass_usage = "-*- texinfo -*- \n\
27402@deftypefn {Loadable Function} {} subclass()\n\
27403@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27404Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27405\n\
27406See the SWIG manual for usage examples.\n\
27407@end deftypefn";
27408
27409DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27411 for (int j = 0; j < args.length(); ++j) {
27412 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27413 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27414 octave_swig_type *ost = osr->get_ptr();
27415 if (!ost->is_owned()) {
27416 error("subclass: cannot subclass object not constructed on octave side");
27417 return octave_value_list();
27418 }
27419 top->merge(*ost);
27420 } else if (args(j).is_function_handle()) {
27421 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27422 } else if (args(j).is_string()) {
27423 if (j + 1 >= args.length()) {
27424 error("subclass: member assignments must be of string,value form");
27425 return octave_value_list();
27426 }
27427 top->assign(args(j).string_value(), args(j + 1));
27428 ++j;
27429 } else {
27430 error("subclass: invalid arguments to subclass()");
27431 return octave_value_list();
27432 }
27433 }
27434 return octave_value(Swig::swig_value_ref(top));
27435}
27436
27437static const char *const swig_type_usage = "-*- texinfo -*- \n\
27438@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27439Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27440@end deftypefn";
27441
27442DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27443 if (args.length() != 1) {
27444 error("swig_type: must be called with only a single object");
27445 return octave_value_list();
27446 }
27448 if (!ost) {
27449 error("swig_type: object is not a swig_ref");
27450 return octave_value_list();
27451 }
27452 return octave_value(ost->swig_type_name());
27453}
27454
27455static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27456@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27457Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27458otherwise return `<unknown>'.\n\
27459@end deftypefn";
27460
27461DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27462 if (args.length() != 1 || !args(0).is_string()) {
27463 error("swig_typequery: must be called with single string argument");
27464 return octave_value_list();
27465 }
27466 swig_module_info *module = SWIG_GetModule(0);
27467 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27468 if (!type)
27469 return octave_value("<unknown>");
27470 return octave_value(type->name);
27471}
27472
27473static const char *const swig_this_usage = "-*- texinfo -*- \n\
27474@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27475Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27476@end deftypefn";
27477
27478DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27479 if (args.length() != 1) {
27480 error("swig_this: must be called with only a single object");
27481 return octave_value_list();
27482 }
27483 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27484 return octave_value(octave_uint64(0));
27486 if (!ost) {
27487 error("swig_this: object is not a swig_ref");
27488 return octave_value_list();
27489 }
27490 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27491}
27492
27493static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27494@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27495Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27496@end deftypefn";
27497
27498DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27499 if (args.length() != 3) {
27500 error("swig_octave_prereq: must be called with 3 arguments");
27501 return octave_value_list();
27502 }
27503 const int major = args(0).int_value();
27504 const int minor = args(1).int_value();
27505 const int patch = args(2).int_value();
27506 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27507 return octave_value(prereq);
27508}
27509
27510static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27511@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27512Exit Octave without performing any memory cleanup.\n\
27513@end deftypefn";
27514
27515DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27516 if (args.length() > 1) {
27517 error("swig_exit: must be called with at most one arguments");
27518 return octave_value_list();
27519 }
27520 int exit_status = 0;
27521 if (args.length() == 1) {
27522 exit_status = args(0).int_value();
27523 }
27524 ::_Exit(exit_status);
27525 return octave_value();
27526}
27527
27528static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27529@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27530Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27531@end deftypefn";
27532
27534
27535 static octave_swig_type* module_ns = 0;
27536
27537 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27538 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27539 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27540 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27541 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27542 // can be turned off with macro definition.
27543#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27544#if !SWIG_OCTAVE_PREREQ(4,4,0)
27545#if SWIG_OCTAVE_PREREQ(3,2,0)
27546 octave_exit = ::_Exit;
27547#endif
27548#endif
27549#endif
27550
27551 // check for no input and output args
27552 if (args.length() != 0 || nargout != 0) {
27553 print_usage();
27554 return octave_value_list();
27555 }
27556
27557 // create module on first function call
27558 if (!module_ns) {
27559
27560 // workaround bug in octave where installing global variable of custom type and then
27561 // exiting without explicitly clearing the variable causes octave to segfault.
27562#if SWIG_OCTAVE_PREREQ(3,2,0)
27563 octave_value_list eval_args;
27564 eval_args.append("base");
27565 eval_args.append("function __swig_atexit__; "
27566 " if mislocked() "
27567 " clear -all; "
27568 " else "
27569 " mlock(); "
27570 " endif; "
27571 "endfunction; "
27572 "__swig_atexit__; "
27573 "atexit(\"__swig_atexit__\", false); "
27574 "atexit(\"__swig_atexit__\")");
27575#if SWIG_OCTAVE_PREREQ(4,4,0)
27576 octave::feval("evalin", eval_args, 0);
27577#else
27578 feval("evalin", eval_args, 0);
27579#endif
27580#endif
27581
27582#if SWIG_OCTAVE_PREREQ(4,4,0)
27583 {
27584 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27585 string_vector types = typeinfo.installed_type_names();
27586 bool register_octave_swig_ref = true;
27587 bool register_octave_swig_packed = true;
27588 for (int i = 0; i < types.numel(); ++i) {
27589 if (types(i) == octave_swig_ref::static_type_name()) {
27590 register_octave_swig_ref = false;
27591 octave_swig_ref::set_type_id(i);
27592 }
27593 if (types(i) == octave_swig_packed::static_type_name()) {
27594 register_octave_swig_packed = false;
27595 octave_swig_packed::set_type_id(i);
27596 }
27597 }
27598 if (register_octave_swig_ref) {
27599 octave_swig_ref::register_type();
27600 }
27601 if (register_octave_swig_packed) {
27602 octave_swig_packed::register_type();
27603 }
27604 }
27605#else
27606 octave_swig_ref::register_type();
27607 octave_swig_packed::register_type();
27608#endif
27611
27612#if SWIG_OCTAVE_PREREQ(8,0,0)
27613 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27614 octave_function *me = tree_eval.current_function();
27615#elif SWIG_OCTAVE_PREREQ(6,0,0)
27616 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27617 octave::call_stack& stack = tree_eval.get_call_stack();
27618 octave_function *me = stack.current_function();
27619#elif SWIG_OCTAVE_PREREQ(4,4,0)
27620 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27621 octave_function *me = stack.current();
27622#else
27623 octave_function *me = octave_call_stack::current();
27624#endif
27625
27626 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27627 return octave_value_list();
27628 }
27629 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27630 return octave_value_list();
27631 }
27632 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27633 return octave_value_list();
27634 }
27635 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27636 return octave_value_list();
27637 }
27638 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27639 return octave_value_list();
27640 }
27641 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27642 return octave_value_list();
27643 }
27644
27645 octave_swig_type* cvar_ns=0;
27646 if (std::string(SWIG_global_name) != ".") {
27647 cvar_ns=new octave_swig_type;
27648 for (int j=0;swig_globals[j].name;++j)
27649 if (swig_globals[j].get_method)
27650 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27651 }
27652
27653 module_ns=new octave_swig_type(0, 0, 0, true);
27654 if (std::string(SWIG_global_name) != ".") {
27655 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27656 }
27657 else {
27658 for (int j=0;swig_globals[j].name;++j)
27659 if (swig_globals[j].get_method)
27660 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27661 }
27662 for (int j=0;swig_globals[j].name;++j)
27663 if (swig_globals[j].method)
27664 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27665
27666 // * need better solution here; swig_type -> octave_class mapping is
27667 // * really n-to-1, in some cases such as template partial spec, etc.
27668 // * see failing tests.
27669 for (int j=0;swig_types[j];++j)
27670 if (swig_types[j]->clientdata) {
27672 module_ns->assign(c->name,
27674 (new octave_swig_type(0,swig_types[j])));
27675 }
27676
27677 if (!SWIG_init_user(module_ns)) {
27678 delete module_ns;
27679 module_ns=0;
27680 return octave_value_list();
27681 }
27682
27683 SWIG_InstallOps(octave_swig_ref::static_type_id());
27684
27686 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27687 if (mb->second.first && mb->second.first->method) {
27688 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27689 return octave_value_list();
27690 }
27691 }
27692 }
27693
27694#if SWIG_OCTAVE_PREREQ(4,4,0)
27695 octave::interpreter::the_interpreter()->mlock();
27696#elif SWIG_OCTAVE_PREREQ(3,2,0)
27697 mlock();
27698#else
27699 mlock(me->name());
27700#endif
27701
27702 }
27703
27705 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27706 if (mb->second.second.is_defined()) {
27707 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27708 SWIG_Octave_LinkGlobalValue(mb->first);
27709 }
27710 }
27711
27714
27715 return octave_value_list();
27716
27717}
27718
27719
27720static bool SWIG_init_user(octave_swig_type* module_ns)
27721{
27722 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27723 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27724 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27725 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27726 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27727 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27728 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27729 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27730 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27731 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27732 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27733 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27734 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27735 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27736 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27737 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27738 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27739 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27740 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27741 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27742 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27743 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27744 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27745 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27746 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27747 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27748 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27749 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27750 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27751 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27752 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27753 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27754 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27755 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27756 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27757 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27758 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27759 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27760 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27761 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27762 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27763 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27764 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27765 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27766 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27767 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27768 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27769 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27770 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27771 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27772 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27773 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27774 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27775 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27811 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27812 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27813 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27814 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27815 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27816 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27817 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27818 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27819 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27820 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27821 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27822 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27823 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27824 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27825 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27826 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27827 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27828 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27829 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27830 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27831 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27832 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27833 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27834 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27835 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27836 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27837 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27838 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27839 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27840 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27841 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27842 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27843 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27844 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27845 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27846 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27847 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27848 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27849 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27850 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27851 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27852 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27853 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27854 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27855 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27856 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27857 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27858 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27859 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27860 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27861 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27862 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27863 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27864 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27865 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27866 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27867 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27868 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27869 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27870 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27871 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27872 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27873 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27874 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27875 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27876 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27877 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27878 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27879 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27880 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27881 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27882 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27883 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27884 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27885 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27886 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27887 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27888 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27889 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27890 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27891 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27892 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27893 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27894 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27895 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27896 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27897 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27898 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27899 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27900 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27901 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27902 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27903 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27904 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27905 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27906 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27907 return true;
27908}
27909
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
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()
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
std::map< std::string, member_value_pair > member_map
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)
member_map::const_iterator swig_member_const_iterator
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
void merge(octave_swig_type &rhs)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
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
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
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)
#define SWIG_SyntaxError
static const char * _wrap_plflush_texinfo
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
static const char * _wrap_plsfnam_texinfo
#define SWIG_CheckState(r)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plot3dc_texinfo
static const char * _wrap_plptex_texinfo
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
static const char * _wrap_plbin_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
static const char * _wrap_plsmaj_texinfo
#define SWIG_TypeError
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
#define SWIG_RuntimeError
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
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)
#define SWIGRUNTIME
static const char * _wrap_plsurf3d_texinfo
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_plgfnam_texinfo
static const char * _wrap_plenv0_texinfo
#define swigreg_binary_op(name)
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
#define SWIG_ValueError
static const char * _wrap_plsfci_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
static const char * _wrap_plgchr_texinfo
#define SWIG_AddCast(r)
static const char * _wrap_plstripd_texinfo
static const char * _wrap_plsori_texinfo
static const char * _wrap_plsdiplt_texinfo
#define SWIG_name_d
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
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
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
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
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
#define SWIG_IOError
static const char * _wrap_plsfont_texinfo
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_pllegend_texinfo
#define SWIG_NullReferenceError
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
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 * _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)
static const char * _wrap_plclear_texinfo
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)
#define SWIG_MemoryError
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plvasp_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
SWIGRUNTIME void SWIG_InstallOps(int tid)
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
static const char * _wrap_plw3d_texinfo
#define SWIG_SystemError
#define SWIG_DivisionByZero
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
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)
#define SWIG_OverflowError
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
#define SWIG_IsOK(r)
static const char * _wrap_plspal1_texinfo
static const char * _wrap_plscmap0a_texinfo
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)
#define SWIG_IndexError
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_texinfo
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
#define SWIGINTERNINLINE
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
#define SWIGRUNTIMEINLINE
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_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)
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)
struct swig_type_info *(* swig_dycast_func)(void **)
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)
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)
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
static swig_cast_info _swigc__p_int[]
#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)
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)
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[]
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
#define SWIG_POINTER_RELEASE
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 SWIG_POINTER_CLEAR
#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)
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
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_ERROR_RELEASE_NOT_OWNED
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
#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 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 *)
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 char buf[200]
Definition tclAPI.c:873
static Tcl_Interp * interp
Definition tkMain.c:120
static const char * name
Definition tkMain.c:135