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 swig_type_info* info = 0;
3652 if (!info) {
3653 info = SWIG_TypeQuery("_p_char");
3654 }
3655 return info;
3656}
3657
3658
3659SWIGINTERNINLINE octave_value
3660SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3661{
3662 return std::string(carray,carray+size);
3663}
3664
3665
3666SWIGINTERN size_t
3667SWIG_strnlen(const char* s, size_t maxlen)
3668{
3669 const char *p;
3670 for (p = s; maxlen-- && *p; p++)
3671 ;
3672 return p - s;
3673}
3674
3675
3676SWIGINTERN int
3677SWIG_AsVal_char (octave_value obj, char *val)
3678{
3679 int res = SWIG_AsCharArray(obj, val, 1);
3680 if (!SWIG_IsOK(res)) {
3681 long v;
3682 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3683 if (SWIG_IsOK(res)) {
3684 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3685 if (val) *val = static_cast< char >(v);
3686 } else {
3687 res = SWIG_OverflowError;
3688 }
3689 }
3690 }
3691 return res;
3692}
3693
3694static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3695Set up transformation from metafile coordinates\n\
3696\n\
3697DESCRIPTION:\n\
3698\n\
3699 Set up transformation from metafile coordinates. The size of the plot\n\
3700 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3701 general-purpose facility just yet (not sure why the user would need\n\
3702 it, for one).\n\
3703\n\
3704 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3705 dimypmm)\n\
3706\n\
3707 This function is not used in any examples.\n\
3708\n\
3709\n\
3710\n\
3711SYNOPSIS:\n\
3712\n\
3713plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3714\n\
3715ARGUMENTS:\n\
3716\n\
3717 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3718\n\
3719 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3720\n\
3721 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3722\n\
3723 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3724\n\
3725 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3726\n\
3727 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3728";
3729static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3730Set the cmap0 palette using the specified cmap0*.pal format file\n\
3731\n\
3732DESCRIPTION:\n\
3733\n\
3734 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3735\n\
3736 Redacted form: plspal0(filename)\n\
3737\n\
3738 This function is in example 16.\n\
3739\n\
3740\n\
3741\n\
3742SYNOPSIS:\n\
3743\n\
3744plspal0(filename)\n\
3745\n\
3746ARGUMENTS:\n\
3747\n\
3748 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3749 containing the name of the cmap0*.pal file. If this string is\n\
3750 empty, use the default cmap0*.pal file.\n\
3751";
3752static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3753Set the cmap1 palette using the specified cmap1*.pal format file\n\
3754\n\
3755DESCRIPTION:\n\
3756\n\
3757 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3758\n\
3759 Redacted form: plspal1(filename, interpolate)\n\
3760\n\
3761 This function is used in example 16.\n\
3762\n\
3763\n\
3764\n\
3765SYNOPSIS:\n\
3766\n\
3767plspal1(filename, interpolate)\n\
3768\n\
3769ARGUMENTS:\n\
3770\n\
3771 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3772 containing the name of the cmap1*.pal file. If this string is\n\
3773 empty, use the default cmap1*.pal file.\n\
3774\n\
3775 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3776 columns containing the intensity index, r, g, b, alpha and\n\
3777 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3778 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3779 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3780 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3781 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3782 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3783 are used instead to set the cmap1 palette directly with a call to\n\
3784 plscmap1a.\n\
3785";
3786static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3787Draw a line in 3 space\n\
3788\n\
3789DESCRIPTION:\n\
3790\n\
3791 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3792 first set up the viewport, the 2d viewing window (in world\n\
3793 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3794 more info.\n\
3795\n\
3796 Redacted form: plline3(x, y, z)\n\
3797\n\
3798 This function is used in example 18.\n\
3799\n\
3800\n\
3801\n\
3802SYNOPSIS:\n\
3803\n\
3804plline3(n, x, y, z)\n\
3805\n\
3806ARGUMENTS:\n\
3807\n\
3808 n (PLINT, input) : Number of points defining line.\n\
3809\n\
3810 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3811 points.\n\
3812\n\
3813 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3814 points.\n\
3815\n\
3816 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3817 points.\n\
3818";
3819static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3820Magnitude colored plot surface mesh with contour\n\
3821\n\
3822DESCRIPTION:\n\
3823\n\
3824 A more powerful form of plmesh: the surface mesh can be colored\n\
3825 accordingly to the current z value being plotted, a contour plot can\n\
3826 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3827 plotted function border and the base XY plane.\n\
3828\n\
3829 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3830\n\
3831 This function is used in example 11.\n\
3832\n\
3833\n\
3834\n\
3835SYNOPSIS:\n\
3836\n\
3837plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3838\n\
3839ARGUMENTS:\n\
3840\n\
3841 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3842 which the function is evaluated.\n\
3843\n\
3844 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3845 which the function is evaluated.\n\
3846\n\
3847 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3848 plot. Should have dimensions of\n\
3849 nx by\n\
3850 ny.\n\
3851\n\
3852 nx (PLINT, input) : Number of x values at which function is\n\
3853 evaluated.\n\
3854\n\
3855 ny (PLINT, input) : Number of y values at which function is\n\
3856 evaluated.\n\
3857\n\
3858 opt (PLINT, input) : Determines the way in which the surface is\n\
3859 represented. To specify more than one option just add the options,\n\
3860 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3861 showing z as a function of x for each value of y[j] .\n\
3862 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3863 for each value of x[i] .\n\
3864 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3865 at which function is defined.\n\
3866 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3867 the z value being plotted. The color is used from the current\n\
3868 cmap1.\n\
3869 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3870 using parameters\n\
3871 nlevel and\n\
3872 clevel.\n\
3873 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3874 the borders of the plotted function.\n\
3875\n\
3876\n\
3877 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3878 levels.\n\
3879\n\
3880 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3881";
3882static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3883Draw a line between two points, accounting for coordinate transforms\n\
3884\n\
3885DESCRIPTION:\n\
3886\n\
3887 Joins the point (\n\
3888 x1,\n\
3889 y1) to (\n\
3890 x2,\n\
3891 y2) . If a global coordinate transform is defined then the line is\n\
3892 broken in to n segments to approximate the path. If no transform is\n\
3893 defined then this simply acts like a call to pljoin.\n\
3894\n\
3895 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3896\n\
3897 This function is used in example 22.\n\
3898\n\
3899\n\
3900\n\
3901SYNOPSIS:\n\
3902\n\
3903plpath(n, x1, y1, x2, y2)\n\
3904\n\
3905ARGUMENTS:\n\
3906\n\
3907 n (PLINT, input) : number of points to use to approximate the path.\n\
3908\n\
3909 x1 (PLFLT, input) : x coordinate of first point.\n\
3910\n\
3911 y1 (PLFLT, input) : y coordinate of first point.\n\
3912\n\
3913 x2 (PLFLT, input) : x coordinate of second point.\n\
3914\n\
3915 y2 (PLFLT, input) : y coordinate of second point.\n\
3916";
3917static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3918Write text inside the viewport\n\
3919\n\
3920DESCRIPTION:\n\
3921\n\
3922 Writes text at a specified position and inclination within the\n\
3923 viewport. Text is clipped at the viewport boundaries. The reference\n\
3924 point of a string lies along a line passing through the string at half\n\
3925 the height of a capital letter. The position of the reference point\n\
3926 along this line is determined by just, the reference point is placed\n\
3927 at world coordinates (\n\
3928 x,\n\
3929 y) within the viewport. The inclination of the string is specified\n\
3930 in terms of differences of world coordinates making it easy to write\n\
3931 text parallel to a line in a graph.\n\
3932\n\
3933 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3934\n\
3935 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3936\n\
3937\n\
3938\n\
3939SYNOPSIS:\n\
3940\n\
3941plptex(x, y, dx, dy, just, text)\n\
3942\n\
3943ARGUMENTS:\n\
3944\n\
3945 x (PLFLT, input) : x coordinate of reference point of string.\n\
3946\n\
3947 y (PLFLT, input) : y coordinate of reference point of string.\n\
3948\n\
3949 dx (PLFLT, input) : Together with dy, this specifies the\n\
3950 inclination of the string. The baseline of the string is parallel\n\
3951 to a line joining (\n\
3952 x,\n\
3953 y) to (\n\
3954 x+\n\
3955 dx,\n\
3956 y+\n\
3957 dy) .\n\
3958\n\
3959 dy (PLFLT, input) : Together with dx, this specifies the\n\
3960 inclination of the string.\n\
3961\n\
3962 just (PLFLT, input) : Specifies the position of the string relative\n\
3963 to its reference point. If just=0. , the reference point is at\n\
3964 the left and if just=1. , it is at the right of the string. Other\n\
3965 values of just give intermediate justifications.\n\
3966\n\
3967 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3968 written out.\n\
3969";
3970static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3971Set family file parameters\n\
3972\n\
3973DESCRIPTION:\n\
3974\n\
3975 Sets variables dealing with output file familying. Does nothing if\n\
3976 familying not supported by the driver. This routine, if used, must be\n\
3977 called before initializing PLplot. See the PLplot documentation for\n\
3978 more information.\n\
3979\n\
3980 Redacted form: plsfam(fam, num, bmax)\n\
3981\n\
3982 This function is used in examples 14 and 31.\n\
3983\n\
3984\n\
3985\n\
3986SYNOPSIS:\n\
3987\n\
3988plsfam(fam, num, bmax)\n\
3989\n\
3990ARGUMENTS:\n\
3991\n\
3992 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3993 is enabled.\n\
3994\n\
3995 num (PLINT, input) : Current family file number.\n\
3996\n\
3997 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3998 file.\n\
3999";
4000static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
4001Set y axis parameters\n\
4002\n\
4003DESCRIPTION:\n\
4004\n\
4005 Identical to plsxax, except that arguments are flags for y axis. See\n\
4006 the description of plsxax for more detail.\n\
4007\n\
4008 Redacted form: plsyax(digmax, digits)\n\
4009\n\
4010 This function is used in examples 1, 14, and 31.\n\
4011\n\
4012\n\
4013\n\
4014SYNOPSIS:\n\
4015\n\
4016plsyax(digmax, digits)\n\
4017\n\
4018ARGUMENTS:\n\
4019\n\
4020 digmax (PLINT, input) : Variable to set the maximum number of\n\
4021 digits for the y axis. If nonzero, the printed label will be\n\
4022 switched to a floating-point representation when the number of\n\
4023 digits exceeds digmax.\n\
4024\n\
4025 digits (PLINT, input) : Field digits value. Currently, changing\n\
4026 its value here has no effect since it is set only by plbox or\n\
4027 plbox3. However, the user may obtain its value after a call to\n\
4028 either of these functions by calling plgyax.\n\
4029";
4030static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
4031Get z axis parameters\n\
4032\n\
4033DESCRIPTION:\n\
4034\n\
4035 Identical to plgxax, except that arguments are flags for z axis. See\n\
4036 the description of plgxax for more detail.\n\
4037\n\
4038 Redacted form: plgzax(p_digmax, p_digits)\n\
4039\n\
4040 This function is used in example 31.\n\
4041\n\
4042\n\
4043\n\
4044SYNOPSIS:\n\
4045\n\
4046plgzax(p_digmax, p_digits)\n\
4047\n\
4048ARGUMENTS:\n\
4049\n\
4050 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4051 number of digits for the z axis. If nonzero, the printed label\n\
4052 has been switched to a floating-point representation when the\n\
4053 number of digits exceeds this value.\n\
4054\n\
4055 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4056 number of digits for the numeric labels (z axis) from the last\n\
4057 plot.\n\
4058";
4059static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
4060Set format of numerical label for contours\n\
4061\n\
4062DESCRIPTION:\n\
4063\n\
4064 Set format of numerical label for contours.\n\
4065\n\
4066 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4067\n\
4068 This function is used example 9.\n\
4069\n\
4070\n\
4071\n\
4072SYNOPSIS:\n\
4073\n\
4074pl_setcontlabelformat(lexp, sigdig)\n\
4075\n\
4076ARGUMENTS:\n\
4077\n\
4078 lexp (PLINT, input) : If the contour numerical label is greater\n\
4079 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4080 format is used. Default value of lexp is 4.\n\
4081\n\
4082 sigdig (PLINT, input) : Number of significant digits. Default\n\
4083 value is 2.\n\
4084";
4085static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4086Set pen width\n\
4087\n\
4088DESCRIPTION:\n\
4089\n\
4090 Sets the pen width.\n\
4091\n\
4092 Redacted form: plwidth(width)\n\
4093\n\
4094 This function is used in examples 1 and 2.\n\
4095\n\
4096\n\
4097\n\
4098SYNOPSIS:\n\
4099\n\
4100plwidth(width)\n\
4101\n\
4102ARGUMENTS:\n\
4103\n\
4104 width (PLFLT, input) : The desired pen width. If width is negative\n\
4105 or the same as the previous value no action is taken. width = 0.\n\
4106 should be interpreted as as the minimum valid pen width for the\n\
4107 device. The interpretation of positive width values is also\n\
4108 device dependent.\n\
4109";
4110static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4111Get parameters that define current plot-space window\n\
4112\n\
4113DESCRIPTION:\n\
4114\n\
4115 Get relative minima and maxima that define current plot-space window.\n\
4116 If plsdiplt has not been called the default values pointed to by\n\
4117 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4118\n\
4119 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4120\n\
4121 This function is used in example 31.\n\
4122\n\
4123\n\
4124\n\
4125SYNOPSIS:\n\
4126\n\
4127plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4128\n\
4129ARGUMENTS:\n\
4130\n\
4131 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4132 minimum in x.\n\
4133\n\
4134 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4135 minimum in y.\n\
4136\n\
4137 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4138 maximum in x.\n\
4139\n\
4140 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4141 maximum in y.\n\
4142";
4143static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4144Set the cmap1 argument range for continuous color plots\n\
4145\n\
4146DESCRIPTION:\n\
4147\n\
4148 Set the cmap1 argument range for continuous color plots that\n\
4149 corresponds to the range of data values. The maximum range\n\
4150 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4151 the cmap1 argument range that is specified with this routine, the\n\
4152 smaller the subset of the cmap1 color palette that is used to\n\
4153 represent the continuous data being plotted. If\n\
4154 min_color is greater than\n\
4155 max_color or\n\
4156 max_color is greater than 1.0 or\n\
4157 min_color is less than 0.0 then no change is made to the cmap1\n\
4158 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4159\n\
4160 Redacted form: plscmap1_range(min_color, max_color)\n\
4161\n\
4162 This function is currently used in example 33.\n\
4163\n\
4164\n\
4165\n\
4166SYNOPSIS:\n\
4167\n\
4168plscmap1_range(min_color, max_color)\n\
4169\n\
4170ARGUMENTS:\n\
4171\n\
4172 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4173 than 0.0, then 0.0 is used instead.\n\
4174\n\
4175 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4176 than 1.0, then 1.0 is used instead.\n\
4177";
4178static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4179Select standard viewport\n\
4180\n\
4181DESCRIPTION:\n\
4182\n\
4183 Selects the largest viewport within the subpage that leaves a standard\n\
4184 margin (left-hand margin of eight character heights, and a margin\n\
4185 around the other three sides of five character heights).\n\
4186\n\
4187 Redacted form: plvsta()\n\
4188\n\
4189 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4190\n\
4191\n\
4192\n\
4193SYNOPSIS:\n\
4194\n\
4195plvsta()\n\
4196";
4197static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4198Load Hershey fonts\n\
4199\n\
4200DESCRIPTION:\n\
4201\n\
4202 Loads the Hershey fonts used for text and symbols. This routine may\n\
4203 be called before or after initializing PLplot. If not explicitly\n\
4204 called before PLplot initialization, then by default that\n\
4205 initialization loads Hershey fonts with the extended character set.\n\
4206 This routine only has a practical effect for devices that still use\n\
4207 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4208 system fonts instead of Hershey fonts).\n\
4209\n\
4210 Redacted form: plfontld(fnt)\n\
4211\n\
4212 This function is used in examples 1 and 7.\n\
4213\n\
4214\n\
4215\n\
4216SYNOPSIS:\n\
4217\n\
4218plfontld(fnt)\n\
4219\n\
4220ARGUMENTS:\n\
4221\n\
4222 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4223 A zero value specifies Hershey fonts with the standard character\n\
4224 set and a non-zero value (the default assumed if plfontld is never\n\
4225 called) specifies Hershey fonts with the extended character set.\n\
4226";
4227static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4228Draw error bars in x direction\n\
4229\n\
4230DESCRIPTION:\n\
4231\n\
4232 Draws a set of n error bars in x direction, the i\'th error bar\n\
4233 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4234 of the error bars are of length equal to the minor tick length\n\
4235 (settable using plsmin).\n\
4236\n\
4237 Redacted form: General: plerrx(xmin, ymax, y)\n\
4238\n\
4239\n\
4240 This function is used in example 29.\n\
4241\n\
4242\n\
4243\n\
4244SYNOPSIS:\n\
4245\n\
4246plerrx(n, xmin, xmax, y)\n\
4247\n\
4248ARGUMENTS:\n\
4249\n\
4250 n (PLINT, input) : Number of error bars to draw.\n\
4251\n\
4252 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4253 of the left-hand endpoints of the error bars.\n\
4254\n\
4255 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4256 of the right-hand endpoints of the error bars.\n\
4257\n\
4258 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4259 the error bars.\n\
4260";
4261static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4262Plot shaded 3-d surface plot\n\
4263\n\
4264DESCRIPTION:\n\
4265\n\
4266 Plots a three-dimensional shaded surface plot within the environment\n\
4267 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4268 z[\n\
4269 nx][\n\
4270 ny], the point z[i][j] being the value of the function at (\n\
4271 x[i],\n\
4272 y[j]). Note that the points in vectors x and y do not need to be\n\
4273 equally spaced, but must be stored in ascending order. For further\n\
4274 details see the PLplot documentation.\n\
4275\n\
4276 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4277\n\
4278 This function is not used in any examples.\n\
4279\n\
4280\n\
4281\n\
4282SYNOPSIS:\n\
4283\n\
4284plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4285\n\
4286ARGUMENTS:\n\
4287\n\
4288 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4289 which the function is evaluated.\n\
4290\n\
4291 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4292 which the function is evaluated.\n\
4293\n\
4294 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4295 plot. Should have dimensions of\n\
4296 nx by\n\
4297 ny.\n\
4298\n\
4299 nx (PLINT, input) : Number of x values at which function is\n\
4300 evaluated.\n\
4301\n\
4302 ny (PLINT, input) : Number of y values at which function is\n\
4303 evaluated.\n\
4304\n\
4305 opt (PLINT, input) : Determines the way in which the surface is\n\
4306 represented. To specify more than one option just add the options,\n\
4307 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4308 connecting points at which function is defined.\n\
4309 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4310 using parameters\n\
4311 nlevel and\n\
4312 clevel.\n\
4313 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4314 using parameters\n\
4315 nlevel and\n\
4316 clevel.\n\
4317 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4318 the borders of the plotted function.\n\
4319 opt=MAG_COLOR : the surface is colored according to the value\n\
4320 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4321 according to the intensity of the reflected light in the\n\
4322 surface from a light source whose position is set using\n\
4323 pllightsource.\n\
4324\n\
4325\n\
4326 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4327 levels.\n\
4328\n\
4329 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4330";
4331static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4332Get the current library version number\n\
4333\n\
4334DESCRIPTION:\n\
4335\n\
4336 Get the current library version number. Note: you must have allocated\n\
4337 space for this (80 characters is safe).\n\
4338\n\
4339 Redacted form: plgver(p_ver)\n\
4340\n\
4341 This function is used in example 1.\n\
4342\n\
4343\n\
4344\n\
4345SYNOPSIS:\n\
4346\n\
4347plgver(p_ver)\n\
4348\n\
4349ARGUMENTS:\n\
4350\n\
4351 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4352 (with preallocated length of 80 characters or more) containing the\n\
4353 PLplot version number.\n\
4354";
4355static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4356End plotting session for current stream\n\
4357\n\
4358DESCRIPTION:\n\
4359\n\
4360 Ends a plotting session for the current output stream only. See\n\
4361 plsstrm for more info.\n\
4362\n\
4363 Redacted form: plend1()\n\
4364\n\
4365 This function is used in examples 1 and 20.\n\
4366\n\
4367\n\
4368\n\
4369SYNOPSIS:\n\
4370\n\
4371plend1()\n\
4372";
4373static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4374Draw error bars in the y direction\n\
4375\n\
4376DESCRIPTION:\n\
4377\n\
4378 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4379 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4380 of the error bars are of length equal to the minor tick length\n\
4381 (settable using plsmin).\n\
4382\n\
4383 Redacted form: General: plerry(x, ymin, ymax)\n\
4384\n\
4385\n\
4386 This function is used in example 29.\n\
4387\n\
4388\n\
4389\n\
4390SYNOPSIS:\n\
4391\n\
4392plerry(n, x, ymin, ymax)\n\
4393\n\
4394ARGUMENTS:\n\
4395\n\
4396 n (PLINT, input) : Number of error bars to draw.\n\
4397\n\
4398 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4399 the error bars.\n\
4400\n\
4401 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4402 of the lower endpoints of the error bars.\n\
4403\n\
4404 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4405 of the upper endpoints of the error bars.\n\
4406";
4407static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4408Set seed for internal random number generator.\n\
4409\n\
4410DESCRIPTION:\n\
4411\n\
4412 Set the seed for the internal random number generator. See plrandd for\n\
4413 further details.\n\
4414\n\
4415 Redacted form: plseed(seed)\n\
4416\n\
4417 This function is used in example 21.\n\
4418\n\
4419\n\
4420\n\
4421SYNOPSIS:\n\
4422\n\
4423plseed(seed)\n\
4424\n\
4425ARGUMENTS:\n\
4426\n\
4427 seed (unsigned int, input) : Seed for random number generator.\n\
4428";
4429static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4430Specify viewport using normalized subpage coordinates\n\
4431\n\
4432DESCRIPTION:\n\
4433\n\
4434 Device-independent routine for setting up the viewport. This defines\n\
4435 the viewport in terms of normalized subpage coordinates which run from\n\
4436 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4437 current subpage. Use the alternate routine plsvpa in order to create\n\
4438 a viewport of a definite size.\n\
4439\n\
4440 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4441\n\
4442 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4443 24, 26, 27, and 31.\n\
4444\n\
4445\n\
4446\n\
4447SYNOPSIS:\n\
4448\n\
4449plvpor(xmin, xmax, ymin, ymax)\n\
4450\n\
4451ARGUMENTS:\n\
4452\n\
4453 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4454 left-hand edge of the viewport.\n\
4455\n\
4456 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4457 right-hand edge of the viewport.\n\
4458\n\
4459 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4460 bottom edge of the viewport.\n\
4461\n\
4462 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4463 edge of the viewport.\n\
4464";
4465static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4466Plot surface mesh\n\
4467\n\
4468DESCRIPTION:\n\
4469\n\
4470 Plots a surface mesh within the environment set up by plw3d. The\n\
4471 surface is defined by the matrix z[\n\
4472 nx][\n\
4473 ny] , the point z[i][j] being the value of the function at (\n\
4474 x[i],\n\
4475 y[j]). Note that the points in vectors x and y do not need to be\n\
4476 equally spaced, but must be stored in ascending order. The parameter\n\
4477 opt controls the way in which the surface is displayed. For further\n\
4478 details see the PLplot documentation.\n\
4479\n\
4480 Redacted form: plmesh(x, y, z, opt)\n\
4481\n\
4482 This function is used in example 11.\n\
4483\n\
4484\n\
4485\n\
4486SYNOPSIS:\n\
4487\n\
4488plmesh(x, y, z, nx, ny, opt)\n\
4489\n\
4490ARGUMENTS:\n\
4491\n\
4492 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4493 which the function is evaluated.\n\
4494\n\
4495 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4496 which the function is evaluated.\n\
4497\n\
4498 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4499 plot. Should have dimensions of\n\
4500 nx by\n\
4501 ny.\n\
4502\n\
4503 nx (PLINT, input) : Number of x values at which function has been\n\
4504 evaluated.\n\
4505\n\
4506 ny (PLINT, input) : Number of y values at which function has been\n\
4507 evaluated.\n\
4508\n\
4509 opt (PLINT, input) : Determines the way in which the surface is\n\
4510 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4511 function of x for each value of y[j] .\n\
4512 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4513 for each value of x[i] .\n\
4514 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4515 at which function is defined.\n\
4516";
4517static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4518Get the cmap1 argument range for continuous color plots\n\
4519\n\
4520DESCRIPTION:\n\
4521\n\
4522 Get the cmap1 argument range for continuous color plots. (Use\n\
4523 plscmap1_range to set the cmap1 argument range.)\n\
4524\n\
4525 Redacted form: plgcmap1_range(min_color, max_color)\n\
4526\n\
4527 This function is currently not used in any example.\n\
4528\n\
4529\n\
4530\n\
4531SYNOPSIS:\n\
4532\n\
4533plgcmap1_range(min_color, max_color)\n\
4534\n\
4535ARGUMENTS:\n\
4536\n\
4537 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4538 minimum cmap1 argument.\n\
4539\n\
4540 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4541 maximum cmap1 argument.\n\
4542";
4543static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4544Set arrow style for vector plots\n\
4545\n\
4546DESCRIPTION:\n\
4547\n\
4548 Set the style for the arrow used by plvect to plot vectors.\n\
4549\n\
4550 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4551\n\
4552 This function is used in example 22.\n\
4553\n\
4554\n\
4555\n\
4556SYNOPSIS:\n\
4557\n\
4558plsvect(arrowx, arrowy, npts, fill)\n\
4559\n\
4560ARGUMENTS:\n\
4561\n\
4562 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4563 the x and y points which make up the arrow. The arrow is plotted\n\
4564 by joining these points to form a polygon. The scaling assumes\n\
4565 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4566 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4567 will be reset to its default.\n\
4568\n\
4569 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4570 arrowy.\n\
4571\n\
4572 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4573 fill is false then the arrow is open.\n\
4574";
4575static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4576Draw filled polygon\n\
4577\n\
4578DESCRIPTION:\n\
4579\n\
4580 Fills the polygon defined by the n points (\n\
4581 x[i],\n\
4582 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4583 style is a solid fill. The routine will automatically close the\n\
4584 polygon between the last and first vertices. If multiple closed\n\
4585 polygons are passed in x and y then plfill will fill in between them.\n\
4586\n\
4587 Redacted form: plfill(x,y)\n\
4588\n\
4589 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4590\n\
4591\n\
4592\n\
4593SYNOPSIS:\n\
4594\n\
4595plfill(n, x, y)\n\
4596\n\
4597ARGUMENTS:\n\
4598\n\
4599 n (PLINT, input) : Number of vertices in polygon.\n\
4600\n\
4601 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4602 vertices.\n\
4603\n\
4604 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4605 vertices.\n\
4606";
4607static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4608Convert HLS color to RGB\n\
4609\n\
4610DESCRIPTION:\n\
4611\n\
4612 Convert HLS color coordinates to RGB.\n\
4613\n\
4614 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4615\n\
4616\n\
4617 This function is used in example 2.\n\
4618\n\
4619\n\
4620\n\
4621SYNOPSIS:\n\
4622\n\
4623plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4624\n\
4625ARGUMENTS:\n\
4626\n\
4627 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4628 cylinder.\n\
4629\n\
4630 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4631 the axis of the color cylinder.\n\
4632\n\
4633 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4634 the radius of the color cylinder.\n\
4635\n\
4636 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4637 (0.0-1.0) of the color.\n\
4638\n\
4639 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4640 intensity (0.0-1.0) of the color.\n\
4641\n\
4642 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4643 intensity (0.0-1.0) of the color.\n\
4644";
4645static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4646Set format for date / time labels\n\
4647\n\
4648DESCRIPTION:\n\
4649\n\
4650 Sets the format for date / time labels. To enable date / time format\n\
4651 labels see the options to plbox, plbox3, and plenv.\n\
4652\n\
4653 Redacted form: pltimefmt(fmt)\n\
4654\n\
4655 This function is used in example 29.\n\
4656\n\
4657\n\
4658\n\
4659SYNOPSIS:\n\
4660\n\
4661pltimefmt(fmt)\n\
4662\n\
4663ARGUMENTS:\n\
4664\n\
4665 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4666 interpreted similarly to the format specifier of typical system\n\
4667 strftime routines except that PLplot ignores locale and also\n\
4668 supplies some useful extensions in the context of plotting. All\n\
4669 text in the string is printed as-is other than conversion\n\
4670 specifications which take the form of a \'%\' character followed by\n\
4671 further conversion specification character. The conversion\n\
4672 specifications which are similar to those provided by system\n\
4673 strftime routines are the following: %a: The abbreviated (English)\n\
4674 weekday name.\n\
4675 %A: The full (English) weekday name.\n\
4676 %b: The abbreviated (English) month name.\n\
4677 %B: The full (English) month name.\n\
4678 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4679 %C: The century number (year/100) as a 2-digit integer.\n\
4680 %d: The day of the month as a decimal number (range 01 to 31).\n\
4681 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4682 %e: Like %d, but a leading zero is replaced by a space.\n\
4683 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4684 %h: Equivalent to %b.\n\
4685 %H: The hour as a decimal number using a 24-hour clock (range\n\
4686 00 to 23).\n\
4687 %I: The hour as a decimal number using a 12-hour clock (range\n\
4688 01 to 12).\n\
4689 %j: The day of the year as a decimal number (range 001 to\n\
4690 366).\n\
4691 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4692 23); single digits are preceded by a blank. (See also %H.)\n\
4693 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4694 12); single digits are preceded by a blank. (See also %I.)\n\
4695 %m: The month as a decimal number (range 01 to 12).\n\
4696 %M: The minute as a decimal number (range 00 to 59).\n\
4697 %n: A newline character.\n\
4698 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4699 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4700 %r: Equivalent to %I:%M:%S %p.\n\
4701 %R: The time in 24-hour notation (%H:%M). For a version\n\
4702 including the seconds, see %T below.\n\
4703 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4704 +0000 (UTC).\n\
4705 %S: The second as a decimal number (range 00 to 60). (The\n\
4706 range is up to 60 to allow for occasional leap seconds.)\n\
4707 %t: A tab character.\n\
4708 %T: The time in 24-hour notation (%H:%M:%S).\n\
4709 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4710 being 1. See also %w.\n\
4711 %U: The week number of the current year as a decimal number,\n\
4712 range 00 to 53, starting with the first Sunday as the first\n\
4713 day of week 01. See also %V and %W.\n\
4714 %v: Equivalent to %e-%b-%Y.\n\
4715 %V: The ISO 8601 week number of the current year as a decimal\n\
4716 number, range 01 to 53, where week 1 is the first week that\n\
4717 has at least 4 days in the new year. See also %U and %W.\n\
4718 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4719 being 0. See also %u.\n\
4720 %W: The week number of the current year as a decimal number,\n\
4721 range 00 to 53, starting with the first Monday as the first\n\
4722 day of week 01.\n\
4723 %x: Equivalent to %a %b %d %Y.\n\
4724 %X: Equivalent to %T.\n\
4725 %y: The year as a decimal number without a century (range 00\n\
4726 to 99).\n\
4727 %Y: The year as a decimal number including a century.\n\
4728 %z: The UTC time-zone string = \"+0000\".\n\
4729 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4730 %+: The UTC date and time in default format of the Unix date\n\
4731 command which is equivalent to %a %b %d %T %Z %Y.\n\
4732 %%: A literal \"%\" character.\n\
4733 The conversion specifications which are extensions to those normally\n\
4734 provided by system strftime routines are the following: %(0-9):\n\
4735 The fractional part of the seconds field (including leading\n\
4736 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4737 seconds to millisecond accuracy (00.000).\n\
4738 %.: The fractional part of the seconds field (including\n\
4739 leading decimal point) to the maximum available accuracy. Thus\n\
4740 %S%. would give seconds with fractional part up to 9 decimal\n\
4741 places if available.\n\
4742";
4743static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4744Get current subpage parameters\n\
4745\n\
4746DESCRIPTION:\n\
4747\n\
4748 Gets the size of the current subpage in millimeters measured from the\n\
4749 bottom left hand corner of the output device page or screen. Can be\n\
4750 used in conjunction with plsvpa for setting the size of a viewport in\n\
4751 absolute coordinates (millimeters).\n\
4752\n\
4753 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4754\n\
4755 This function is used in example 23.\n\
4756\n\
4757\n\
4758\n\
4759SYNOPSIS:\n\
4760\n\
4761plgspa(xmin, xmax, ymin, ymax)\n\
4762\n\
4763ARGUMENTS:\n\
4764\n\
4765 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4766 the left hand edge of the subpage in millimeters.\n\
4767\n\
4768 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4769 the right hand edge of the subpage in millimeters.\n\
4770\n\
4771 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4772 the bottom edge of the subpage in millimeters.\n\
4773\n\
4774 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4775 the top edge of the subpage in millimeters.\n\
4776";
4777static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4778Calculate world coordinates and corresponding window index from relative device coordinates\n\
4779\n\
4780DESCRIPTION:\n\
4781\n\
4782 Calculate world coordinates, wx and wy, and corresponding window index\n\
4783 from relative device coordinates, rx and ry.\n\
4784\n\
4785 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4786\n\
4787\n\
4788 This function is used in example 31.\n\
4789\n\
4790\n\
4791\n\
4792SYNOPSIS:\n\
4793\n\
4794plcalc_world(rx, ry, wx, wy, window)\n\
4795\n\
4796ARGUMENTS:\n\
4797\n\
4798 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4799 the x coordinate.\n\
4800\n\
4801 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4802 the y coordinate.\n\
4803\n\
4804 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4805 coordinate corresponding to the relative device coordinates rx and\n\
4806 ry.\n\
4807\n\
4808 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4809 coordinate corresponding to the relative device coordinates rx and\n\
4810 ry.\n\
4811\n\
4812 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4813 defined window index that corresponds to the input relative device\n\
4814 coordinates (and the returned world coordinates). To give some\n\
4815 background on the window index, for each page the initial window\n\
4816 index is set to zero, and each time plwind is called within the\n\
4817 page, world and device coordinates are stored for the window and\n\
4818 the window index is incremented. Thus, for a simple page layout\n\
4819 with non-overlapping viewports and one window per viewport, window\n\
4820 corresponds to the viewport index (in the order which the\n\
4821 viewport/windows were created) of the only viewport/window\n\
4822 corresponding to rx and ry. However, for more complicated layouts\n\
4823 with potentially overlapping viewports and possibly more than one\n\
4824 window (set of world coordinates) per viewport, window and the\n\
4825 corresponding output world coordinates corresponds to the last\n\
4826 window created that fulfills the criterion that the relative\n\
4827 device coordinates are inside it. Finally, in all cases where the\n\
4828 input relative device coordinates are not inside any\n\
4829 viewport/window, then the returned value of the last defined\n\
4830 window index is set to -1.\n\
4831";
4832static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4833Get output file name\n\
4834\n\
4835DESCRIPTION:\n\
4836\n\
4837 Gets the current output file name, if applicable.\n\
4838\n\
4839 Redacted form: plgfnam(fnam)\n\
4840\n\
4841 This function is used in example 31.\n\
4842\n\
4843\n\
4844\n\
4845SYNOPSIS:\n\
4846\n\
4847plgfnam(fnam)\n\
4848\n\
4849ARGUMENTS:\n\
4850\n\
4851 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4852 (with preallocated length of 80 characters or more) containing the\n\
4853 file name.\n\
4854";
4855static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4856Vector plot\n\
4857\n\
4858DESCRIPTION:\n\
4859\n\
4860 Draws a plot of vector data contained in the matrices (\n\
4861 u[\n\
4862 nx][\n\
4863 ny],\n\
4864 v[\n\
4865 nx][\n\
4866 ny]) . The scaling factor for the vectors is given by scale. A\n\
4867 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4868 additional data required by the transformation routine to map indices\n\
4869 within the matrices to the world coordinates. The style of the vector\n\
4870 arrow may be set using plsvect.\n\
4871\n\
4872 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4873 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4874 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4875 with either one or two dimensions.\n\
4876\n\
4877 This function is used in example 22.\n\
4878\n\
4879\n\
4880\n\
4881SYNOPSIS:\n\
4882\n\
4883plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4884\n\
4885ARGUMENTS:\n\
4886\n\
4887 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4888 and y components of the vector data to be plotted.\n\
4889\n\
4890 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4891\n\
4892 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4893 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4894 automatically calculated for the data. If scale < 0 then the\n\
4895 scaling factor is automatically calculated for the data and then\n\
4896 multiplied by -\n\
4897 scale. If scale > 0 then the scaling factor is set to scale.\n\
4898\n\
4899 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4900 defines the transformation between the zero-based indices of the\n\
4901 matrices u and v and world coordinates.For the C case,\n\
4902 transformation functions are provided in the PLplot library: pltr0\n\
4903 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4904 mappings respectively defined by vectors and matrices. In\n\
4905 addition, C callback routines for the transformation can be\n\
4906 supplied by the user such as the mypltr function in\n\
4907 examples/c/x09c.c which provides a general linear transformation\n\
4908 between index coordinates and world coordinates.For languages\n\
4909 other than C you should consult the PLplot documentation for the\n\
4910 details concerning how PLTRANSFORM_callback arguments are\n\
4911 interfaced. However, in general, a particular pattern of\n\
4912 callback-associated arguments such as a tr vector with 6 elements;\n\
4913 xg and yg vectors; or xg and yg matrices are respectively\n\
4914 interfaced to a linear-transformation routine similar to the above\n\
4915 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4916 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4917 support native language callbacks for handling index to\n\
4918 world-coordinate transformations. Examples of these various\n\
4919 approaches are given in examples/<language>x09*,\n\
4920 examples/<language>x16*, examples/<language>x20*,\n\
4921 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4922 supported languages.\n\
4923\n\
4924 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4925 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4926 that is externally supplied.\n\
4927";
4928static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4929Plot a glyph at the specified points\n\
4930\n\
4931DESCRIPTION:\n\
4932\n\
4933 Plot a glyph at the specified points. (This function is largely\n\
4934 superseded by plstring which gives access to many[!] more glyphs.)\n\
4935\n\
4936 Redacted form: plsym(x, y, code)\n\
4937\n\
4938 This function is used in example 7.\n\
4939\n\
4940\n\
4941\n\
4942SYNOPSIS:\n\
4943\n\
4944plsym(n, x, y, code)\n\
4945\n\
4946ARGUMENTS:\n\
4947\n\
4948 n (PLINT, input) : Number of points in the x and y vectors.\n\
4949\n\
4950 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4951 the points.\n\
4952\n\
4953 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4954 the points.\n\
4955\n\
4956 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4957 to be plotted at each of the n points.\n\
4958";
4959static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4960Get viewport limits in normalized device coordinates\n\
4961\n\
4962DESCRIPTION:\n\
4963\n\
4964 Get viewport limits in normalized device coordinates.\n\
4965\n\
4966 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4967\n\
4968\n\
4969 This function is used in example 31.\n\
4970\n\
4971\n\
4972\n\
4973SYNOPSIS:\n\
4974\n\
4975plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4976\n\
4977ARGUMENTS:\n\
4978\n\
4979 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4980 viewport limit of the normalized device coordinate in x.\n\
4981\n\
4982 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4983 viewport limit of the normalized device coordinate in x.\n\
4984\n\
4985 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4986 viewport limit of the normalized device coordinate in y.\n\
4987\n\
4988 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4989 viewport limit of the normalized device coordinate in y.\n\
4990";
4991static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4992Get page parameters\n\
4993\n\
4994DESCRIPTION:\n\
4995\n\
4996 Gets the current page configuration. The length and offset values are\n\
4997 expressed in units that are specific to the current driver. For\n\
4998 instance: screen drivers will usually interpret them as number of\n\
4999 pixels, whereas printer drivers will usually use mm.\n\
5000\n\
5001 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5002\n\
5003 This function is used in examples 14 and 31.\n\
5004\n\
5005\n\
5006\n\
5007SYNOPSIS:\n\
5008\n\
5009plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5010\n\
5011ARGUMENTS:\n\
5012\n\
5013 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5014 pixels/inch (DPI) in x.\n\
5015\n\
5016 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5017 pixels/inch (DPI) in y.\n\
5018\n\
5019 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5020 length.\n\
5021\n\
5022 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5023 length.\n\
5024\n\
5025 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5026 offset.\n\
5027\n\
5028 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5029 offset.\n\
5030";
5031static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
5032Plot a glyph at the specified 3D points\n\
5033\n\
5034DESCRIPTION:\n\
5035\n\
5036 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5037 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5038 this function similar to what is done for plline3. The glyph is\n\
5039 specified with a PLplot user string. Note that the user string is not\n\
5040 actually limited to one glyph so it is possible (but not normally\n\
5041 useful) to plot more than one glyph at the specified points with this\n\
5042 function. As with plmtex and plptex, the user string can contain FCI\n\
5043 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5044 else PLplot escapes for Hershey or unicode text to determine the\n\
5045 glyph.\n\
5046\n\
5047 Redacted form: plstring3(x, y, z, string)\n\
5048\n\
5049 This function is used in example 18.\n\
5050\n\
5051\n\
5052\n\
5053SYNOPSIS:\n\
5054\n\
5055plstring3(n, x, y, z, string)\n\
5056\n\
5057ARGUMENTS:\n\
5058\n\
5059 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5060\n\
5061 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5062 the points.\n\
5063\n\
5064 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5065 the points.\n\
5066\n\
5067 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5068 the points.\n\
5069\n\
5070 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5071 the glyph(s) to be plotted at each of the n points. points.\n\
5072";
5073static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
5074Shade regions on the basis of value\n\
5075\n\
5076DESCRIPTION:\n\
5077\n\
5078 Shade regions on the basis of value. This is the high-level routine\n\
5079 for making continuous color shaded plots with cmap1 while plshade\n\
5080 should be used to plot individual shaded regions using either cmap0 or\n\
5081 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5082 our supported languages.\n\
5083\n\
5084 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5085 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5086 pltr_data)\n\
5087\n\
5088\n\
5089 This function is used in examples 16, 21, and 22.\n\
5090\n\
5091\n\
5092\n\
5093SYNOPSIS:\n\
5094\n\
5095plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5096\n\
5097ARGUMENTS:\n\
5098\n\
5099 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5100 plot. Should have dimensions of\n\
5101 nx by\n\
5102 ny.\n\
5103\n\
5104 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5105\n\
5106 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5107\n\
5108 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5109 the region that should be plotted in the shade plot. This\n\
5110 function accepts x and y coordinates as input arguments and must\n\
5111 return 1 if the point is to be included in the shade plot and 0\n\
5112 otherwise. If you want to plot the entire shade plot (the usual\n\
5113 case), this argument should be set to NULL.\n\
5114\n\
5115 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5116 pltr below for how these arguments are used (only for the special case\n\
5117 when the callback function\n\
5118 pltr is not supplied).\n\
5119\n\
5120 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5121 corresponding to the edges of each shaded region that will be\n\
5122 plotted by this function. To work properly the levels should be\n\
5123 monotonic.\n\
5124\n\
5125 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5126 of shade edge values in clevel).\n\
5127\n\
5128 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5129 pattern.\n\
5130\n\
5131 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5132 contours defining edges of shaded regions. The pen color is only\n\
5133 temporary set for the contour drawing. Set this value to zero or\n\
5134 less if no shade edge contours are wanted.\n\
5135\n\
5136 cont_width (PLFLT, input) : Defines line width used for contours\n\
5137 defining edges of shaded regions. This value may not be honored\n\
5138 by all drivers. The pen width is only temporary set for the\n\
5139 contour drawing. Set this value to zero or less if no shade edge\n\
5140 contours are wanted.\n\
5141\n\
5142 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5143 region. Use plfill for this purpose.\n\
5144\n\
5145 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5146 map to rectangles after coordinate transformation with pltrl.\n\
5147 Otherwise, set rectangular to false. If rectangular is set to\n\
5148 true, plshade tries to save time by filling large rectangles.\n\
5149 This optimization fails if the coordinate transformation distorts\n\
5150 the shape of rectangles. For example a plot in polar coordinates\n\
5151 has to have rectangular set to false.\n\
5152\n\
5153 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5154 defines the transformation between the zero-based indices of the\n\
5155 matrix a and world coordinates. If\n\
5156 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5157 indices of a are mapped to the range\n\
5158 xmin through\n\
5159 xmax and the y indices of a are mapped to the range\n\
5160 ymin through\n\
5161 ymax.For the C case, transformation functions are provided in the\n\
5162 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5163 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5164 matrices. In addition, C callback routines for the transformation\n\
5165 can be supplied by the user such as the mypltr function in\n\
5166 examples/c/x09c.c which provides a general linear transformation\n\
5167 between index coordinates and world coordinates.For languages\n\
5168 other than C you should consult the PLplot documentation for the\n\
5169 details concerning how PLTRANSFORM_callback arguments are\n\
5170 interfaced. However, in general, a particular pattern of\n\
5171 callback-associated arguments such as a tr vector with 6 elements;\n\
5172 xg and yg vectors; or xg and yg matrices are respectively\n\
5173 interfaced to a linear-transformation routine similar to the above\n\
5174 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5175 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5176 support native language callbacks for handling index to\n\
5177 world-coordinate transformations. Examples of these various\n\
5178 approaches are given in examples/<language>x09*,\n\
5179 examples/<language>x16*, examples/<language>x20*,\n\
5180 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5181 supported languages.\n\
5182\n\
5183 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5184 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5185 externally supplied.\n\
5186";
5187static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5188Set output file name\n\
5189\n\
5190DESCRIPTION:\n\
5191\n\
5192 Sets the current output file name, if applicable. If the file name\n\
5193 has not been specified and is required by the driver, the user will be\n\
5194 prompted for it. If using the X-windows output driver, this sets the\n\
5195 display name. This routine, if used, must be called before\n\
5196 initializing PLplot.\n\
5197\n\
5198 Redacted form: plsfnam(fnam)\n\
5199\n\
5200 This function is used in examples 1 and 20.\n\
5201\n\
5202\n\
5203\n\
5204SYNOPSIS:\n\
5205\n\
5206plsfnam(fnam)\n\
5207\n\
5208ARGUMENTS:\n\
5209\n\
5210 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5211 the file name.\n\
5212";
5213static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5214Contour plot\n\
5215\n\
5216DESCRIPTION:\n\
5217\n\
5218 Draws a contour plot of the data in f[\n\
5219 nx][\n\
5220 ny], using the nlevel contour levels specified by clevel. Only the\n\
5221 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5222 where all these index ranges are interpreted as one-based for\n\
5223 historical reasons. A transformation routine pointed to by pltr with\n\
5224 a generic pointer pltr_data for additional data required by the\n\
5225 transformation routine is used to map indices within the matrix to the\n\
5226 world coordinates.\n\
5227\n\
5228 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5229 where (see above discussion) the pltr, pltr_data callback arguments\n\
5230 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5231 vectors; or xg and yg matrices.\n\
5232\n\
5233 This function is used in examples 9, 14, 16, and 22.\n\
5234\n\
5235\n\
5236\n\
5237SYNOPSIS:\n\
5238\n\
5239plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5240\n\
5241ARGUMENTS:\n\
5242\n\
5243 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5244\n\
5245 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5246\n\
5247 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5248 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5249 zero-based for historical backwards-compatibility reasons.\n\
5250\n\
5251 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5252 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5253 zero-based for historical backwards-compatibility reasons.\n\
5254\n\
5255 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5256 which to draw contours.\n\
5257\n\
5258 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5259\n\
5260 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5261 defines the transformation between the zero-based indices of the\n\
5262 matrix f and the world coordinates.For the C case, transformation\n\
5263 functions are provided in the PLplot library: pltr0 for the\n\
5264 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5265 respectively defined by vectors and matrices. In addition, C\n\
5266 callback routines for the transformation can be supplied by the\n\
5267 user such as the mypltr function in examples/c/x09c.c which\n\
5268 provides a general linear transformation between index coordinates\n\
5269 and world coordinates.For languages other than C you should\n\
5270 consult the PLplot documentation for the details concerning how\n\
5271 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5272 general, a particular pattern of callback-associated arguments\n\
5273 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5274 yg matrices are respectively interfaced to a linear-transformation\n\
5275 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5276 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5277 the PLplot documentation) support native language callbacks for\n\
5278 handling index to world-coordinate transformations. Examples of\n\
5279 these various approaches are given in examples/<language>x09*,\n\
5280 examples/<language>x16*, examples/<language>x20*,\n\
5281 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5282 supported languages.\n\
5283\n\
5284 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5285 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5286 that is externally supplied.\n\
5287";
5288static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5289Set parameters that define current plot-space window\n\
5290\n\
5291DESCRIPTION:\n\
5292\n\
5293 Set relative minima and maxima that define the current plot-space\n\
5294 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5295 xmax, and ymax are 0., 0., 1., and 1.\n\
5296\n\
5297 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5298\n\
5299 This function is used in example 31.\n\
5300\n\
5301\n\
5302\n\
5303SYNOPSIS:\n\
5304\n\
5305plsdiplt(xmin, ymin, xmax, ymax)\n\
5306\n\
5307ARGUMENTS:\n\
5308\n\
5309 xmin (PLFLT, input) : Relative minimum in x.\n\
5310\n\
5311 ymin (PLFLT, input) : Relative minimum in y.\n\
5312\n\
5313 xmax (PLFLT, input) : Relative maximum in x.\n\
5314\n\
5315 ymax (PLFLT, input) : Relative maximum in y.\n\
5316";
5317static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5318Write text inside the viewport of a 3D plot\n\
5319\n\
5320DESCRIPTION:\n\
5321\n\
5322 Writes text at a specified position and inclination and with a\n\
5323 specified shear within the viewport. Text is clipped at the viewport\n\
5324 boundaries. The reference point of a string lies along a line passing\n\
5325 through the string at half the height of a capital letter. The\n\
5326 position of the reference point along this line is determined by just,\n\
5327 and the reference point is placed at world coordinates (\n\
5328 wx,\n\
5329 wy,\n\
5330 wz) within the viewport. The inclination and shear of the string is\n\
5331 specified in terms of differences of world coordinates making it easy\n\
5332 to write text parallel to a line in a graph.\n\
5333\n\
5334 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5335\n\
5336 This function is used in example 28.\n\
5337\n\
5338\n\
5339\n\
5340SYNOPSIS:\n\
5341\n\
5342plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5343\n\
5344ARGUMENTS:\n\
5345\n\
5346 wx (PLFLT, input) : x world coordinate of reference point of\n\
5347 string.\n\
5348\n\
5349 wy (PLFLT, input) : y world coordinate of reference point of\n\
5350 string.\n\
5351\n\
5352 wz (PLFLT, input) : z world coordinate of reference point of\n\
5353 string.\n\
5354\n\
5355 dx (PLFLT, input) : Together with dy and\n\
5356 dz , this specifies the inclination of the string. The baseline of\n\
5357 the string is parallel to a line joining (\n\
5358 x,\n\
5359 y,\n\
5360 z) to (\n\
5361 x+\n\
5362 dx,\n\
5363 y+\n\
5364 dy,\n\
5365 z+\n\
5366 dz) .\n\
5367\n\
5368 dy (PLFLT, input) : Together with dx and\n\
5369 dz, this specifies the inclination of the string.\n\
5370\n\
5371 dz (PLFLT, input) : Together with dx and\n\
5372 dy, this specifies the inclination of the string.\n\
5373\n\
5374 sx (PLFLT, input) : Together with sy and\n\
5375 sz , this specifies the shear of the string. The string is sheared so\n\
5376 that the characters are vertically parallel to a line joining (\n\
5377 x,\n\
5378 y,\n\
5379 z) to (\n\
5380 x+\n\
5381 sx,\n\
5382 y+\n\
5383 sy,\n\
5384 z+\n\
5385 sz) . If sx =\n\
5386 sy =\n\
5387 sz = 0.) then the text is not sheared.\n\
5388\n\
5389 sy (PLFLT, input) : Together with sx and\n\
5390 sz, this specifies shear of the string.\n\
5391\n\
5392 sz (PLFLT, input) : Together with sx and\n\
5393 sy, this specifies shear of the string.\n\
5394\n\
5395 just (PLFLT, input) : Specifies the position of the string relative\n\
5396 to its reference point. If just=0. , the reference point is at\n\
5397 the left and if just=1. , it is at the right of the string. Other\n\
5398 values of just give intermediate justifications.\n\
5399\n\
5400 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5401 written out.\n\
5402";
5403static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5404Plot continental outline or shapefile data in world coordinates\n\
5405\n\
5406DESCRIPTION:\n\
5407\n\
5408 Plots continental outlines or shapefile data in world coordinates. A\n\
5409 demonstration of how to use this function to create different\n\
5410 projections can be found in examples/c/x19c. PLplot is provided with\n\
5411 basic coastal outlines and USA state borders. To use the map\n\
5412 functionality PLplot must be compiled with the shapelib library.\n\
5413 Shapefiles have become a popular standard for geographical data and\n\
5414 data in this format can be easily found from a number of online\n\
5415 sources. Shapefile data is actually provided as three or more files\n\
5416 with the same filename, but different extensions. The .shp and .shx\n\
5417 files are required for plotting Shapefile data with PLplot.\n\
5418\n\
5419 PLplot currently supports the point, multipoint, polyline and polygon\n\
5420 objects within shapefiles. However holes in polygons are not\n\
5421 supported. When plmap is used the type of object is derived from the\n\
5422 shapefile, if you wish to override the type then use one of the other\n\
5423 plmap variants. The built in maps have line data only.\n\
5424\n\
5425 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5426\n\
5427 This function is used in example 19.\n\
5428\n\
5429\n\
5430\n\
5431SYNOPSIS:\n\
5432\n\
5433plmap(mapform, name, minx, maxx, miny, maxy)\n\
5434\n\
5435ARGUMENTS:\n\
5436\n\
5437 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5438 transform the original map data coordinates to a new coordinate\n\
5439 system. The PLplot-supplied map data is provided as latitudes and\n\
5440 longitudes; other Shapefile data may be provided in other\n\
5441 coordinate systems as can be found in their .prj plain text files.\n\
5442 For example, by using this transform we can change from a\n\
5443 longitude, latitude coordinate to a polar stereographic\n\
5444 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5445 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5446 corresponding y coordinates (latitudes for the PLplot supplied\n\
5447 data). After the call to mapform(), x[] and y[] should be\n\
5448 replaced by the corresponding plot coordinates. If no transform is\n\
5449 desired, mapform can be replaced by NULL.\n\
5450\n\
5451 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5452 the type of map plotted. This is either one of the PLplot built-in\n\
5453 maps or the file name of a set of Shapefile files without the file\n\
5454 extensions. For the PLplot built-in maps the possible values are:\n\
5455 \"globe\" -- continental outlines\n\
5456 \"usa\" -- USA and state boundaries\n\
5457 \"cglobe\" -- continental outlines and countries\n\
5458 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5459\n\
5460\n\
5461 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5462 drawn. The units must match the shapefile (built in maps are\n\
5463 degrees lat/lon). Objects in the file which do not encroach on the\n\
5464 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5465 note this is simply an optimisation, not a clipping so for objects\n\
5466 with some points inside the box and some points outside the box\n\
5467 all the points will be rendered. These parameters also define\n\
5468 latitude and longitude wrapping for shapefiles using these units.\n\
5469 Longitude points will be wrapped by integer multiples of 360\n\
5470 degrees to place them in the box. This allows the same data to be\n\
5471 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5472 you plot from -180-540 you will get two cycles of data drawn. The\n\
5473 value of minx must be less than the value of maxx. Passing in a\n\
5474 nan, max/-max floating point number or +/-infinity will case the\n\
5475 bounding box from the shapefile to be used.\n\
5476\n\
5477 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5478 drawn - see minx.\n\
5479\n\
5480 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5481 drawn - see minx.\n\
5482\n\
5483 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5484 drawn - see minx.\n\
5485";
5486static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5487Specify viewport using coordinates and aspect ratio\n\
5488\n\
5489DESCRIPTION:\n\
5490\n\
5491 Device-independent routine for setting up the viewport. The viewport\n\
5492 is chosen to be the largest with the given aspect ratio that fits\n\
5493 within the specified region (in terms of normalized subpage\n\
5494 coordinates). This routine is functionally equivalent to plvpor when\n\
5495 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5496 routine reserves no extra space at the edges for labels.\n\
5497\n\
5498 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5499\n\
5500 This function is used in example 9.\n\
5501\n\
5502\n\
5503\n\
5504SYNOPSIS:\n\
5505\n\
5506plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5507\n\
5508ARGUMENTS:\n\
5509\n\
5510 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5511 left-hand edge of the viewport.\n\
5512\n\
5513 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5514 right-hand edge of the viewport.\n\
5515\n\
5516 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5517 bottom edge of the viewport.\n\
5518\n\
5519 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5520 edge of the viewport.\n\
5521\n\
5522 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5523 axis.\n\
5524";
5525static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5526Set the pause (on end-of-page) status\n\
5527\n\
5528DESCRIPTION:\n\
5529\n\
5530 Set the pause (on end-of-page) status.\n\
5531\n\
5532 Redacted form: plspause(pause)\n\
5533\n\
5534 This function is in examples 14,20.\n\
5535\n\
5536\n\
5537\n\
5538SYNOPSIS:\n\
5539\n\
5540plspause(pause)\n\
5541\n\
5542ARGUMENTS:\n\
5543\n\
5544 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5545 end-of-page for those drivers which support this. Otherwise there\n\
5546 is no pause.\n\
5547";
5548static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5549Plot 3-d surface plot\n\
5550\n\
5551DESCRIPTION:\n\
5552\n\
5553 Plots a three-dimensional surface plot within the environment set up\n\
5554 by plw3d. The surface is defined by the matrix z[\n\
5555 nx][\n\
5556 ny] , the point z[i][j] being the value of the function at (\n\
5557 x[i],\n\
5558 y[j]). Note that the points in vectors x and y do not need to be\n\
5559 equally spaced, but must be stored in ascending order. The parameter\n\
5560 opt controls the way in which the surface is displayed. For further\n\
5561 details see the PLplot documentation. The only difference between\n\
5562 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5563 while plot3d only draws the surface as viewed from the top.\n\
5564\n\
5565 Redacted form: plot3d(x, y, z, opt, side)\n\
5566\n\
5567 This function is used in examples 11 and 21.\n\
5568\n\
5569\n\
5570\n\
5571SYNOPSIS:\n\
5572\n\
5573plot3d(x, y, z, nx, ny, opt, side)\n\
5574\n\
5575ARGUMENTS:\n\
5576\n\
5577 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5578 which the function is evaluated.\n\
5579\n\
5580 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5581 which the function is evaluated.\n\
5582\n\
5583 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5584 plot. Should have dimensions of\n\
5585 nx by\n\
5586 ny.\n\
5587\n\
5588 nx (PLINT, input) : Number of x values at which function is\n\
5589 evaluated.\n\
5590\n\
5591 ny (PLINT, input) : Number of y values at which function is\n\
5592 evaluated.\n\
5593\n\
5594 opt (PLINT, input) : Determines the way in which the surface is\n\
5595 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5596 function of x for each value of y[j] .\n\
5597 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5598 for each value of x[i] .\n\
5599 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5600 at which function is defined.\n\
5601\n\
5602\n\
5603 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5604 should be draw on the figure. If side is true sides are drawn,\n\
5605 otherwise no sides are drawn.\n\
5606";
5607static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5608Copy state parameters from the reference stream to the current stream\n\
5609\n\
5610DESCRIPTION:\n\
5611\n\
5612 Copies state parameters from the reference stream to the current\n\
5613 stream. Tell driver interface to map device coordinates unless flags\n\
5614 == 1.\n\
5615\n\
5616 This function is used for making save files of selected plots (e.g.\n\
5617 from the TK driver). After initializing, you can get a copy of the\n\
5618 current plot to the specified device by switching to this stream and\n\
5619 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5620 appropriate. The plot buffer must have previously been enabled (done\n\
5621 automatically by some display drivers, such as X).\n\
5622\n\
5623 Redacted form: plcpstrm(iplsr, flags)\n\
5624\n\
5625 This function is used in example 1,20.\n\
5626\n\
5627\n\
5628\n\
5629SYNOPSIS:\n\
5630\n\
5631plcpstrm(iplsr, flags)\n\
5632\n\
5633ARGUMENTS:\n\
5634\n\
5635 iplsr (PLINT, input) : Number of reference stream.\n\
5636\n\
5637 flags (PLBOOL, input) : If flags is set to true the device\n\
5638 coordinates are not copied from the reference to current stream.\n\
5639";
5640static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5641Set page parameters\n\
5642\n\
5643DESCRIPTION:\n\
5644\n\
5645 Sets the page configuration (optional). If an individual parameter is\n\
5646 zero then that parameter value is not updated. Not all parameters are\n\
5647 recognized by all drivers and the interpretation is device-dependent.\n\
5648 The X-window driver uses the length and offset parameters to determine\n\
5649 the window size and location. The length and offset values are\n\
5650 expressed in units that are specific to the current driver. For\n\
5651 instance: screen drivers will usually interpret them as number of\n\
5652 pixels, whereas printer drivers will usually use mm.\n\
5653\n\
5654 This routine, if used, must be called before initializing PLplot. It\n\
5655 may be called at later times for interactive drivers to change only\n\
5656 the dpi for subsequent redraws which you can force via a call to\n\
5657 plreplot. If this function is not called then the page size defaults\n\
5658 to landscape A4 for drivers which use real world page sizes and 744\n\
5659 pixels wide by 538 pixels high for raster drivers. The default value\n\
5660 for dx and dy is 90 pixels per inch for raster drivers.\n\
5661\n\
5662\n\
5663\n\
5664 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5665\n\
5666 This function is used in examples 14 and 31.\n\
5667\n\
5668\n\
5669\n\
5670SYNOPSIS:\n\
5671\n\
5672plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5673\n\
5674ARGUMENTS:\n\
5675\n\
5676 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5677 by raster drivers, ignored by drivers which use \"real world\" units\n\
5678 (e.g. mm).\n\
5679\n\
5680 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5681 by raster drivers, ignored by drivers which use \"real world\" units\n\
5682 (e.g. mm).\n\
5683\n\
5684 xleng (PLINT, input) : Page length, x.\n\
5685\n\
5686 yleng (PLINT, input) : Page length, y.\n\
5687\n\
5688 xoff (PLINT, input) : Page offset, x.\n\
5689\n\
5690 yoff (PLINT, input) : Page offset, y.\n\
5691";
5692static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5693Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5694\n\
5695DESCRIPTION:\n\
5696\n\
5697 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5698 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5699 Values are negative if an invalid color id is given.\n\
5700\n\
5701 Redacted form: plgcola(r, g, b)\n\
5702\n\
5703 This function is used in example 30.\n\
5704\n\
5705\n\
5706\n\
5707SYNOPSIS:\n\
5708\n\
5709plgcol0a(icol0, r, g, b, alpha)\n\
5710\n\
5711ARGUMENTS:\n\
5712\n\
5713 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5714\n\
5715 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5716 in the range from 0 to 255.\n\
5717\n\
5718 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5719 in the range from 0 to 255.\n\
5720\n\
5721 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5722 in the range from 0 to 255.\n\
5723\n\
5724 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5725 transparency in the range from (0.0-1.0).\n\
5726";
5727static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5728Returns 8-bit RGB values for given color index from cmap0\n\
5729\n\
5730DESCRIPTION:\n\
5731\n\
5732 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5733 PLplot documentation). Values are negative if an invalid color id is\n\
5734 given.\n\
5735\n\
5736 Redacted form: plgcol0(icol0, r, g, b)\n\
5737\n\
5738 This function is used in example 2.\n\
5739\n\
5740\n\
5741\n\
5742SYNOPSIS:\n\
5743\n\
5744plgcol0(icol0, r, g, b)\n\
5745\n\
5746ARGUMENTS:\n\
5747\n\
5748 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5749\n\
5750 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5751 value.\n\
5752\n\
5753 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5754 value.\n\
5755\n\
5756 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5757 value.\n\
5758";
5759static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5760Set parameters incrementally (zoom mode) that define current plot-space window\n\
5761\n\
5762DESCRIPTION:\n\
5763\n\
5764 Set relative minima and maxima incrementally (zoom mode) that define\n\
5765 the current plot-space window. This function has the same effect as\n\
5766 plsdiplt if that function has not been previously called. Otherwise,\n\
5767 this function implements zoom mode using the transformation min_used =\n\
5768 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5769 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5770 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5771\n\
5772 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5773\n\
5774 This function is used in example 31.\n\
5775\n\
5776\n\
5777\n\
5778SYNOPSIS:\n\
5779\n\
5780plsdiplz(xmin, ymin, xmax, ymax)\n\
5781\n\
5782ARGUMENTS:\n\
5783\n\
5784 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5785\n\
5786 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5787\n\
5788 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5789\n\
5790 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5791";
5792static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5793Plot all or a subset of Shapefile data, filling the polygons\n\
5794\n\
5795DESCRIPTION:\n\
5796\n\
5797 As per plmapline, however the items are filled in the same way as\n\
5798 plfill.\n\
5799\n\
5800 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5801 plotentries)\n\
5802\n\
5803 This function is used in example 19.\n\
5804\n\
5805\n\
5806\n\
5807SYNOPSIS:\n\
5808\n\
5809plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5810\n\
5811ARGUMENTS:\n\
5812\n\
5813 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5814 transform the coordinates given in the shapefile into a plot\n\
5815 coordinate system. By using this transform, we can change from a\n\
5816 longitude, latitude coordinate to a polar stereographic project,\n\
5817 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5818 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5819 mapform(), x[] and y[] should be replaced by the corresponding\n\
5820 plot coordinates. If no transform is desired, mapform can be\n\
5821 replaced by NULL.\n\
5822\n\
5823 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5824 the file name of a set of Shapefile files without the file\n\
5825 extension.\n\
5826\n\
5827 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5828 be in the same units as used by the Shapefile. You could use a\n\
5829 very large negative number to plot everything, but you can improve\n\
5830 performance by limiting the area drawn. The units must match those\n\
5831 of the Shapefile projection, which may be for example longitude or\n\
5832 distance. The value of minx must be less than the value of maxx.\n\
5833\n\
5834 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5835 use a very large number to plot everything, but you can improve\n\
5836 performance by limiting the area drawn.\n\
5837\n\
5838 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5839 be in the same units as used by the Shapefile. You could use a\n\
5840 very large negative number to plot everything, but you can improve\n\
5841 performance by limiting the area drawn. The units must match those\n\
5842 of the Shapefile projection, which may be for example latitude or\n\
5843 distance. The value of miny must be less than the value of maxy.\n\
5844\n\
5845 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5846 use a very large number to plot everything, but you can improve\n\
5847 performance by limiting the area drawn.\n\
5848\n\
5849 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5850 zero-based indices of the Shapefile elements which will be drawn.\n\
5851 Setting\n\
5852 plotentries to NULL will plot all elements of the Shapefile.\n\
5853\n\
5854 nplotentries (PLINT, input) : The number of items in\n\
5855 plotentries. Ignored if\n\
5856 plotentries is NULL.\n\
5857";
5858static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5859Draw a line\n\
5860\n\
5861DESCRIPTION:\n\
5862\n\
5863 Draws line defined by n points in x and y.\n\
5864\n\
5865 Redacted form: plline(x, y)\n\
5866\n\
5867 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5868 25-27, and 29.\n\
5869\n\
5870\n\
5871\n\
5872SYNOPSIS:\n\
5873\n\
5874plline(n, x, y)\n\
5875\n\
5876ARGUMENTS:\n\
5877\n\
5878 n (PLINT, input) : Number of points defining line.\n\
5879\n\
5880 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5881 points.\n\
5882\n\
5883 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5884 points.\n\
5885";
5886static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5887Get viewport limits in world coordinates\n\
5888\n\
5889DESCRIPTION:\n\
5890\n\
5891 Get viewport limits in world coordinates.\n\
5892\n\
5893 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5894\n\
5895\n\
5896 This function is used in example 31.\n\
5897\n\
5898\n\
5899\n\
5900SYNOPSIS:\n\
5901\n\
5902plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5903\n\
5904ARGUMENTS:\n\
5905\n\
5906 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5907 viewport limit of the world coordinate in x.\n\
5908\n\
5909 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5910 viewport limit of the world coordinate in x.\n\
5911\n\
5912 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5913 viewport limit of the world coordinate in y.\n\
5914\n\
5915 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5916 viewport limit of the world coordinate in y.\n\
5917";
5918static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5919Set area line fill pattern\n\
5920\n\
5921DESCRIPTION:\n\
5922\n\
5923 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5924 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5925 inclinations and spacings. The arguments to this routine are the\n\
5926 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5927 elements) specifying the inclinations in tenths of a degree and the\n\
5928 spacing in micrometers. (See also plpsty)\n\
5929\n\
5930 Redacted form: General: plpat(inc, del)\n\
5931\n\
5932\n\
5933 This function is used in example 15.\n\
5934\n\
5935\n\
5936\n\
5937SYNOPSIS:\n\
5938\n\
5939plpat(nlin, inc, del)\n\
5940\n\
5941ARGUMENTS:\n\
5942\n\
5943 nlin (PLINT, input) : Number of sets of lines making up the\n\
5944 pattern, either 1 or 2.\n\
5945\n\
5946 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5947 inclination in tenths of a degree. (Should be between -900 and\n\
5948 900).\n\
5949\n\
5950 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5951 spacing in micrometers between the lines making up the pattern.\n\
5952";
5953static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5954Set x axis parameters\n\
5955\n\
5956DESCRIPTION:\n\
5957\n\
5958 Sets values of the digmax and digits flags for the x axis. See the\n\
5959 PLplot documentation for more information.\n\
5960\n\
5961 Redacted form: plsxax(digmax, digits)\n\
5962\n\
5963 This function is used in example 31.\n\
5964\n\
5965\n\
5966\n\
5967SYNOPSIS:\n\
5968\n\
5969plsxax(digmax, digits)\n\
5970\n\
5971ARGUMENTS:\n\
5972\n\
5973 digmax (PLINT, input) : Variable to set the maximum number of\n\
5974 digits for the x axis. If nonzero, the printed label will be\n\
5975 switched to a floating-point representation when the number of\n\
5976 digits exceeds digmax.\n\
5977\n\
5978 digits (PLINT, input) : Field digits value. Currently, changing\n\
5979 its value here has no effect since it is set only by plbox or\n\
5980 plbox3. However, the user may obtain its value after a call to\n\
5981 either of these functions by calling plgxax.\n\
5982";
5983static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5984Get family file parameters\n\
5985\n\
5986DESCRIPTION:\n\
5987\n\
5988 Gets information about current family file, if familying is enabled.\n\
5989 See the PLplot documentation for more information.\n\
5990\n\
5991 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5992\n\
5993 This function is used in examples 14 and 31.\n\
5994\n\
5995\n\
5996\n\
5997SYNOPSIS:\n\
5998\n\
5999plgfam(p_fam, p_num, p_bmax)\n\
6000\n\
6001ARGUMENTS:\n\
6002\n\
6003 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6004 family flag value. If nonzero, familying is enabled for the\n\
6005 current device.\n\
6006\n\
6007 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6008 family file number.\n\
6009\n\
6010 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6011 file size (in bytes) for a family file.\n\
6012";
6013static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
6014Get y axis parameters\n\
6015\n\
6016DESCRIPTION:\n\
6017\n\
6018 Identical to plgxax, except that arguments are flags for y axis. See\n\
6019 the description of plgxax for more detail.\n\
6020\n\
6021 Redacted form: plgyax(p_digmax, p_digits)\n\
6022\n\
6023 This function is used in example 31.\n\
6024\n\
6025\n\
6026\n\
6027SYNOPSIS:\n\
6028\n\
6029plgyax(p_digmax, p_digits)\n\
6030\n\
6031ARGUMENTS:\n\
6032\n\
6033 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6034 number of digits for the y axis. If nonzero, the printed label\n\
6035 has been switched to a floating-point representation when the\n\
6036 number of digits exceeds this value.\n\
6037\n\
6038 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6039 number of digits for the numeric labels (y axis) from the last\n\
6040 plot.\n\
6041";
6042static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6043Plot a glyph at the specified points\n\
6044\n\
6045DESCRIPTION:\n\
6046\n\
6047 Plot a glyph at the specified points. (This function is largely\n\
6048 superseded by plstring which gives access to many[!] more glyphs.)\n\
6049 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6050 and a draw at the same place. Not ideal, since a sufficiently\n\
6051 intelligent output device may optimize it away, or there may be faster\n\
6052 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6053 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6054 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6055 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6056 code <= 127 the corresponding printable ASCII character is plotted.\n\
6057\n\
6058 Redacted form: plpoin(x, y, code)\n\
6059\n\
6060 This function is used in examples 1, 6, 14, and 29.\n\
6061\n\
6062\n\
6063\n\
6064SYNOPSIS:\n\
6065\n\
6066plpoin(n, x, y, code)\n\
6067\n\
6068ARGUMENTS:\n\
6069\n\
6070 n (PLINT, input) : Number of points in the x and y vectors.\n\
6071\n\
6072 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6073 points.\n\
6074\n\
6075 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6076 points.\n\
6077\n\
6078 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6079 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6080 each of the n points.\n\
6081";
6082static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6083Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6084\n\
6085DESCRIPTION:\n\
6086\n\
6087 As per plmapline, however the items are plotted as strings or points\n\
6088 in the same way as plstring.\n\
6089\n\
6090 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6091 maxy, plotentries)\n\
6092\n\
6093 This function is not used in any examples.\n\
6094\n\
6095\n\
6096\n\
6097SYNOPSIS:\n\
6098\n\
6099plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6100\n\
6101ARGUMENTS:\n\
6102\n\
6103 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6104 transform the coordinates given in the shapefile into a plot\n\
6105 coordinate system. By using this transform, we can change from a\n\
6106 longitude, latitude coordinate to a polar stereographic project,\n\
6107 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6108 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6109 mapform(), x[] and y[] should be replaced by the corresponding\n\
6110 plot coordinates. If no transform is desired, mapform can be\n\
6111 replaced by NULL.\n\
6112\n\
6113 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6114 the file name of a set of Shapefile files without the file\n\
6115 extension.\n\
6116\n\
6117 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6118 drawn.\n\
6119\n\
6120 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6121 be in the same units as used by the Shapefile. You could use a\n\
6122 very large negative number to plot everything, but you can improve\n\
6123 performance by limiting the area drawn. The units must match those\n\
6124 of the Shapefile projection, which may be for example longitude or\n\
6125 distance. The value of minx must be less than the value of maxx.\n\
6126\n\
6127 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6128 use a very large number to plot everything, but you can improve\n\
6129 performance by limiting the area drawn.\n\
6130\n\
6131 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6132 be in the same units as used by the Shapefile. You could use a\n\
6133 very large negative number to plot everything, but you can improve\n\
6134 performance by limiting the area drawn. The units must match those\n\
6135 of the Shapefile projection, which may be for example latitude or\n\
6136 distance. The value of miny must be less than the value of maxy.\n\
6137\n\
6138 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6139 use a very large number to plot everything, but you can improve\n\
6140 performance by limiting the area drawn.\n\
6141\n\
6142 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6143 zero-based indices of the Shapefile elements which will be drawn.\n\
6144 Setting\n\
6145 plotentries to NULL will plot all elements of the Shapefile.\n\
6146\n\
6147 nplotentries (PLINT, input) : The number of items in\n\
6148 plotentries. Ignored if\n\
6149 plotentries is NULL.\n\
6150";
6151static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6152Select area fill pattern\n\
6153\n\
6154DESCRIPTION:\n\
6155\n\
6156 If\n\
6157 patt is zero or less use either a hardware solid fill if the drivers\n\
6158 have that capability (virtually all do) or fall back to a software\n\
6159 emulation of a solid fill using the eighth area line fill pattern. If\n\
6160 0 <\n\
6161 patt <= 8, then select one of eight predefined area line fill patterns\n\
6162 to use (see plpat if you desire other patterns).\n\
6163\n\
6164 Redacted form: plpsty(patt)\n\
6165\n\
6166 This function is used in examples 12, 13, 15, 16, and 25.\n\
6167\n\
6168\n\
6169\n\
6170SYNOPSIS:\n\
6171\n\
6172plpsty(patt)\n\
6173\n\
6174ARGUMENTS:\n\
6175\n\
6176 patt (PLINT, input) : The desired pattern index. If\n\
6177 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6178 above) used. For\n\
6179 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6180 line fill capability itself (most deliberately do not so that line\n\
6181 fill patterns look identical for those drivers), the patterns\n\
6182 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6183 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6184 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6185 (8) lines at both 45 degrees and -45 degrees.\n\
6186";
6187static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6188Set 8-bit RGB values for given cmap0 color index\n\
6189\n\
6190DESCRIPTION:\n\
6191\n\
6192 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6193 index. Overwrites the previous color value for the given index and,\n\
6194 thus, does not result in any additional allocation of space for\n\
6195 colors.\n\
6196\n\
6197 Redacted form: plscol0(icol0, r, g, b)\n\
6198\n\
6199 This function is used in any example 31.\n\
6200\n\
6201\n\
6202\n\
6203SYNOPSIS:\n\
6204\n\
6205plscol0(icol0, r, g, b)\n\
6206\n\
6207ARGUMENTS:\n\
6208\n\
6209 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6210 number of colors (which is set by default, by plscmap0n, or even\n\
6211 by plscmap0).\n\
6212\n\
6213 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6214 degree of red in the color.\n\
6215\n\
6216 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6217 degree of green in the color.\n\
6218\n\
6219 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6220 degree of blue in the color.\n\
6221";
6222static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6223Used to globally turn color output on/off\n\
6224\n\
6225DESCRIPTION:\n\
6226\n\
6227 Used to globally turn color output on/off for those drivers/devices\n\
6228 that support it.\n\
6229\n\
6230 Redacted form: plscolor(color)\n\
6231\n\
6232 This function is used in example 31.\n\
6233\n\
6234\n\
6235\n\
6236SYNOPSIS:\n\
6237\n\
6238plscolor(color)\n\
6239\n\
6240ARGUMENTS:\n\
6241\n\
6242 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6243 turned off. If non-zero, color is turned on.\n\
6244";
6245static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6246End plotting session\n\
6247\n\
6248DESCRIPTION:\n\
6249\n\
6250 Ends a plotting session, tidies up all the output files, switches\n\
6251 interactive devices back into text mode and frees up any memory that\n\
6252 was allocated. Must be called before end of program.\n\
6253\n\
6254 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6255 wait state after a call to plend or other functions which trigger the\n\
6256 end of a plot page. To avoid this, use the plspause function.\n\
6257\n\
6258 Redacted form: plend()\n\
6259\n\
6260 This function is used in all of the examples.\n\
6261\n\
6262\n\
6263\n\
6264SYNOPSIS:\n\
6265\n\
6266plend()\n\
6267";
6268static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6269Plot a histogram from binned data\n\
6270\n\
6271DESCRIPTION:\n\
6272\n\
6273 Plots a histogram consisting of nbin bins. The value associated with\n\
6274 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6275 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6276 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6277 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6278 placed midway between the values in the x vector. Also see plhist for\n\
6279 drawing histograms from unbinned data.\n\
6280\n\
6281 Redacted form: General: plbin(x, y, opt)\n\
6282 Python: plbin(nbin, x, y, opt)\n\
6283\n\
6284\n\
6285 This function is not used in any examples.\n\
6286\n\
6287\n\
6288\n\
6289SYNOPSIS:\n\
6290\n\
6291plbin(nbin, x, y, opt)\n\
6292\n\
6293ARGUMENTS:\n\
6294\n\
6295 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6296 and y vectors.)\n\
6297\n\
6298 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6299 with bins. These must form a strictly increasing sequence.\n\
6300\n\
6301 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6302 proportional to the number of points in each bin. This is a PLFLT\n\
6303 (instead of PLINT) vector so as to allow histograms of\n\
6304 probabilities, etc.\n\
6305\n\
6306 opt (PLINT, input) : Is a combination of several flags:\n\
6307 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6308 outer bins are expanded to fill up the entire x-axis and bins of\n\
6309 zero height are simply drawn.\n\
6310 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6311 between the x values. If the values in x are equally spaced,\n\
6312 the values are the center values of the bins.\n\
6313 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6314 size as the ones inside.\n\
6315 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6316 (there is a gap for such bins).\n\
6317";
6318static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6319Plot a 2D matrix using cmap1\n\
6320\n\
6321DESCRIPTION:\n\
6322\n\
6323 Plot a 2D matrix using cmap1.\n\
6324\n\
6325 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6326 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6327\n\
6328\n\
6329 This function is used in example 20.\n\
6330\n\
6331\n\
6332\n\
6333SYNOPSIS:\n\
6334\n\
6335plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6336\n\
6337ARGUMENTS:\n\
6338\n\
6339 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6340 plot. Should have dimensions of\n\
6341 nx by\n\
6342 ny.\n\
6343\n\
6344 nx, ny (PLINT, input) : Dimensions of idata\n\
6345\n\
6346 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6347 pltr below for how these arguments are used (only for the special case\n\
6348 when the callback function\n\
6349 pltr is not supplied).\n\
6350\n\
6351 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6352 (inclusive) will be plotted.\n\
6353\n\
6354 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6355 values to use for value to color mappings. A datum equal to or\n\
6356 less than valuemin will be plotted with color 0.0, while a datum\n\
6357 equal to or greater than valuemax will be plotted with color 1.0.\n\
6358 Data between valuemin and valuemax map linearly to colors in the\n\
6359 range (0.0-1.0).\n\
6360\n\
6361 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6362 defines the transformation between the zero-based indices of the\n\
6363 matrix idata and world coordinates. If\n\
6364 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6365 indices of idata are mapped to the range\n\
6366 xmin through\n\
6367 xmax and the y indices of idata are mapped to the range\n\
6368 ymin through\n\
6369 ymax.For the C case, transformation functions are provided in the\n\
6370 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6371 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6372 matrices. In addition, C callback routines for the transformation\n\
6373 can be supplied by the user such as the mypltr function in\n\
6374 examples/c/x09c.c which provides a general linear transformation\n\
6375 between index coordinates and world coordinates.For languages\n\
6376 other than C you should consult the PLplot documentation for the\n\
6377 details concerning how PLTRANSFORM_callback arguments are\n\
6378 interfaced. However, in general, a particular pattern of\n\
6379 callback-associated arguments such as a tr vector with 6 elements;\n\
6380 xg and yg vectors; or xg and yg matrices are respectively\n\
6381 interfaced to a linear-transformation routine similar to the above\n\
6382 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6383 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6384 support native language callbacks for handling index to\n\
6385 world-coordinate transformations. Examples of these various\n\
6386 approaches are given in examples/<language>x09*,\n\
6387 examples/<language>x16*, examples/<language>x20*,\n\
6388 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6389 supported languages.\n\
6390\n\
6391 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6392 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6393 externally supplied.\n\
6394";
6395static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6396Sets the 3D position of the light source\n\
6397\n\
6398DESCRIPTION:\n\
6399\n\
6400 Sets the 3D position of the light source for use with plsurf3d and\n\
6401 plsurf3dl\n\
6402\n\
6403 Redacted form: pllightsource(x, y, z)\n\
6404\n\
6405 This function is used in example 8.\n\
6406\n\
6407\n\
6408\n\
6409SYNOPSIS:\n\
6410\n\
6411pllightsource(x, y, z)\n\
6412\n\
6413ARGUMENTS:\n\
6414\n\
6415 x (PLFLT, input) : X-coordinate of the light source.\n\
6416\n\
6417 y (PLFLT, input) : Y-coordinate of the light source.\n\
6418\n\
6419 z (PLFLT, input) : Z-coordinate of the light source.\n\
6420";
6421static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6422Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6423\n\
6424DESCRIPTION:\n\
6425\n\
6426 When the implementation is completed this variant of plot3dc (see that\n\
6427 function\'s documentation for more details) should be suitable for the\n\
6428 case where the area of the x, y coordinate grid where z is defined can\n\
6429 be non-rectangular. The implementation is incomplete so the last 4\n\
6430 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6431 indexymax; are currently ignored and the functionality is otherwise\n\
6432 identical to that of plot3dc.\n\
6433\n\
6434 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6435 indexymin, indexymax)\n\
6436\n\
6437\n\
6438 This function is not used in any example.\n\
6439\n\
6440\n\
6441\n\
6442SYNOPSIS:\n\
6443\n\
6444plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6445\n\
6446ARGUMENTS:\n\
6447\n\
6448 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6449 which the function is evaluated.\n\
6450\n\
6451 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6452 which the function is evaluated.\n\
6453\n\
6454 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6455 plot. Should have dimensions of\n\
6456 nx by\n\
6457 ny.\n\
6458\n\
6459 nx (PLINT, input) : Number of x values at which the function is\n\
6460 evaluated.\n\
6461\n\
6462 ny (PLINT, input) : Number of y values at which the function is\n\
6463 evaluated.\n\
6464\n\
6465 opt (PLINT, input) : Determines the way in which the surface is\n\
6466 represented. To specify more than one option just add the options,\n\
6467 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6468 showing z as a function of x for each value of y[j] .\n\
6469 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6470 for each value of x[i] .\n\
6471 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6472 at which function is defined.\n\
6473 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6474 the z value being plotted. The color is used from the current\n\
6475 cmap1.\n\
6476 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6477 using parameters\n\
6478 nlevel and\n\
6479 clevel.\n\
6480 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6481 the borders of the plotted function.\n\
6482\n\
6483\n\
6484 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6485 levels.\n\
6486\n\
6487 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6488\n\
6489 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6490 corresponds to the first x index where z is defined.\n\
6491\n\
6492 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6493 which corresponds (by convention) to one more than the last x\n\
6494 index value where z is defined.\n\
6495\n\
6496 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6497 values which all must be ≥ 0. These values are the first y index\n\
6498 where z is defined for a particular x index in the range from\n\
6499 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6500 indexxmax.\n\
6501\n\
6502 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6503 values which all must be ≤ ny. These values correspond (by\n\
6504 convention) to one more than the last y index where z is defined\n\
6505 for a particular x index in the range from indexxmin to indexxmax\n\
6506 - 1. The dimension of indexymax is indexxmax.\n\
6507";
6508static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6509Creates a new stream and makes it the default\n\
6510\n\
6511DESCRIPTION:\n\
6512\n\
6513 Creates a new stream and makes it the default. Differs from using\n\
6514 plsstrm, in that a free stream number is found, and returned.\n\
6515 Unfortunately, I have to start at stream 1 and work upward, since\n\
6516 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6517 that no initial, library-opening call is required. So stream 0 must\n\
6518 be preallocated, and there is no simple way of determining whether it\n\
6519 is already in use or not.\n\
6520\n\
6521 Redacted form: plmkstrm(p_strm)\n\
6522\n\
6523 This function is used in examples 1 and 20.\n\
6524\n\
6525\n\
6526\n\
6527SYNOPSIS:\n\
6528\n\
6529plmkstrm(p_strm)\n\
6530\n\
6531ARGUMENTS:\n\
6532\n\
6533 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6534 number of the created stream.\n\
6535";
6536static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6537Set FCI (font characterization integer)\n\
6538\n\
6539DESCRIPTION:\n\
6540\n\
6541 Sets font characteristics to be used at the start of the next string\n\
6542 using the FCI approach. See the PLplot documentation for more\n\
6543 information. Note, plsfont (which calls plsfci internally) provides a\n\
6544 more user-friendly API for setting the font characterisitics.\n\
6545\n\
6546 Redacted form: General: plsfci(fci)\n\
6547\n\
6548\n\
6549 This function is used in example 23.\n\
6550\n\
6551\n\
6552\n\
6553SYNOPSIS:\n\
6554\n\
6555plsfci(fci)\n\
6556\n\
6557ARGUMENTS:\n\
6558\n\
6559 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6560 of FCI.\n\
6561";
6562static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6563Initialize PLplot\n\
6564\n\
6565DESCRIPTION:\n\
6566\n\
6567 Initializing the plotting package. The program prompts for the device\n\
6568 keyword or number of the desired output device. Hitting a RETURN in\n\
6569 response to the prompt is the same as selecting the first device.\n\
6570 plinit will issue no prompt if either the device was specified\n\
6571 previously (via command line flag, the plsetopt function, or the\n\
6572 plsdev function), or if only one device is enabled when PLplot is\n\
6573 installed. If subpages have been specified, the output device is\n\
6574 divided into nx by ny subpages, each of which may be used\n\
6575 independently. If plinit is called again during a program, the\n\
6576 previously opened file will be closed. The subroutine pladv is used\n\
6577 to advance from one subpage to the next.\n\
6578\n\
6579 Redacted form: plinit()\n\
6580\n\
6581 This function is used in all of the examples.\n\
6582\n\
6583\n\
6584\n\
6585SYNOPSIS:\n\
6586\n\
6587plinit()\n\
6588";
6589static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6590Set line style\n\
6591\n\
6592DESCRIPTION:\n\
6593\n\
6594 This sets up the line style for all lines subsequently drawn. A line\n\
6595 consists of segments in which the pen is alternately down and up. The\n\
6596 lengths of these segments are passed in the vectors mark and space\n\
6597 respectively. The number of mark-space pairs is specified by nms. In\n\
6598 order to return the line style to the default continuous line, plstyl\n\
6599 should be called with nms =0 .(see also pllsty)\n\
6600\n\
6601 Redacted form: plstyl(mark, space)\n\
6602\n\
6603 This function is used in examples 1, 9, and 14.\n\
6604\n\
6605\n\
6606\n\
6607SYNOPSIS:\n\
6608\n\
6609plstyl(nms, mark, space)\n\
6610\n\
6611ARGUMENTS:\n\
6612\n\
6613 nms (PLINT, input) : The number of mark and space elements in a\n\
6614 line. Thus a simple broken line can be obtained by setting nms=1\n\
6615 . A continuous line is specified by setting nms=0 .\n\
6616\n\
6617 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6618 segments during which the pen is down, measured in micrometers.\n\
6619\n\
6620 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6621 the segments during which the pen is up, measured in micrometers.\n\
6622";
6623static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6624Set length of minor ticks\n\
6625\n\
6626DESCRIPTION:\n\
6627\n\
6628 This sets up the length of the minor ticks and the length of the\n\
6629 terminals on error bars. The actual length is the product of the\n\
6630 default length and a scaling factor as for character height.\n\
6631\n\
6632 Redacted form: plsmin(def, scale)\n\
6633\n\
6634 This function is used in example 29.\n\
6635\n\
6636\n\
6637\n\
6638SYNOPSIS:\n\
6639\n\
6640plsmin(def, scale)\n\
6641\n\
6642ARGUMENTS:\n\
6643\n\
6644 def (PLFLT, input) : The default length of a minor tick in\n\
6645 millimeters, should be set to zero if the default length is to\n\
6646 remain unchanged.\n\
6647\n\
6648 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6649 actual tick length.\n\
6650";
6651static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6652Draw a box with axes, etc, in 3-d\n\
6653\n\
6654DESCRIPTION:\n\
6655\n\
6656 Draws axes, numeric and text labels for a three-dimensional surface\n\
6657 plot. For a more complete description of three-dimensional plotting\n\
6658 see the PLplot documentation.\n\
6659\n\
6660 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6661 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6662\n\
6663\n\
6664 This function is used in examples 8, 11, 18, and 21.\n\
6665\n\
6666\n\
6667\n\
6668SYNOPSIS:\n\
6669\n\
6670plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6671\n\
6672ARGUMENTS:\n\
6673\n\
6674 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6675 options for the x axis. The string can include any combination of\n\
6676 the following letters (upper or lower case) in any order: b: Draws\n\
6677 axis at base, at height z=\n\
6678 zmin where zmin is defined by call to plw3d. This character must be\n\
6679 specified in order to use any of the other options.\n\
6680 d: Plot labels as date / time. Values are assumed to be\n\
6681 seconds since the epoch (as used by gmtime).\n\
6682 f: Always use fixed point numeric labels.\n\
6683 i: Inverts tick marks, so they are drawn downwards, rather\n\
6684 than upwards.\n\
6685 l: Labels axis logarithmically. This only affects the labels,\n\
6686 not the data, and so it is necessary to compute the logarithms\n\
6687 of data points before passing them to any of the drawing\n\
6688 routines.\n\
6689 n: Writes numeric labels at major tick intervals.\n\
6690 o: Use custom labelling function to generate axis label text.\n\
6691 The custom labelling function can be defined with the\n\
6692 plslabelfunc command.\n\
6693 s: Enables subticks between major ticks, only valid if t is\n\
6694 also specified.\n\
6695 t: Draws major ticks.\n\
6696 u: If this is specified, the text label for the axis is\n\
6697 written under the axis.\n\
6698\n\
6699\n\
6700 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6701 the text label for the x axis. It is only drawn if u is in the\n\
6702 xopt string.\n\
6703\n\
6704 xtick (PLFLT, input) : World coordinate interval between major\n\
6705 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6706 generates a suitable tick interval.\n\
6707\n\
6708 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6709 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6710 generates a suitable minor tick interval.\n\
6711\n\
6712 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6713 options for the y axis. The string is interpreted in the same way\n\
6714 as xopt.\n\
6715\n\
6716 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6717 the text label for the y axis. It is only drawn if u is in the\n\
6718 yopt string.\n\
6719\n\
6720 ytick (PLFLT, input) : World coordinate interval between major\n\
6721 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6722 generates a suitable tick interval.\n\
6723\n\
6724 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6725 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6726 generates a suitable minor tick interval.\n\
6727\n\
6728 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6729 options for the z axis. The string can include any combination of\n\
6730 the following letters (upper or lower case) in any order: b: Draws\n\
6731 z axis to the left of the surface plot.\n\
6732 c: Draws z axis to the right of the surface plot.\n\
6733 d: Draws grid lines parallel to the x-y plane behind the\n\
6734 figure. These lines are not drawn until after plot3d or\n\
6735 plmesh are called because of the need for hidden line removal.\n\
6736 e: Plot labels as date / time. Values are assumed to be\n\
6737 seconds since the epoch (as used by gmtime). Note this\n\
6738 suboption is interpreted the same as the d suboption for xopt\n\
6739 and yopt, but it has to be identified as e for zopt since d\n\
6740 has already been used for the different purpose above.\n\
6741 f: Always use fixed point numeric labels.\n\
6742 i: Inverts tick marks, so they are drawn away from the center.\n\
6743 l: Labels axis logarithmically. This only affects the labels,\n\
6744 not the data, and so it is necessary to compute the logarithms\n\
6745 of data points before passing them to any of the drawing\n\
6746 routines.\n\
6747 m: Writes numeric labels at major tick intervals on the\n\
6748 right-hand z axis.\n\
6749 n: Writes numeric labels at major tick intervals on the\n\
6750 left-hand z axis.\n\
6751 o: Use custom labelling function to generate axis label text.\n\
6752 The custom labelling function can be defined with the\n\
6753 plslabelfunc command.\n\
6754 s: Enables subticks between major ticks, only valid if t is\n\
6755 also specified.\n\
6756 t: Draws major ticks.\n\
6757 u: If this is specified, the text label is written beside the\n\
6758 left-hand axis.\n\
6759 v: If this is specified, the text label is written beside the\n\
6760 right-hand axis.\n\
6761\n\
6762\n\
6763 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6764 the text label for the z axis. It is only drawn if u or v are in\n\
6765 the zopt string.\n\
6766\n\
6767 ztick (PLFLT, input) : World coordinate interval between major\n\
6768 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6769 generates a suitable tick interval.\n\
6770\n\
6771 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6772 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6773 generates a suitable minor tick interval.\n\
6774";
6775static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6776Set character size\n\
6777\n\
6778DESCRIPTION:\n\
6779\n\
6780 This sets up the size of all subsequent characters drawn. The actual\n\
6781 height of a character is the product of the default character size and\n\
6782 a scaling factor.\n\
6783\n\
6784 Redacted form: plschr(def, scale)\n\
6785\n\
6786 This function is used in examples 2, 13, 23, and 24.\n\
6787\n\
6788\n\
6789\n\
6790SYNOPSIS:\n\
6791\n\
6792plschr(def, scale)\n\
6793\n\
6794ARGUMENTS:\n\
6795\n\
6796 def (PLFLT, input) : The default height of a character in\n\
6797 millimeters, should be set to zero if the default height is to\n\
6798 remain unchanged. For rasterized drivers the dx and dy values\n\
6799 specified in plspage are used to convert from mm to pixels (note\n\
6800 the different unit systems used). This dpi aware scaling is not\n\
6801 implemented for all drivers yet.\n\
6802\n\
6803 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6804 actual character height.\n\
6805";
6806static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6807Calculate continuous time from broken-down time for the current stream\n\
6808\n\
6809DESCRIPTION:\n\
6810\n\
6811 Calculate continuous time, ctime, from broken-down time for the\n\
6812 current stream. The broken-down\n\
6813 time is specified by the following parameters: year, month, day, hour,\n\
6814 min, and sec. This function is the inverse of plbtime.\n\
6815\n\
6816 The PLplot definition of broken-down time is a calendar time that\n\
6817 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6818 responsibility to apply those offsets (if so desired) before using the\n\
6819 PLplot time API. By default broken-down time is defined using the\n\
6820 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6821 continuous time is defined as the number of seconds since the Unix\n\
6822 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6823 broken-down and continuous time are possible, see plconfigtime which\n\
6824 specifies that transformation for the current stream.\n\
6825\n\
6826 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6827 ctime)\n\
6828\n\
6829\n\
6830 This function is used in example 29.\n\
6831\n\
6832\n\
6833\n\
6834SYNOPSIS:\n\
6835\n\
6836plctime(year, month, day, hour, min, sec, ctime)\n\
6837\n\
6838ARGUMENTS:\n\
6839\n\
6840 year (PLINT, input) : Input year.\n\
6841\n\
6842 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6843 (December).\n\
6844\n\
6845 day (PLINT, input) : Input day in range from 1 to 31.\n\
6846\n\
6847 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6848\n\
6849 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6850\n\
6851 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6852\n\
6853 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6854 time calculated from the broken-down time specified by the\n\
6855 previous parameters.\n\
6856";
6857static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6858Set color, cmap0\n\
6859\n\
6860DESCRIPTION:\n\
6861\n\
6862 Sets the color index for cmap0 (see the PLplot documentation).\n\
6863\n\
6864 Redacted form: plcol0(icol0)\n\
6865\n\
6866 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6867\n\
6868\n\
6869\n\
6870SYNOPSIS:\n\
6871\n\
6872plcol0(icol0)\n\
6873\n\
6874ARGUMENTS:\n\
6875\n\
6876 icol0 (PLINT, input) : Integer representing the color. The\n\
6877 defaults at present are (these may change):\n\
6878 0 black (default background)\n\
6879 1 red (default foreground)\n\
6880 2 yellow\n\
6881 3 green\n\
6882 4 aquamarine\n\
6883 5 pink\n\
6884 6 wheat\n\
6885 7 grey\n\
6886 8 brown\n\
6887 9 blue\n\
6888 10 BlueViolet\n\
6889 11 cyan\n\
6890 12 turquoise\n\
6891 13 magenta\n\
6892 14 salmon\n\
6893 15 white\n\
6894\n\
6895 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6896 change an individual color in the cmap0 color palette.\n\
6897";
6898static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6899Set color, cmap1\n\
6900\n\
6901DESCRIPTION:\n\
6902\n\
6903 Sets the color for cmap1 (see the PLplot documentation).\n\
6904\n\
6905 Redacted form: plcol1(col1)\n\
6906\n\
6907 This function is used in examples 12 and 21.\n\
6908\n\
6909\n\
6910\n\
6911SYNOPSIS:\n\
6912\n\
6913plcol1(col1)\n\
6914\n\
6915ARGUMENTS:\n\
6916\n\
6917 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6918 is mapped to color using the continuous cmap1 palette which by\n\
6919 default ranges from blue to the background color to red. The\n\
6920 cmap1 palette can also be straightforwardly changed by the user\n\
6921 with plscmap1 or plscmap1l.\n\
6922";
6923static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6924Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6925\n\
6926DESCRIPTION:\n\
6927\n\
6928 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6929\n\
6930 Redacted form: plgcolbg(r, g, b)\n\
6931\n\
6932 This function is used in example 31.\n\
6933\n\
6934\n\
6935\n\
6936SYNOPSIS:\n\
6937\n\
6938plgcolbg(r, g, b)\n\
6939\n\
6940ARGUMENTS:\n\
6941\n\
6942 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6943 in the range from 0 to 255.\n\
6944\n\
6945 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6946 in the range from 0 to 255.\n\
6947\n\
6948 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6949 in the range from 0 to 255.\n\
6950";
6951static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6952Draw a circular or elliptical arc\n\
6953\n\
6954DESCRIPTION:\n\
6955\n\
6956 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6957 semiminor axis b, starting at angle1 and ending at angle2.\n\
6958\n\
6959 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6960 fill)\n\
6961\n\
6962\n\
6963 This function is used in examples 3 and 27.\n\
6964\n\
6965\n\
6966\n\
6967SYNOPSIS:\n\
6968\n\
6969plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6970\n\
6971ARGUMENTS:\n\
6972\n\
6973 x (PLFLT, input) : X coordinate of arc center.\n\
6974\n\
6975 y (PLFLT, input) : Y coordinate of arc center.\n\
6976\n\
6977 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6978\n\
6979 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6980\n\
6981 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6982 semimajor axis.\n\
6983\n\
6984 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6985 semimajor axis.\n\
6986\n\
6987 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6988 X-axis.\n\
6989\n\
6990 fill (PLBOOL, input) : Draw a filled arc.\n\
6991";
6992static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6993Parse command-line arguments\n\
6994\n\
6995DESCRIPTION:\n\
6996\n\
6997 Parse command-line arguments.\n\
6998\n\
6999 plparseopts removes all recognized flags (decreasing argc\n\
7000 accordingly), so that invalid input may be readily detected. It can\n\
7001 also be used to process user command line flags. The user can merge\n\
7002 an option table of type PLOptionTable into the internal option table\n\
7003 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7004 the external table(s) be parsed by calling plClearOpts before\n\
7005 plMergeOpts.\n\
7006\n\
7007 The default action taken by plparseopts is as follows:\n\
7008 Returns with an error if an unrecognized option or badly formed\n\
7009 option-value pair are encountered.\n\
7010 Returns immediately (return code 0) when the first non-option command\n\
7011 line argument is found.\n\
7012 Returns with the return code of the option handler, if one was called.\n\
7013\n\
7014 Deletes command line arguments from argv list as they are found, and\n\
7015 decrements argc accordingly.\n\
7016 Does not show \"invisible\" options in usage or help messages.\n\
7017 Assumes the program name is contained in argv[0].\n\
7018\n\
7019 These behaviors may be controlled through the\n\
7020 mode argument.\n\
7021\n\
7022 Redacted form: General: plparseopts(argv, mode)\n\
7023\n\
7024\n\
7025 This function is used in all of the examples.\n\
7026\n\
7027\n\
7028\n\
7029SYNOPSIS:\n\
7030\n\
7031PLINT plparseopts(p_argc, argv, mode)\n\
7032\n\
7033ARGUMENTS:\n\
7034\n\
7035 p_argc (int *, input/output) : Number of arguments.\n\
7036\n\
7037 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7038 strings containing *p_argc command-line arguments.\n\
7039\n\
7040 mode (PLINT, input) : Parsing mode with the following\n\
7041 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7042 and all error messages enabled, including program exit when an\n\
7043 error occurs. Anything on the command line that isn\'t recognized\n\
7044 as a valid option or option argument is flagged as an error.\n\
7045 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7046 of errors.\n\
7047 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7048 arguments.\n\
7049 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7050 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7051 pointer to the program name.\n\
7052 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7053 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7054 unrecognized arguments.\n\
7055";
7056static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
7057Get parameters that define current device-space window\n\
7058\n\
7059DESCRIPTION:\n\
7060\n\
7061 Get relative margin width, aspect ratio, and relative justification\n\
7062 that define current device-space window. If plsdidev has not been\n\
7063 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7064 p_jy will all be 0.\n\
7065\n\
7066 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7067\n\
7068 This function is used in example 31.\n\
7069\n\
7070\n\
7071\n\
7072SYNOPSIS:\n\
7073\n\
7074plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7075\n\
7076ARGUMENTS:\n\
7077\n\
7078 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7079 margin width.\n\
7080\n\
7081 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7082 ratio.\n\
7083\n\
7084 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7085 justification in x.\n\
7086\n\
7087 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7088 justification in y.\n\
7089";
7090static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7091Assign a function to use for generating custom axis labels\n\
7092\n\
7093DESCRIPTION:\n\
7094\n\
7095 This function allows a user to provide their own function to provide\n\
7096 axis label text. The user function is given the numeric value for a\n\
7097 point on an axis and returns a string label to correspond with that\n\
7098 value. Custom axis labels can be enabled by passing appropriate\n\
7099 arguments to plenv, plbox, plbox3 and similar functions.\n\
7100\n\
7101 This function is used in example 19.\n\
7102\n\
7103\n\
7104\n\
7105SYNOPSIS:\n\
7106\n\
7107plslabelfunc(label_func, label_data)\n\
7108\n\
7109ARGUMENTS:\n\
7110\n\
7111 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7112 label function. In order to reset to the default labelling, set\n\
7113 this to NULL. The labelling function parameters are, in order:\n\
7114 axis: This indicates which axis a label is being requested for.\n\
7115 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7116\n\
7117 value: This is the value along the axis which is being labelled.\n\
7118\n\
7119 label_text: The string representation of the label value.\n\
7120\n\
7121 length: The maximum length in characters allowed for label_text.\n\
7122\n\
7123\n\
7124 label_data (PLPointer, input) : This parameter may be used to pass\n\
7125 data to the label_func function.\n\
7126";
7127static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7128Get the (current) run level\n\
7129\n\
7130DESCRIPTION:\n\
7131\n\
7132 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7133 1, initialized\n\
7134 2, viewport defined\n\
7135 3, world coordinates defined\n\
7136\n\
7137\n\
7138 Redacted form: plglevel(p_level)\n\
7139\n\
7140 This function is used in example 31.\n\
7141\n\
7142\n\
7143\n\
7144SYNOPSIS:\n\
7145\n\
7146plglevel(p_level)\n\
7147\n\
7148ARGUMENTS:\n\
7149\n\
7150 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7151 level.\n\
7152";
7153static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7154Select line style\n\
7155\n\
7156DESCRIPTION:\n\
7157\n\
7158 This sets the line style according to one of eight predefined patterns\n\
7159 (also see plstyl).\n\
7160\n\
7161 Redacted form: pllsty(lin)\n\
7162\n\
7163 This function is used in examples 9, 12, 22, and 25.\n\
7164\n\
7165\n\
7166\n\
7167SYNOPSIS:\n\
7168\n\
7169pllsty(lin)\n\
7170\n\
7171ARGUMENTS:\n\
7172\n\
7173 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7174 a continuous line, line style 2 is a line with short dashes and\n\
7175 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7176 4 has long dashes and short gaps and so on.\n\
7177";
7178static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7179Set up standard window and draw box\n\
7180\n\
7181DESCRIPTION:\n\
7182\n\
7183 Sets up plotter environment for simple graphs by calling pladv and\n\
7184 setting up viewport and window to sensible default values. plenv\n\
7185 leaves a standard margin (left-hand margin of eight character heights,\n\
7186 and a margin around the other three sides of five character heights)\n\
7187 around most graphs for axis labels and a title. When these defaults\n\
7188 are not suitable, use the individual routines plvpas, plvpor, or\n\
7189 plvasp for setting up the viewport, plwind for defining the window,\n\
7190 and plbox for drawing the box.\n\
7191\n\
7192 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7193\n\
7194 This function is used in example 1,3,9,13,14,19-22,29.\n\
7195\n\
7196\n\
7197\n\
7198SYNOPSIS:\n\
7199\n\
7200plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7201\n\
7202ARGUMENTS:\n\
7203\n\
7204 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7205 world coordinates).\n\
7206\n\
7207 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7208 world coordinates).\n\
7209\n\
7210 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7211 coordinates).\n\
7212\n\
7213 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7214 coordinates).\n\
7215\n\
7216 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7217 scales will not be set, the user must set up the scale before\n\
7218 calling plenv using plsvpa, plvasp or other.\n\
7219 0: the x and y axes are scaled independently to use as much of\n\
7220 the screen as possible.\n\
7221 1: the scales of the x and y axes are made equal.\n\
7222 2: the axis of the x and y axes are made equal, and the plot\n\
7223 box will be square.\n\
7224\n\
7225\n\
7226 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7227 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7228 -1: draw box only.\n\
7229 0: draw box, ticks, and numeric tick labels.\n\
7230 1: also draw coordinate axes at x=0 and y=0.\n\
7231 2: also draw a grid at major tick positions in both\n\
7232 coordinates.\n\
7233 3: also draw a grid at minor tick positions in both\n\
7234 coordinates.\n\
7235 10: same as 0 except logarithmic x tick marks. (The x data\n\
7236 have to be converted to logarithms separately.)\n\
7237 11: same as 1 except logarithmic x tick marks. (The x data\n\
7238 have to be converted to logarithms separately.)\n\
7239 12: same as 2 except logarithmic x tick marks. (The x data\n\
7240 have to be converted to logarithms separately.)\n\
7241 13: same as 3 except logarithmic x tick marks. (The x data\n\
7242 have to be converted to logarithms separately.)\n\
7243 20: same as 0 except logarithmic y tick marks. (The y data\n\
7244 have to be converted to logarithms separately.)\n\
7245 21: same as 1 except logarithmic y tick marks. (The y data\n\
7246 have to be converted to logarithms separately.)\n\
7247 22: same as 2 except logarithmic y tick marks. (The y data\n\
7248 have to be converted to logarithms separately.)\n\
7249 23: same as 3 except logarithmic y tick marks. (The y data\n\
7250 have to be converted to logarithms separately.)\n\
7251 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7252 and y data have to be converted to logarithms separately.)\n\
7253 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7254 and y data have to be converted to logarithms separately.)\n\
7255 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7256 and y data have to be converted to logarithms separately.)\n\
7257 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7258 and y data have to be converted to logarithms separately.)\n\
7259 40: same as 0 except date / time x labels.\n\
7260 41: same as 1 except date / time x labels.\n\
7261 42: same as 2 except date / time x labels.\n\
7262 43: same as 3 except date / time x labels.\n\
7263 50: same as 0 except date / time y labels.\n\
7264 51: same as 1 except date / time y labels.\n\
7265 52: same as 2 except date / time y labels.\n\
7266 53: same as 3 except date / time y labels.\n\
7267 60: same as 0 except date / time x and y labels.\n\
7268 61: same as 1 except date / time x and y labels.\n\
7269 62: same as 2 except date / time x and y labels.\n\
7270 63: same as 3 except date / time x and y labels.\n\
7271 70: same as 0 except custom x and y labels.\n\
7272 71: same as 1 except custom x and y labels.\n\
7273 72: same as 2 except custom x and y labels.\n\
7274 73: same as 3 except custom x and y labels.\n\
7275";
7276static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7277Initialization\n\
7278\n\
7279DESCRIPTION:\n\
7280\n\
7281 Alternative to plstar for initializing the plotting package. The\n\
7282 device name keyword for the desired output device must be supplied as\n\
7283 an argument. These keywords are the same as those printed out by\n\
7284 plstar. If the requested device is not available, or if the input\n\
7285 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7286 is used. This routine also divides the output device page into nx by\n\
7287 ny subpages, each of which may be used independently. The subroutine\n\
7288 pladv is used to advance from one subpage to the next.\n\
7289\n\
7290 Redacted form: General: plstart(devname, nx, ny)\n\
7291\n\
7292\n\
7293 This function is not used in any examples.\n\
7294\n\
7295\n\
7296\n\
7297SYNOPSIS:\n\
7298\n\
7299plstart(devname, nx, ny)\n\
7300\n\
7301ARGUMENTS:\n\
7302\n\
7303 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7304 containing the device name keyword of the required output device.\n\
7305 If\n\
7306 devname is NULL or if the first character of the string is a ``?\'\',\n\
7307 the normal (prompted) start up is used.\n\
7308\n\
7309 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7310 x direction.\n\
7311\n\
7312 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7313 y direction.\n\
7314";
7315static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7316Plot a glyph at the specified points\n\
7317\n\
7318DESCRIPTION:\n\
7319\n\
7320 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7321 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7322 is specified with a PLplot user string. Note that the user string is\n\
7323 not actually limited to one glyph so it is possible (but not normally\n\
7324 useful) to plot more than one glyph at the specified points with this\n\
7325 function. As with plmtex and plptex, the user string can contain FCI\n\
7326 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7327 else PLplot escapes for Hershey or unicode text to determine the\n\
7328 glyph.\n\
7329\n\
7330 Redacted form: plstring(x, y, string)\n\
7331\n\
7332 This function is used in examples 4, 21 and 26.\n\
7333\n\
7334\n\
7335\n\
7336SYNOPSIS:\n\
7337\n\
7338plstring(n, x, y, string)\n\
7339\n\
7340ARGUMENTS:\n\
7341\n\
7342 n (PLINT, input) : Number of points in the x and y vectors.\n\
7343\n\
7344 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7345 the points.\n\
7346\n\
7347 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7348 the points.\n\
7349\n\
7350 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7351 the glyph(s) to be plotted at each of the n points.\n\
7352";
7353static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7354Write text relative to viewport boundaries in 3D plots\n\
7355\n\
7356DESCRIPTION:\n\
7357\n\
7358 Writes text at a specified position relative to the viewport\n\
7359 boundaries. Text may be written inside or outside the viewport, but\n\
7360 is clipped at the subpage boundaries. The reference point of a string\n\
7361 lies along a line passing through the string at half the height of a\n\
7362 capital letter. The position of the reference point along this line\n\
7363 is determined by just, and the position of the reference point\n\
7364 relative to the viewport is set by disp and pos.\n\
7365\n\
7366 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7367\n\
7368 This function is used in example 28.\n\
7369\n\
7370\n\
7371\n\
7372SYNOPSIS:\n\
7373\n\
7374plmtex3(side, disp, pos, just, text)\n\
7375\n\
7376ARGUMENTS:\n\
7377\n\
7378 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7379 the side of the viewport along which the text is to be written.\n\
7380 The string should contain one or more of the following characters:\n\
7381 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7382 only label the X axis, not both the X and Y axes. x: Label the X\n\
7383 axis.\n\
7384 y: Label the Y axis.\n\
7385 z: Label the Z axis.\n\
7386 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7387 For X it is the axis that starts at y-min. For Y it is the\n\
7388 axis that starts at x-min.\n\
7389 s: Label the secondary axis.\n\
7390 v: Draw the text perpendicular to the axis.\n\
7391\n\
7392\n\
7393 disp (PLFLT, input) : Position of the reference point of string,\n\
7394 measured outwards from the specified viewport edge in units of the\n\
7395 current character height. Use negative disp to write within the\n\
7396 viewport.\n\
7397\n\
7398 pos (PLFLT, input) : Position of the reference point of string\n\
7399 along the specified edge, expressed as a fraction of the length of\n\
7400 the edge.\n\
7401\n\
7402 just (PLFLT, input) : Specifies the position of the string relative\n\
7403 to its reference point. If just=0. , the reference point is at\n\
7404 the left and if just=1. , it is at the right of the string. Other\n\
7405 values of just give intermediate justifications.\n\
7406\n\
7407 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7408 written out.\n\
7409";
7410static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7411Get plot orientation\n\
7412\n\
7413DESCRIPTION:\n\
7414\n\
7415 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7416 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7417 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7418 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7419 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7420 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7421 not been called the default value pointed to by p_rot will be 0.\n\
7422\n\
7423 Redacted form: plgdiori(p_rot)\n\
7424\n\
7425 This function is not used in any examples.\n\
7426\n\
7427\n\
7428\n\
7429SYNOPSIS:\n\
7430\n\
7431plgdiori(p_rot)\n\
7432\n\
7433ARGUMENTS:\n\
7434\n\
7435 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7436 parameter.\n\
7437";
7438static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7439Simple routine to write labels\n\
7440\n\
7441DESCRIPTION:\n\
7442\n\
7443 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7444\n\
7445 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7446\n\
7447 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7448\n\
7449\n\
7450\n\
7451SYNOPSIS:\n\
7452\n\
7453pllab(xlabel, ylabel, tlabel)\n\
7454\n\
7455ARGUMENTS:\n\
7456\n\
7457 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7458 the label for the x axis.\n\
7459\n\
7460 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7461 the label for the y axis.\n\
7462\n\
7463 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7464 the title of the plot.\n\
7465";
7466static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7467Switch to text screen\n\
7468\n\
7469DESCRIPTION:\n\
7470\n\
7471 Sets an interactive device to text mode, used in conjunction with\n\
7472 plgra to allow graphics and text to be interspersed. On a device\n\
7473 which supports separate text and graphics windows, this command causes\n\
7474 control to be switched to the text window. This can be useful for\n\
7475 printing diagnostic messages or getting user input, which would\n\
7476 otherwise interfere with the plots. The program must switch back to\n\
7477 the graphics window before issuing plot commands, as the text (or\n\
7478 console) device will probably become quite confused otherwise. If\n\
7479 already in text mode, this command is ignored. It is also ignored on\n\
7480 devices which only support a single window or use a different method\n\
7481 for shifting focus (see also plgra).\n\
7482\n\
7483 Redacted form: pltext()\n\
7484\n\
7485 This function is used in example 1.\n\
7486\n\
7487\n\
7488\n\
7489SYNOPSIS:\n\
7490\n\
7491pltext()\n\
7492";
7493static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7494Plot all or a subset of Shapefile data using lines in world coordinates\n\
7495\n\
7496DESCRIPTION:\n\
7497\n\
7498 Plot all or a subset of Shapefile data using lines in world\n\
7499 coordinates. Our 19th standard example demonstrates how to use this\n\
7500 function. This function plots data from a Shapefile using lines as in\n\
7501 plmap, however it also has the option of also only drawing specified\n\
7502 elements from the Shapefile. The vector of indices of the required\n\
7503 elements are passed as a function argument. The Shapefile data should\n\
7504 include a metadata file (extension.dbf) listing all items within the\n\
7505 Shapefile. This file can be opened by most popular spreadsheet\n\
7506 programs and can be used to decide which indices to pass to this\n\
7507 function.\n\
7508\n\
7509 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7510 plotentries)\n\
7511\n\
7512 This function is used in example 19.\n\
7513\n\
7514\n\
7515\n\
7516SYNOPSIS:\n\
7517\n\
7518plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7519\n\
7520ARGUMENTS:\n\
7521\n\
7522 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7523 transform the coordinates given in the shapefile into a plot\n\
7524 coordinate system. By using this transform, we can change from a\n\
7525 longitude, latitude coordinate to a polar stereographic project,\n\
7526 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7527 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7528 mapform(), x[] and y[] should be replaced by the corresponding\n\
7529 plot coordinates. If no transform is desired, mapform can be\n\
7530 replaced by NULL.\n\
7531\n\
7532 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7533 the file name of a set of Shapefile files without the file\n\
7534 extension.\n\
7535\n\
7536 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7537 be in the same units as used by the Shapefile. You could use a\n\
7538 very large negative number to plot everything, but you can improve\n\
7539 performance by limiting the area drawn. The units must match those\n\
7540 of the Shapefile projection, which may be for example longitude or\n\
7541 distance. The value of minx must be less than the value of maxx.\n\
7542\n\
7543 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7544 use a very large number to plot everything, but you can improve\n\
7545 performance by limiting the area drawn.\n\
7546\n\
7547 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7548 be in the same units as used by the Shapefile. You could use a\n\
7549 very large negative number to plot everything, but you can improve\n\
7550 performance by limiting the area drawn. The units must match those\n\
7551 of the Shapefile projection, which may be for example latitude or\n\
7552 distance. The value of miny must be less than the value of maxy.\n\
7553\n\
7554 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7555 use a very large number to plot everything, but you can improve\n\
7556 performance by limiting the area drawn.\n\
7557\n\
7558 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7559 zero-based indices of the Shapefile elements which will be drawn.\n\
7560 Setting\n\
7561 plotentries to NULL will plot all elements of the Shapefile.\n\
7562\n\
7563 nplotentries (PLINT, input) : The number of items in\n\
7564 plotentries. Ignored if\n\
7565 plotentries is NULL.\n\
7566";
7567static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7568Set precision in numeric labels\n\
7569\n\
7570DESCRIPTION:\n\
7571\n\
7572 Sets the number of places after the decimal point in numeric labels.\n\
7573\n\
7574 Redacted form: plprec(setp, prec)\n\
7575\n\
7576 This function is used in example 29.\n\
7577\n\
7578\n\
7579\n\
7580SYNOPSIS:\n\
7581\n\
7582plprec(setp, prec)\n\
7583\n\
7584ARGUMENTS:\n\
7585\n\
7586 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7587 automatically determines the number of places to use after the\n\
7588 decimal point in numeric labels (like those used to label axes).\n\
7589 If setp is 1 then prec sets the number of places.\n\
7590\n\
7591 prec (PLINT, input) : The number of characters to draw after the\n\
7592 decimal point in numeric labels.\n\
7593";
7594static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7595Draw a line between two points\n\
7596\n\
7597DESCRIPTION:\n\
7598\n\
7599 Joins the point (\n\
7600 x1,\n\
7601 y1) to (\n\
7602 x2,\n\
7603 y2).\n\
7604\n\
7605 Redacted form: pljoin(x1,y1,x2,y2)\n\
7606\n\
7607 This function is used in examples 3 and 14.\n\
7608\n\
7609\n\
7610\n\
7611SYNOPSIS:\n\
7612\n\
7613pljoin(x1, y1, x2, y2)\n\
7614\n\
7615ARGUMENTS:\n\
7616\n\
7617 x1 (PLFLT, input) : x coordinate of first point.\n\
7618\n\
7619 y1 (PLFLT, input) : y coordinate of first point.\n\
7620\n\
7621 x2 (PLFLT, input) : x coordinate of second point.\n\
7622\n\
7623 y2 (PLFLT, input) : y coordinate of second point.\n\
7624";
7625static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7626Set the device (keyword) name\n\
7627\n\
7628DESCRIPTION:\n\
7629\n\
7630 Set the device (keyword) name.\n\
7631\n\
7632 Redacted form: plsdev(devname)\n\
7633\n\
7634 This function is used in examples 1, 14, and 20.\n\
7635\n\
7636\n\
7637\n\
7638SYNOPSIS:\n\
7639\n\
7640plsdev(devname)\n\
7641\n\
7642ARGUMENTS:\n\
7643\n\
7644 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7645 containing the device name keyword of the required output device.\n\
7646 If\n\
7647 devname is NULL or if the first character of the string is a ``?\'\',\n\
7648 the normal (prompted) start up is used.\n\
7649";
7650static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7651Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7652\n\
7653DESCRIPTION:\n\
7654\n\
7655 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7656 (see the PLplot documentation) index. Overwrites the previous color\n\
7657 value for the given index and, thus, does not result in any additional\n\
7658 allocation of space for colors.\n\
7659\n\
7660 This function is used in example 30.\n\
7661\n\
7662\n\
7663\n\
7664SYNOPSIS:\n\
7665\n\
7666plscol0a(icol0, r, g, b, alpha)\n\
7667\n\
7668ARGUMENTS:\n\
7669\n\
7670 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7671 number of colors (which is set by default, by plscmap0n, or even\n\
7672 by plscmap0).\n\
7673\n\
7674 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7675 degree of red in the color.\n\
7676\n\
7677 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7678 degree of green in the color.\n\
7679\n\
7680 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7681 degree of blue in the color.\n\
7682\n\
7683 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7684 (0.0-1.0).\n\
7685";
7686static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7687Draw filled polygon in 3D\n\
7688\n\
7689DESCRIPTION:\n\
7690\n\
7691 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7692 vectors using the pattern defined by plpsty or plpat. The routine\n\
7693 will automatically close the polygon between the last and first\n\
7694 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7695 plfill3 will fill in between them.\n\
7696\n\
7697 Redacted form: General: plfill3(x, y, z)\n\
7698\n\
7699\n\
7700 This function is used in example 15.\n\
7701\n\
7702\n\
7703\n\
7704SYNOPSIS:\n\
7705\n\
7706plfill3(n, x, y, z)\n\
7707\n\
7708ARGUMENTS:\n\
7709\n\
7710 n (PLINT, input) : Number of vertices in polygon.\n\
7711\n\
7712 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7713 vertices.\n\
7714\n\
7715 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7716 vertices.\n\
7717\n\
7718 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7719 vertices.\n\
7720";
7721static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7722Specify window\n\
7723\n\
7724DESCRIPTION:\n\
7725\n\
7726 Specify the window, i.e., the world coordinates of the edges of the\n\
7727 viewport.\n\
7728\n\
7729 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7730\n\
7731 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7732 29, and 31.\n\
7733\n\
7734\n\
7735\n\
7736SYNOPSIS:\n\
7737\n\
7738plwind(xmin, xmax, ymin, ymax)\n\
7739\n\
7740ARGUMENTS:\n\
7741\n\
7742 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7743 of the viewport.\n\
7744\n\
7745 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7746 of the viewport.\n\
7747\n\
7748 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7749 the viewport.\n\
7750\n\
7751 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7752 viewport.\n\
7753";
7754static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7755Draw text at points defined by Shapefile data in world coordinates\n\
7756\n\
7757DESCRIPTION:\n\
7758\n\
7759 As per plmapline, however the items are plotted as text in the same\n\
7760 way as plptex.\n\
7761\n\
7762 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7763 miny, maxy, plotentry)\n\
7764\n\
7765 This function is used in example 19.\n\
7766\n\
7767\n\
7768\n\
7769SYNOPSIS:\n\
7770\n\
7771plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7772\n\
7773ARGUMENTS:\n\
7774\n\
7775 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7776 transform the coordinates given in the shapefile into a plot\n\
7777 coordinate system. By using this transform, we can change from a\n\
7778 longitude, latitude coordinate to a polar stereographic project,\n\
7779 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7780 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7781 mapform(), x[] and y[] should be replaced by the corresponding\n\
7782 plot coordinates. If no transform is desired, mapform can be\n\
7783 replaced by NULL.\n\
7784\n\
7785 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7786 the file name of a set of Shapefile files without the file\n\
7787 extension.\n\
7788\n\
7789 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7790 dy/dx.\n\
7791\n\
7792 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7793 dy/dx.\n\
7794\n\
7795 just (PLFLT, input) : Set the justification of the text. The value\n\
7796 given will be the fraction of the distance along the string that\n\
7797 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7798 centralized text and 1.0 gives right aligned text.\n\
7799\n\
7800 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7801\n\
7802 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7803 be in the same units as used by the Shapefile. You could use a\n\
7804 very large negative number to plot everything, but you can improve\n\
7805 performance by limiting the area drawn. The units must match those\n\
7806 of the Shapefile projection, which may be for example longitude or\n\
7807 distance. The value of minx must be less than the value of maxx.\n\
7808\n\
7809 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7810 use a very large number to plot everything, but you can improve\n\
7811 performance by limiting the area drawn.\n\
7812\n\
7813 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7814 be in the same units as used by the Shapefile. You could use a\n\
7815 very large negative number to plot everything, but you can improve\n\
7816 performance by limiting the area drawn. The units must match those\n\
7817 of the Shapefile projection, which may be for example latitude or\n\
7818 distance. The value of miny must be less than the value of maxy.\n\
7819\n\
7820 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7821 use a very large number to plot everything, but you can improve\n\
7822 performance by limiting the area drawn.\n\
7823\n\
7824 plotentry (PLINT, input) : An integer indicating which text string\n\
7825 of the Shapefile (zero indexed) will be drawn.\n\
7826";
7827static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7828Switch to graphics screen\n\
7829\n\
7830DESCRIPTION:\n\
7831\n\
7832 Sets an interactive device to graphics mode, used in conjunction with\n\
7833 pltext to allow graphics and text to be interspersed. On a device\n\
7834 which supports separate text and graphics windows, this command causes\n\
7835 control to be switched to the graphics window. If already in graphics\n\
7836 mode, this command is ignored. It is also ignored on devices which\n\
7837 only support a single window or use a different method for shifting\n\
7838 focus. See also pltext.\n\
7839\n\
7840 Redacted form: plgra()\n\
7841\n\
7842 This function is used in example 1.\n\
7843\n\
7844\n\
7845\n\
7846SYNOPSIS:\n\
7847\n\
7848plgra()\n\
7849";
7850static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7851Set parameters of contour labelling other than format of numerical label\n\
7852\n\
7853DESCRIPTION:\n\
7854\n\
7855 Set parameters of contour labelling other than those handled by\n\
7856 pl_setcontlabelformat.\n\
7857\n\
7858 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7859\n\
7860 This function is used in example 9.\n\
7861\n\
7862\n\
7863\n\
7864SYNOPSIS:\n\
7865\n\
7866pl_setcontlabelparam(offset, size, spacing, active)\n\
7867\n\
7868ARGUMENTS:\n\
7869\n\
7870 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7871 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7872\n\
7873 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7874 Default value is 0.3.\n\
7875\n\
7876 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7877 Default value is 0.1.\n\
7878\n\
7879 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7880 contour labels on. Default is off (0).\n\
7881";
7882static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7883Get family, style and weight of the current font\n\
7884\n\
7885DESCRIPTION:\n\
7886\n\
7887 Gets information about current font. See the PLplot documentation for\n\
7888 more information on font selection.\n\
7889\n\
7890 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7891\n\
7892 This function is used in example 23.\n\
7893\n\
7894\n\
7895\n\
7896SYNOPSIS:\n\
7897\n\
7898plgfont(p_family, p_style, p_weight)\n\
7899\n\
7900ARGUMENTS:\n\
7901\n\
7902 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7903 font family. The available values are given by the PL_FCI_*\n\
7904 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7905 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7906 p_family is NULL then the font family is not returned.\n\
7907\n\
7908 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7909 font style. The available values are given by the PL_FCI_*\n\
7910 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7911 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7912 style is not returned.\n\
7913\n\
7914 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7915 font weight. The available values are given by the PL_FCI_*\n\
7916 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7917 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7918 returned.\n\
7919";
7920static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7921Plot a histogram from unbinned data\n\
7922\n\
7923DESCRIPTION:\n\
7924\n\
7925 Plots a histogram from n data points stored in the data vector. This\n\
7926 routine bins the data into nbin bins equally spaced between datmin and\n\
7927 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7928 opt allows, among other things, the histogram either to be plotted in\n\
7929 an existing window or causes plhist to call plenv with suitable limits\n\
7930 before plotting the histogram.\n\
7931\n\
7932 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7933\n\
7934 This function is used in example 5.\n\
7935\n\
7936\n\
7937\n\
7938SYNOPSIS:\n\
7939\n\
7940plhist(n, data, datmin, datmax, nbin, opt)\n\
7941\n\
7942ARGUMENTS:\n\
7943\n\
7944 n (PLINT, input) : Number of data points.\n\
7945\n\
7946 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7947 n data points.\n\
7948\n\
7949 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7950\n\
7951 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7952\n\
7953 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7954 divide the interval xmin to xmax.\n\
7955\n\
7956 opt (PLINT, input) : Is a combination of several flags:\n\
7957 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7958 the histogram data, the outer bins are expanded to fill up the\n\
7959 entire x-axis, data outside the given extremes are assigned to the\n\
7960 outer bins and bins of zero height are simply drawn.\n\
7961 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7962 to fit the histogram data, without this flag, plenv is called\n\
7963 to set the world coordinates.\n\
7964 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7965 extremes are not taken into account. This option should\n\
7966 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7967 properly present the data.\n\
7968 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7969 size as the ones inside.\n\
7970 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7971 (there is a gap for such bins).\n\
7972";
7973static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7974Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7975\n\
7976DESCRIPTION:\n\
7977\n\
7978 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7979 alpha transparency value.\n\
7980\n\
7981 This function is used in example 31.\n\
7982\n\
7983\n\
7984\n\
7985SYNOPSIS:\n\
7986\n\
7987plgcolbga(r, g, b, alpha)\n\
7988\n\
7989ARGUMENTS:\n\
7990\n\
7991 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7992 in the range from 0 to 255.\n\
7993\n\
7994 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7995 in the range from 0 to 255.\n\
7996\n\
7997 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7998 in the range from 0 to 255.\n\
7999\n\
8000 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8001 transparency in the range (0.0-1.0).\n\
8002";
8003static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
8004Set orientation\n\
8005\n\
8006DESCRIPTION:\n\
8007\n\
8008 Set integer plot orientation parameter. This function is identical to\n\
8009 plsdiori except for the type of the argument, and should be used in\n\
8010 the same way. See the documentation of plsdiori for details.\n\
8011\n\
8012 Redacted form: plsori(ori)\n\
8013\n\
8014 This function is used in example 3.\n\
8015\n\
8016\n\
8017\n\
8018SYNOPSIS:\n\
8019\n\
8020plsori(ori)\n\
8021\n\
8022ARGUMENTS:\n\
8023\n\
8024 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8025 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8026 angle.\n\
8027";
8028static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
8029Plot latitude and longitude lines\n\
8030\n\
8031DESCRIPTION:\n\
8032\n\
8033 Displays latitude and longitude on the current plot. The lines are\n\
8034 plotted in the current color and line style.\n\
8035\n\
8036 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8037 minlat, maxlat)\n\
8038\n\
8039 This function is used in example 19.\n\
8040\n\
8041\n\
8042\n\
8043SYNOPSIS:\n\
8044\n\
8045plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8046\n\
8047ARGUMENTS:\n\
8048\n\
8049 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8050 transform the coordinate longitudes and latitudes to a plot\n\
8051 coordinate system. By using this transform, we can change from a\n\
8052 longitude, latitude coordinate to a polar stereographic project,\n\
8053 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8054 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8055 mapform(), x[] and y[] should be replaced by the corresponding\n\
8056 plot coordinates. If no transform is desired, mapform can be\n\
8057 replaced by NULL.\n\
8058\n\
8059 dlong (PLFLT, input) : The interval in degrees at which the\n\
8060 longitude lines are to be plotted.\n\
8061\n\
8062 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8063 lines are to be plotted.\n\
8064\n\
8065 minlong (PLFLT, input) : The value of the longitude on the left\n\
8066 side of the plot. The value of minlong must be less than the value\n\
8067 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8068 equal to 360.\n\
8069\n\
8070 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8071 side of the plot.\n\
8072\n\
8073 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8074 background. One can always use -90.0 as the boundary outside the\n\
8075 plot window will be automatically eliminated. However, the\n\
8076 program will be faster if one can reduce the size of the\n\
8077 background plotted.\n\
8078\n\
8079 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8080 background. One can always use 90.0 as the boundary outside the\n\
8081 plot window will be automatically eliminated.\n\
8082";
8083static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8084Clear current (sub)page\n\
8085\n\
8086DESCRIPTION:\n\
8087\n\
8088 Clears the current page, effectively erasing everything that have been\n\
8089 drawn. This command only works with interactive drivers; if the\n\
8090 driver does not support this, the page is filled with the background\n\
8091 color in use. If the current page is divided into subpages, only the\n\
8092 current subpage is erased. The nth subpage can be selected with\n\
8093 pladv(n).\n\
8094\n\
8095 Redacted form: General: plclear()\n\
8096\n\
8097\n\
8098 This function is not used in any examples.\n\
8099\n\
8100\n\
8101\n\
8102SYNOPSIS:\n\
8103\n\
8104plclear()\n\
8105";
8106static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8107Initialization\n\
8108\n\
8109DESCRIPTION:\n\
8110\n\
8111 Initializing the plotting package. The program prompts for the device\n\
8112 keyword or number of the desired output device. Hitting a RETURN in\n\
8113 response to the prompt is the same as selecting the first device. If\n\
8114 only one device is enabled when PLplot is installed, plstar will issue\n\
8115 no prompt. The output device is divided into nx by ny subpages, each\n\
8116 of which may be used independently. The subroutine pladv is used to\n\
8117 advance from one subpage to the next.\n\
8118\n\
8119 Redacted form: plstar(nx, ny)\n\
8120\n\
8121 This function is used in example 1.\n\
8122\n\
8123\n\
8124\n\
8125SYNOPSIS:\n\
8126\n\
8127plstar(nx, ny)\n\
8128\n\
8129ARGUMENTS:\n\
8130\n\
8131 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8132 x direction.\n\
8133\n\
8134 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8135 y direction.\n\
8136";
8137static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8138Write text relative to viewport boundaries\n\
8139\n\
8140DESCRIPTION:\n\
8141\n\
8142 Writes text at a specified position relative to the viewport\n\
8143 boundaries. Text may be written inside or outside the viewport, but\n\
8144 is clipped at the subpage boundaries. The reference point of a string\n\
8145 lies along a line passing through the string at half the height of a\n\
8146 capital letter. The position of the reference point along this line\n\
8147 is determined by just, and the position of the reference point\n\
8148 relative to the viewport is set by disp and pos.\n\
8149\n\
8150 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8151\n\
8152\n\
8153 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8154 26.\n\
8155\n\
8156\n\
8157\n\
8158SYNOPSIS:\n\
8159\n\
8160plmtex(side, disp, pos, just, text)\n\
8161\n\
8162ARGUMENTS:\n\
8163\n\
8164 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8165 the side of the viewport along which the text is to be written.\n\
8166 The string must be one of: b: Bottom of viewport, text written\n\
8167 parallel to edge.\n\
8168 bv: Bottom of viewport, text written at right angles to edge.\n\
8169 l: Left of viewport, text written parallel to edge.\n\
8170 lv: Left of viewport, text written at right angles to edge.\n\
8171 r: Right of viewport, text written parallel to edge.\n\
8172 rv: Right of viewport, text written at right angles to edge.\n\
8173 t: Top of viewport, text written parallel to edge.\n\
8174 tv: Top of viewport, text written at right angles to edge.\n\
8175\n\
8176\n\
8177 disp (PLFLT, input) : Position of the reference point of string,\n\
8178 measured outwards from the specified viewport edge in units of the\n\
8179 current character height. Use negative disp to write within the\n\
8180 viewport.\n\
8181\n\
8182 pos (PLFLT, input) : Position of the reference point of string\n\
8183 along the specified edge, expressed as a fraction of the length of\n\
8184 the edge.\n\
8185\n\
8186 just (PLFLT, input) : Specifies the position of the string relative\n\
8187 to its reference point. If just=0. , the reference point is at\n\
8188 the left and if just=1. , it is at the right of the string. Other\n\
8189 values of just give intermediate justifications.\n\
8190\n\
8191 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8192 written out.\n\
8193";
8194static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8195Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8196\n\
8197DESCRIPTION:\n\
8198\n\
8199 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8200 PLFLT alpha transparency value (see the PLplot documentation).\n\
8201\n\
8202 This function is used in example 31.\n\
8203\n\
8204\n\
8205\n\
8206SYNOPSIS:\n\
8207\n\
8208plscolbga(r, g, b, alpha)\n\
8209\n\
8210ARGUMENTS:\n\
8211\n\
8212 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8213 degree of red in the color.\n\
8214\n\
8215 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8216 degree of green in the color.\n\
8217\n\
8218 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8219 degree of blue in the color.\n\
8220\n\
8221 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8222 (0.0-1.0).\n\
8223";
8224static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8225Replays contents of plot buffer to current device/file\n\
8226\n\
8227DESCRIPTION:\n\
8228\n\
8229 Replays contents of plot buffer to current device/file.\n\
8230\n\
8231 Redacted form: plreplot()\n\
8232\n\
8233 This function is used in example 1,20.\n\
8234\n\
8235\n\
8236\n\
8237SYNOPSIS:\n\
8238\n\
8239plreplot()\n\
8240";
8241static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8242Plot a glyph at the specified 3D points\n\
8243\n\
8244DESCRIPTION:\n\
8245\n\
8246 Plot a glyph at the specified 3D points. (This function is largely\n\
8247 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8248 Set up the call to this function similar to what is done for plline3.\n\
8249 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8250 and a draw at the same place. Not ideal, since a sufficiently\n\
8251 intelligent output device may optimize it away, or there may be faster\n\
8252 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8253 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8254 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8255 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8256 code <= 127 the corresponding printable ASCII character is plotted.\n\
8257\n\
8258 Redacted form: plpoin3(x, y, z, code)\n\
8259\n\
8260 This function is not used in any example.\n\
8261\n\
8262\n\
8263\n\
8264SYNOPSIS:\n\
8265\n\
8266plpoin3(n, x, y, z, code)\n\
8267\n\
8268ARGUMENTS:\n\
8269\n\
8270 n (PLINT, input) : Number of points in the x and y vectors.\n\
8271\n\
8272 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8273 points.\n\
8274\n\
8275 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8276 points.\n\
8277\n\
8278 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8279 points.\n\
8280\n\
8281 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8282 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8283 each of the n points.\n\
8284";
8285static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8286Set family, style and weight of the current font\n\
8287\n\
8288DESCRIPTION:\n\
8289\n\
8290 Sets the current font. See the PLplot documentation for more\n\
8291 information on font selection.\n\
8292\n\
8293 Redacted form: plsfont(family, style, weight)\n\
8294\n\
8295 This function is used in example 23.\n\
8296\n\
8297\n\
8298\n\
8299SYNOPSIS:\n\
8300\n\
8301plsfont(family, style, weight)\n\
8302\n\
8303ARGUMENTS:\n\
8304\n\
8305 family (PLINT, input) : Font family to select for the current font.\n\
8306 The available values are given by the PL_FCI_* constants in\n\
8307 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8308 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8309 signifies that the font family should not be altered.\n\
8310\n\
8311 style (PLINT, input) : Font style to select for the current font.\n\
8312 The available values are given by the PL_FCI_* constants in\n\
8313 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8314 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8315 should not be altered.\n\
8316\n\
8317 weight (PLINT, input) : Font weight to select for the current font.\n\
8318 The available values are given by the PL_FCI_* constants in\n\
8319 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8320 negative value signifies that the font weight should not be\n\
8321 altered.\n\
8322";
8323static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8324Draw a box with axes, etc. with arbitrary origin\n\
8325\n\
8326DESCRIPTION:\n\
8327\n\
8328 Draws a box around the currently defined viewport with arbitrary\n\
8329 world-coordinate origin specified by x0 and y0 and labels it with\n\
8330 world coordinate values appropriate to the window. Thus plaxes should\n\
8331 only be called after defining both viewport and window. The ascii\n\
8332 character strings xopt and yopt specify how the box should be drawn as\n\
8333 described below. If ticks and/or subticks are to be drawn for a\n\
8334 particular axis, the tick intervals and number of subintervals may be\n\
8335 specified explicitly, or they may be defaulted by setting the\n\
8336 appropriate arguments to zero.\n\
8337\n\
8338 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8339 ytick, nysub)\n\
8340\n\
8341\n\
8342 This function is not used in any examples.\n\
8343\n\
8344\n\
8345\n\
8346SYNOPSIS:\n\
8347\n\
8348plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8349\n\
8350ARGUMENTS:\n\
8351\n\
8352 x0 (PLFLT, input) : World X coordinate of origin.\n\
8353\n\
8354 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8355\n\
8356 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8357 options for the x axis. The string can include any combination of\n\
8358 the following letters (upper or lower case) in any order: a: Draws\n\
8359 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8360 (x=0).\n\
8361 b: Draws bottom (X) or left (Y) edge of frame.\n\
8362 c: Draws top (X) or right (Y) edge of frame.\n\
8363 d: Plot labels as date / time. Values are assumed to be\n\
8364 seconds since the epoch (as used by gmtime).\n\
8365 f: Always use fixed point numeric labels.\n\
8366 g: Draws a grid at the major tick interval.\n\
8367 h: Draws a grid at the minor tick interval.\n\
8368 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8369 inwards.\n\
8370 l: Labels axis logarithmically. This only affects the labels,\n\
8371 not the data, and so it is necessary to compute the logarithms\n\
8372 of data points before passing them to any of the drawing\n\
8373 routines.\n\
8374 m: Writes numeric labels at major tick intervals in the\n\
8375 unconventional location (above box for X, right of box for Y).\n\
8376 n: Writes numeric labels at major tick intervals in the\n\
8377 conventional location (below box for X, left of box for Y).\n\
8378 o: Use custom labelling function to generate axis label text.\n\
8379 The custom labelling function can be defined with the\n\
8380 plslabelfunc command.\n\
8381 s: Enables subticks between major ticks, only valid if t is\n\
8382 also specified.\n\
8383 t: Draws major ticks.\n\
8384 u: Exactly like \"b\" except don\'t draw edge line.\n\
8385 w: Exactly like \"c\" except don\'t draw edge line.\n\
8386 x: Exactly like \"t\" (including the side effect of the\n\
8387 numerical labels for the major ticks) except exclude drawing\n\
8388 the major and minor tick marks.\n\
8389\n\
8390\n\
8391 xtick (PLFLT, input) : World coordinate interval between major\n\
8392 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8393 generates a suitable tick interval.\n\
8394\n\
8395 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8396 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8397 generates a suitable minor tick interval.\n\
8398\n\
8399 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8400 options for the y axis. The string can include any combination of\n\
8401 the letters defined above for xopt, and in addition may contain:\n\
8402 v: Write numeric labels for the y axis parallel to the base of the\n\
8403 graph, rather than parallel to the axis.\n\
8404\n\
8405\n\
8406 ytick (PLFLT, input) : World coordinate interval between major\n\
8407 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8408 generates a suitable tick interval.\n\
8409\n\
8410 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8411 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8412 generates a suitable minor tick interval.\n\
8413";
8414static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8415Begin a new page\n\
8416\n\
8417DESCRIPTION:\n\
8418\n\
8419 Begins a new page. For a file driver, the output file is opened if\n\
8420 necessary. Advancing the page via pleop and plbop is useful when a\n\
8421 page break is desired at a particular point when plotting to subpages.\n\
8422 Another use for pleop and plbop is when plotting pages to different\n\
8423 files, since you can manually set the file name by calling plsfnam\n\
8424 after the call to pleop. (In fact some drivers may only support a\n\
8425 single page per file, making this a necessity.) One way to handle\n\
8426 this case automatically is to page advance via pladv, but enable\n\
8427 familying (see plsfam) with a small limit on the file size so that a\n\
8428 new family member file will be created on each page break.\n\
8429\n\
8430 Redacted form: plbop()\n\
8431\n\
8432 This function is used in examples 2 and 20.\n\
8433\n\
8434\n\
8435\n\
8436SYNOPSIS:\n\
8437\n\
8438plbop()\n\
8439";
8440static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8441Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8442\n\
8443DESCRIPTION:\n\
8444\n\
8445 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8446 and PLFLT alpha transparency value. This sets the entire color map --\n\
8447 only as many colors as specified will be allocated.\n\
8448\n\
8449 Redacted form: plscmap0a(r, g, b, alpha)\n\
8450\n\
8451 This function is used in examples 30.\n\
8452\n\
8453\n\
8454\n\
8455SYNOPSIS:\n\
8456\n\
8457plscmap0a(r, g, b, alpha, ncol0)\n\
8458\n\
8459ARGUMENTS:\n\
8460\n\
8461 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8462 integers (0-255) representing the degree of red in the color.\n\
8463\n\
8464 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8465 integers (0-255) representing the degree of green in the color.\n\
8466\n\
8467 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8468 integers (0-255) representing the degree of blue in the color.\n\
8469\n\
8470 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8471 representing the alpha transparency of the color.\n\
8472\n\
8473 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8474 vectors.\n\
8475";
8476static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8477Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8478\n\
8479DESCRIPTION:\n\
8480\n\
8481 This is a variant of plscmap1l that supports alpha channel\n\
8482 transparency. It sets cmap1 colors using a piece-wise linear\n\
8483 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8484 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8485 transparency value (0.0-1.0). It may be called at any time.\n\
8486\n\
8487 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8488 alpha, alt_hue_path)\n\
8489\n\
8490 This function is used in example 30.\n\
8491\n\
8492\n\
8493\n\
8494SYNOPSIS:\n\
8495\n\
8496plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8497\n\
8498ARGUMENTS:\n\
8499\n\
8500 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8501\n\
8502 npts (PLINT, input) : number of control points.\n\
8503\n\
8504 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8505 intensity index (0.0-1.0) in ascending order for each control\n\
8506 point.\n\
8507\n\
8508 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8509 coordinate (H or R) for each control point.\n\
8510\n\
8511 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8512 coordinate (L or G) for each control point.\n\
8513\n\
8514 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8515 coordinate (S or B) for each control point.\n\
8516\n\
8517 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8518 transparency value (0.0-1.0) for each control point.\n\
8519\n\
8520 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8521 npts - 1 elements) containing the alternative interpolation method\n\
8522 Boolean value for each control point interval. (alt_hue_path[i]\n\
8523 refers to the interpolation interval between the i and i + 1\n\
8524 control points).\n\
8525";
8526static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8527Enter or leave xor mode\n\
8528\n\
8529DESCRIPTION:\n\
8530\n\
8531 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8532 those drivers (e.g., the xwin driver) that support it. Enables\n\
8533 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8534 is not capable of xor operation it returns a status of false.\n\
8535\n\
8536 Redacted form: plxormod(mode, status)\n\
8537\n\
8538 This function is used in examples 1 and 20.\n\
8539\n\
8540\n\
8541\n\
8542SYNOPSIS:\n\
8543\n\
8544plxormod(mode, status)\n\
8545\n\
8546ARGUMENTS:\n\
8547\n\
8548 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8549 is false means leave xor mode.\n\
8550\n\
8551 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8552 modestatus of true (false) means driver is capable (incapable) of\n\
8553 xor mode.\n\
8554";
8555static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8556Eject current page\n\
8557\n\
8558DESCRIPTION:\n\
8559\n\
8560 Clears the graphics screen of an interactive device, or ejects a page\n\
8561 on a plotter. See plbop for more information.\n\
8562\n\
8563 Redacted form: pleop()\n\
8564\n\
8565 This function is used in example 2,14.\n\
8566\n\
8567\n\
8568\n\
8569SYNOPSIS:\n\
8570\n\
8571pleop()\n\
8572";
8573static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8574Draw a box with axes, etc\n\
8575\n\
8576DESCRIPTION:\n\
8577\n\
8578 Draws a box around the currently defined viewport, and labels it with\n\
8579 world coordinate values appropriate to the window. Thus plbox should\n\
8580 only be called after defining both viewport and window. The ascii\n\
8581 character strings xopt and yopt specify how the box should be drawn as\n\
8582 described below. If ticks and/or subticks are to be drawn for a\n\
8583 particular axis, the tick intervals and number of subintervals may be\n\
8584 specified explicitly, or they may be defaulted by setting the\n\
8585 appropriate arguments to zero.\n\
8586\n\
8587 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8588\n\
8589\n\
8590 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8591 and 29.\n\
8592\n\
8593\n\
8594\n\
8595SYNOPSIS:\n\
8596\n\
8597plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8598\n\
8599ARGUMENTS:\n\
8600\n\
8601 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8602 options for the x axis. The string can include any combination of\n\
8603 the following letters (upper or lower case) in any order: a: Draws\n\
8604 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8605 (x=0).\n\
8606 b: Draws bottom (X) or left (Y) edge of frame.\n\
8607 c: Draws top (X) or right (Y) edge of frame.\n\
8608 d: Plot labels as date / time. Values are assumed to be\n\
8609 seconds since the epoch (as used by gmtime).\n\
8610 f: Always use fixed point numeric labels.\n\
8611 g: Draws a grid at the major tick interval.\n\
8612 h: Draws a grid at the minor tick interval.\n\
8613 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8614 inwards.\n\
8615 l: Labels axis logarithmically. This only affects the labels,\n\
8616 not the data, and so it is necessary to compute the logarithms\n\
8617 of data points before passing them to any of the drawing\n\
8618 routines.\n\
8619 m: Writes numeric labels at major tick intervals in the\n\
8620 unconventional location (above box for X, right of box for Y).\n\
8621 n: Writes numeric labels at major tick intervals in the\n\
8622 conventional location (below box for X, left of box for Y).\n\
8623 o: Use custom labelling function to generate axis label text.\n\
8624 The custom labelling function can be defined with the\n\
8625 plslabelfunc command.\n\
8626 s: Enables subticks between major ticks, only valid if t is\n\
8627 also specified.\n\
8628 t: Draws major ticks.\n\
8629 u: Exactly like \"b\" except don\'t draw edge line.\n\
8630 w: Exactly like \"c\" except don\'t draw edge line.\n\
8631 x: Exactly like \"t\" (including the side effect of the\n\
8632 numerical labels for the major ticks) except exclude drawing\n\
8633 the major and minor tick marks.\n\
8634\n\
8635\n\
8636 xtick (PLFLT, input) : World coordinate interval between major\n\
8637 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8638 generates a suitable tick interval.\n\
8639\n\
8640 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8641 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8642 generates a suitable minor tick interval.\n\
8643\n\
8644 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8645 options for the y axis. The string can include any combination of\n\
8646 the letters defined above for xopt, and in addition may contain:\n\
8647 v: Write numeric labels for the y axis parallel to the base of the\n\
8648 graph, rather than parallel to the axis.\n\
8649\n\
8650\n\
8651 ytick (PLFLT, input) : World coordinate interval between major\n\
8652 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8653 generates a suitable tick interval.\n\
8654\n\
8655 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8656 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8657 generates a suitable minor tick interval.\n\
8658";
8659static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8660Get x axis parameters\n\
8661\n\
8662DESCRIPTION:\n\
8663\n\
8664 Returns current values of the p_digmax and p_digits flags for the x\n\
8665 axis. p_digits is updated after the plot is drawn, so this routine\n\
8666 should only be called after the call to plbox (or plbox3) is complete.\n\
8667 See the PLplot documentation for more information.\n\
8668\n\
8669 Redacted form: plgxax(p_digmax, p_digits)\n\
8670\n\
8671 This function is used in example 31.\n\
8672\n\
8673\n\
8674\n\
8675SYNOPSIS:\n\
8676\n\
8677plgxax(p_digmax, p_digits)\n\
8678\n\
8679ARGUMENTS:\n\
8680\n\
8681 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8682 number of digits for the x axis. If nonzero, the printed label\n\
8683 has been switched to a floating-point representation when the\n\
8684 number of digits exceeds this value.\n\
8685\n\
8686 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8687 number of digits for the numeric labels (x axis) from the last\n\
8688 plot.\n\
8689";
8690static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8691Set font\n\
8692\n\
8693DESCRIPTION:\n\
8694\n\
8695 Sets the font used for subsequent text and symbols. For devices that\n\
8696 still use Hershey fonts this routine has no effect unless the Hershey\n\
8697 fonts with extended character set are loaded (see plfontld). For\n\
8698 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8699 this routine calls the plsfci routine with argument set up\n\
8700 appropriately for the various cases below. However, this method of\n\
8701 specifying the font for unicode-aware devices is deprecated, and the\n\
8702 much more flexible method of calling plsfont directly is recommended\n\
8703 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8704\n\
8705 Redacted form: plfont(ifont)\n\
8706\n\
8707 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8708\n\
8709\n\
8710\n\
8711SYNOPSIS:\n\
8712\n\
8713plfont(ifont)\n\
8714\n\
8715ARGUMENTS:\n\
8716\n\
8717 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8718 (simplest and fastest)\n\
8719 2: Serif font\n\
8720 3: Italic font\n\
8721 4: Script font\n\
8722";
8723static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8724Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8725\n\
8726DESCRIPTION:\n\
8727\n\
8728 Routine for creating a discrete plot legend with a plotted filled box,\n\
8729 line, and/or line of symbols for each annotated legend entry. (See\n\
8730 plcolorbar for similar functionality for creating continuous color\n\
8731 bars.) The arguments of pllegend provide control over the location\n\
8732 and size of the legend as well as the location and characteristics of\n\
8733 the elements (most of which are optional) within that legend. The\n\
8734 resulting legend is clipped at the boundaries of the current subpage.\n\
8735 (N.B. the adopted coordinate system used for some of the parameters is\n\
8736 defined in the documentation of the position parameter.)\n\
8737\n\
8738 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8739 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8740 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8741 test_justification, text_colors, text, box_colors, box_patterns,\n\
8742 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8743 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8744\n\
8745 This function is used in examples 4, 26, and 33.\n\
8746\n\
8747\n\
8748\n\
8749SYNOPSIS:\n\
8750\n\
8751pllegend(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\
8752\n\
8753ARGUMENTS:\n\
8754\n\
8755 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8756 legend width in adopted coordinates. This quantity is calculated\n\
8757 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8758 the routine depending on nlegend and nrow), and the length\n\
8759 (calculated internally) of the longest text string.\n\
8760\n\
8761 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8762 legend height in adopted coordinates. This quantity is calculated\n\
8763 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8764 the routine depending on nlegend and nrow).\n\
8765\n\
8766 opt (PLINT, input) : opt contains bits controlling the overall\n\
8767 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8768 on the left of the legend and the plotted area on the right.\n\
8769 Otherwise, put the text area on the right of the legend and the\n\
8770 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8771 plot a (semitransparent) background for the legend. If the\n\
8772 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8773 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8774 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8775 plot the resulting array of legend entries in row-major order.\n\
8776 Otherwise, plot the legend entries in column-major order.\n\
8777\n\
8778 position (PLINT, input) : position contains bits which control the\n\
8779 overall position of the legend and the definition of the adopted\n\
8780 coordinates used for positions just like what is done for the\n\
8781 position argument for plcolorbar. However, note that the defaults\n\
8782 for the position bits (see below) are different than the\n\
8783 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8784 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8785 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8786 the 16 possible standard positions (the 4 corners and centers of\n\
8787 the 4 sides for both the inside and outside cases) of the legend\n\
8788 relative to the adopted coordinate system. The corner positions\n\
8789 are specified by the appropriate combination of two of the\n\
8790 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8791 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8792 value of one of those bits. The adopted coordinates are\n\
8793 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8794 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8795 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8796 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8797 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8798 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8799 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8800 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8801\n\
8802 x (PLFLT, input) : X offset of the legend position in adopted\n\
8803 coordinates from the specified standard position of the legend.\n\
8804 For positive x, the direction of motion away from the standard\n\
8805 position is inward/outward from the standard corner positions or\n\
8806 standard left or right positions if the\n\
8807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8808 For the standard top or bottom positions, the direction of motion\n\
8809 is toward positive X.\n\
8810\n\
8811 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8812 coordinates from the specified standard position of the legend.\n\
8813 For positive y, the direction of motion away from the standard\n\
8814 position is inward/outward from the standard corner positions or\n\
8815 standard top or bottom positions if the\n\
8816 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8817 the standard left or right positions, the direction of motion is\n\
8818 toward positive Y.\n\
8819\n\
8820 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8821 of the plot area (where the colored boxes, lines, and/or lines of\n\
8822 symbols are drawn) of the legend.\n\
8823\n\
8824 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8825 legend (PL_LEGEND_BACKGROUND).\n\
8826\n\
8827 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8828 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8829\n\
8830 bb_style (PLINT, input) : The pllsty style number for the\n\
8831 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8832\n\
8833 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8834 render the\n\
8835 nlegend legend entries. For internal transformations of\n\
8836 nrow, see further remarks under\n\
8837 nlegend.\n\
8838\n\
8839 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8840 to render the\n\
8841 nlegend legend entries. For internal transformations of\n\
8842 ncolumn, see further remarks under\n\
8843 nlegend.\n\
8844\n\
8845 nlegend (PLINT, input) : Number of legend entries. The above\n\
8846 nrow and\n\
8847 ncolumn values are transformed internally to be consistent with\n\
8848 nlegend. If either\n\
8849 nrow or\n\
8850 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8851 of\n\
8852 nrow and\n\
8853 ncolumn is less than\n\
8854 nlegend, the smaller of the two (or\n\
8855 nrow, if\n\
8856 nrow ==\n\
8857 ncolumn) is increased so the product is >=\n\
8858 nlegend. Thus, for example, the common\n\
8859 nrow = 0,\n\
8860 ncolumn = 0 case is transformed internally to\n\
8861 nrow =\n\
8862 nlegend,\n\
8863 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8864 column.\n\
8865\n\
8866 opt_array (PLINT_VECTOR, input) : A vector of\n\
8867 nlegend values of options to control each individual plotted area\n\
8868 corresponding to a legend entry. If the\n\
8869 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8870 area. If the\n\
8871 PL_LEGEND_COLOR_BOX,\n\
8872 PL_LEGEND_LINE, and/or\n\
8873 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8874 entry is plotted with a colored box; a line; and/or a line of\n\
8875 symbols.\n\
8876\n\
8877 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8878 area in units of character width.\n\
8879\n\
8880 text_scale (PLFLT, input) : Character height scale for text\n\
8881 annotations.\n\
8882\n\
8883 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8884 character height from one legend entry to the next.\n\
8885\n\
8886 text_justification (PLFLT, input) : Justification parameter used\n\
8887 for text justification. The most common values of\n\
8888 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8889 is left justified, centred, or right justified within the text\n\
8890 area, but other values are allowed as well.\n\
8891\n\
8892 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8893 nlegend cmap0 text colors.\n\
8894\n\
8895 text (PLCHAR_MATRIX, input) : A vector of\n\
8896 nlegend UTF-8 character strings containing the legend annotations.\n\
8897\n\
8898 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8899 nlegend cmap0 colors for the discrete colored boxes (\n\
8900 PL_LEGEND_COLOR_BOX).\n\
8901\n\
8902 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8903 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8904 PL_LEGEND_COLOR_BOX).\n\
8905\n\
8906 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8907 nlegend scales (units of fraction of character height) for the height\n\
8908 of the discrete colored boxes (\n\
8909 PL_LEGEND_COLOR_BOX).\n\
8910\n\
8911 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8912 nlegend line widths for the patterns specified by box_patterns (\n\
8913 PL_LEGEND_COLOR_BOX).\n\
8914\n\
8915 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8916 nlegend cmap0 line colors (\n\
8917 PL_LEGEND_LINE).\n\
8918\n\
8919 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8920 nlegend line styles (plsty indices) (\n\
8921 PL_LEGEND_LINE).\n\
8922\n\
8923 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8924 nlegend line widths (\n\
8925 PL_LEGEND_LINE).\n\
8926\n\
8927 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8928 nlegend cmap0 symbol colors (\n\
8929 PL_LEGEND_SYMBOL).\n\
8930\n\
8931 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8932 nlegend scale values for the symbol height (\n\
8933 PL_LEGEND_SYMBOL).\n\
8934\n\
8935 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8936 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8937 area (\n\
8938 PL_LEGEND_SYMBOL).\n\
8939\n\
8940 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8941 nlegend UTF-8 character strings containing the legend symbols. (\n\
8942 PL_LEGEND_SYMBOL).\n\
8943";
8944static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8945Set the background color by 8-bit RGB value\n\
8946\n\
8947DESCRIPTION:\n\
8948\n\
8949 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8950 the PLplot documentation).\n\
8951\n\
8952 Redacted form: plscolbg(r, g, b)\n\
8953\n\
8954 This function is used in examples 15 and 31.\n\
8955\n\
8956\n\
8957\n\
8958SYNOPSIS:\n\
8959\n\
8960plscolbg(r, g, b)\n\
8961\n\
8962ARGUMENTS:\n\
8963\n\
8964 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8965 degree of red in the color.\n\
8966\n\
8967 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8968 degree of green in the color.\n\
8969\n\
8970 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8971 degree of blue in the color.\n\
8972";
8973static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8974Set parameters that define current device-space window\n\
8975\n\
8976DESCRIPTION:\n\
8977\n\
8978 Set relative margin width, aspect ratio, and relative justification\n\
8979 that define current device-space window. If you want to just use the\n\
8980 previous value for any of these, just pass in the magic value\n\
8981 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8982 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8983 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8984 to a device-specific value.\n\
8985\n\
8986 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8987\n\
8988 This function is used in example 31.\n\
8989\n\
8990\n\
8991\n\
8992SYNOPSIS:\n\
8993\n\
8994plsdidev(mar, aspect, jx, jy)\n\
8995\n\
8996ARGUMENTS:\n\
8997\n\
8998 mar (PLFLT, input) : Relative margin width.\n\
8999\n\
9000 aspect (PLFLT, input) : Aspect ratio.\n\
9001\n\
9002 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9003 the range -0.5 to 0.5.\n\
9004\n\
9005 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9006 the range -0.5 to 0.5.\n\
9007";
9008static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9009Specify viewport using aspect ratio only\n\
9010\n\
9011DESCRIPTION:\n\
9012\n\
9013 Selects the largest viewport with the given aspect ratio within the\n\
9014 subpage that leaves a standard margin (left-hand margin of eight\n\
9015 character heights, and a margin around the other three sides of five\n\
9016 character heights).\n\
9017\n\
9018 Redacted form: plvasp(aspect)\n\
9019\n\
9020 This function is used in example 13.\n\
9021\n\
9022\n\
9023\n\
9024SYNOPSIS:\n\
9025\n\
9026plvasp(aspect)\n\
9027\n\
9028ARGUMENTS:\n\
9029\n\
9030 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9031 axis of resulting viewport.\n\
9032";
9033static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
9034Configure the transformations required for projecting a 3D surface on a 2D window\n\
9035\n\
9036DESCRIPTION:\n\
9037\n\
9038 Configure the transformations required for projecting a 3D surface on\n\
9039 an existing 2D window. Those transformations (see the PLplot\n\
9040 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9041 surface which has its limits expressed in 3D world coordinates and\n\
9042 also normalized 3D coordinates (used for interpreting the altitude and\n\
9043 azimuth of the viewing angle). The transformations consist of the\n\
9044 linear transform from 3D world coordinates to normalized 3D\n\
9045 coordinates, and the 3D rotation of normalized coordinates required to\n\
9046 align the pole of the new 3D coordinate system with the viewing\n\
9047 direction specified by altitude and azimuth so that x and y of the\n\
9048 surface elements in that transformed coordinate system are the\n\
9049 projection of the 3D surface with given viewing direction on the 2D\n\
9050 window.\n\
9051\n\
9052 The enclosing rectangular cuboid for the surface plot is defined by\n\
9053 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9054 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9055 sizes of basex by basey by height so that xmin maps to -\n\
9056 basex/2, xmax maps to basex/2, ymin maps to -\n\
9057 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9058 The resulting rectangular cuboid in normalized coordinates is then\n\
9059 viewed by an observer at altitude alt and azimuth az. This routine\n\
9060 must be called before plbox3 or any of the 3D surface plotting\n\
9061 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9062 plsurf3dl or plfill3.\n\
9063\n\
9064 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9065 zmin, zmax, alt, az)\n\
9066\n\
9067 This function is examples 8, 11, 18, and 21.\n\
9068\n\
9069\n\
9070\n\
9071SYNOPSIS:\n\
9072\n\
9073plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9074\n\
9075ARGUMENTS:\n\
9076\n\
9077 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9078 rectangular cuboid.\n\
9079\n\
9080 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9081 rectangular cuboid.\n\
9082\n\
9083 height (PLFLT, input) : The normalized z coordinate size of the\n\
9084 rectangular cuboid.\n\
9085\n\
9086 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9087 rectangular cuboid.\n\
9088\n\
9089 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9090 rectangular cuboid.\n\
9091\n\
9092 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9093 rectangular cuboid.\n\
9094\n\
9095 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9096 rectangular cuboid.\n\
9097\n\
9098 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9099 rectangular cuboid.\n\
9100\n\
9101 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9102 rectangular cuboid.\n\
9103\n\
9104 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9105 plane of the rectangular cuboid in normalized coordinates.\n\
9106\n\
9107 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9108 rectangular cuboid in normalized coordinates. When az=0, the\n\
9109 observer is looking face onto the zx plane of the rectangular\n\
9110 cuboid in normalized coordinates, and as az is increased, the\n\
9111 observer moves clockwise around that cuboid when viewed from above\n\
9112 the xy plane.\n\
9113";
9114static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9115Wait for graphics input event and translate to world coordinates.\n\
9116\n\
9117DESCRIPTION:\n\
9118\n\
9119 Wait for graphics input event and translate to world coordinates.\n\
9120 Returns 0 if no translation to world coordinates is possible.\n\
9121\n\
9122 This function returns 1 on success and 0 if no translation to world\n\
9123 coordinates is possible.\n\
9124\n\
9125 Redacted form: plGetCursor(gin)\n\
9126\n\
9127 This function is used in examples 1 and 20.\n\
9128\n\
9129\n\
9130\n\
9131SYNOPSIS:\n\
9132\n\
9133PLINT plGetCursor(gin)\n\
9134\n\
9135ARGUMENTS:\n\
9136\n\
9137 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9138 which will contain the output. The structure is not allocated by\n\
9139 the routine and must exist before the function is called.\n\
9140";
9141static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9142Set number of colors in cmap0\n\
9143\n\
9144DESCRIPTION:\n\
9145\n\
9146 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9147 (or reallocate) cmap0, and fill with default values for those colors\n\
9148 not previously allocated. The first 16 default colors are given in\n\
9149 the plcol0 documentation. For larger indices the default color is\n\
9150 red.\n\
9151\n\
9152 The drivers are not guaranteed to support more than 16 colors.\n\
9153\n\
9154 Redacted form: plscmap0n(ncol0)\n\
9155\n\
9156 This function is used in examples 15, 16, and 24.\n\
9157\n\
9158\n\
9159\n\
9160SYNOPSIS:\n\
9161\n\
9162plscmap0n(ncol0)\n\
9163\n\
9164ARGUMENTS:\n\
9165\n\
9166 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9167 the cmap0 palette. If this number is zero or less, then the value\n\
9168 from the previous call to plscmap0n is used and if there is no\n\
9169 previous call, then a default value is used.\n\
9170";
9171static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9172Set z axis parameters\n\
9173\n\
9174DESCRIPTION:\n\
9175\n\
9176 Identical to plsxax, except that arguments are flags for z axis. See\n\
9177 the description of plsxax for more detail.\n\
9178\n\
9179 Redacted form: plszax(digmax, digits)\n\
9180\n\
9181 This function is used in example 31.\n\
9182\n\
9183\n\
9184\n\
9185SYNOPSIS:\n\
9186\n\
9187plszax(digmax, digits)\n\
9188\n\
9189ARGUMENTS:\n\
9190\n\
9191 digmax (PLINT, input) : Variable to set the maximum number of\n\
9192 digits for the z axis. If nonzero, the printed label will be\n\
9193 switched to a floating-point representation when the number of\n\
9194 digits exceeds digmax.\n\
9195\n\
9196 digits (PLINT, input) : Field digits value. Currently, changing\n\
9197 its value here has no effect since it is set only by plbox or\n\
9198 plbox3. However, the user may obtain its value after a call to\n\
9199 either of these functions by calling plgzax.\n\
9200";
9201static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9202Get FCI (font characterization integer)\n\
9203\n\
9204DESCRIPTION:\n\
9205\n\
9206 Gets information about the current font using the FCI approach. See\n\
9207 the PLplot documentation for more information.\n\
9208\n\
9209 Redacted form: plgfci(p_fci)\n\
9210\n\
9211 This function is used in example 23.\n\
9212\n\
9213\n\
9214\n\
9215SYNOPSIS:\n\
9216\n\
9217plgfci(p_fci)\n\
9218\n\
9219ARGUMENTS:\n\
9220\n\
9221 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9222 FCI value.\n\
9223";
9224static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9225Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9226\n\
9227DESCRIPTION:\n\
9228\n\
9229 Sets up plotter environment for simple graphs by calling pladv and\n\
9230 setting up viewport and window to sensible default values. plenv0\n\
9231 leaves a standard margin (left-hand margin of eight character heights,\n\
9232 and a margin around the other three sides of five character heights)\n\
9233 around most graphs for axis labels and a title. When these defaults\n\
9234 are not suitable, use the individual routines plvpas, plvpor, or\n\
9235 plvasp for setting up the viewport, plwind for defining the window,\n\
9236 and plbox for drawing the box.\n\
9237\n\
9238 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9239\n\
9240 This function is used in example 21.\n\
9241\n\
9242\n\
9243\n\
9244SYNOPSIS:\n\
9245\n\
9246plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9247\n\
9248ARGUMENTS:\n\
9249\n\
9250 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9251 world coordinates).\n\
9252\n\
9253 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9254 world coordinates).\n\
9255\n\
9256 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9257 coordinates).\n\
9258\n\
9259 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9260 coordinates).\n\
9261\n\
9262 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9263 scales will not be set, the user must set up the scale before\n\
9264 calling plenv0 using plsvpa, plvasp or other.\n\
9265 0: the x and y axes are scaled independently to use as much of\n\
9266 the screen as possible.\n\
9267 1: the scales of the x and y axes are made equal.\n\
9268 2: the axis of the x and y axes are made equal, and the plot\n\
9269 box will be square.\n\
9270\n\
9271\n\
9272 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9273 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9274 -1: draw box only.\n\
9275 0: draw box, ticks, and numeric tick labels.\n\
9276 1: also draw coordinate axes at x=0 and y=0.\n\
9277 2: also draw a grid at major tick positions in both\n\
9278 coordinates.\n\
9279 3: also draw a grid at minor tick positions in both\n\
9280 coordinates.\n\
9281 10: same as 0 except logarithmic x tick marks. (The x data\n\
9282 have to be converted to logarithms separately.)\n\
9283 11: same as 1 except logarithmic x tick marks. (The x data\n\
9284 have to be converted to logarithms separately.)\n\
9285 12: same as 2 except logarithmic x tick marks. (The x data\n\
9286 have to be converted to logarithms separately.)\n\
9287 13: same as 3 except logarithmic x tick marks. (The x data\n\
9288 have to be converted to logarithms separately.)\n\
9289 20: same as 0 except logarithmic y tick marks. (The y data\n\
9290 have to be converted to logarithms separately.)\n\
9291 21: same as 1 except logarithmic y tick marks. (The y data\n\
9292 have to be converted to logarithms separately.)\n\
9293 22: same as 2 except logarithmic y tick marks. (The y data\n\
9294 have to be converted to logarithms separately.)\n\
9295 23: same as 3 except logarithmic y tick marks. (The y data\n\
9296 have to be converted to logarithms separately.)\n\
9297 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9298 and y data have to be converted to logarithms separately.)\n\
9299 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9300 and y data have to be converted to logarithms separately.)\n\
9301 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9302 and y data have to be converted to logarithms separately.)\n\
9303 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9304 and y data have to be converted to logarithms separately.)\n\
9305 40: same as 0 except date / time x labels.\n\
9306 41: same as 1 except date / time x labels.\n\
9307 42: same as 2 except date / time x labels.\n\
9308 43: same as 3 except date / time x labels.\n\
9309 50: same as 0 except date / time y labels.\n\
9310 51: same as 1 except date / time y labels.\n\
9311 52: same as 2 except date / time y labels.\n\
9312 53: same as 3 except date / time y labels.\n\
9313 60: same as 0 except date / time x and y labels.\n\
9314 61: same as 1 except date / time x and y labels.\n\
9315 62: same as 2 except date / time x and y labels.\n\
9316 63: same as 3 except date / time x and y labels.\n\
9317 70: same as 0 except custom x and y labels.\n\
9318 71: same as 1 except custom x and y labels.\n\
9319 72: same as 2 except custom x and y labels.\n\
9320 73: same as 3 except custom x and y labels.\n\
9321";
9322static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9323Set symbol size\n\
9324\n\
9325DESCRIPTION:\n\
9326\n\
9327 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9328 plsym. The actual height of a symbol is the product of the default\n\
9329 symbol size and a scaling factor as for the character height.\n\
9330\n\
9331 Redacted form: plssym(def, scale)\n\
9332\n\
9333 This function is used in example 29.\n\
9334\n\
9335\n\
9336\n\
9337SYNOPSIS:\n\
9338\n\
9339plssym(def, scale)\n\
9340\n\
9341ARGUMENTS:\n\
9342\n\
9343 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9344 should be set to zero if the default height is to remain\n\
9345 unchanged.\n\
9346\n\
9347 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9348 actual symbol height.\n\
9349";
9350static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9351Set plot orientation\n\
9352\n\
9353DESCRIPTION:\n\
9354\n\
9355 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9356 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9357 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9358 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9359 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9360 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9361 not called the default value of rot is 0.\n\
9362\n\
9363 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9364 probably want to change the aspect ratio to a value suitable for the\n\
9365 plot orientation using a call to plsdidev or the command-line options\n\
9366 -a or -freeaspect. For more documentation of those options see the\n\
9367 PLplot documentation. Such command-line options can be set internally\n\
9368 using plsetopt or set directly using the command line and parsed using\n\
9369 a call to plparseopts.\n\
9370\n\
9371 Redacted form: plsdiori(rot)\n\
9372\n\
9373 This function is not used in any examples.\n\
9374\n\
9375\n\
9376\n\
9377SYNOPSIS:\n\
9378\n\
9379plsdiori(rot)\n\
9380\n\
9381ARGUMENTS:\n\
9382\n\
9383 rot (PLFLT, input) : Plot orientation parameter.\n\
9384";
9385static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9386Advance the (sub-)page\n\
9387\n\
9388DESCRIPTION:\n\
9389\n\
9390 Advances to the next subpage if sub=0, performing a page advance if\n\
9391 there are no remaining subpages on the current page. If subpages\n\
9392 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9393 PLplot switches to the specified subpage. Note that this allows you\n\
9394 to overwrite a plot on the specified subpage; if this is not what you\n\
9395 intended, use pleop followed by plbop to first advance the page. This\n\
9396 routine is called automatically (with page=0) by plenv, but if plenv\n\
9397 is not used, pladv must be called after initializing PLplot but before\n\
9398 defining the viewport.\n\
9399\n\
9400 Redacted form: pladv(page)\n\
9401\n\
9402 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9403 29, and 31.\n\
9404\n\
9405\n\
9406\n\
9407SYNOPSIS:\n\
9408\n\
9409pladv(page)\n\
9410\n\
9411ARGUMENTS:\n\
9412\n\
9413 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9414 in the top left corner and increasing along the rows) to which to\n\
9415 advance. Set to zero to advance to the next subpage (or to the\n\
9416 next page if subpages are not being used).\n\
9417";
9418static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9419Set cmap0 colors by 8-bit RGB values\n\
9420\n\
9421DESCRIPTION:\n\
9422\n\
9423 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9424 documentation). This sets the entire color map -- only as many colors\n\
9425 as specified will be allocated.\n\
9426\n\
9427 Redacted form: plscmap0(r, g, b)\n\
9428\n\
9429 This function is used in examples 2 and 24.\n\
9430\n\
9431\n\
9432\n\
9433SYNOPSIS:\n\
9434\n\
9435plscmap0(r, g, b, ncol0)\n\
9436\n\
9437ARGUMENTS:\n\
9438\n\
9439 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9440 integers (0-255) representing the degree of red in the color.\n\
9441\n\
9442 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9443 integers (0-255) representing the degree of green in the color.\n\
9444\n\
9445 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9446 integers (0-255) representing the degree of blue in the color.\n\
9447\n\
9448 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9449";
9450static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9451Get character default height and current (scaled) height\n\
9452\n\
9453DESCRIPTION:\n\
9454\n\
9455 Get character default height and current (scaled) height.\n\
9456\n\
9457 Redacted form: plgchr(p_def, p_ht)\n\
9458\n\
9459 This function is used in example 23.\n\
9460\n\
9461\n\
9462\n\
9463SYNOPSIS:\n\
9464\n\
9465plgchr(p_def, p_ht)\n\
9466\n\
9467ARGUMENTS:\n\
9468\n\
9469 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9470 character height (mm).\n\
9471\n\
9472 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9473 character height (mm).\n\
9474";
9475static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9476Set opaque RGB cmap1 colors values\n\
9477\n\
9478DESCRIPTION:\n\
9479\n\
9480 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9481 vector values. This function also sets the number of cmap1 colors.\n\
9482 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9483 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9484 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9485 to\n\
9486 ncol1-1. So in order for this continuous color model to work\n\
9487 properly, it is the responsibility of the user of plscmap1 to insure\n\
9488 that these RGB vectors are continuous functions of their integer\n\
9489 indices.\n\
9490\n\
9491 Redacted form: plscmap1(r, g, b)\n\
9492\n\
9493 This function is used in example 31.\n\
9494\n\
9495\n\
9496\n\
9497SYNOPSIS:\n\
9498\n\
9499plscmap1(r, g, b, ncol1)\n\
9500\n\
9501ARGUMENTS:\n\
9502\n\
9503 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9504 8-bit integers in the range from 0-255) the degree of red in the\n\
9505 color as a continuous function of the integer index of the vector.\n\
9506\n\
9507 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9508 8-bit integers in the range from 0-255) the degree of green in the\n\
9509 color as a continuous function of the integer index of the vector.\n\
9510\n\
9511 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9512 8-bit integers in the range from 0-255) the degree of blue in the\n\
9513 color as a continuous function of the integer index of the vector.\n\
9514\n\
9515 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9516";
9517static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9518Set any command-line option\n\
9519\n\
9520DESCRIPTION:\n\
9521\n\
9522 Set any command-line option internally from a program before it\n\
9523 invokes plinit. opt is the name of the command-line option and optarg\n\
9524 is the corresponding command-line option argument.\n\
9525\n\
9526 This function returns 0 on success.\n\
9527\n\
9528 Redacted form: plsetopt(opt, optarg)\n\
9529\n\
9530 This function is used in example 14.\n\
9531\n\
9532\n\
9533\n\
9534SYNOPSIS:\n\
9535\n\
9536PLINT plsetopt(opt, optarg)\n\
9537\n\
9538ARGUMENTS:\n\
9539\n\
9540 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9541 the command-line option.\n\
9542\n\
9543 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9544 containing the argument of the command-line option.\n\
9545";
9546static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9547Draw linear gradient inside polygon\n\
9548\n\
9549DESCRIPTION:\n\
9550\n\
9551 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9552 points (\n\
9553 x[i],\n\
9554 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9555 polygon coordinates and the gradient angle are all expressed in world\n\
9556 coordinates. The angle from the x axis for both the rotated\n\
9557 coordinate system and the gradient vector is specified by angle. The\n\
9558 magnitude of the gradient vector is the difference between the maximum\n\
9559 and minimum values of x for the vertices in the rotated coordinate\n\
9560 system. The origin of the gradient vector can be interpreted as being\n\
9561 anywhere on the line corresponding to the minimum x value for the\n\
9562 vertices in the rotated coordinate system. The distance along the\n\
9563 gradient vector is linearly transformed to the independent variable of\n\
9564 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9565 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9566 color corresponding to the independent variable of cmap1. For more\n\
9567 information about cmap1 (see the PLplot documentation).\n\
9568\n\
9569 Redacted form: plgradient(x,y,angle)\n\
9570\n\
9571 This function is used in examples 25 and 30.\n\
9572\n\
9573\n\
9574\n\
9575SYNOPSIS:\n\
9576\n\
9577plgradient(n, x, y, angle)\n\
9578\n\
9579ARGUMENTS:\n\
9580\n\
9581 n (PLINT, input) : Number of vertices in polygon.\n\
9582\n\
9583 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9584 vertices.\n\
9585\n\
9586 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9587 vertices.\n\
9588\n\
9589 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9590 axis.\n\
9591";
9592static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9593Set length of major ticks\n\
9594\n\
9595DESCRIPTION:\n\
9596\n\
9597 This sets up the length of the major ticks. The actual length is the\n\
9598 product of the default length and a scaling factor as for character\n\
9599 height.\n\
9600\n\
9601 Redacted form: plsmaj(def, scale)\n\
9602\n\
9603 This function is used in example 29.\n\
9604\n\
9605\n\
9606\n\
9607SYNOPSIS:\n\
9608\n\
9609plsmaj(def, scale)\n\
9610\n\
9611ARGUMENTS:\n\
9612\n\
9613 def (PLFLT, input) : The default length of a major tick in\n\
9614 millimeters, should be set to zero if the default length is to\n\
9615 remain unchanged.\n\
9616\n\
9617 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9618 actual tick length.\n\
9619";
9620static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9621Set a global coordinate transform function\n\
9622\n\
9623DESCRIPTION:\n\
9624\n\
9625 This function can be used to define a coordinate transformation which\n\
9626 affects all elements drawn within the current plot window. The\n\
9627 coordinate_transform callback function is similar to that provided for\n\
9628 the plmap and plmeridians functions. The coordinate_transform_data\n\
9629 parameter may be used to pass extra data to coordinate_transform.\n\
9630\n\
9631 Redacted form: General: plstransform(coordinate_transform,\n\
9632 coordinate_transform_data)\n\
9633\n\
9634\n\
9635 This function is used in examples 19 and 22.\n\
9636\n\
9637\n\
9638\n\
9639SYNOPSIS:\n\
9640\n\
9641plstransform(coordinate_transform, coordinate_transform_data)\n\
9642\n\
9643ARGUMENTS:\n\
9644\n\
9645 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9646 function that defines the transformation from the input (x, y)\n\
9647 world coordinates to new PLplot world coordinates. If\n\
9648 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9649 case), then no transform is applied.\n\
9650\n\
9651 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9652 for\n\
9653 coordinate_transform.\n\
9654";
9655static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9656Configure the transformation between continuous and broken-down time for the current stream\n\
9657\n\
9658DESCRIPTION:\n\
9659\n\
9660 Configure the transformation between continuous and broken-down time\n\
9661 for the current stream. This transformation is used by both plbtime\n\
9662 and plctime.\n\
9663\n\
9664 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9665 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9666\n\
9667\n\
9668 This function is used in example 29.\n\
9669\n\
9670\n\
9671\n\
9672SYNOPSIS:\n\
9673\n\
9674plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9675\n\
9676ARGUMENTS:\n\
9677\n\
9678 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9679 As a special case, if\n\
9680 scale is 0., then all other arguments are ignored, and the result (the\n\
9681 default used by PLplot) is the equivalent of a call to\n\
9682 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9683 That is, for this special case broken-down time is calculated with\n\
9684 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9685 and the continuous time is defined as the number of seconds since\n\
9686 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9687\n\
9688 offset1 (PLFLT, input) : If\n\
9689 ifbtime_offset is true, the parameters\n\
9690 offset1 and\n\
9691 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9692 (with units in days) specify the epoch of the continuous time\n\
9693 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9694 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9695 are used to specify the origin to allow users (by specifying\n\
9696 offset1 as an integer that can be exactly represented by a\n\
9697 floating-point variable and specifying\n\
9698 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9699 the numerical errors of the continuous time representation.\n\
9700\n\
9701 offset2 (PLFLT, input) : See documentation of\n\
9702 offset1.\n\
9703\n\
9704 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9705 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9706 calendar is used for broken-down time rather than the proleptic\n\
9707 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9708 have been historically used to define UTC are inserted into the\n\
9709 broken-down time. Other possibilities for additional control bits\n\
9710 for ccontrol exist such as making the historical time corrections\n\
9711 in the broken-down time corresponding to ET (ephemeris time) or\n\
9712 making the (slightly non-constant) corrections from international\n\
9713 atomic time (TAI) to what astronomers define as terrestrial time\n\
9714 (TT). But those additional possibilities have not been\n\
9715 implemented yet in the qsastime library (one of the PLplot utility\n\
9716 libraries).\n\
9717\n\
9718 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9719 epoch of the continuous time scale is specified by the user. If\n\
9720 ifbtime_offset is false, then\n\
9721 offset1 and\n\
9722 offset2 are used to specify the epoch, and the following broken-down\n\
9723 time parameters are completely ignored. If\n\
9724 ifbtime_offset is true, then\n\
9725 offset1 and\n\
9726 offset2 are completely ignored, and the following broken-down time\n\
9727 parameters are used to specify the epoch.\n\
9728\n\
9729 year (PLINT, input) : Year of epoch.\n\
9730\n\
9731 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9732 11 (December).\n\
9733\n\
9734 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9735\n\
9736 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9737\n\
9738 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9739\n\
9740 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9741";
9742static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9743Flushes the output stream\n\
9744\n\
9745DESCRIPTION:\n\
9746\n\
9747 Flushes the output stream. Use sparingly, if at all.\n\
9748\n\
9749 Redacted form: plflush()\n\
9750\n\
9751 This function is used in examples 1 and 14.\n\
9752\n\
9753\n\
9754\n\
9755SYNOPSIS:\n\
9756\n\
9757plflush()\n\
9758";
9759static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9760Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9761\n\
9762DESCRIPTION:\n\
9763\n\
9764 This variant of plsurf3d (see that function\'s documentation for more\n\
9765 details) should be suitable for the case where the area of the x, y\n\
9766 coordinate grid where z is defined can be non-rectangular. The limits\n\
9767 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9768 indexymin, and indexymax.\n\
9769\n\
9770 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9771 indexymax)\n\
9772\n\
9773 This function is used in example 8.\n\
9774\n\
9775\n\
9776\n\
9777SYNOPSIS:\n\
9778\n\
9779plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9780\n\
9781ARGUMENTS:\n\
9782\n\
9783 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9784 which the function is evaluated.\n\
9785\n\
9786 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9787 which the function is evaluated.\n\
9788\n\
9789 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9790 plot. Should have dimensions of\n\
9791 nx by\n\
9792 ny.\n\
9793\n\
9794 nx (PLINT, input) : Number of x values at which function is\n\
9795 evaluated.\n\
9796\n\
9797 ny (PLINT, input) : Number of y values at which function is\n\
9798 evaluated.\n\
9799\n\
9800 opt (PLINT, input) : Determines the way in which the surface is\n\
9801 represented. To specify more than one option just add the options,\n\
9802 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9803 connecting points at which function is defined.\n\
9804 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9805 using parameters\n\
9806 nlevel and\n\
9807 clevel.\n\
9808 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9809 using parameters\n\
9810 nlevel and\n\
9811 clevel.\n\
9812 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9813 the borders of the plotted function.\n\
9814 opt=MAG_COLOR : the surface is colored according to the value\n\
9815 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9816 according to the intensity of the reflected light in the\n\
9817 surface from a light source whose position is set using\n\
9818 pllightsource.\n\
9819\n\
9820\n\
9821 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9822 levels.\n\
9823\n\
9824 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9825\n\
9826 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9827 corresponds to the first x index where z is defined.\n\
9828\n\
9829 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9830 which corresponds (by convention) to one more than the last x\n\
9831 index value where z is defined.\n\
9832\n\
9833 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9834 values which all must be ≥ 0. These values are the first y index\n\
9835 where z is defined for a particular x index in the range from\n\
9836 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9837 indexxmax.\n\
9838\n\
9839 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9840 values which all must be ≤ ny. These values correspond (by\n\
9841 convention) to one more than the last y index where z is defined\n\
9842 for a particular x index in the range from indexxmin to indexxmax\n\
9843 - 1. The dimension of indexymax is indexxmax.\n\
9844";
9845static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9846Set semitransparent cmap1 RGBA colors.\n\
9847\n\
9848DESCRIPTION:\n\
9849\n\
9850 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9851 RGBA vector values. This function also sets the number of cmap1\n\
9852 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9853 floating-point index in the range from 0.0-1.0 which is linearly\n\
9854 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9855 vectors in the range from 0 to\n\
9856 ncol1-1. So in order for this continuous color model to work\n\
9857 properly, it is the responsibility of the user of plscmap1 to insure\n\
9858 that these RGBA vectors are continuous functions of their integer\n\
9859 indices.\n\
9860\n\
9861 Redacted form: plscmap1a(r, g, b, alpha)\n\
9862\n\
9863 This function is used in example 31.\n\
9864\n\
9865\n\
9866\n\
9867SYNOPSIS:\n\
9868\n\
9869plscmap1a(r, g, b, alpha, ncol1)\n\
9870\n\
9871ARGUMENTS:\n\
9872\n\
9873 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9874 8-bit integers in the range from 0-255) the degree of red in the\n\
9875 color as a continuous function of the integer index of the vector.\n\
9876\n\
9877 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9878 8-bit integers in the range from 0-255) the degree of green in the\n\
9879 color as a continuous function of the integer index of the vector.\n\
9880\n\
9881 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9882 8-bit integers in the range from 0-255) the degree of blue in the\n\
9883 color as a continuous function of the integer index of the vector.\n\
9884\n\
9885 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9886 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9887 completely transparent and 1.0 corresponds to completely opaque)\n\
9888 the alpha transparency of the color as a continuous function of\n\
9889 the integer index of the vector.\n\
9890\n\
9891 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9892 vectors.\n\
9893";
9894static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9895Calculate broken-down time from continuous time for the current stream\n\
9896\n\
9897DESCRIPTION:\n\
9898\n\
9899 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9900 continuous time, ctime for the current stream. This function is the\n\
9901 inverse of plctime.\n\
9902\n\
9903 The PLplot definition of broken-down time is a calendar time that\n\
9904 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9905 responsibility to apply those offsets (if so desired) before using the\n\
9906 PLplot time API. By default broken-down time is defined using the\n\
9907 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9908 continuous time is defined as the number of seconds since the Unix\n\
9909 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9910 broken-down and continuous time are possible, see plconfigtime.\n\
9911\n\
9912 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9913 ctime)\n\
9914\n\
9915\n\
9916 This function is used in example 29.\n\
9917\n\
9918\n\
9919\n\
9920SYNOPSIS:\n\
9921\n\
9922plbtime(year, month, day, hour, min, sec, ctime)\n\
9923\n\
9924ARGUMENTS:\n\
9925\n\
9926 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9927 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9928 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9929 BCE, etc.)\n\
9930\n\
9931 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9932 the year in the range from 0 (January) to 11 (December).\n\
9933\n\
9934 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9935 month in the range from 1 to 31.\n\
9936\n\
9937 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9938 day in the range from 0 to 23.\n\
9939\n\
9940 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9941 hour in the range from 0 to 59\n\
9942\n\
9943 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9944 minute in range from 0. to 60.\n\
9945\n\
9946 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9947 time is calculated.\n\
9948";
9949static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9950Convert RGB color to HLS\n\
9951\n\
9952DESCRIPTION:\n\
9953\n\
9954 Convert RGB color coordinates to HLS\n\
9955\n\
9956 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9957\n\
9958\n\
9959 This function is used in example 2.\n\
9960\n\
9961\n\
9962\n\
9963SYNOPSIS:\n\
9964\n\
9965plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9966\n\
9967ARGUMENTS:\n\
9968\n\
9969 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9970\n\
9971 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9972\n\
9973 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9974\n\
9975 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9976 degrees (0.0-360.0) on the color cylinder.\n\
9977\n\
9978 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9979 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9980 cylinder.\n\
9981\n\
9982 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9983 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9984 cylinder.\n\
9985";
9986static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9987Get the current device (keyword) name\n\
9988\n\
9989DESCRIPTION:\n\
9990\n\
9991 Get the current device (keyword) name. Note: you must have allocated\n\
9992 space for this (80 characters is safe).\n\
9993\n\
9994 Redacted form: plgdev(p_dev)\n\
9995\n\
9996 This function is used in example 14.\n\
9997\n\
9998\n\
9999\n\
10000SYNOPSIS:\n\
10001\n\
10002plgdev(p_dev)\n\
10003\n\
10004ARGUMENTS:\n\
10005\n\
10006 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10007 (with preallocated length of 80 characters or more) containing the\n\
10008 device (keyword) name.\n\
10009";
10010static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
10011Set the number of subpages in x and y\n\
10012\n\
10013DESCRIPTION:\n\
10014\n\
10015 Set the number of subpages in x and y.\n\
10016\n\
10017 Redacted form: plssub(nx, ny)\n\
10018\n\
10019 This function is examples 1,2,14,21,25,27.\n\
10020\n\
10021\n\
10022\n\
10023SYNOPSIS:\n\
10024\n\
10025plssub(nx, ny)\n\
10026\n\
10027ARGUMENTS:\n\
10028\n\
10029 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10030 of window columns).\n\
10031\n\
10032 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10033 of window rows).\n\
10034";
10035static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
10036Get current stream number\n\
10037\n\
10038DESCRIPTION:\n\
10039\n\
10040 Gets the number of the current output stream. See also plsstrm.\n\
10041\n\
10042 Redacted form: plgstrm(p_strm)\n\
10043\n\
10044 This function is used in example 1,20.\n\
10045\n\
10046\n\
10047\n\
10048SYNOPSIS:\n\
10049\n\
10050plgstrm(p_strm)\n\
10051\n\
10052ARGUMENTS:\n\
10053\n\
10054 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10055 stream value.\n\
10056";
10057static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
10058Random number generator returning a real random number in the range [0,1]\n\
10059\n\
10060DESCRIPTION:\n\
10061\n\
10062 Random number generator returning a real random number in the range\n\
10063 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10064 / compilers provide their own random number generator, and so this is\n\
10065 provided purely for convenience and to give a consistent random number\n\
10066 generator across all languages supported by PLplot. This is\n\
10067 particularly useful for comparing results from the test suite of\n\
10068 examples.\n\
10069\n\
10070 Redacted form: plrandd()\n\
10071\n\
10072 This function is used in examples 17 and 21.\n\
10073\n\
10074\n\
10075\n\
10076SYNOPSIS:\n\
10077\n\
10078plrandd()\n\
10079";
10080static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10081Add a point to a strip chart\n\
10082\n\
10083DESCRIPTION:\n\
10084\n\
10085 Add a point to a given pen of a given strip chart. There is no need\n\
10086 for all pens to have the same number of points or to be equally\n\
10087 sampled in the x coordinate. Allocates memory and rescales as\n\
10088 necessary.\n\
10089\n\
10090 Redacted form: plstripa(id, pen, x, y)\n\
10091\n\
10092 This function is used in example 17.\n\
10093\n\
10094\n\
10095\n\
10096SYNOPSIS:\n\
10097\n\
10098plstripa(id, pen, x, y)\n\
10099\n\
10100ARGUMENTS:\n\
10101\n\
10102 id (PLINT, input) : Identification number of the strip chart (set\n\
10103 up in plstripc).\n\
10104\n\
10105 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10106\n\
10107 x (PLFLT, input) : X coordinate of point to plot.\n\
10108\n\
10109 y (PLFLT, input) : Y coordinate of point to plot.\n\
10110";
10111static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10112Set device-compression level\n\
10113\n\
10114DESCRIPTION:\n\
10115\n\
10116 Set device-compression level. Only used for drivers that provide\n\
10117 compression. This function, if used, should be invoked before a call\n\
10118 to plinit.\n\
10119\n\
10120 Redacted form: plscompression(compression)\n\
10121\n\
10122 This function is used in example 31.\n\
10123\n\
10124\n\
10125\n\
10126SYNOPSIS:\n\
10127\n\
10128plscompression(compression)\n\
10129\n\
10130ARGUMENTS:\n\
10131\n\
10132 compression (PLINT, input) : The desired compression level. This is\n\
10133 a device-dependent value. Currently only the jpeg and png devices\n\
10134 use these values. For jpeg value is the jpeg quality which should\n\
10135 normally be in the range 0-95. Higher values denote higher quality\n\
10136 and hence larger image sizes. For png values are in the range -1\n\
10137 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10138 A value of -1 denotes the default zlib compression level. Values\n\
10139 in the range 10-99 are divided by 10 and then used as the zlib\n\
10140 compression level. Higher compression levels correspond to greater\n\
10141 compression and small file sizes at the expense of more\n\
10142 computation.\n\
10143";
10144static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10145Specify viewport in absolute coordinates\n\
10146\n\
10147DESCRIPTION:\n\
10148\n\
10149 Alternate routine to plvpor for setting up the viewport. This routine\n\
10150 should be used only if the viewport is required to have a definite\n\
10151 size in millimeters. The routine plgspa is useful for finding out the\n\
10152 size of the current subpage.\n\
10153\n\
10154 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10155\n\
10156 This function is used in example 10.\n\
10157\n\
10158\n\
10159\n\
10160SYNOPSIS:\n\
10161\n\
10162plsvpa(xmin, xmax, ymin, ymax)\n\
10163\n\
10164ARGUMENTS:\n\
10165\n\
10166 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10167 viewport from the left-hand edge of the subpage in millimeters.\n\
10168\n\
10169 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10170 viewport from the left-hand edge of the subpage in millimeters.\n\
10171\n\
10172 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10173 viewport from the bottom edge of the subpage in millimeters.\n\
10174\n\
10175 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10176 from the bottom edge of the subpage in millimeters.\n\
10177";
10178static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10179Draw a polygon in 3 space\n\
10180\n\
10181DESCRIPTION:\n\
10182\n\
10183 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10184 like plline3, but differs from that function in that plpoly3 attempts\n\
10185 to determine if the polygon is viewable depending on the order of the\n\
10186 points within the vector and the value of ifcc. If the back of\n\
10187 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10188 you want, then use plline3 instead.\n\
10189\n\
10190 The points are assumed to be in a plane, and the directionality of the\n\
10191 plane is determined from the first three points. Additional points do\n\
10192 not have to lie on the plane defined by the first three, but if they\n\
10193 do not, then the determination of visibility obviously can\'t be 100%\n\
10194 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10195 consider breaking them into smaller polygons. 3 points define a plane\n\
10196 :-).\n\
10197\n\
10198 Bugs: If one of the first two segments is of zero length, or if they\n\
10199 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10200 being correct. Avoid such situations :-). See x18c.c for an example\n\
10201 of this problem. (Search for 20.1).\n\
10202\n\
10203 Redacted form: plpoly3(x, y, z, code)\n\
10204\n\
10205 This function is used in example 18.\n\
10206\n\
10207\n\
10208\n\
10209SYNOPSIS:\n\
10210\n\
10211plpoly3(n, x, y, z, draw, ifcc)\n\
10212\n\
10213ARGUMENTS:\n\
10214\n\
10215 n (PLINT, input) : Number of points defining line.\n\
10216\n\
10217 x (PLFLT_VECTOR, input) : A vector containing\n\
10218 n x coordinates of points.\n\
10219\n\
10220 y (PLFLT_VECTOR, input) : A vector containing\n\
10221 n y coordinates of points.\n\
10222\n\
10223 z (PLFLT_VECTOR, input) : A vector containing\n\
10224 n z coordinates of points.\n\
10225\n\
10226 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10227 n-1 Boolean values which control drawing the segments of the polygon.\n\
10228 If draw[i] is true, then the polygon segment from index [i] to\n\
10229 [i+1] is drawn, otherwise, not.\n\
10230\n\
10231 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10232 polygon is determined by assuming the points are laid out in a\n\
10233 counter-clockwise order. Otherwise, the directionality of the\n\
10234 polygon is determined by assuming the points are laid out in a\n\
10235 clockwise order.\n\
10236";
10237static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10238Magnitude colored plot surface with contour\n\
10239\n\
10240DESCRIPTION:\n\
10241\n\
10242 Aside from dropping the\n\
10243 side functionality this is a more powerful form of plot3d: the surface\n\
10244 mesh can be colored accordingly to the current z value being plotted,\n\
10245 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10246 drawn between the plotted function border and the base XY plane. The\n\
10247 arguments are identical to those of plmeshc. The only difference\n\
10248 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10249 the surface, while plot3dc only draws the surface as viewed from the\n\
10250 top.\n\
10251\n\
10252 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10253\n\
10254\n\
10255 This function is used in example 21.\n\
10256\n\
10257\n\
10258\n\
10259SYNOPSIS:\n\
10260\n\
10261plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10262\n\
10263ARGUMENTS:\n\
10264\n\
10265 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10266 which the function is evaluated.\n\
10267\n\
10268 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10269 which the function is evaluated.\n\
10270\n\
10271 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10272 plot. Should have dimensions of\n\
10273 nx by\n\
10274 ny.\n\
10275\n\
10276 nx (PLINT, input) : Number of x values at which function is\n\
10277 evaluated.\n\
10278\n\
10279 ny (PLINT, input) : Number of y values at which function is\n\
10280 evaluated.\n\
10281\n\
10282 opt (PLINT, input) : Determines the way in which the surface is\n\
10283 represented. To specify more than one option just add the options,\n\
10284 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10285 showing z as a function of x for each value of y[j] .\n\
10286 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10287 for each value of x[i] .\n\
10288 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10289 at which function is defined.\n\
10290 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10291 the z value being plotted. The color is used from the current\n\
10292 cmap1.\n\
10293 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10294 using parameters\n\
10295 nlevel and\n\
10296 clevel.\n\
10297 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10298 the borders of the plotted function.\n\
10299\n\
10300\n\
10301 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10302 levels.\n\
10303\n\
10304 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10305";
10306static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10307Create a 4-pen strip chart\n\
10308\n\
10309DESCRIPTION:\n\
10310\n\
10311 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10312\n\
10313 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10314 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10315 styline, legline, labx, laby, labz)\n\
10316\n\
10317\n\
10318 This function is used in example 17.\n\
10319\n\
10320\n\
10321\n\
10322SYNOPSIS:\n\
10323\n\
10324plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10325\n\
10326ARGUMENTS:\n\
10327\n\
10328 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10329 number of the strip chart to use on plstripa and plstripd.\n\
10330\n\
10331 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10332 the x-axis specification as in plbox.\n\
10333\n\
10334 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10335 the y-axis specification as in plbox.\n\
10336\n\
10337 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10338 change as data are added.\n\
10339\n\
10340 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10341 change as data are added.\n\
10342\n\
10343 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10344 is multiplied by the factor (1 +\n\
10345 xjump) .\n\
10346\n\
10347 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10348 change as data are added.\n\
10349\n\
10350 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10351 change as data are added.\n\
10352\n\
10353 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10354\n\
10355 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10356\n\
10357 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10358 true, otherwise not.\n\
10359\n\
10360 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10361 otherwise slide display.\n\
10362\n\
10363 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10364\n\
10365 collab (PLINT, input) : Legend color index (cmap0).\n\
10366\n\
10367 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10368 indices for the 4 pens.\n\
10369\n\
10370 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10371 indices for the 4 pens.\n\
10372\n\
10373 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10374 strings containing legends for the 4 pens.\n\
10375\n\
10376 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10377 the label for the x axis.\n\
10378\n\
10379 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10380 the label for the y axis.\n\
10381\n\
10382 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10383 the plot title.\n\
10384";
10385static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10386Deletes and releases memory used by a strip chart\n\
10387\n\
10388DESCRIPTION:\n\
10389\n\
10390 Deletes and releases memory used by a strip chart.\n\
10391\n\
10392 Redacted form: plstripd(id)\n\
10393\n\
10394 This function is used in example 17.\n\
10395\n\
10396\n\
10397\n\
10398SYNOPSIS:\n\
10399\n\
10400plstripd(id)\n\
10401\n\
10402ARGUMENTS:\n\
10403\n\
10404 id (PLINT, input) : Identification number of strip chart to delete.\n\
10405";
10406static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10407Set cmap1 colors using a piece-wise linear relationship\n\
10408\n\
10409DESCRIPTION:\n\
10410\n\
10411 Set cmap1 colors using a piece-wise linear relationship between the\n\
10412 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10413 (see the PLplot documentation). May be called at any time.\n\
10414\n\
10415 The idea here is to specify a number of control points that define the\n\
10416 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10417 these points, linear interpolation is used which gives a smooth\n\
10418 variation of color with intensity index. Any number of control points\n\
10419 may be specified, located at arbitrary positions, although typically 2\n\
10420 - 4 are enough. Another way of stating this is that we are traversing\n\
10421 a given number of lines through HLS or RGB space as we move through\n\
10422 cmap1 intensity indices. The control points at the minimum and\n\
10423 maximum position (0 and 1) must always be specified. By adding more\n\
10424 control points you can get more variation. One good technique for\n\
10425 plotting functions that vary about some expected average is to use an\n\
10426 additional 2 control points in the center (position ~= 0.5) that are\n\
10427 the same lightness as the background (typically white for paper\n\
10428 output, black for crt), and same hue as the boundary control points.\n\
10429 This allows the highs and lows to be very easily distinguished.\n\
10430\n\
10431 Each control point must specify the cmap1 intensity index and the\n\
10432 associated three coordinates in HLS or RGB space. The first point\n\
10433 must correspond to position = 0, and the last to position = 1.\n\
10434\n\
10435 If RGB colors are provided then the interpolation takes place in RGB\n\
10436 space and is trivial. However if HLS colors are provided then, because\n\
10437 of the circular nature of the color wheel for the hue coordinate, the\n\
10438 interpolation could be performed in either direction around the color\n\
10439 wheel. The default behaviour is for the hue to be linearly\n\
10440 interpolated ignoring this circular property of hue. So for example,\n\
10441 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10442 green and cyan. If instead you wish to interpolate the other way\n\
10443 around the color wheel you have two options. You may provide hues\n\
10444 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10445 for red the interpolation will proceed via magenta. Alternatively you\n\
10446 can utilise the alt_hue_path variable to reverse the direction of\n\
10447 interpolation if you need to provide hues within the [0-360) range.\n\
10448\n\
10449 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10450 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10451 -120]falsegreen-yellow-red-magenta-blue[240\n\
10452 480]falseblue-magenta-red-yellow-green[120\n\
10453 240]truegreen-yellow-red-magenta-blue[240\n\
10454 120]trueblue-magenta-red-yellow-green\n\
10455\n\
10456 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10457 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10458 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10459\n\
10460 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10461 alt_hue_path)\n\
10462\n\
10463 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10464\n\
10465\n\
10466\n\
10467SYNOPSIS:\n\
10468\n\
10469plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10470\n\
10471ARGUMENTS:\n\
10472\n\
10473 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10474\n\
10475 npts (PLINT, input) : number of control points\n\
10476\n\
10477 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10478 intensity index (0.0-1.0) in ascending order for each control\n\
10479 point.\n\
10480\n\
10481 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10482 coordinate (H or R) for each control point.\n\
10483\n\
10484 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10485 coordinate (L or G) for each control point.\n\
10486\n\
10487 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10488 coordinate (S or B) for each control point.\n\
10489\n\
10490 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10491 npts - 1 elements), each containing either true to use the reversed\n\
10492 HLS interpolation or false to use the regular HLS interpolation.\n\
10493 (alt_hue_path[i] refers to the interpolation interval between the\n\
10494 i and i + 1 control points). This parameter is not used for RGB\n\
10495 colors (\n\
10496 itype = true).\n\
10497";
10498static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10499Shade individual region on the basis of value\n\
10500\n\
10501DESCRIPTION:\n\
10502\n\
10503 Shade individual region on the basis of value. Use plshades if you\n\
10504 want to shade a number of contiguous regions using continuous colors.\n\
10505 In particular the edge contours are treated properly in plshades. If\n\
10506 you attempt to do contiguous regions with plshade the contours at the\n\
10507 edge of the shade are partially obliterated by subsequent plots of\n\
10508 contiguous shaded regions.\n\
10509\n\
10510 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10511 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10512 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10513\n\
10514\n\
10515 This function is used in example 15.\n\
10516\n\
10517\n\
10518\n\
10519SYNOPSIS:\n\
10520\n\
10521plshade(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\
10522\n\
10523ARGUMENTS:\n\
10524\n\
10525 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10526 plot. Should have dimensions of\n\
10527 nx by\n\
10528 ny.\n\
10529\n\
10530 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10531\n\
10532 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10533\n\
10534 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10535 the region that should be plotted in the shade plot. This\n\
10536 function accepts x and y coordinates as input arguments and must\n\
10537 return 1 if the point is to be included in the shade plot and 0\n\
10538 otherwise. If you want to plot the entire shade plot (the usual\n\
10539 case), this argument should be set to NULL.\n\
10540\n\
10541 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10542 pltr below for how these arguments are used (only for the special case\n\
10543 when the callback function\n\
10544 pltr is not supplied).\n\
10545\n\
10546 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10547 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10548\n\
10549 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10550 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10551\n\
10552 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10553 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10554 then sh_color is interpreted as a cmap1 argument in the range\n\
10555 (0.0-1.0).\n\
10556\n\
10557 sh_color (PLFLT, input) : Defines color map index with integer\n\
10558 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10559\n\
10560 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10561\n\
10562 min_color (PLINT, input) : Defines pen color, width used by the\n\
10563 boundary of shaded region. The min values are used for the\n\
10564 shade_min boundary, and the max values are used on the shade_max\n\
10565 boundary. Set color and width to zero for no plotted boundaries.\n\
10566\n\
10567 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10568 boundary of shaded region. The min values are used for the\n\
10569 shade_min boundary, and the max values are used on the shade_max\n\
10570 boundary. Set color and width to zero for no plotted boundaries.\n\
10571\n\
10572 max_color (PLINT, input) : Defines pen color, width used by the\n\
10573 boundary of shaded region. The min values are used for the\n\
10574 shade_min boundary, and the max values are used on the shade_max\n\
10575 boundary. Set color and width to zero for no plotted boundaries.\n\
10576\n\
10577 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10578 boundary of shaded region. The min values are used for the\n\
10579 shade_min boundary, and the max values are used on the shade_max\n\
10580 boundary. Set color and width to zero for no plotted boundaries.\n\
10581\n\
10582 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10583 Use plfill. Future version of PLplot may have other fill\n\
10584 routines.\n\
10585\n\
10586 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10587 map to rectangles after coordinate transformation with pltrl.\n\
10588 Otherwise, set rectangular to false. If rectangular is set to\n\
10589 true, plshade tries to save time by filling large rectangles.\n\
10590 This optimization fails if the coordinate transformation distorts\n\
10591 the shape of rectangles. For example a plot in polar coordinates\n\
10592 has to have rectangular set to false.\n\
10593\n\
10594 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10595 defines the transformation between the zero-based indices of the\n\
10596 matrix a and world coordinates. If\n\
10597 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10598 indices of a are mapped to the range\n\
10599 xmin through\n\
10600 xmax and the y indices of a are mapped to the range\n\
10601 ymin through\n\
10602 ymax.For the C case, transformation functions are provided in the\n\
10603 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10604 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10605 matrices. In addition, C callback routines for the transformation\n\
10606 can be supplied by the user such as the mypltr function in\n\
10607 examples/c/x09c.c which provides a general linear transformation\n\
10608 between index coordinates and world coordinates.For languages\n\
10609 other than C you should consult the PLplot documentation for the\n\
10610 details concerning how PLTRANSFORM_callback arguments are\n\
10611 interfaced. However, in general, a particular pattern of\n\
10612 callback-associated arguments such as a tr vector with 6 elements;\n\
10613 xg and yg vectors; or xg and yg matrices are respectively\n\
10614 interfaced to a linear-transformation routine similar to the above\n\
10615 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10616 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10617 support native language callbacks for handling index to\n\
10618 world-coordinate transformations. Examples of these various\n\
10619 approaches are given in examples/<language>x09*,\n\
10620 examples/<language>x16*, examples/<language>x20*,\n\
10621 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10622 supported languages.\n\
10623\n\
10624 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10625 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10626 externally supplied.\n\
10627";
10628static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10629Set number of colors in cmap1\n\
10630\n\
10631DESCRIPTION:\n\
10632\n\
10633 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10634 values if this is the first allocation (see the PLplot documentation).\n\
10635\n\
10636 Redacted form: plscmap1n(ncol1)\n\
10637\n\
10638 This function is used in examples 8, 11, 20, and 21.\n\
10639\n\
10640\n\
10641\n\
10642SYNOPSIS:\n\
10643\n\
10644plscmap1n(ncol1)\n\
10645\n\
10646ARGUMENTS:\n\
10647\n\
10648 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10649 the cmap1 palette. If this number is zero or less, then the value\n\
10650 from the previous call to plscmap1n is used and if there is no\n\
10651 previous call, then a default value is used.\n\
10652";
10653static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10654Advance to the next family file on the next new page\n\
10655\n\
10656DESCRIPTION:\n\
10657\n\
10658 Advance to the next family file on the next new page.\n\
10659\n\
10660 Redacted form: plfamadv()\n\
10661\n\
10662 This function is not used in any examples.\n\
10663\n\
10664\n\
10665\n\
10666SYNOPSIS:\n\
10667\n\
10668plfamadv()\n\
10669";
10670static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10671Set the escape character for text strings\n\
10672\n\
10673DESCRIPTION:\n\
10674\n\
10675 Set the escape character for text strings. From C (in contrast to\n\
10676 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10677 characters are allowed to prevent the user from shooting himself in\n\
10678 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10679 use of backslash as a character escape). Here are the allowed escape\n\
10680 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10681 #, ASCII 35\n\
10682 $, ASCII 36\n\
10683 %, ASCII 37\n\
10684 &, ASCII 38\n\
10685 *, ASCII 42\n\
10686 @, ASCII 64\n\
10687 ^, ASCII 94\n\
10688 ~, ASCII 126\n\
10689\n\
10690\n\
10691 Redacted form: General: plsesc(esc)\n\
10692\n\
10693\n\
10694 This function is used in example 29.\n\
10695\n\
10696\n\
10697\n\
10698SYNOPSIS:\n\
10699\n\
10700plsesc(esc)\n\
10701\n\
10702ARGUMENTS:\n\
10703\n\
10704 esc (char, input) : Escape character.\n\
10705";
10706static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10707Plot color bar for image, shade or gradient plots\n\
10708\n\
10709DESCRIPTION:\n\
10710\n\
10711 Routine for creating a continuous color bar for image, shade, or\n\
10712 gradient plots. (See pllegend for similar functionality for creating\n\
10713 legends with discrete elements). The arguments of plcolorbar provide\n\
10714 control over the location and size of the color bar as well as the\n\
10715 location and characteristics of the elements (most of which are\n\
10716 optional) within that color bar. The resulting color bar is clipped\n\
10717 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10718 system used for some of the parameters is defined in the documentation\n\
10719 of the position parameter.)\n\
10720\n\
10721 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10722 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10723 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10724 labels, axis_opts, ticks, sub_ticks, values)\n\
10725\n\
10726 This function is used in examples 16 and 33.\n\
10727\n\
10728\n\
10729\n\
10730SYNOPSIS:\n\
10731\n\
10732plcolorbar(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\
10733\n\
10734ARGUMENTS:\n\
10735\n\
10736 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10737 labelled and decorated color bar width in adopted coordinates.\n\
10738\n\
10739 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10740 labelled and decorated color bar height in adopted coordinates.\n\
10741\n\
10742 opt (PLINT, input) : opt contains bits controlling the overall\n\
10743 color bar. The orientation (direction of the maximum value) of\n\
10744 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10745 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10746 specified, the default orientation is toward the top if the\n\
10747 colorbar is placed on the left or right of the viewport or toward\n\
10748 the right if the colorbar is placed on the top or bottom of the\n\
10749 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10750 (semitransparent) background for the color bar. If the\n\
10751 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10752 color bar. The type of color bar must be specified with one of\n\
10753 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10754 more than one of those bits is set only the first one in the above\n\
10755 list is honored. The position of the (optional) label/title can be\n\
10756 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10757 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10758 will be drawn. If more than one of this list of bits is specified,\n\
10759 only the first one on the list is honored. End-caps for the color\n\
10760 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10761 If a particular color bar cap option is not specified then no cap\n\
10762 will be drawn for that end. As a special case for\n\
10763 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10764 specified. If this option is provided then any tick marks and tick\n\
10765 labels will be placed at the breaks between shaded segments. TODO:\n\
10766 This should be expanded to support custom placement of tick marks\n\
10767 and tick labels at custom value locations for any color bar type.\n\
10768\n\
10769 position (PLINT, input) : position contains bits which control the\n\
10770 overall position of the color bar and the definition of the\n\
10771 adopted coordinates used for positions just like what is done for\n\
10772 the position argument for pllegend. However, note that the\n\
10773 defaults for the position bits (see below) are different than the\n\
10774 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10775 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10776 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10777 the 16 possible standard positions (the 4 corners and centers of\n\
10778 the 4 sides for both the inside and outside cases) of the color\n\
10779 bar relative to the adopted coordinate system. The corner\n\
10780 positions are specified by the appropriate combination of two of\n\
10781 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10782 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10783 value of one of those bits. The adopted coordinates are\n\
10784 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10785 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10786 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10787 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10788 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10789 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10790 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10791 PL_POSITION_VIEWPORT.\n\
10792\n\
10793 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10794 coordinates from the specified standard position of the color bar.\n\
10795 For positive x, the direction of motion away from the standard\n\
10796 position is inward/outward from the standard corner positions or\n\
10797 standard left or right positions if the\n\
10798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10799 For the standard top or bottom positions, the direction of motion\n\
10800 is toward positive X.\n\
10801\n\
10802 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10803 coordinates from the specified standard position of the color bar.\n\
10804 For positive y, the direction of motion away from the standard\n\
10805 position is inward/outward from the standard corner positions or\n\
10806 standard top or bottom positions if the\n\
10807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10808 For the standard left or right positions, the direction of motion\n\
10809 is toward positive Y.\n\
10810\n\
10811 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10812 the X direction in adopted coordinates.\n\
10813\n\
10814 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10815 the Y direction in adopted coordinates.\n\
10816\n\
10817 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10818 color bar (PL_COLORBAR_BACKGROUND).\n\
10819\n\
10820 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10821 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10822\n\
10823 bb_style (PLINT, input) : The pllsty style number for the\n\
10824 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10825\n\
10826 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10827 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10828\n\
10829 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10830 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10831\n\
10832 cont_color (PLINT, input) : The cmap0 contour color for\n\
10833 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10834 it will be interpreted according to the design of plshades.\n\
10835\n\
10836 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10837 plots. This is passed directly to plshades, so it will be\n\
10838 interpreted according to the design of plshades.\n\
10839\n\
10840 n_labels (PLINT, input) : Number of labels to place around the\n\
10841 color bar.\n\
10842\n\
10843 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10844 n_labels labels.\n\
10845\n\
10846 labels (PLCHAR_MATRIX, input) : A vector of\n\
10847 n_labels UTF-8 character strings containing the labels for the color\n\
10848 bar. Ignored if no label position is specified with one of the\n\
10849 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10850 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10851 corresponding label_opts field.\n\
10852\n\
10853 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10854 value must be greater than 0. It is typically 1 (numerical axis\n\
10855 labels are provided for one of the long edges of the color bar),\n\
10856 but it can be larger if multiple numerical axis labels for the\n\
10857 long edges of the color bar are desired.\n\
10858\n\
10859 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10860 n_axes ascii character strings containing options (interpreted as for\n\
10861 plbox) for the color bar\'s axis definitions.\n\
10862\n\
10863 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10864 spacing of the major tick marks (interpreted as for plbox) for the\n\
10865 color bar\'s axis definitions.\n\
10866\n\
10867 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10868 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10869 axis definitions.\n\
10870\n\
10871 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10872 elements in each of the n_axes rows of the values matrix.\n\
10873\n\
10874 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10875 values for the data range represented by the color bar. For a row\n\
10876 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10877 elements in the row is specified by n_values[i_axis]. For\n\
10878 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10879 is 2, and the corresponding row elements of the values matrix are\n\
10880 the minimum and maximum value represented by the colorbar. For\n\
10881 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10882 of the values matrix is interpreted the same as the nlevel and\n\
10883 clevel arguments of plshades.\n\
10884";
10885static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10886Set current output stream\n\
10887\n\
10888DESCRIPTION:\n\
10889\n\
10890 Sets the number of the current output stream. The stream number\n\
10891 defaults to 0 unless changed by this routine. The first use of this\n\
10892 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10893\n\
10894 Redacted form: plsstrm(strm)\n\
10895\n\
10896 This function is examples 1,14,20.\n\
10897\n\
10898\n\
10899\n\
10900SYNOPSIS:\n\
10901\n\
10902plsstrm(strm)\n\
10903\n\
10904ARGUMENTS:\n\
10905\n\
10906 strm (PLINT, input) : The current stream number.\n\
10907";
10908static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10909Get the current device-compression setting\n\
10910\n\
10911DESCRIPTION:\n\
10912\n\
10913 Get the current device-compression setting. This parameter is only\n\
10914 used for drivers that provide compression.\n\
10915\n\
10916 Redacted form: plgcompression(compression)\n\
10917\n\
10918 This function is used in example 31.\n\
10919\n\
10920\n\
10921\n\
10922SYNOPSIS:\n\
10923\n\
10924plgcompression(compression)\n\
10925\n\
10926ARGUMENTS:\n\
10927\n\
10928 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10929 compression setting for the current device.\n\
10930";
10931static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10932Grid data from irregularly sampled data\n\
10933\n\
10934DESCRIPTION:\n\
10935\n\
10936 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10937 require data organized as a grid, i.e., with x sample point values\n\
10938 independent of y coordinate and vice versa. This function takes\n\
10939 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10940 vectors; reads the desired grid location from the input vectors\n\
10941 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10942 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10943 interpolate the data to the grid is specified with the argument type\n\
10944 which can have one parameter specified in argument data.\n\
10945\n\
10946 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10947 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10948\n\
10949\n\
10950 This function is used in example 21.\n\
10951\n\
10952\n\
10953\n\
10954SYNOPSIS:\n\
10955\n\
10956plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10957\n\
10958ARGUMENTS:\n\
10959\n\
10960 x (PLFLT_VECTOR, input) : The input x vector.\n\
10961\n\
10962 y (PLFLT_VECTOR, input) : The input y vector.\n\
10963\n\
10964 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10965 y[i], z[i] represents one data sample coordinate.\n\
10966\n\
10967 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10968 vectors.\n\
10969\n\
10970 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10971 in the x direction. Usually xg has nptsx equally spaced values\n\
10972 from the minimum to the maximum values of the x input vector.\n\
10973\n\
10974 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10975\n\
10976 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10977 in the y direction. Similar to the xg parameter.\n\
10978\n\
10979 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10980\n\
10981 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10982 where data lies in the grid specified by xg and yg. Therefore the\n\
10983 zg matrix must be dimensioned\n\
10984 nptsx by\n\
10985 nptsy.\n\
10986\n\
10987 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10988 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10989 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10990 GRID_NNI: Natural Neighbors Interpolation\n\
10991 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10992 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10993 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10994 Weighted\n\
10995 For details of the algorithms read the source file plgridd.c.\n\
10996\n\
10997 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10998 which can be specified through this argument. Currently, for\n\
10999 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11000 use, the lower the value, the noisier (more local) the\n\
11001 approximation is.\n\
11002 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11003 range [1. .. 2.]. High values enable the usage of very thin\n\
11004 triangles for interpolation, possibly resulting in error in\n\
11005 the approximation.\n\
11006 GRID_NNI, only weights greater than data will be accepted. If\n\
11007 0, all weights will be accepted.\n\
11008";
11009
11010SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
11011 PLINT arg1 ;
11012 PLINT *arg2 = (PLINT *) 0 ;
11013 char **arg3 = (char **) 0 ;
11014 Matrix temp1 ;
11015 octave_value_list _out;
11016 octave_value_list *_outp=&_out;
11017 octave_value _outv;
11018
11019 try {
11020 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
11021 SWIG_fail;
11022 }
11023 {
11024 if ( _n_dims( args(0) ) > 1 )
11025 {
11026 error( "argument must be a scalar or vector" ); SWIG_fail;
11027 }
11028 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
11029 arg2 = new PLINT[Alen];
11030 temp1 = args(0).matrix_value();
11031 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
11032 }
11033 {
11034 charMatrix temp_matrix;
11035 Cell temp_cell;
11036 char *tmp_cstring;
11037 std::string str;
11038 size_t max_length = 0, non_blank_length;
11039 int i, ifcell;
11040 if ( _n_dims( args(1) ) > 2 )
11041 {
11042 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11043 }
11044#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11045 if ( !args(1).isempty() )
11046#else
11047 if ( !args(1).is_empty() )
11048#endif
11049 {
11050 if ( _dim( args(1), 0 ) != Alen )
11051 {
11052 error( "first dimension must be same length as previous vector" ); SWIG_fail;
11053 }
11054 arg3 = new char*[Alen];
11055#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11056 ifcell = args(1).iscell();
11057#else
11058 ifcell = args(1).is_cell();
11059#endif
11060 if ( ifcell )
11061 {
11062 temp_cell = args(1).cell_value();
11063 }
11064 else
11065 {
11066 temp_matrix = args(1).char_matrix_value();
11067 // Allow one extra space for null termination.
11068 max_length = _dim( args(1), 1 ) + 1;
11069 }
11070
11071 for ( i = 0; i < Alen; i++ )
11072 {
11073 // Must copy string to "permanent" location because the string
11074 // location corresponding to tmp_cstring gets
11075 // overwritten for each iteration of loop.
11076 if ( ifcell )
11077 {
11078 if ( temp_cell.elem( i ).is_string() )
11079 {
11080 str = temp_cell.elem( i ).string_value();
11081 // leave room for null termination.
11082 max_length = str.size() + 1;
11083 tmp_cstring = (char *) str.c_str();
11084 }
11085 else
11086 {
11087 // Use null string if user attempts to pass a cell array
11088 // with a non-string element (likely an empty element
11089 // since that should be allowed by the PLplot interface
11090 // if that element is going to be unused).
11091 // leave room for null termination.
11092 max_length = 1;
11093 tmp_cstring = (char *) "";
11094 }
11095 }
11096 else
11097 {
11098 str = temp_matrix.row_as_string( i );
11099 tmp_cstring = (char *) str.c_str();
11100 }
11101 arg3[i] = new char[max_length];
11102 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11103 arg3[i][max_length - 1] = '\0';
11104 // All the trailing blank crapola should not be needed for
11105 // string cell arrays.
11106 if ( !ifcell )
11107 {
11108 // remove trailing-blank padding that is used by the
11109 // charMatrix class to insure all strings in a given
11110 // charMatrix instance have the same length.
11111 // This transformation also removes legitimate trailing
11112 // blanks but there is nothing we can do about that
11113 // for the charMatrix class.
11114
11115 // Look for trailing nulls first (just in case, although that
11116 // shouldn't happen if charMatrix implemented as documented)
11117 // before looking for trailing blanks.
11118 non_blank_length = max_length - 2;
11119 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11120 {
11121 non_blank_length--;
11122 }
11123 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11124 {
11125 non_blank_length--;
11126 }
11127 arg3[i][non_blank_length + 1] = '\0';
11128 }
11129 }
11130 }
11131 else
11132 {
11133 arg3 = NULL;
11134 }
11135 }
11136 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11137 _outv = octave_value();
11138 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11139 {
11140 delete [] arg2;
11141 }
11142 {
11143 int i;
11144 if ( arg3 != NULL )
11145 {
11146 for ( i = 0; i < Alen; i++ )
11147 {
11148 delete[] arg3[i];
11149 }
11150 delete[] arg3;
11151 }
11152 }
11153 return _out;
11154 fail:
11155 {
11156 delete [] arg2;
11157 }
11158 {
11159 int i;
11160 if ( arg3 != NULL )
11161 {
11162 for ( i = 0; i < Alen; i++ )
11163 {
11164 delete[] arg3[i];
11165 }
11166 delete[] arg3;
11167 }
11168 }
11169 return octave_value_list();
11170 }
11171 catch(...) {
11172 {
11173 delete [] arg2;
11174 }
11175 {
11176 int i;
11177 if ( arg3 != NULL )
11178 {
11179 for ( i = 0; i < Alen; i++ )
11180 {
11181 delete[] arg3[i];
11182 }
11183 delete[] arg3;
11184 }
11185 }
11186 throw;
11187 }
11188}
11189
11190
11192 int *arg1 = (int *) 0 ;
11193 int *arg2 = (int *) 0 ;
11194 int *arg3 = (int *) 0 ;
11195 char *arg4 = (char *) 0 ;
11196 int *arg5 = (int *) 0 ;
11197 int *arg6 = (int *) 0 ;
11198 PLFLT *arg7 = (PLFLT *) 0 ;
11199 PLFLT *arg8 = (PLFLT *) 0 ;
11200 PLFLT *arg9 = (PLFLT *) 0 ;
11201 PLFLT *arg10 = (PLFLT *) 0 ;
11202 int *arg11 = (int *) 0 ;
11203 int temp1 ;
11204 int res1 = SWIG_TMPOBJ ;
11205 int temp2 ;
11206 int res2 = SWIG_TMPOBJ ;
11207 int temp3 ;
11208 int res3 = SWIG_TMPOBJ ;
11209 char local_string4[80] ;
11210 int temp5 ;
11211 int res5 = SWIG_TMPOBJ ;
11212 int temp6 ;
11213 int res6 = SWIG_TMPOBJ ;
11214 PLFLT temp7 ;
11215 int res7 = SWIG_TMPOBJ ;
11216 PLFLT temp8 ;
11217 int res8 = SWIG_TMPOBJ ;
11218 PLFLT temp9 ;
11219 int res9 = SWIG_TMPOBJ ;
11220 PLFLT temp10 ;
11221 int res10 = SWIG_TMPOBJ ;
11222 int temp11 ;
11223 int res11 = SWIG_TMPOBJ ;
11224 size_t local_string_length4 ;
11225 charMatrix local_charMatrix4 ;
11226 octave_value_list retval4 ;
11227 octave_value_list _out;
11228 octave_value_list *_outp=&_out;
11229 octave_value _outv;
11230 int result;
11231
11232 try {
11233 arg1 = &temp1;
11234 arg2 = &temp2;
11235 arg3 = &temp3;
11236 {
11237 arg4 = local_string4;
11238 }
11239 arg5 = &temp5;
11240 arg6 = &temp6;
11241 arg7 = &temp7;
11242 arg8 = &temp8;
11243 arg9 = &temp9;
11244 arg10 = &temp10;
11245 arg11 = &temp11;
11246 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11247 SWIG_fail;
11248 }
11249 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11250 _outv = SWIG_From_int(static_cast< int >(result));
11251 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11252 if (SWIG_IsTmpObj(res1)) {
11253 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11254 } else {
11255 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11256 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11257 }
11258 if (SWIG_IsTmpObj(res2)) {
11259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11260 } else {
11261 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11262 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11263 }
11264 if (SWIG_IsTmpObj(res3)) {
11265 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11266 } else {
11267 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11268 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11269 }
11270 {
11271 local_string_length4 = strlen( local_string4 );
11272 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11273 local_charMatrix4.insert( local_string4, 0, 0 );
11274 retval4( 0 ) = octave_value( local_charMatrix4 );
11275 _outp = SWIG_Octave_AppendOutput(_outp, retval4( 0 ));
11276 }
11277 if (SWIG_IsTmpObj(res5)) {
11278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11279 } else {
11280 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11282 }
11283 if (SWIG_IsTmpObj(res6)) {
11284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11285 } else {
11286 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11288 }
11289 if (SWIG_IsTmpObj(res7)) {
11290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11291 } else {
11292 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11294 }
11295 if (SWIG_IsTmpObj(res8)) {
11296 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11297 } else {
11298 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11299 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11300 }
11301 if (SWIG_IsTmpObj(res9)) {
11302 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11303 } else {
11304 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11305 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11306 }
11307 if (SWIG_IsTmpObj(res10)) {
11308 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11309 } else {
11310 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11311 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11312 }
11313 if (SWIG_IsTmpObj(res11)) {
11314 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11315 } else {
11316 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11317 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11318 }
11319 return _out;
11320 fail:
11321 return octave_value_list();
11322 }
11323 catch(...) {
11324 throw;
11325 }
11326}
11327
11328
11329SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11330 PLFLT *arg1 = (PLFLT *) 0 ;
11331 PLFLT *arg2 = (PLFLT *) 0 ;
11332 PLFLT arg3 ;
11333 PLFLT arg4 ;
11334 PLFLT temp1 ;
11335 int res1 = SWIG_TMPOBJ ;
11336 PLFLT temp2 ;
11337 int res2 = SWIG_TMPOBJ ;
11338 double val3 ;
11339 int ecode3 = 0 ;
11340 double val4 ;
11341 int ecode4 = 0 ;
11342 octave_value_list _out;
11343 octave_value_list *_outp=&_out;
11344 octave_value _outv;
11345 int result;
11346
11347 try {
11348 arg1 = &temp1;
11349 arg2 = &temp2;
11350 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11351 SWIG_fail;
11352 }
11353 ecode3 = SWIG_AsVal_double(args(0), &val3);
11354 if (!SWIG_IsOK(ecode3)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11356 }
11357 arg3 = static_cast< PLFLT >(val3);
11358 ecode4 = SWIG_AsVal_double(args(1), &val4);
11359 if (!SWIG_IsOK(ecode4)) {
11360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11361 }
11362 arg4 = static_cast< PLFLT >(val4);
11363 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11364 _outv = SWIG_From_int(static_cast< int >(result));
11365 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11366 if (SWIG_IsTmpObj(res1)) {
11367 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11368 } else {
11369 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11370 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11371 }
11372 if (SWIG_IsTmpObj(res2)) {
11373 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11374 } else {
11375 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11376 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11377 }
11378 return _out;
11379 fail:
11380 return octave_value_list();
11381 }
11382 catch(...) {
11383 throw;
11384 }
11385}
11386
11387
11389 PLINT *arg1 = (PLINT *) 0 ;
11390 char *arg2 = (char *) 0 ;
11391 char *arg3 = (char *) 0 ;
11392 PLFLT arg4 ;
11393 PLFLT arg5 ;
11394 PLFLT arg6 ;
11395 PLFLT arg7 ;
11396 PLFLT arg8 ;
11397 PLFLT arg9 ;
11398 PLFLT arg10 ;
11399 PLBOOL arg11 ;
11400 PLBOOL arg12 ;
11401 PLINT arg13 ;
11402 PLINT arg14 ;
11403 PLINT *arg15 = (PLINT *) 0 ;
11404 PLINT *arg16 = (PLINT *) 0 ;
11405 char *arg17 = (char *) 0 ;
11406 char *arg18 = (char *) 0 ;
11407 char *arg19 = (char *) 0 ;
11408 char *arg20 = (char *) 0 ;
11409 char *arg21 = (char *) 0 ;
11410 char *arg22 = (char *) 0 ;
11411 char *arg23 = (char *) 0 ;
11412 PLINT temp1 ;
11413 int res1 = SWIG_TMPOBJ ;
11414 int res2 ;
11415 char *buf2 = 0 ;
11416 int alloc2 = 0 ;
11417 int res3 ;
11418 char *buf3 = 0 ;
11419 int alloc3 = 0 ;
11420 double val4 ;
11421 int ecode4 = 0 ;
11422 double val5 ;
11423 int ecode5 = 0 ;
11424 double val6 ;
11425 int ecode6 = 0 ;
11426 double val7 ;
11427 int ecode7 = 0 ;
11428 double val8 ;
11429 int ecode8 = 0 ;
11430 double val9 ;
11431 int ecode9 = 0 ;
11432 double val10 ;
11433 int ecode10 = 0 ;
11434 int val11 ;
11435 int ecode11 = 0 ;
11436 int val12 ;
11437 int ecode12 = 0 ;
11438 int val13 ;
11439 int ecode13 = 0 ;
11440 int val14 ;
11441 int ecode14 = 0 ;
11442 Matrix temp15 ;
11443 Matrix temp16 ;
11444 int res17 ;
11445 char *buf17 = 0 ;
11446 int alloc17 = 0 ;
11447 int res18 ;
11448 char *buf18 = 0 ;
11449 int alloc18 = 0 ;
11450 int res19 ;
11451 char *buf19 = 0 ;
11452 int alloc19 = 0 ;
11453 int res20 ;
11454 char *buf20 = 0 ;
11455 int alloc20 = 0 ;
11456 int res21 ;
11457 char *buf21 = 0 ;
11458 int alloc21 = 0 ;
11459 int res22 ;
11460 char *buf22 = 0 ;
11461 int alloc22 = 0 ;
11462 int res23 ;
11463 char *buf23 = 0 ;
11464 int alloc23 = 0 ;
11465 octave_value_list _out;
11466 octave_value_list *_outp=&_out;
11467 octave_value _outv;
11468
11469 try {
11470 arg1 = &temp1;
11471 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11472 SWIG_fail;
11473 }
11474 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11475 if (!SWIG_IsOK(res2)) {
11476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11477 }
11478 arg2 = reinterpret_cast< char * >(buf2);
11479 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11480 if (!SWIG_IsOK(res3)) {
11481 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11482 }
11483 arg3 = reinterpret_cast< char * >(buf3);
11484 ecode4 = SWIG_AsVal_double(args(2), &val4);
11485 if (!SWIG_IsOK(ecode4)) {
11486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11487 }
11488 arg4 = static_cast< PLFLT >(val4);
11489 ecode5 = SWIG_AsVal_double(args(3), &val5);
11490 if (!SWIG_IsOK(ecode5)) {
11491 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11492 }
11493 arg5 = static_cast< PLFLT >(val5);
11494 ecode6 = SWIG_AsVal_double(args(4), &val6);
11495 if (!SWIG_IsOK(ecode6)) {
11496 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11497 }
11498 arg6 = static_cast< PLFLT >(val6);
11499 ecode7 = SWIG_AsVal_double(args(5), &val7);
11500 if (!SWIG_IsOK(ecode7)) {
11501 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11502 }
11503 arg7 = static_cast< PLFLT >(val7);
11504 ecode8 = SWIG_AsVal_double(args(6), &val8);
11505 if (!SWIG_IsOK(ecode8)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11507 }
11508 arg8 = static_cast< PLFLT >(val8);
11509 ecode9 = SWIG_AsVal_double(args(7), &val9);
11510 if (!SWIG_IsOK(ecode9)) {
11511 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11512 }
11513 arg9 = static_cast< PLFLT >(val9);
11514 ecode10 = SWIG_AsVal_double(args(8), &val10);
11515 if (!SWIG_IsOK(ecode10)) {
11516 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11517 }
11518 arg10 = static_cast< PLFLT >(val10);
11519 ecode11 = SWIG_AsVal_int(args(9), &val11);
11520 if (!SWIG_IsOK(ecode11)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11522 }
11523 arg11 = static_cast< PLBOOL >(val11);
11524 ecode12 = SWIG_AsVal_int(args(10), &val12);
11525 if (!SWIG_IsOK(ecode12)) {
11526 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11527 }
11528 arg12 = static_cast< PLBOOL >(val12);
11529 ecode13 = SWIG_AsVal_int(args(11), &val13);
11530 if (!SWIG_IsOK(ecode13)) {
11531 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11532 }
11533 arg13 = static_cast< PLINT >(val13);
11534 ecode14 = SWIG_AsVal_int(args(12), &val14);
11535 if (!SWIG_IsOK(ecode14)) {
11536 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11537 }
11538 arg14 = static_cast< PLINT >(val14);
11539 {
11540 if ( _n_dims( args(13) ) > 1 )
11541 {
11542 error( "argument must be a scalar or vector" ); SWIG_fail;
11543 }
11544 Alen = (PLINT) ( _dim( args(13), 0 ) );
11545 temp15 = args(13).matrix_value();
11546 arg15 = new PLINT[Alen];
11547 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11548 }
11549 {
11550 if ( _n_dims( args(14) ) > 1 )
11551 {
11552 error( "argument must be a scalar or vector" ); SWIG_fail;
11553 }
11554 if ( _dim( args(14), 0 ) != Alen )
11555 {
11556 error( "argument vectors must be same length" ); SWIG_fail;
11557 }
11558 temp16 = args(14).matrix_value();
11559 arg16 = new PLINT[Alen];
11560 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11561 }
11562 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11563 if (!SWIG_IsOK(res17)) {
11564 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11565 }
11566 arg17 = reinterpret_cast< char * >(buf17);
11567 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11568 if (!SWIG_IsOK(res18)) {
11569 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11570 }
11571 arg18 = reinterpret_cast< char * >(buf18);
11572 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11573 if (!SWIG_IsOK(res19)) {
11574 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11575 }
11576 arg19 = reinterpret_cast< char * >(buf19);
11577 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11578 if (!SWIG_IsOK(res20)) {
11579 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11580 }
11581 arg20 = reinterpret_cast< char * >(buf20);
11582 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11583 if (!SWIG_IsOK(res21)) {
11584 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11585 }
11586 arg21 = reinterpret_cast< char * >(buf21);
11587 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11588 if (!SWIG_IsOK(res22)) {
11589 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11590 }
11591 arg22 = reinterpret_cast< char * >(buf22);
11592 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11593 if (!SWIG_IsOK(res23)) {
11594 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11595 }
11596 arg23 = reinterpret_cast< char * >(buf23);
11597 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);
11598 _outv = octave_value();
11599 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11600 if (SWIG_IsTmpObj(res1)) {
11601 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11602 } else {
11603 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11604 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11605 }
11606 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11607 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11608 {
11609 delete [] arg15;
11610 }
11611 {
11612 delete [] arg16;
11613 }
11614 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11615 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11616 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11617 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11618 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11619 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11620 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11621 return _out;
11622 fail:
11623 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11624 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11625 {
11626 delete [] arg15;
11627 }
11628 {
11629 delete [] arg16;
11630 }
11631 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11632 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11633 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11634 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11635 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11636 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11637 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11638 return octave_value_list();
11639 }
11640 catch(...) {
11641 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11642 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11643 {
11644 delete [] arg15;
11645 }
11646 {
11647 delete [] arg16;
11648 }
11649 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11650 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11651 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11652 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11653 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11654 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11655 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11656 throw;
11657 }
11658}
11659
11660
11662 PLFLT *arg1 = (PLFLT *) 0 ;
11663 PLINT arg2 ;
11664 PLINT arg3 ;
11665 PLINT arg4 ;
11666 PLINT arg5 ;
11667 PLINT arg6 ;
11668 PLINT arg7 ;
11669 PLFLT *arg8 = (PLFLT *) 0 ;
11670 PLINT arg9 ;
11671 PLFLT *arg10 = (PLFLT *) 0 ;
11672 Matrix temp1 ;
11673 int val4 ;
11674 int ecode4 = 0 ;
11675 int val5 ;
11676 int ecode5 = 0 ;
11677 int val6 ;
11678 int ecode6 = 0 ;
11679 int val7 ;
11680 int ecode7 = 0 ;
11681 Matrix temp8 ;
11682 Matrix temp10 ;
11683 octave_value_list _out;
11684 octave_value_list *_outp=&_out;
11685 octave_value _outv;
11686
11687 try {
11688 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11689 SWIG_fail;
11690 }
11691 {
11692 if ( _n_dims( args(0) ) > 2 )
11693 {
11694 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11695 }
11696 temp1 = args(0).matrix_value();
11697 arg1 = &temp1( 0, 0 );
11698 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11699 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11700 }
11701 ecode4 = SWIG_AsVal_int(args(1), &val4);
11702 if (!SWIG_IsOK(ecode4)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11704 }
11705 arg4 = static_cast< PLINT >(val4);
11706 ecode5 = SWIG_AsVal_int(args(2), &val5);
11707 if (!SWIG_IsOK(ecode5)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11709 }
11710 arg5 = static_cast< PLINT >(val5);
11711 ecode6 = SWIG_AsVal_int(args(3), &val6);
11712 if (!SWIG_IsOK(ecode6)) {
11713 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11714 }
11715 arg6 = static_cast< PLINT >(val6);
11716 ecode7 = SWIG_AsVal_int(args(4), &val7);
11717 if (!SWIG_IsOK(ecode7)) {
11718 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11719 }
11720 arg7 = static_cast< PLINT >(val7);
11721 {
11722 if ( _n_dims( args(5) ) > 1 )
11723 {
11724 error( "argument must be a scalar or vector" ); SWIG_fail;
11725 }
11726 temp8 = args(5).matrix_value();
11727 arg8 = &temp8( 0, 0 );
11728 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11729 }
11730 {
11731 if ( _n_dims( args(6) ) > 1 )
11732 {
11733 error( "argument must be a scalar or vector" ); SWIG_fail;
11734 }
11735 if ( _dim( args(6), 0 ) != 6 )
11736 {
11737 error( "argument vectors must have length of 6" ); SWIG_fail;
11738 }
11739 temp10 = args(6).matrix_value();
11740 arg10 = &temp10( 0, 0 );
11741 }
11742 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11743 _outv = octave_value();
11744 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11745 {
11746
11747 }
11748 {
11749
11750 }
11751 {
11752
11753 }
11754 return _out;
11755 fail:
11756 {
11757
11758 }
11759 {
11760
11761 }
11762 {
11763
11764 }
11765 return octave_value_list();
11766 }
11767 catch(...) {
11768 {
11769
11770 }
11771 {
11772
11773 }
11774 {
11775
11776 }
11777 throw;
11778 }
11779}
11780
11781
11782SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11783 PLFLT *arg1 = (PLFLT *) 0 ;
11784 PLINT arg2 ;
11785 PLINT arg3 ;
11786 PLINT arg4 ;
11787 PLINT arg5 ;
11788 PLINT arg6 ;
11789 PLINT arg7 ;
11790 PLFLT *arg8 = (PLFLT *) 0 ;
11791 PLINT arg9 ;
11792 Matrix temp1 ;
11793 int val4 ;
11794 int ecode4 = 0 ;
11795 int val5 ;
11796 int ecode5 = 0 ;
11797 int val6 ;
11798 int ecode6 = 0 ;
11799 int val7 ;
11800 int ecode7 = 0 ;
11801 Matrix temp8 ;
11802 octave_value_list _out;
11803 octave_value_list *_outp=&_out;
11804 octave_value _outv;
11805
11806 try {
11807 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11808 SWIG_fail;
11809 }
11810 {
11811 if ( _n_dims( args(0) ) > 2 )
11812 {
11813 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11814 }
11815 temp1 = args(0).matrix_value();
11816 arg1 = &temp1( 0, 0 );
11817 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11818 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11819 }
11820 ecode4 = SWIG_AsVal_int(args(1), &val4);
11821 if (!SWIG_IsOK(ecode4)) {
11822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11823 }
11824 arg4 = static_cast< PLINT >(val4);
11825 ecode5 = SWIG_AsVal_int(args(2), &val5);
11826 if (!SWIG_IsOK(ecode5)) {
11827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11828 }
11829 arg5 = static_cast< PLINT >(val5);
11830 ecode6 = SWIG_AsVal_int(args(3), &val6);
11831 if (!SWIG_IsOK(ecode6)) {
11832 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11833 }
11834 arg6 = static_cast< PLINT >(val6);
11835 ecode7 = SWIG_AsVal_int(args(4), &val7);
11836 if (!SWIG_IsOK(ecode7)) {
11837 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11838 }
11839 arg7 = static_cast< PLINT >(val7);
11840 {
11841 if ( _n_dims( args(5) ) > 1 )
11842 {
11843 error( "argument must be a scalar or vector" ); SWIG_fail;
11844 }
11845 temp8 = args(5).matrix_value();
11846 arg8 = &temp8( 0, 0 );
11847 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11848 }
11849 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11850 _outv = octave_value();
11851 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11852 {
11853
11854 }
11855 {
11856
11857 }
11858 return _out;
11859 fail:
11860 {
11861
11862 }
11863 {
11864
11865 }
11866 return octave_value_list();
11867 }
11868 catch(...) {
11869 {
11870
11871 }
11872 {
11873
11874 }
11875 throw;
11876 }
11877}
11878
11879
11880SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11881 PLFLT *arg1 = (PLFLT *) 0 ;
11882 PLINT arg2 ;
11883 PLINT arg3 ;
11884 PLINT arg4 ;
11885 PLINT arg5 ;
11886 PLINT arg6 ;
11887 PLINT arg7 ;
11888 PLFLT *arg8 = (PLFLT *) 0 ;
11889 PLINT arg9 ;
11890 PLFLT *arg10 = (PLFLT *) 0 ;
11891 PLFLT *arg11 = (PLFLT *) 0 ;
11892 Matrix temp1 ;
11893 int val4 ;
11894 int ecode4 = 0 ;
11895 int val5 ;
11896 int ecode5 = 0 ;
11897 int val6 ;
11898 int ecode6 = 0 ;
11899 int val7 ;
11900 int ecode7 = 0 ;
11901 Matrix temp8 ;
11902 Matrix temp10 ;
11903 Matrix temp11 ;
11904 octave_value_list _out;
11905 octave_value_list *_outp=&_out;
11906 octave_value _outv;
11907
11908 try {
11909 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11910 SWIG_fail;
11911 }
11912 {
11913 if ( _n_dims( args(0) ) > 2 )
11914 {
11915 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11916 }
11917 temp1 = args(0).matrix_value();
11918 arg1 = &temp1( 0, 0 );
11919 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11920 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11921 }
11922 ecode4 = SWIG_AsVal_int(args(1), &val4);
11923 if (!SWIG_IsOK(ecode4)) {
11924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11925 }
11926 arg4 = static_cast< PLINT >(val4);
11927 ecode5 = SWIG_AsVal_int(args(2), &val5);
11928 if (!SWIG_IsOK(ecode5)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11930 }
11931 arg5 = static_cast< PLINT >(val5);
11932 ecode6 = SWIG_AsVal_int(args(3), &val6);
11933 if (!SWIG_IsOK(ecode6)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11935 }
11936 arg6 = static_cast< PLINT >(val6);
11937 ecode7 = SWIG_AsVal_int(args(4), &val7);
11938 if (!SWIG_IsOK(ecode7)) {
11939 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11940 }
11941 arg7 = static_cast< PLINT >(val7);
11942 {
11943 if ( _n_dims( args(5) ) > 1 )
11944 {
11945 error( "argument must be a scalar or vector" ); SWIG_fail;
11946 }
11947 temp8 = args(5).matrix_value();
11948 arg8 = &temp8( 0, 0 );
11949 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11950 }
11951 {
11952 if ( _n_dims( args(6) ) > 1 )
11953 {
11954 error( "argument must be a scalar or vector" ); SWIG_fail;
11955 }
11956 if ( _dim( args(6), 0 ) != Xlen )
11957 {
11958 error( "argument vectors must be same length" ); SWIG_fail;
11959 }
11960 temp10 = args(6).matrix_value();
11961 arg10 = &temp10( 0, 0 );
11962 }
11963 {
11964 if ( _n_dims( args(7) ) > 1 )
11965 {
11966 error( "argument must be a scalar or vector" ); SWIG_fail;
11967 }
11968 if ( _dim( args(7), 0 ) != Ylen )
11969 {
11970 error( "argument vectors must be same length" ); SWIG_fail;
11971 }
11972 temp11 = args(7).matrix_value();
11973 arg11 = &temp11( 0, 0 );
11974 }
11975 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11976 _outv = octave_value();
11977 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11978 {
11979
11980 }
11981 {
11982
11983 }
11984 {
11985
11986 }
11987 {
11988
11989 }
11990 return _out;
11991 fail:
11992 {
11993
11994 }
11995 {
11996
11997 }
11998 {
11999
12000 }
12001 {
12002
12003 }
12004 return octave_value_list();
12005 }
12006 catch(...) {
12007 {
12008
12009 }
12010 {
12011
12012 }
12013 {
12014
12015 }
12016 {
12017
12018 }
12019 throw;
12020 }
12021}
12022
12023
12024SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
12025 PLFLT *arg1 = (PLFLT *) 0 ;
12026 PLINT arg2 ;
12027 PLINT arg3 ;
12028 PLINT arg4 ;
12029 PLINT arg5 ;
12030 PLINT arg6 ;
12031 PLINT arg7 ;
12032 PLFLT *arg8 = (PLFLT *) 0 ;
12033 PLINT arg9 ;
12034 PLFLT *arg10 = (PLFLT *) 0 ;
12035 PLFLT *arg11 = (PLFLT *) 0 ;
12036 Matrix temp1 ;
12037 int val4 ;
12038 int ecode4 = 0 ;
12039 int val5 ;
12040 int ecode5 = 0 ;
12041 int val6 ;
12042 int ecode6 = 0 ;
12043 int val7 ;
12044 int ecode7 = 0 ;
12045 Matrix temp8 ;
12046 Matrix temp10 ;
12047 Matrix temp11 ;
12048 octave_value_list _out;
12049 octave_value_list *_outp=&_out;
12050 octave_value _outv;
12051
12052 try {
12053 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
12054 SWIG_fail;
12055 }
12056 {
12057 if ( _n_dims( args(0) ) > 2 )
12058 {
12059 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12060 }
12061 temp1 = args(0).matrix_value();
12062 arg1 = &temp1( 0, 0 );
12063 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12064 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12065 }
12066 ecode4 = SWIG_AsVal_int(args(1), &val4);
12067 if (!SWIG_IsOK(ecode4)) {
12068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
12069 }
12070 arg4 = static_cast< PLINT >(val4);
12071 ecode5 = SWIG_AsVal_int(args(2), &val5);
12072 if (!SWIG_IsOK(ecode5)) {
12073 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
12074 }
12075 arg5 = static_cast< PLINT >(val5);
12076 ecode6 = SWIG_AsVal_int(args(3), &val6);
12077 if (!SWIG_IsOK(ecode6)) {
12078 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
12079 }
12080 arg6 = static_cast< PLINT >(val6);
12081 ecode7 = SWIG_AsVal_int(args(4), &val7);
12082 if (!SWIG_IsOK(ecode7)) {
12083 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12084 }
12085 arg7 = static_cast< PLINT >(val7);
12086 {
12087 if ( _n_dims( args(5) ) > 1 )
12088 {
12089 error( "argument must be a scalar or vector" ); SWIG_fail;
12090 }
12091 temp8 = args(5).matrix_value();
12092 arg8 = &temp8( 0, 0 );
12093 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12094 }
12095 {
12096 if ( _n_dims( args(6) ) > 2 )
12097 {
12098 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12099 }
12100 if ( _dim( args(6), 0 ) != Xlen )
12101 {
12102 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12103 }
12104 if ( _dim( args(6), 1 ) != Ylen )
12105 {
12106 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12107 }
12108 temp10 = args(6).matrix_value();
12109 arg10 = &temp10( 0, 0 );
12110 }
12111 {
12112 if ( _n_dims( args(7) ) > 2 )
12113 {
12114 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12115 }
12116 if ( _dim( args(7), 0 ) != Xlen )
12117 {
12118 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12119 }
12120 if ( _dim( args(7), 1 ) != Ylen )
12121 {
12122 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12123 }
12124 temp11 = args(7).matrix_value();
12125 arg11 = &temp11( 0, 0 );
12126 }
12127 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12128 _outv = octave_value();
12129 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12130 {
12131
12132 }
12133 {
12134
12135 }
12136 {
12137
12138 }
12139 {
12140
12141 }
12142 return _out;
12143 fail:
12144 {
12145
12146 }
12147 {
12148
12149 }
12150 {
12151
12152 }
12153 {
12154
12155 }
12156 return octave_value_list();
12157 }
12158 catch(...) {
12159 {
12160
12161 }
12162 {
12163
12164 }
12165 {
12166
12167 }
12168 {
12169
12170 }
12171 throw;
12172 }
12173}
12174
12175
12176SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12177 PLFLT *arg1 = (PLFLT *) 0 ;
12178 PLINT arg2 ;
12179 PLINT arg3 ;
12180 PLINT arg4 ;
12181 PLINT arg5 ;
12182 PLINT arg6 ;
12183 PLINT arg7 ;
12184 PLFLT *arg8 = (PLFLT *) 0 ;
12185 PLINT arg9 ;
12186 PLFLT *arg10 = (PLFLT *) 0 ;
12187 PLFLT *arg11 = (PLFLT *) 0 ;
12188 Matrix temp1 ;
12189 int val4 ;
12190 int ecode4 = 0 ;
12191 int val5 ;
12192 int ecode5 = 0 ;
12193 int val6 ;
12194 int ecode6 = 0 ;
12195 int val7 ;
12196 int ecode7 = 0 ;
12197 Matrix temp8 ;
12198 Matrix temp10 ;
12199 Matrix temp11 ;
12200 octave_value_list _out;
12201 octave_value_list *_outp=&_out;
12202 octave_value _outv;
12203
12204 try {
12205 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12206 SWIG_fail;
12207 }
12208 {
12209 if ( _n_dims( args(0) ) > 2 )
12210 {
12211 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12212 }
12213 temp1 = args(0).matrix_value();
12214 arg1 = &temp1( 0, 0 );
12215 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12216 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12217 }
12218 ecode4 = SWIG_AsVal_int(args(1), &val4);
12219 if (!SWIG_IsOK(ecode4)) {
12220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12221 }
12222 arg4 = static_cast< PLINT >(val4);
12223 ecode5 = SWIG_AsVal_int(args(2), &val5);
12224 if (!SWIG_IsOK(ecode5)) {
12225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12226 }
12227 arg5 = static_cast< PLINT >(val5);
12228 ecode6 = SWIG_AsVal_int(args(3), &val6);
12229 if (!SWIG_IsOK(ecode6)) {
12230 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12231 }
12232 arg6 = static_cast< PLINT >(val6);
12233 ecode7 = SWIG_AsVal_int(args(4), &val7);
12234 if (!SWIG_IsOK(ecode7)) {
12235 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12236 }
12237 arg7 = static_cast< PLINT >(val7);
12238 {
12239 if ( _n_dims( args(5) ) > 1 )
12240 {
12241 error( "argument must be a scalar or vector" ); SWIG_fail;
12242 }
12243 temp8 = args(5).matrix_value();
12244 arg8 = &temp8( 0, 0 );
12245 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12246 }
12247 {
12248 if ( _n_dims( args(6) ) > 2 )
12249 {
12250 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12251 }
12252 if ( _dim( args(6), 0 ) != Xlen )
12253 {
12254 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12255 }
12256 if ( _dim( args(6), 1 ) != Ylen )
12257 {
12258 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12259 }
12260 temp10 = args(6).matrix_value();
12261 arg10 = &temp10( 0, 0 );
12262 }
12263 {
12264 if ( _n_dims( args(7) ) > 2 )
12265 {
12266 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12267 }
12268 if ( _dim( args(7), 0 ) != Xlen )
12269 {
12270 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12271 }
12272 if ( _dim( args(7), 1 ) != Ylen )
12273 {
12274 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12275 }
12276 temp11 = args(7).matrix_value();
12277 arg11 = &temp11( 0, 0 );
12278 }
12279 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12280 _outv = octave_value();
12281 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12282 {
12283
12284 }
12285 {
12286
12287 }
12288 {
12289
12290 }
12291 {
12292
12293 }
12294 return _out;
12295 fail:
12296 {
12297
12298 }
12299 {
12300
12301 }
12302 {
12303
12304 }
12305 {
12306
12307 }
12308 return octave_value_list();
12309 }
12310 catch(...) {
12311 {
12312
12313 }
12314 {
12315
12316 }
12317 {
12318
12319 }
12320 {
12321
12322 }
12323 throw;
12324 }
12325}
12326
12327
12328SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12329 PLFLT *arg1 = (PLFLT *) 0 ;
12330 PLFLT *arg2 = (PLFLT *) 0 ;
12331 PLFLT *arg3 = (PLFLT *) 0 ;
12332 PLINT arg4 ;
12333 PLFLT *arg5 = (PLFLT *) 0 ;
12334 PLINT arg6 ;
12335 PLFLT *arg7 = (PLFLT *) 0 ;
12336 PLINT arg8 ;
12337 PLFLT *arg9 = (PLFLT *) 0 ;
12338 PLINT arg10 ;
12339 PLFLT arg11 ;
12340 Matrix temp1 ;
12341 Matrix temp2 ;
12342 Matrix temp3 ;
12343 Matrix temp5 ;
12344 Matrix temp7 ;
12345 octave_value_list retval7 ;
12346 int val10 ;
12347 int ecode10 = 0 ;
12348 double val11 ;
12349 int ecode11 = 0 ;
12350 octave_value_list _out;
12351 octave_value_list *_outp=&_out;
12352 octave_value _outv;
12353
12354 try {
12355 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12356 SWIG_fail;
12357 }
12358 {
12359 if ( _n_dims( args(0) ) > 1 )
12360 {
12361 error( "argument must be a scalar or vector" ); SWIG_fail;
12362 }
12363 Alen = (PLINT) ( _dim( args(0), 0 ) );
12364 temp1 = args(0).matrix_value();
12365 arg1 = &temp1( 0, 0 );
12366 }
12367 {
12368 if ( _n_dims( args(1) ) > 1 )
12369 {
12370 error( "argument must be a scalar or vector" ); SWIG_fail;
12371 }
12372 if ( _dim( args(1), 0 ) != Alen )
12373 {
12374 error( "argument vectors must be same length" ); SWIG_fail;
12375 }
12376 temp2 = args(1).matrix_value();
12377 arg2 = &temp2( 0, 0 );
12378 }
12379 {
12380 if ( _n_dims( args(2) ) > 1 )
12381 {
12382 error( "argument must be a scalar or vector" ); SWIG_fail;
12383 }
12384 if ( _dim( args(2), 0 ) != Alen )
12385 {
12386 error( "argument vectors must be same length" ); SWIG_fail;
12387 }
12388 temp3 = args(2).matrix_value();
12389 arg3 = &temp3( 0, 0 );
12390 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12391 }
12392 {
12393 if ( _n_dims( args(3) ) > 1 )
12394 {
12395 error( "argument must be a scalar or vector" ); SWIG_fail;
12396 }
12397 temp5 = args(3).matrix_value();
12398 arg5 = &temp5( 0, 0 );
12399 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12400 }
12401 {
12402 if ( _n_dims( args(4) ) > 1 )
12403 {
12404 error( "argument must be a scalar or vector" ); SWIG_fail;
12405 }
12406 temp7 = args(4).matrix_value();
12407 arg7 = &temp7( 0, 0 );
12408 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12409 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12410 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12411 }
12412 ecode10 = SWIG_AsVal_int(args(5), &val10);
12413 if (!SWIG_IsOK(ecode10)) {
12414 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12415 }
12416 arg10 = static_cast< PLINT >(val10);
12417 ecode11 = SWIG_AsVal_double(args(6), &val11);
12418 if (!SWIG_IsOK(ecode11)) {
12419 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12420 }
12421 arg11 = static_cast< PLFLT >(val11);
12422 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12423 _outv = octave_value();
12424 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12425 {
12426 _outp = SWIG_Octave_AppendOutput(_outp, retval7( 0 ));
12427 }
12428 {
12429
12430 }
12431 {
12432
12433 }
12434 {
12435
12436 }
12437 {
12438
12439 }
12440 {
12441
12442 }
12443 return _out;
12444 fail:
12445 {
12446
12447 }
12448 {
12449
12450 }
12451 {
12452
12453 }
12454 {
12455
12456 }
12457 {
12458
12459 }
12460 return octave_value_list();
12461 }
12462 catch(...) {
12463 {
12464
12465 }
12466 {
12467
12468 }
12469 {
12470
12471 }
12472 {
12473
12474 }
12475 {
12476
12477 }
12478 throw;
12479 }
12480}
12481
12482
12484 PLFLT *arg1 = (PLFLT *) 0 ;
12485 PLFLT *arg2 = (PLFLT *) 0 ;
12486 PLFLT *arg3 = (PLFLT *) 0 ;
12487 PLINT arg4 ;
12488 PLINT arg5 ;
12489 PLINT arg6 ;
12490 Matrix temp1 ;
12491 Matrix temp2 ;
12492 Matrix temp3 ;
12493 int val6 ;
12494 int ecode6 = 0 ;
12495 octave_value_list _out;
12496 octave_value_list *_outp=&_out;
12497 octave_value _outv;
12498
12499 try {
12500 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12501 SWIG_fail;
12502 }
12503 {
12504 if ( _n_dims( args(0) ) > 1 )
12505 {
12506 error( "argument must be a scalar or vector" ); SWIG_fail;
12507 }
12508 temp1 = args(0).matrix_value();
12509 arg1 = &temp1( 0, 0 );
12510 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12511 }
12512 {
12513 if ( _n_dims( args(1) ) > 1 )
12514 {
12515 error( "argument must be a scalar or vector" ); SWIG_fail;
12516 }
12517 temp2 = args(1).matrix_value();
12518 arg2 = &temp2( 0, 0 );
12519 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12520 }
12521 {
12522 if ( _n_dims( args(2) ) > 2 )
12523 {
12524 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12525 }
12526 if ( _dim( args(2), 0 ) != Xlen )
12527 {
12528 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12529 }
12530 if ( _dim( args(2), 1 ) != Ylen )
12531 {
12532 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12533 }
12534 temp3 = args(2).matrix_value();
12535 arg3 = &temp3( 0, 0 );
12536 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12537 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12538 }
12539 ecode6 = SWIG_AsVal_int(args(3), &val6);
12540 if (!SWIG_IsOK(ecode6)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12542 }
12543 arg6 = static_cast< PLINT >(val6);
12544 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12545 _outv = octave_value();
12546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12547 {
12548
12549 }
12550 {
12551
12552 }
12553 {
12554
12555 }
12556 return _out;
12557 fail:
12558 {
12559
12560 }
12561 {
12562
12563 }
12564 {
12565
12566 }
12567 return octave_value_list();
12568 }
12569 catch(...) {
12570 {
12571
12572 }
12573 {
12574
12575 }
12576 {
12577
12578 }
12579 throw;
12580 }
12581}
12582
12583
12585 PLFLT *arg1 = (PLFLT *) 0 ;
12586 PLFLT *arg2 = (PLFLT *) 0 ;
12587 PLFLT *arg3 = (PLFLT *) 0 ;
12588 PLINT arg4 ;
12589 PLINT arg5 ;
12590 PLINT arg6 ;
12591 PLFLT *arg7 = (PLFLT *) 0 ;
12592 PLINT arg8 ;
12593 Matrix temp1 ;
12594 Matrix temp2 ;
12595 Matrix temp3 ;
12596 int val6 ;
12597 int ecode6 = 0 ;
12598 Matrix temp7 ;
12599 octave_value_list _out;
12600 octave_value_list *_outp=&_out;
12601 octave_value _outv;
12602
12603 try {
12604 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12605 SWIG_fail;
12606 }
12607 {
12608 if ( _n_dims( args(0) ) > 1 )
12609 {
12610 error( "argument must be a scalar or vector" ); SWIG_fail;
12611 }
12612 temp1 = args(0).matrix_value();
12613 arg1 = &temp1( 0, 0 );
12614 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12615 }
12616 {
12617 if ( _n_dims( args(1) ) > 1 )
12618 {
12619 error( "argument must be a scalar or vector" ); SWIG_fail;
12620 }
12621 temp2 = args(1).matrix_value();
12622 arg2 = &temp2( 0, 0 );
12623 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12624 }
12625 {
12626 if ( _n_dims( args(2) ) > 2 )
12627 {
12628 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12629 }
12630 if ( _dim( args(2), 0 ) != Xlen )
12631 {
12632 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12633 }
12634 if ( _dim( args(2), 1 ) != Ylen )
12635 {
12636 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12637 }
12638 temp3 = args(2).matrix_value();
12639 arg3 = &temp3( 0, 0 );
12640 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12641 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12642 }
12643 ecode6 = SWIG_AsVal_int(args(3), &val6);
12644 if (!SWIG_IsOK(ecode6)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12646 }
12647 arg6 = static_cast< PLINT >(val6);
12648 {
12649 if ( _n_dims( args(4) ) > 1 )
12650 {
12651 error( "argument must be a scalar or vector" ); SWIG_fail;
12652 }
12653 temp7 = args(4).matrix_value();
12654 arg7 = &temp7( 0, 0 );
12655 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12656 }
12657 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12658 _outv = octave_value();
12659 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12660 {
12661
12662 }
12663 {
12664
12665 }
12666 {
12667
12668 }
12669 {
12670
12671 }
12672 return _out;
12673 fail:
12674 {
12675
12676 }
12677 {
12678
12679 }
12680 {
12681
12682 }
12683 {
12684
12685 }
12686 return octave_value_list();
12687 }
12688 catch(...) {
12689 {
12690
12691 }
12692 {
12693
12694 }
12695 {
12696
12697 }
12698 {
12699
12700 }
12701 throw;
12702 }
12703}
12704
12705
12707 PLFLT *arg1 = (PLFLT *) 0 ;
12708 PLFLT *arg2 = (PLFLT *) 0 ;
12709 PLFLT *arg3 = (PLFLT *) 0 ;
12710 PLINT arg4 ;
12711 PLINT arg5 ;
12712 PLINT arg6 ;
12713 PLBOOL arg7 ;
12714 Matrix temp1 ;
12715 Matrix temp2 ;
12716 Matrix temp3 ;
12717 int val6 ;
12718 int ecode6 = 0 ;
12719 int val7 ;
12720 int ecode7 = 0 ;
12721 octave_value_list _out;
12722 octave_value_list *_outp=&_out;
12723 octave_value _outv;
12724
12725 try {
12726 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12727 SWIG_fail;
12728 }
12729 {
12730 if ( _n_dims( args(0) ) > 1 )
12731 {
12732 error( "argument must be a scalar or vector" ); SWIG_fail;
12733 }
12734 temp1 = args(0).matrix_value();
12735 arg1 = &temp1( 0, 0 );
12736 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12737 }
12738 {
12739 if ( _n_dims( args(1) ) > 1 )
12740 {
12741 error( "argument must be a scalar or vector" ); SWIG_fail;
12742 }
12743 temp2 = args(1).matrix_value();
12744 arg2 = &temp2( 0, 0 );
12745 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12746 }
12747 {
12748 if ( _n_dims( args(2) ) > 2 )
12749 {
12750 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12751 }
12752 if ( _dim( args(2), 0 ) != Xlen )
12753 {
12754 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12755 }
12756 if ( _dim( args(2), 1 ) != Ylen )
12757 {
12758 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12759 }
12760 temp3 = args(2).matrix_value();
12761 arg3 = &temp3( 0, 0 );
12762 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12763 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12764 }
12765 ecode6 = SWIG_AsVal_int(args(3), &val6);
12766 if (!SWIG_IsOK(ecode6)) {
12767 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12768 }
12769 arg6 = static_cast< PLINT >(val6);
12770 ecode7 = SWIG_AsVal_int(args(4), &val7);
12771 if (!SWIG_IsOK(ecode7)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12773 }
12774 arg7 = static_cast< PLBOOL >(val7);
12775 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12776 _outv = octave_value();
12777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12778 {
12779
12780 }
12781 {
12782
12783 }
12784 {
12785
12786 }
12787 return _out;
12788 fail:
12789 {
12790
12791 }
12792 {
12793
12794 }
12795 {
12796
12797 }
12798 return octave_value_list();
12799 }
12800 catch(...) {
12801 {
12802
12803 }
12804 {
12805
12806 }
12807 {
12808
12809 }
12810 throw;
12811 }
12812}
12813
12814
12816 PLFLT *arg1 = (PLFLT *) 0 ;
12817 PLFLT *arg2 = (PLFLT *) 0 ;
12818 PLFLT *arg3 = (PLFLT *) 0 ;
12819 PLINT arg4 ;
12820 PLINT arg5 ;
12821 PLINT arg6 ;
12822 PLFLT *arg7 = (PLFLT *) 0 ;
12823 PLINT arg8 ;
12824 Matrix temp1 ;
12825 Matrix temp2 ;
12826 Matrix temp3 ;
12827 int val6 ;
12828 int ecode6 = 0 ;
12829 Matrix temp7 ;
12830 octave_value_list _out;
12831 octave_value_list *_outp=&_out;
12832 octave_value _outv;
12833
12834 try {
12835 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12836 SWIG_fail;
12837 }
12838 {
12839 if ( _n_dims( args(0) ) > 1 )
12840 {
12841 error( "argument must be a scalar or vector" ); SWIG_fail;
12842 }
12843 temp1 = args(0).matrix_value();
12844 arg1 = &temp1( 0, 0 );
12845 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12846 }
12847 {
12848 if ( _n_dims( args(1) ) > 1 )
12849 {
12850 error( "argument must be a scalar or vector" ); SWIG_fail;
12851 }
12852 temp2 = args(1).matrix_value();
12853 arg2 = &temp2( 0, 0 );
12854 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12855 }
12856 {
12857 if ( _n_dims( args(2) ) > 2 )
12858 {
12859 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12860 }
12861 if ( _dim( args(2), 0 ) != Xlen )
12862 {
12863 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12864 }
12865 if ( _dim( args(2), 1 ) != Ylen )
12866 {
12867 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12868 }
12869 temp3 = args(2).matrix_value();
12870 arg3 = &temp3( 0, 0 );
12871 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12872 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12873 }
12874 ecode6 = SWIG_AsVal_int(args(3), &val6);
12875 if (!SWIG_IsOK(ecode6)) {
12876 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12877 }
12878 arg6 = static_cast< PLINT >(val6);
12879 {
12880 if ( _n_dims( args(4) ) > 1 )
12881 {
12882 error( "argument must be a scalar or vector" ); SWIG_fail;
12883 }
12884 temp7 = args(4).matrix_value();
12885 arg7 = &temp7( 0, 0 );
12886 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12887 }
12888 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12889 _outv = octave_value();
12890 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12891 {
12892
12893 }
12894 {
12895
12896 }
12897 {
12898
12899 }
12900 {
12901
12902 }
12903 return _out;
12904 fail:
12905 {
12906
12907 }
12908 {
12909
12910 }
12911 {
12912
12913 }
12914 {
12915
12916 }
12917 return octave_value_list();
12918 }
12919 catch(...) {
12920 {
12921
12922 }
12923 {
12924
12925 }
12926 {
12927
12928 }
12929 {
12930
12931 }
12932 throw;
12933 }
12934}
12935
12936
12938 PLFLT *arg1 = (PLFLT *) 0 ;
12939 PLFLT *arg2 = (PLFLT *) 0 ;
12940 PLFLT *arg3 = (PLFLT *) 0 ;
12941 PLINT arg4 ;
12942 PLINT arg5 ;
12943 PLINT arg6 ;
12944 PLFLT *arg7 = (PLFLT *) 0 ;
12945 PLINT arg8 ;
12946 PLINT arg9 ;
12947 PLINT arg10 ;
12948 PLINT *arg11 = (PLINT *) 0 ;
12949 PLINT *arg12 = (PLINT *) 0 ;
12950 Matrix temp1 ;
12951 Matrix temp2 ;
12952 Matrix temp3 ;
12953 int val6 ;
12954 int ecode6 = 0 ;
12955 Matrix temp7 ;
12956 int val9 ;
12957 int ecode9 = 0 ;
12958 Matrix temp10 ;
12959 Matrix temp12 ;
12960 octave_value_list _out;
12961 octave_value_list *_outp=&_out;
12962 octave_value _outv;
12963
12964 try {
12965 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12966 SWIG_fail;
12967 }
12968 {
12969 if ( _n_dims( args(0) ) > 1 )
12970 {
12971 error( "argument must be a scalar or vector" ); SWIG_fail;
12972 }
12973 temp1 = args(0).matrix_value();
12974 arg1 = &temp1( 0, 0 );
12975 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12976 }
12977 {
12978 if ( _n_dims( args(1) ) > 1 )
12979 {
12980 error( "argument must be a scalar or vector" ); SWIG_fail;
12981 }
12982 temp2 = args(1).matrix_value();
12983 arg2 = &temp2( 0, 0 );
12984 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12985 }
12986 {
12987 if ( _n_dims( args(2) ) > 2 )
12988 {
12989 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12990 }
12991 if ( _dim( args(2), 0 ) != Xlen )
12992 {
12993 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12994 }
12995 if ( _dim( args(2), 1 ) != Ylen )
12996 {
12997 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12998 }
12999 temp3 = args(2).matrix_value();
13000 arg3 = &temp3( 0, 0 );
13001 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13002 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13003 }
13004 ecode6 = SWIG_AsVal_int(args(3), &val6);
13005 if (!SWIG_IsOK(ecode6)) {
13006 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
13007 }
13008 arg6 = static_cast< PLINT >(val6);
13009 {
13010 if ( _n_dims( args(4) ) > 1 )
13011 {
13012 error( "argument must be a scalar or vector" ); SWIG_fail;
13013 }
13014 temp7 = args(4).matrix_value();
13015 arg7 = &temp7( 0, 0 );
13016 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13017 }
13018 ecode9 = SWIG_AsVal_int(args(5), &val9);
13019 if (!SWIG_IsOK(ecode9)) {
13020 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
13021 }
13022 arg9 = static_cast< PLINT >(val9);
13023 {
13024 if ( _n_dims( args(6) ) > 1 )
13025 {
13026 error( "argument must be a scalar or vector" ); SWIG_fail;
13027 }
13028 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13029 arg11 = new PLINT[Alen];
13030 temp10 = args(6).matrix_value();
13031 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13032 }
13033 {
13034 if ( _n_dims( args(7) ) > 1 )
13035 {
13036 error( "argument must be a scalar or vector" ); SWIG_fail;
13037 }
13038 if ( _dim( args(7), 0 ) != Alen )
13039 {
13040 error( "argument vectors must be same length" ); SWIG_fail;
13041 }
13042 temp12 = args(7).matrix_value();
13043 arg12 = new PLINT[Alen];
13044 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13045 }
13046 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);
13047 _outv = octave_value();
13048 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13049 {
13050
13051 }
13052 {
13053
13054 }
13055 {
13056
13057 }
13058 {
13059
13060 }
13061 {
13062 delete [] arg11;
13063 }
13064 {
13065 delete [] arg12;
13066 }
13067 return _out;
13068 fail:
13069 {
13070
13071 }
13072 {
13073
13074 }
13075 {
13076
13077 }
13078 {
13079
13080 }
13081 {
13082 delete [] arg11;
13083 }
13084 {
13085 delete [] arg12;
13086 }
13087 return octave_value_list();
13088 }
13089 catch(...) {
13090 {
13091
13092 }
13093 {
13094
13095 }
13096 {
13097
13098 }
13099 {
13100
13101 }
13102 {
13103 delete [] arg11;
13104 }
13105 {
13106 delete [] arg12;
13107 }
13108 throw;
13109 }
13110}
13111
13112
13114 PLFLT *arg1 = (PLFLT *) 0 ;
13115 PLFLT *arg2 = (PLFLT *) 0 ;
13116 PLFLT *arg3 = (PLFLT *) 0 ;
13117 PLINT arg4 ;
13118 PLINT arg5 ;
13119 PLINT arg6 ;
13120 PLFLT *arg7 = (PLFLT *) 0 ;
13121 PLINT arg8 ;
13122 Matrix temp1 ;
13123 Matrix temp2 ;
13124 Matrix temp3 ;
13125 int val6 ;
13126 int ecode6 = 0 ;
13127 Matrix temp7 ;
13128 octave_value_list _out;
13129 octave_value_list *_outp=&_out;
13130 octave_value _outv;
13131
13132 try {
13133 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13134 SWIG_fail;
13135 }
13136 {
13137 if ( _n_dims( args(0) ) > 1 )
13138 {
13139 error( "argument must be a scalar or vector" ); SWIG_fail;
13140 }
13141 temp1 = args(0).matrix_value();
13142 arg1 = &temp1( 0, 0 );
13143 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13144 }
13145 {
13146 if ( _n_dims( args(1) ) > 1 )
13147 {
13148 error( "argument must be a scalar or vector" ); SWIG_fail;
13149 }
13150 temp2 = args(1).matrix_value();
13151 arg2 = &temp2( 0, 0 );
13152 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13153 }
13154 {
13155 if ( _n_dims( args(2) ) > 2 )
13156 {
13157 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13158 }
13159 if ( _dim( args(2), 0 ) != Xlen )
13160 {
13161 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13162 }
13163 if ( _dim( args(2), 1 ) != Ylen )
13164 {
13165 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13166 }
13167 temp3 = args(2).matrix_value();
13168 arg3 = &temp3( 0, 0 );
13169 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13170 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13171 }
13172 ecode6 = SWIG_AsVal_int(args(3), &val6);
13173 if (!SWIG_IsOK(ecode6)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13175 }
13176 arg6 = static_cast< PLINT >(val6);
13177 {
13178 if ( _n_dims( args(4) ) > 1 )
13179 {
13180 error( "argument must be a scalar or vector" ); SWIG_fail;
13181 }
13182 temp7 = args(4).matrix_value();
13183 arg7 = &temp7( 0, 0 );
13184 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13185 }
13186 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13187 _outv = octave_value();
13188 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13189 {
13190
13191 }
13192 {
13193
13194 }
13195 {
13196
13197 }
13198 {
13199
13200 }
13201 return _out;
13202 fail:
13203 {
13204
13205 }
13206 {
13207
13208 }
13209 {
13210
13211 }
13212 {
13213
13214 }
13215 return octave_value_list();
13216 }
13217 catch(...) {
13218 {
13219
13220 }
13221 {
13222
13223 }
13224 {
13225
13226 }
13227 {
13228
13229 }
13230 throw;
13231 }
13232}
13233
13234
13236 PLFLT *arg1 = (PLFLT *) 0 ;
13237 PLFLT *arg2 = (PLFLT *) 0 ;
13238 PLFLT *arg3 = (PLFLT *) 0 ;
13239 PLINT arg4 ;
13240 PLINT arg5 ;
13241 PLINT arg6 ;
13242 PLFLT *arg7 = (PLFLT *) 0 ;
13243 PLINT arg8 ;
13244 PLINT arg9 ;
13245 PLINT arg10 ;
13246 PLINT *arg11 = (PLINT *) 0 ;
13247 PLINT *arg12 = (PLINT *) 0 ;
13248 Matrix temp1 ;
13249 Matrix temp2 ;
13250 Matrix temp3 ;
13251 int val6 ;
13252 int ecode6 = 0 ;
13253 Matrix temp7 ;
13254 int val9 ;
13255 int ecode9 = 0 ;
13256 Matrix temp10 ;
13257 Matrix temp12 ;
13258 octave_value_list _out;
13259 octave_value_list *_outp=&_out;
13260 octave_value _outv;
13261
13262 try {
13263 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13264 SWIG_fail;
13265 }
13266 {
13267 if ( _n_dims( args(0) ) > 1 )
13268 {
13269 error( "argument must be a scalar or vector" ); SWIG_fail;
13270 }
13271 temp1 = args(0).matrix_value();
13272 arg1 = &temp1( 0, 0 );
13273 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13274 }
13275 {
13276 if ( _n_dims( args(1) ) > 1 )
13277 {
13278 error( "argument must be a scalar or vector" ); SWIG_fail;
13279 }
13280 temp2 = args(1).matrix_value();
13281 arg2 = &temp2( 0, 0 );
13282 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13283 }
13284 {
13285 if ( _n_dims( args(2) ) > 2 )
13286 {
13287 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13288 }
13289 if ( _dim( args(2), 0 ) != Xlen )
13290 {
13291 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13292 }
13293 if ( _dim( args(2), 1 ) != Ylen )
13294 {
13295 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13296 }
13297 temp3 = args(2).matrix_value();
13298 arg3 = &temp3( 0, 0 );
13299 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13300 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13301 }
13302 ecode6 = SWIG_AsVal_int(args(3), &val6);
13303 if (!SWIG_IsOK(ecode6)) {
13304 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13305 }
13306 arg6 = static_cast< PLINT >(val6);
13307 {
13308 if ( _n_dims( args(4) ) > 1 )
13309 {
13310 error( "argument must be a scalar or vector" ); SWIG_fail;
13311 }
13312 temp7 = args(4).matrix_value();
13313 arg7 = &temp7( 0, 0 );
13314 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13315 }
13316 ecode9 = SWIG_AsVal_int(args(5), &val9);
13317 if (!SWIG_IsOK(ecode9)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13319 }
13320 arg9 = static_cast< PLINT >(val9);
13321 {
13322 if ( _n_dims( args(6) ) > 1 )
13323 {
13324 error( "argument must be a scalar or vector" ); SWIG_fail;
13325 }
13326 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13327 arg11 = new PLINT[Alen];
13328 temp10 = args(6).matrix_value();
13329 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13330 }
13331 {
13332 if ( _n_dims( args(7) ) > 1 )
13333 {
13334 error( "argument must be a scalar or vector" ); SWIG_fail;
13335 }
13336 if ( _dim( args(7), 0 ) != Alen )
13337 {
13338 error( "argument vectors must be same length" ); SWIG_fail;
13339 }
13340 temp12 = args(7).matrix_value();
13341 arg12 = new PLINT[Alen];
13342 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13343 }
13344 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);
13345 _outv = octave_value();
13346 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13347 {
13348
13349 }
13350 {
13351
13352 }
13353 {
13354
13355 }
13356 {
13357
13358 }
13359 {
13360 delete [] arg11;
13361 }
13362 {
13363 delete [] arg12;
13364 }
13365 return _out;
13366 fail:
13367 {
13368
13369 }
13370 {
13371
13372 }
13373 {
13374
13375 }
13376 {
13377
13378 }
13379 {
13380 delete [] arg11;
13381 }
13382 {
13383 delete [] arg12;
13384 }
13385 return octave_value_list();
13386 }
13387 catch(...) {
13388 {
13389
13390 }
13391 {
13392
13393 }
13394 {
13395
13396 }
13397 {
13398
13399 }
13400 {
13401 delete [] arg11;
13402 }
13403 {
13404 delete [] arg12;
13405 }
13406 throw;
13407 }
13408}
13409
13410
13412 PLFLT *arg1 = (PLFLT *) 0 ;
13413 PLINT arg2 ;
13414 PLINT arg3 ;
13415 PLFLT *arg4 = (PLFLT *) 0 ;
13416 PLFLT arg5 ;
13417 PLFLT arg6 ;
13418 PLFLT arg7 ;
13419 PLFLT arg8 ;
13420 PLFLT arg9 ;
13421 PLFLT arg10 ;
13422 PLINT arg11 ;
13423 PLFLT arg12 ;
13424 PLINT arg13 ;
13425 PLINT arg14 ;
13426 PLINT arg15 ;
13427 PLINT arg16 ;
13428 PLINT arg17 ;
13429 PLBOOL arg18 ;
13430 PLFLT *arg19 = (PLFLT *) 0 ;
13431 Matrix temp1 ;
13432 Matrix temp4 ;
13433 double val5 ;
13434 int ecode5 = 0 ;
13435 double val6 ;
13436 int ecode6 = 0 ;
13437 double val7 ;
13438 int ecode7 = 0 ;
13439 double val8 ;
13440 int ecode8 = 0 ;
13441 double val9 ;
13442 int ecode9 = 0 ;
13443 double val10 ;
13444 int ecode10 = 0 ;
13445 int val11 ;
13446 int ecode11 = 0 ;
13447 double val12 ;
13448 int ecode12 = 0 ;
13449 int val13 ;
13450 int ecode13 = 0 ;
13451 int val14 ;
13452 int ecode14 = 0 ;
13453 int val15 ;
13454 int ecode15 = 0 ;
13455 int val16 ;
13456 int ecode16 = 0 ;
13457 int val17 ;
13458 int ecode17 = 0 ;
13459 int val18 ;
13460 int ecode18 = 0 ;
13461 Matrix temp19 ;
13462 octave_value_list _out;
13463 octave_value_list *_outp=&_out;
13464 octave_value _outv;
13465
13466 try {
13467 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13468 SWIG_fail;
13469 }
13470 {
13471 if ( _n_dims( args(0) ) > 2 )
13472 {
13473 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13474 }
13475 temp1 = args(0).matrix_value();
13476 arg1 = &temp1( 0, 0 );
13477 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13478 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13479 }
13480 {
13481 if ( _n_dims( args(1) ) > 1 )
13482 {
13483 error( "argument must be a scalar or vector" ); SWIG_fail;
13484 }
13485 Alen = (PLINT) ( _dim( args(1), 0 ) );
13486 temp4 = args(1).matrix_value();
13487 arg4 = &temp4( 0, 0 );
13488 }
13489 ecode5 = SWIG_AsVal_double(args(2), &val5);
13490 if (!SWIG_IsOK(ecode5)) {
13491 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13492 }
13493 arg5 = static_cast< PLFLT >(val5);
13494 ecode6 = SWIG_AsVal_double(args(3), &val6);
13495 if (!SWIG_IsOK(ecode6)) {
13496 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13497 }
13498 arg6 = static_cast< PLFLT >(val6);
13499 ecode7 = SWIG_AsVal_double(args(4), &val7);
13500 if (!SWIG_IsOK(ecode7)) {
13501 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13502 }
13503 arg7 = static_cast< PLFLT >(val7);
13504 ecode8 = SWIG_AsVal_double(args(5), &val8);
13505 if (!SWIG_IsOK(ecode8)) {
13506 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13507 }
13508 arg8 = static_cast< PLFLT >(val8);
13509 ecode9 = SWIG_AsVal_double(args(6), &val9);
13510 if (!SWIG_IsOK(ecode9)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13512 }
13513 arg9 = static_cast< PLFLT >(val9);
13514 ecode10 = SWIG_AsVal_double(args(7), &val10);
13515 if (!SWIG_IsOK(ecode10)) {
13516 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13517 }
13518 arg10 = static_cast< PLFLT >(val10);
13519 ecode11 = SWIG_AsVal_int(args(8), &val11);
13520 if (!SWIG_IsOK(ecode11)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13522 }
13523 arg11 = static_cast< PLINT >(val11);
13524 ecode12 = SWIG_AsVal_double(args(9), &val12);
13525 if (!SWIG_IsOK(ecode12)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13527 }
13528 arg12 = static_cast< PLFLT >(val12);
13529 ecode13 = SWIG_AsVal_int(args(10), &val13);
13530 if (!SWIG_IsOK(ecode13)) {
13531 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13532 }
13533 arg13 = static_cast< PLINT >(val13);
13534 ecode14 = SWIG_AsVal_int(args(11), &val14);
13535 if (!SWIG_IsOK(ecode14)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13537 }
13538 arg14 = static_cast< PLINT >(val14);
13539 ecode15 = SWIG_AsVal_int(args(12), &val15);
13540 if (!SWIG_IsOK(ecode15)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13542 }
13543 arg15 = static_cast< PLINT >(val15);
13544 ecode16 = SWIG_AsVal_int(args(13), &val16);
13545 if (!SWIG_IsOK(ecode16)) {
13546 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13547 }
13548 arg16 = static_cast< PLINT >(val16);
13549 ecode17 = SWIG_AsVal_int(args(14), &val17);
13550 if (!SWIG_IsOK(ecode17)) {
13551 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13552 }
13553 arg17 = static_cast< PLINT >(val17);
13554 ecode18 = SWIG_AsVal_int(args(15), &val18);
13555 if (!SWIG_IsOK(ecode18)) {
13556 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13557 }
13558 arg18 = static_cast< PLBOOL >(val18);
13559 {
13560 if ( _n_dims( args(16) ) > 1 )
13561 {
13562 error( "argument must be a scalar or vector" ); SWIG_fail;
13563 }
13564 if ( _dim( args(16), 0 ) != 6 )
13565 {
13566 error( "argument vectors must have length of 6" ); SWIG_fail;
13567 }
13568 temp19 = args(16).matrix_value();
13569 arg19 = &temp19( 0, 0 );
13570 }
13571 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);
13572 _outv = octave_value();
13573 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13574 {
13575
13576 }
13577 {
13578
13579 }
13580 {
13581
13582 }
13583 return _out;
13584 fail:
13585 {
13586
13587 }
13588 {
13589
13590 }
13591 {
13592
13593 }
13594 return octave_value_list();
13595 }
13596 catch(...) {
13597 {
13598
13599 }
13600 {
13601
13602 }
13603 {
13604
13605 }
13606 throw;
13607 }
13608}
13609
13610
13611SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13612 PLFLT *arg1 = (PLFLT *) 0 ;
13613 PLINT arg2 ;
13614 PLINT arg3 ;
13615 char *arg4 = (char *) 0 ;
13616 PLFLT arg5 ;
13617 PLFLT arg6 ;
13618 PLFLT arg7 ;
13619 PLFLT arg8 ;
13620 PLFLT arg9 ;
13621 PLFLT arg10 ;
13622 PLINT arg11 ;
13623 PLFLT arg12 ;
13624 PLINT arg13 ;
13625 PLINT arg14 ;
13626 PLINT arg15 ;
13627 PLINT arg16 ;
13628 PLINT arg17 ;
13629 PLBOOL arg18 ;
13630 PLFLT *arg19 = (PLFLT *) 0 ;
13631 PLFLT *arg20 = (PLFLT *) 0 ;
13632 Matrix temp1 ;
13633 int res4 ;
13634 char *buf4 = 0 ;
13635 int alloc4 = 0 ;
13636 double val5 ;
13637 int ecode5 = 0 ;
13638 double val6 ;
13639 int ecode6 = 0 ;
13640 double val7 ;
13641 int ecode7 = 0 ;
13642 double val8 ;
13643 int ecode8 = 0 ;
13644 double val9 ;
13645 int ecode9 = 0 ;
13646 double val10 ;
13647 int ecode10 = 0 ;
13648 int val11 ;
13649 int ecode11 = 0 ;
13650 double val12 ;
13651 int ecode12 = 0 ;
13652 int val13 ;
13653 int ecode13 = 0 ;
13654 int val14 ;
13655 int ecode14 = 0 ;
13656 int val15 ;
13657 int ecode15 = 0 ;
13658 int val16 ;
13659 int ecode16 = 0 ;
13660 int val17 ;
13661 int ecode17 = 0 ;
13662 int val18 ;
13663 int ecode18 = 0 ;
13664 Matrix temp19 ;
13665 Matrix temp20 ;
13666 octave_value_list _out;
13667 octave_value_list *_outp=&_out;
13668 octave_value _outv;
13669
13670 try {
13671 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13672 SWIG_fail;
13673 }
13674 {
13675 if ( _n_dims( args(0) ) > 2 )
13676 {
13677 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13678 }
13679 temp1 = args(0).matrix_value();
13680 arg1 = &temp1( 0, 0 );
13681 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13682 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13683 }
13684 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13685 if (!SWIG_IsOK(res4)) {
13686 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13687 }
13688 arg4 = reinterpret_cast< char * >(buf4);
13689 ecode5 = SWIG_AsVal_double(args(2), &val5);
13690 if (!SWIG_IsOK(ecode5)) {
13691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13692 }
13693 arg5 = static_cast< PLFLT >(val5);
13694 ecode6 = SWIG_AsVal_double(args(3), &val6);
13695 if (!SWIG_IsOK(ecode6)) {
13696 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13697 }
13698 arg6 = static_cast< PLFLT >(val6);
13699 ecode7 = SWIG_AsVal_double(args(4), &val7);
13700 if (!SWIG_IsOK(ecode7)) {
13701 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13702 }
13703 arg7 = static_cast< PLFLT >(val7);
13704 ecode8 = SWIG_AsVal_double(args(5), &val8);
13705 if (!SWIG_IsOK(ecode8)) {
13706 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13707 }
13708 arg8 = static_cast< PLFLT >(val8);
13709 ecode9 = SWIG_AsVal_double(args(6), &val9);
13710 if (!SWIG_IsOK(ecode9)) {
13711 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13712 }
13713 arg9 = static_cast< PLFLT >(val9);
13714 ecode10 = SWIG_AsVal_double(args(7), &val10);
13715 if (!SWIG_IsOK(ecode10)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13717 }
13718 arg10 = static_cast< PLFLT >(val10);
13719 ecode11 = SWIG_AsVal_int(args(8), &val11);
13720 if (!SWIG_IsOK(ecode11)) {
13721 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13722 }
13723 arg11 = static_cast< PLINT >(val11);
13724 ecode12 = SWIG_AsVal_double(args(9), &val12);
13725 if (!SWIG_IsOK(ecode12)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13727 }
13728 arg12 = static_cast< PLFLT >(val12);
13729 ecode13 = SWIG_AsVal_int(args(10), &val13);
13730 if (!SWIG_IsOK(ecode13)) {
13731 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13732 }
13733 arg13 = static_cast< PLINT >(val13);
13734 ecode14 = SWIG_AsVal_int(args(11), &val14);
13735 if (!SWIG_IsOK(ecode14)) {
13736 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13737 }
13738 arg14 = static_cast< PLINT >(val14);
13739 ecode15 = SWIG_AsVal_int(args(12), &val15);
13740 if (!SWIG_IsOK(ecode15)) {
13741 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13742 }
13743 arg15 = static_cast< PLINT >(val15);
13744 ecode16 = SWIG_AsVal_int(args(13), &val16);
13745 if (!SWIG_IsOK(ecode16)) {
13746 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13747 }
13748 arg16 = static_cast< PLINT >(val16);
13749 ecode17 = SWIG_AsVal_int(args(14), &val17);
13750 if (!SWIG_IsOK(ecode17)) {
13751 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13752 }
13753 arg17 = static_cast< PLINT >(val17);
13754 ecode18 = SWIG_AsVal_int(args(15), &val18);
13755 if (!SWIG_IsOK(ecode18)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13757 }
13758 arg18 = static_cast< PLBOOL >(val18);
13759 {
13760 if ( _n_dims( args(16) ) > 1 )
13761 {
13762 error( "argument must be a scalar or vector" ); SWIG_fail;
13763 }
13764 if ( _dim( args(16), 0 ) != Xlen )
13765 {
13766 error( "argument vectors must be same length" ); SWIG_fail;
13767 }
13768 temp19 = args(16).matrix_value();
13769 arg19 = &temp19( 0, 0 );
13770 }
13771 {
13772 if ( _n_dims( args(17) ) > 1 )
13773 {
13774 error( "argument must be a scalar or vector" ); SWIG_fail;
13775 }
13776 if ( _dim( args(17), 0 ) != Ylen )
13777 {
13778 error( "argument vectors must be same length" ); SWIG_fail;
13779 }
13780 temp20 = args(17).matrix_value();
13781 arg20 = &temp20( 0, 0 );
13782 }
13783 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);
13784 _outv = octave_value();
13785 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13786 {
13787
13788 }
13789 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13790 {
13791
13792 }
13793 {
13794
13795 }
13796 return _out;
13797 fail:
13798 {
13799
13800 }
13801 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13802 {
13803
13804 }
13805 {
13806
13807 }
13808 return octave_value_list();
13809 }
13810 catch(...) {
13811 {
13812
13813 }
13814 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13815 {
13816
13817 }
13818 {
13819
13820 }
13821 throw;
13822 }
13823}
13824
13825
13826SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13827 PLFLT *arg1 = (PLFLT *) 0 ;
13828 PLINT arg2 ;
13829 PLINT arg3 ;
13830 char *arg4 = (char *) 0 ;
13831 PLFLT arg5 ;
13832 PLFLT arg6 ;
13833 PLFLT arg7 ;
13834 PLFLT arg8 ;
13835 PLFLT arg9 ;
13836 PLFLT arg10 ;
13837 PLINT arg11 ;
13838 PLFLT arg12 ;
13839 PLINT arg13 ;
13840 PLINT arg14 ;
13841 PLINT arg15 ;
13842 PLINT arg16 ;
13843 PLINT arg17 ;
13844 PLBOOL arg18 ;
13845 PLFLT *arg19 = (PLFLT *) 0 ;
13846 PLFLT *arg20 = (PLFLT *) 0 ;
13847 Matrix temp1 ;
13848 int res4 ;
13849 char *buf4 = 0 ;
13850 int alloc4 = 0 ;
13851 double val5 ;
13852 int ecode5 = 0 ;
13853 double val6 ;
13854 int ecode6 = 0 ;
13855 double val7 ;
13856 int ecode7 = 0 ;
13857 double val8 ;
13858 int ecode8 = 0 ;
13859 double val9 ;
13860 int ecode9 = 0 ;
13861 double val10 ;
13862 int ecode10 = 0 ;
13863 int val11 ;
13864 int ecode11 = 0 ;
13865 double val12 ;
13866 int ecode12 = 0 ;
13867 int val13 ;
13868 int ecode13 = 0 ;
13869 int val14 ;
13870 int ecode14 = 0 ;
13871 int val15 ;
13872 int ecode15 = 0 ;
13873 int val16 ;
13874 int ecode16 = 0 ;
13875 int val17 ;
13876 int ecode17 = 0 ;
13877 int val18 ;
13878 int ecode18 = 0 ;
13879 Matrix temp19 ;
13880 Matrix temp20 ;
13881 octave_value_list _out;
13882 octave_value_list *_outp=&_out;
13883 octave_value _outv;
13884
13885 try {
13886 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13887 SWIG_fail;
13888 }
13889 {
13890 if ( _n_dims( args(0) ) > 2 )
13891 {
13892 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13893 }
13894 temp1 = args(0).matrix_value();
13895 arg1 = &temp1( 0, 0 );
13896 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13897 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13898 }
13899 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13900 if (!SWIG_IsOK(res4)) {
13901 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13902 }
13903 arg4 = reinterpret_cast< char * >(buf4);
13904 ecode5 = SWIG_AsVal_double(args(2), &val5);
13905 if (!SWIG_IsOK(ecode5)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13907 }
13908 arg5 = static_cast< PLFLT >(val5);
13909 ecode6 = SWIG_AsVal_double(args(3), &val6);
13910 if (!SWIG_IsOK(ecode6)) {
13911 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13912 }
13913 arg6 = static_cast< PLFLT >(val6);
13914 ecode7 = SWIG_AsVal_double(args(4), &val7);
13915 if (!SWIG_IsOK(ecode7)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13917 }
13918 arg7 = static_cast< PLFLT >(val7);
13919 ecode8 = SWIG_AsVal_double(args(5), &val8);
13920 if (!SWIG_IsOK(ecode8)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13922 }
13923 arg8 = static_cast< PLFLT >(val8);
13924 ecode9 = SWIG_AsVal_double(args(6), &val9);
13925 if (!SWIG_IsOK(ecode9)) {
13926 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13927 }
13928 arg9 = static_cast< PLFLT >(val9);
13929 ecode10 = SWIG_AsVal_double(args(7), &val10);
13930 if (!SWIG_IsOK(ecode10)) {
13931 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13932 }
13933 arg10 = static_cast< PLFLT >(val10);
13934 ecode11 = SWIG_AsVal_int(args(8), &val11);
13935 if (!SWIG_IsOK(ecode11)) {
13936 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13937 }
13938 arg11 = static_cast< PLINT >(val11);
13939 ecode12 = SWIG_AsVal_double(args(9), &val12);
13940 if (!SWIG_IsOK(ecode12)) {
13941 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13942 }
13943 arg12 = static_cast< PLFLT >(val12);
13944 ecode13 = SWIG_AsVal_int(args(10), &val13);
13945 if (!SWIG_IsOK(ecode13)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13947 }
13948 arg13 = static_cast< PLINT >(val13);
13949 ecode14 = SWIG_AsVal_int(args(11), &val14);
13950 if (!SWIG_IsOK(ecode14)) {
13951 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13952 }
13953 arg14 = static_cast< PLINT >(val14);
13954 ecode15 = SWIG_AsVal_int(args(12), &val15);
13955 if (!SWIG_IsOK(ecode15)) {
13956 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13957 }
13958 arg15 = static_cast< PLINT >(val15);
13959 ecode16 = SWIG_AsVal_int(args(13), &val16);
13960 if (!SWIG_IsOK(ecode16)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13962 }
13963 arg16 = static_cast< PLINT >(val16);
13964 ecode17 = SWIG_AsVal_int(args(14), &val17);
13965 if (!SWIG_IsOK(ecode17)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13967 }
13968 arg17 = static_cast< PLINT >(val17);
13969 ecode18 = SWIG_AsVal_int(args(15), &val18);
13970 if (!SWIG_IsOK(ecode18)) {
13971 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13972 }
13973 arg18 = static_cast< PLBOOL >(val18);
13974 {
13975 if ( _n_dims( args(16) ) > 2 )
13976 {
13977 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13978 }
13979 temp19 = args(16).matrix_value();
13980 arg19 = &temp19( 0, 0 );
13981 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13982 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13983 }
13984 {
13985 if ( _n_dims( args(17) ) > 2 )
13986 {
13987 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13988 }
13989 temp20 = args(17).matrix_value();
13990 arg20 = &temp20( 0, 0 );
13991 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13992 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13993 }
13994 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);
13995 _outv = octave_value();
13996 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13997 {
13998
13999 }
14000 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14001 {
14002
14003 }
14004 {
14005
14006 }
14007 return _out;
14008 fail:
14009 {
14010
14011 }
14012 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14013 {
14014
14015 }
14016 {
14017
14018 }
14019 return octave_value_list();
14020 }
14021 catch(...) {
14022 {
14023
14024 }
14025 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14026 {
14027
14028 }
14029 {
14030
14031 }
14032 throw;
14033 }
14034}
14035
14036
14038 PLFLT *arg1 = (PLFLT *) 0 ;
14039 PLINT arg2 ;
14040 PLINT arg3 ;
14041 PLFLT arg4 ;
14042 PLFLT arg5 ;
14043 PLFLT arg6 ;
14044 PLFLT arg7 ;
14045 PLFLT *arg8 = (PLFLT *) 0 ;
14046 PLINT arg9 ;
14047 PLINT arg10 ;
14048 PLINT arg11 ;
14049 PLINT arg12 ;
14050 PLBOOL arg13 ;
14051 Matrix temp1 ;
14052 double val4 ;
14053 int ecode4 = 0 ;
14054 double val5 ;
14055 int ecode5 = 0 ;
14056 double val6 ;
14057 int ecode6 = 0 ;
14058 double val7 ;
14059 int ecode7 = 0 ;
14060 Matrix temp8 ;
14061 int val10 ;
14062 int ecode10 = 0 ;
14063 int val11 ;
14064 int ecode11 = 0 ;
14065 int val12 ;
14066 int ecode12 = 0 ;
14067 int val13 ;
14068 int ecode13 = 0 ;
14069 octave_value_list _out;
14070 octave_value_list *_outp=&_out;
14071 octave_value _outv;
14072
14073 try {
14074 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
14075 SWIG_fail;
14076 }
14077 {
14078 if ( _n_dims( args(0) ) > 2 )
14079 {
14080 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14081 }
14082 temp1 = args(0).matrix_value();
14083 arg1 = &temp1( 0, 0 );
14084 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14085 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14086 }
14087 ecode4 = SWIG_AsVal_double(args(1), &val4);
14088 if (!SWIG_IsOK(ecode4)) {
14089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14090 }
14091 arg4 = static_cast< PLFLT >(val4);
14092 ecode5 = SWIG_AsVal_double(args(2), &val5);
14093 if (!SWIG_IsOK(ecode5)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14095 }
14096 arg5 = static_cast< PLFLT >(val5);
14097 ecode6 = SWIG_AsVal_double(args(3), &val6);
14098 if (!SWIG_IsOK(ecode6)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14100 }
14101 arg6 = static_cast< PLFLT >(val6);
14102 ecode7 = SWIG_AsVal_double(args(4), &val7);
14103 if (!SWIG_IsOK(ecode7)) {
14104 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14105 }
14106 arg7 = static_cast< PLFLT >(val7);
14107 {
14108 if ( _n_dims( args(5) ) > 1 )
14109 {
14110 error( "argument must be a scalar or vector" ); SWIG_fail;
14111 }
14112 temp8 = args(5).matrix_value();
14113 arg8 = &temp8( 0, 0 );
14114 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14115 }
14116 ecode10 = SWIG_AsVal_int(args(6), &val10);
14117 if (!SWIG_IsOK(ecode10)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14119 }
14120 arg10 = static_cast< PLINT >(val10);
14121 ecode11 = SWIG_AsVal_int(args(7), &val11);
14122 if (!SWIG_IsOK(ecode11)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14124 }
14125 arg11 = static_cast< PLINT >(val11);
14126 ecode12 = SWIG_AsVal_int(args(8), &val12);
14127 if (!SWIG_IsOK(ecode12)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14129 }
14130 arg12 = static_cast< PLINT >(val12);
14131 ecode13 = SWIG_AsVal_int(args(9), &val13);
14132 if (!SWIG_IsOK(ecode13)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14134 }
14135 arg13 = static_cast< PLBOOL >(val13);
14136 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14137 _outv = octave_value();
14138 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14139 {
14140
14141 }
14142 {
14143
14144 }
14145 return _out;
14146 fail:
14147 {
14148
14149 }
14150 {
14151
14152 }
14153 return octave_value_list();
14154 }
14155 catch(...) {
14156 {
14157
14158 }
14159 {
14160
14161 }
14162 throw;
14163 }
14164}
14165
14166
14167SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14168 PLFLT *arg1 = (PLFLT *) 0 ;
14169 PLINT arg2 ;
14170 PLINT arg3 ;
14171 PLFLT arg4 ;
14172 PLFLT arg5 ;
14173 PLFLT arg6 ;
14174 PLFLT arg7 ;
14175 PLFLT *arg8 = (PLFLT *) 0 ;
14176 PLINT arg9 ;
14177 PLINT arg10 ;
14178 PLINT arg11 ;
14179 PLINT arg12 ;
14180 PLBOOL arg13 ;
14181 PLFLT *arg14 = (PLFLT *) 0 ;
14182 Matrix temp1 ;
14183 double val4 ;
14184 int ecode4 = 0 ;
14185 double val5 ;
14186 int ecode5 = 0 ;
14187 double val6 ;
14188 int ecode6 = 0 ;
14189 double val7 ;
14190 int ecode7 = 0 ;
14191 Matrix temp8 ;
14192 int val10 ;
14193 int ecode10 = 0 ;
14194 int val11 ;
14195 int ecode11 = 0 ;
14196 int val12 ;
14197 int ecode12 = 0 ;
14198 int val13 ;
14199 int ecode13 = 0 ;
14200 Matrix temp14 ;
14201 octave_value_list _out;
14202 octave_value_list *_outp=&_out;
14203 octave_value _outv;
14204
14205 try {
14206 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14207 SWIG_fail;
14208 }
14209 {
14210 if ( _n_dims( args(0) ) > 2 )
14211 {
14212 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14213 }
14214 temp1 = args(0).matrix_value();
14215 arg1 = &temp1( 0, 0 );
14216 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14217 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14218 }
14219 ecode4 = SWIG_AsVal_double(args(1), &val4);
14220 if (!SWIG_IsOK(ecode4)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14222 }
14223 arg4 = static_cast< PLFLT >(val4);
14224 ecode5 = SWIG_AsVal_double(args(2), &val5);
14225 if (!SWIG_IsOK(ecode5)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14227 }
14228 arg5 = static_cast< PLFLT >(val5);
14229 ecode6 = SWIG_AsVal_double(args(3), &val6);
14230 if (!SWIG_IsOK(ecode6)) {
14231 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14232 }
14233 arg6 = static_cast< PLFLT >(val6);
14234 ecode7 = SWIG_AsVal_double(args(4), &val7);
14235 if (!SWIG_IsOK(ecode7)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14237 }
14238 arg7 = static_cast< PLFLT >(val7);
14239 {
14240 if ( _n_dims( args(5) ) > 1 )
14241 {
14242 error( "argument must be a scalar or vector" ); SWIG_fail;
14243 }
14244 temp8 = args(5).matrix_value();
14245 arg8 = &temp8( 0, 0 );
14246 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14247 }
14248 ecode10 = SWIG_AsVal_int(args(6), &val10);
14249 if (!SWIG_IsOK(ecode10)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14251 }
14252 arg10 = static_cast< PLINT >(val10);
14253 ecode11 = SWIG_AsVal_int(args(7), &val11);
14254 if (!SWIG_IsOK(ecode11)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14256 }
14257 arg11 = static_cast< PLINT >(val11);
14258 ecode12 = SWIG_AsVal_int(args(8), &val12);
14259 if (!SWIG_IsOK(ecode12)) {
14260 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14261 }
14262 arg12 = static_cast< PLINT >(val12);
14263 ecode13 = SWIG_AsVal_int(args(9), &val13);
14264 if (!SWIG_IsOK(ecode13)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14266 }
14267 arg13 = static_cast< PLBOOL >(val13);
14268 {
14269 if ( _n_dims( args(10) ) > 1 )
14270 {
14271 error( "argument must be a scalar or vector" ); SWIG_fail;
14272 }
14273 if ( _dim( args(10), 0 ) != 6 )
14274 {
14275 error( "argument vectors must have length of 6" ); SWIG_fail;
14276 }
14277 temp14 = args(10).matrix_value();
14278 arg14 = &temp14( 0, 0 );
14279 }
14280 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14281 _outv = octave_value();
14282 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14283 {
14284
14285 }
14286 {
14287
14288 }
14289 {
14290
14291 }
14292 return _out;
14293 fail:
14294 {
14295
14296 }
14297 {
14298
14299 }
14300 {
14301
14302 }
14303 return octave_value_list();
14304 }
14305 catch(...) {
14306 {
14307
14308 }
14309 {
14310
14311 }
14312 {
14313
14314 }
14315 throw;
14316 }
14317}
14318
14319
14320SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14321 PLFLT *arg1 = (PLFLT *) 0 ;
14322 PLINT arg2 ;
14323 PLINT arg3 ;
14324 PLFLT arg4 ;
14325 PLFLT arg5 ;
14326 PLFLT arg6 ;
14327 PLFLT arg7 ;
14328 PLFLT *arg8 = (PLFLT *) 0 ;
14329 PLINT arg9 ;
14330 PLINT arg10 ;
14331 PLINT arg11 ;
14332 PLINT arg12 ;
14333 PLBOOL arg13 ;
14334 PLFLT *arg14 = (PLFLT *) 0 ;
14335 PLFLT *arg15 = (PLFLT *) 0 ;
14336 Matrix temp1 ;
14337 double val4 ;
14338 int ecode4 = 0 ;
14339 double val5 ;
14340 int ecode5 = 0 ;
14341 double val6 ;
14342 int ecode6 = 0 ;
14343 double val7 ;
14344 int ecode7 = 0 ;
14345 Matrix temp8 ;
14346 int val10 ;
14347 int ecode10 = 0 ;
14348 int val11 ;
14349 int ecode11 = 0 ;
14350 int val12 ;
14351 int ecode12 = 0 ;
14352 int val13 ;
14353 int ecode13 = 0 ;
14354 Matrix temp14 ;
14355 Matrix temp15 ;
14356 octave_value_list _out;
14357 octave_value_list *_outp=&_out;
14358 octave_value _outv;
14359
14360 try {
14361 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14362 SWIG_fail;
14363 }
14364 {
14365 if ( _n_dims( args(0) ) > 2 )
14366 {
14367 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14368 }
14369 temp1 = args(0).matrix_value();
14370 arg1 = &temp1( 0, 0 );
14371 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14372 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14373 }
14374 ecode4 = SWIG_AsVal_double(args(1), &val4);
14375 if (!SWIG_IsOK(ecode4)) {
14376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14377 }
14378 arg4 = static_cast< PLFLT >(val4);
14379 ecode5 = SWIG_AsVal_double(args(2), &val5);
14380 if (!SWIG_IsOK(ecode5)) {
14381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14382 }
14383 arg5 = static_cast< PLFLT >(val5);
14384 ecode6 = SWIG_AsVal_double(args(3), &val6);
14385 if (!SWIG_IsOK(ecode6)) {
14386 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14387 }
14388 arg6 = static_cast< PLFLT >(val6);
14389 ecode7 = SWIG_AsVal_double(args(4), &val7);
14390 if (!SWIG_IsOK(ecode7)) {
14391 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14392 }
14393 arg7 = static_cast< PLFLT >(val7);
14394 {
14395 if ( _n_dims( args(5) ) > 1 )
14396 {
14397 error( "argument must be a scalar or vector" ); SWIG_fail;
14398 }
14399 temp8 = args(5).matrix_value();
14400 arg8 = &temp8( 0, 0 );
14401 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14402 }
14403 ecode10 = SWIG_AsVal_int(args(6), &val10);
14404 if (!SWIG_IsOK(ecode10)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14406 }
14407 arg10 = static_cast< PLINT >(val10);
14408 ecode11 = SWIG_AsVal_int(args(7), &val11);
14409 if (!SWIG_IsOK(ecode11)) {
14410 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14411 }
14412 arg11 = static_cast< PLINT >(val11);
14413 ecode12 = SWIG_AsVal_int(args(8), &val12);
14414 if (!SWIG_IsOK(ecode12)) {
14415 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14416 }
14417 arg12 = static_cast< PLINT >(val12);
14418 ecode13 = SWIG_AsVal_int(args(9), &val13);
14419 if (!SWIG_IsOK(ecode13)) {
14420 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14421 }
14422 arg13 = static_cast< PLBOOL >(val13);
14423 {
14424 if ( _n_dims( args(10) ) > 1 )
14425 {
14426 error( "argument must be a scalar or vector" ); SWIG_fail;
14427 }
14428 if ( _dim( args(10), 0 ) != Xlen )
14429 {
14430 error( "argument vectors must be same length" ); SWIG_fail;
14431 }
14432 temp14 = args(10).matrix_value();
14433 arg14 = &temp14( 0, 0 );
14434 }
14435 {
14436 if ( _n_dims( args(11) ) > 1 )
14437 {
14438 error( "argument must be a scalar or vector" ); SWIG_fail;
14439 }
14440 if ( _dim( args(11), 0 ) != Ylen )
14441 {
14442 error( "argument vectors must be same length" ); SWIG_fail;
14443 }
14444 temp15 = args(11).matrix_value();
14445 arg15 = &temp15( 0, 0 );
14446 }
14447 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);
14448 _outv = octave_value();
14449 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14450 {
14451
14452 }
14453 {
14454
14455 }
14456 {
14457
14458 }
14459 {
14460
14461 }
14462 return _out;
14463 fail:
14464 {
14465
14466 }
14467 {
14468
14469 }
14470 {
14471
14472 }
14473 {
14474
14475 }
14476 return octave_value_list();
14477 }
14478 catch(...) {
14479 {
14480
14481 }
14482 {
14483
14484 }
14485 {
14486
14487 }
14488 {
14489
14490 }
14491 throw;
14492 }
14493}
14494
14495
14496SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14497 PLFLT *arg1 = (PLFLT *) 0 ;
14498 PLINT arg2 ;
14499 PLINT arg3 ;
14500 PLFLT arg4 ;
14501 PLFLT arg5 ;
14502 PLFLT arg6 ;
14503 PLFLT arg7 ;
14504 PLFLT *arg8 = (PLFLT *) 0 ;
14505 PLINT arg9 ;
14506 PLINT arg10 ;
14507 PLINT arg11 ;
14508 PLINT arg12 ;
14509 PLBOOL arg13 ;
14510 PLFLT *arg14 = (PLFLT *) 0 ;
14511 PLFLT *arg15 = (PLFLT *) 0 ;
14512 Matrix temp1 ;
14513 double val4 ;
14514 int ecode4 = 0 ;
14515 double val5 ;
14516 int ecode5 = 0 ;
14517 double val6 ;
14518 int ecode6 = 0 ;
14519 double val7 ;
14520 int ecode7 = 0 ;
14521 Matrix temp8 ;
14522 int val10 ;
14523 int ecode10 = 0 ;
14524 int val11 ;
14525 int ecode11 = 0 ;
14526 int val12 ;
14527 int ecode12 = 0 ;
14528 int val13 ;
14529 int ecode13 = 0 ;
14530 Matrix temp14 ;
14531 Matrix temp15 ;
14532 octave_value_list _out;
14533 octave_value_list *_outp=&_out;
14534 octave_value _outv;
14535
14536 try {
14537 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14538 SWIG_fail;
14539 }
14540 {
14541 if ( _n_dims( args(0) ) > 2 )
14542 {
14543 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14544 }
14545 temp1 = args(0).matrix_value();
14546 arg1 = &temp1( 0, 0 );
14547 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14548 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14549 }
14550 ecode4 = SWIG_AsVal_double(args(1), &val4);
14551 if (!SWIG_IsOK(ecode4)) {
14552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14553 }
14554 arg4 = static_cast< PLFLT >(val4);
14555 ecode5 = SWIG_AsVal_double(args(2), &val5);
14556 if (!SWIG_IsOK(ecode5)) {
14557 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14558 }
14559 arg5 = static_cast< PLFLT >(val5);
14560 ecode6 = SWIG_AsVal_double(args(3), &val6);
14561 if (!SWIG_IsOK(ecode6)) {
14562 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14563 }
14564 arg6 = static_cast< PLFLT >(val6);
14565 ecode7 = SWIG_AsVal_double(args(4), &val7);
14566 if (!SWIG_IsOK(ecode7)) {
14567 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14568 }
14569 arg7 = static_cast< PLFLT >(val7);
14570 {
14571 if ( _n_dims( args(5) ) > 1 )
14572 {
14573 error( "argument must be a scalar or vector" ); SWIG_fail;
14574 }
14575 temp8 = args(5).matrix_value();
14576 arg8 = &temp8( 0, 0 );
14577 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14578 }
14579 ecode10 = SWIG_AsVal_int(args(6), &val10);
14580 if (!SWIG_IsOK(ecode10)) {
14581 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14582 }
14583 arg10 = static_cast< PLINT >(val10);
14584 ecode11 = SWIG_AsVal_int(args(7), &val11);
14585 if (!SWIG_IsOK(ecode11)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14587 }
14588 arg11 = static_cast< PLINT >(val11);
14589 ecode12 = SWIG_AsVal_int(args(8), &val12);
14590 if (!SWIG_IsOK(ecode12)) {
14591 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14592 }
14593 arg12 = static_cast< PLINT >(val12);
14594 ecode13 = SWIG_AsVal_int(args(9), &val13);
14595 if (!SWIG_IsOK(ecode13)) {
14596 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14597 }
14598 arg13 = static_cast< PLBOOL >(val13);
14599 {
14600 if ( _n_dims( args(10) ) > 2 )
14601 {
14602 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14603 }
14604 temp14 = args(10).matrix_value();
14605 arg14 = &temp14( 0, 0 );
14606 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14607 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14608 }
14609 {
14610 if ( _n_dims( args(11) ) > 2 )
14611 {
14612 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14613 }
14614 temp15 = args(11).matrix_value();
14615 arg15 = &temp15( 0, 0 );
14616 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14617 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14618 }
14619 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);
14620 _outv = octave_value();
14621 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14622 {
14623
14624 }
14625 {
14626
14627 }
14628 {
14629
14630 }
14631 {
14632
14633 }
14634 return _out;
14635 fail:
14636 {
14637
14638 }
14639 {
14640
14641 }
14642 {
14643
14644 }
14645 {
14646
14647 }
14648 return octave_value_list();
14649 }
14650 catch(...) {
14651 {
14652
14653 }
14654 {
14655
14656 }
14657 {
14658
14659 }
14660 {
14661
14662 }
14663 throw;
14664 }
14665}
14666
14667
14669 PLFLT *arg1 = (PLFLT *) 0 ;
14670 PLFLT *arg2 = (PLFLT *) 0 ;
14671 PLINT arg3 ;
14672 PLINT arg4 ;
14673 PLFLT arg5 ;
14674 PLFLT *arg6 = (PLFLT *) 0 ;
14675 Matrix temp1 ;
14676 Matrix temp2 ;
14677 double val5 ;
14678 int ecode5 = 0 ;
14679 Matrix temp6 ;
14680 octave_value_list _out;
14681 octave_value_list *_outp=&_out;
14682 octave_value _outv;
14683
14684 try {
14685 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14686 SWIG_fail;
14687 }
14688 {
14689 if ( _n_dims( args(0) ) > 2 )
14690 {
14691 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14692 }
14693 temp1 = args(0).matrix_value();
14694 arg1 = &temp1( 0, 0 );
14695 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14696 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14697 }
14698 {
14699 if ( _n_dims( args(1) ) > 2 )
14700 {
14701 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14702 }
14703 if ( _dim( args(1), 0 ) != Xlen )
14704 {
14705 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14706 }
14707 if ( _dim( args(1), 1 ) != Ylen )
14708 {
14709 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14710 }
14711 temp2 = args(1).matrix_value();
14712 arg2 = &temp2( 0, 0 );
14713 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14714 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14715 }
14716 ecode5 = SWIG_AsVal_double(args(2), &val5);
14717 if (!SWIG_IsOK(ecode5)) {
14718 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14719 }
14720 arg5 = static_cast< PLFLT >(val5);
14721 {
14722 if ( _n_dims( args(3) ) > 1 )
14723 {
14724 error( "argument must be a scalar or vector" ); SWIG_fail;
14725 }
14726 if ( _dim( args(3), 0 ) != 6 )
14727 {
14728 error( "argument vectors must have length of 6" ); SWIG_fail;
14729 }
14730 temp6 = args(3).matrix_value();
14731 arg6 = &temp6( 0, 0 );
14732 }
14733 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14734 _outv = octave_value();
14735 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14736 {
14737
14738 }
14739 {
14740
14741 }
14742 {
14743
14744 }
14745 return _out;
14746 fail:
14747 {
14748
14749 }
14750 {
14751
14752 }
14753 {
14754
14755 }
14756 return octave_value_list();
14757 }
14758 catch(...) {
14759 {
14760
14761 }
14762 {
14763
14764 }
14765 {
14766
14767 }
14768 throw;
14769 }
14770}
14771
14772
14773SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14774 PLFLT *arg1 = (PLFLT *) 0 ;
14775 PLFLT *arg2 = (PLFLT *) 0 ;
14776 PLINT arg3 ;
14777 PLINT arg4 ;
14778 PLFLT arg5 ;
14779 PLFLT *arg6 = (PLFLT *) 0 ;
14780 PLFLT *arg7 = (PLFLT *) 0 ;
14781 Matrix temp1 ;
14782 Matrix temp2 ;
14783 double val5 ;
14784 int ecode5 = 0 ;
14785 Matrix temp6 ;
14786 Matrix temp7 ;
14787 octave_value_list _out;
14788 octave_value_list *_outp=&_out;
14789 octave_value _outv;
14790
14791 try {
14792 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14793 SWIG_fail;
14794 }
14795 {
14796 if ( _n_dims( args(0) ) > 2 )
14797 {
14798 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14799 }
14800 temp1 = args(0).matrix_value();
14801 arg1 = &temp1( 0, 0 );
14802 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14803 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14804 }
14805 {
14806 if ( _n_dims( args(1) ) > 2 )
14807 {
14808 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14809 }
14810 if ( _dim( args(1), 0 ) != Xlen )
14811 {
14812 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14813 }
14814 if ( _dim( args(1), 1 ) != Ylen )
14815 {
14816 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14817 }
14818 temp2 = args(1).matrix_value();
14819 arg2 = &temp2( 0, 0 );
14820 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14821 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14822 }
14823 ecode5 = SWIG_AsVal_double(args(2), &val5);
14824 if (!SWIG_IsOK(ecode5)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14826 }
14827 arg5 = static_cast< PLFLT >(val5);
14828 {
14829 if ( _n_dims( args(3) ) > 1 )
14830 {
14831 error( "argument must be a scalar or vector" ); SWIG_fail;
14832 }
14833 if ( _dim( args(3), 0 ) != Xlen )
14834 {
14835 error( "argument vectors must be same length" ); SWIG_fail;
14836 }
14837 temp6 = args(3).matrix_value();
14838 arg6 = &temp6( 0, 0 );
14839 }
14840 {
14841 if ( _n_dims( args(4) ) > 1 )
14842 {
14843 error( "argument must be a scalar or vector" ); SWIG_fail;
14844 }
14845 if ( _dim( args(4), 0 ) != Ylen )
14846 {
14847 error( "argument vectors must be same length" ); SWIG_fail;
14848 }
14849 temp7 = args(4).matrix_value();
14850 arg7 = &temp7( 0, 0 );
14851 }
14852 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14853 _outv = octave_value();
14854 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14855 {
14856
14857 }
14858 {
14859
14860 }
14861 {
14862
14863 }
14864 {
14865
14866 }
14867 return _out;
14868 fail:
14869 {
14870
14871 }
14872 {
14873
14874 }
14875 {
14876
14877 }
14878 {
14879
14880 }
14881 return octave_value_list();
14882 }
14883 catch(...) {
14884 {
14885
14886 }
14887 {
14888
14889 }
14890 {
14891
14892 }
14893 {
14894
14895 }
14896 throw;
14897 }
14898}
14899
14900
14901SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14902 PLFLT *arg1 = (PLFLT *) 0 ;
14903 PLFLT *arg2 = (PLFLT *) 0 ;
14904 PLINT arg3 ;
14905 PLINT arg4 ;
14906 PLFLT arg5 ;
14907 PLFLT *arg6 = (PLFLT *) 0 ;
14908 PLFLT *arg7 = (PLFLT *) 0 ;
14909 Matrix temp1 ;
14910 Matrix temp2 ;
14911 double val5 ;
14912 int ecode5 = 0 ;
14913 Matrix temp6 ;
14914 Matrix temp7 ;
14915 octave_value_list _out;
14916 octave_value_list *_outp=&_out;
14917 octave_value _outv;
14918
14919 try {
14920 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14921 SWIG_fail;
14922 }
14923 {
14924 if ( _n_dims( args(0) ) > 2 )
14925 {
14926 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14927 }
14928 temp1 = args(0).matrix_value();
14929 arg1 = &temp1( 0, 0 );
14930 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14931 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14932 }
14933 {
14934 if ( _n_dims( args(1) ) > 2 )
14935 {
14936 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14937 }
14938 if ( _dim( args(1), 0 ) != Xlen )
14939 {
14940 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14941 }
14942 if ( _dim( args(1), 1 ) != Ylen )
14943 {
14944 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14945 }
14946 temp2 = args(1).matrix_value();
14947 arg2 = &temp2( 0, 0 );
14948 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14949 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14950 }
14951 ecode5 = SWIG_AsVal_double(args(2), &val5);
14952 if (!SWIG_IsOK(ecode5)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14954 }
14955 arg5 = static_cast< PLFLT >(val5);
14956 {
14957 if ( _n_dims( args(3) ) > 2 )
14958 {
14959 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14960 }
14961 temp6 = args(3).matrix_value();
14962 arg6 = &temp6( 0, 0 );
14963 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14964 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14965 }
14966 {
14967 if ( _n_dims( args(4) ) > 2 )
14968 {
14969 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14970 }
14971 temp7 = args(4).matrix_value();
14972 arg7 = &temp7( 0, 0 );
14973 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14974 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14975 }
14976 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14977 _outv = octave_value();
14978 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14979 {
14980
14981 }
14982 {
14983
14984 }
14985 {
14986
14987 }
14988 {
14989
14990 }
14991 return _out;
14992 fail:
14993 {
14994
14995 }
14996 {
14997
14998 }
14999 {
15000
15001 }
15002 {
15003
15004 }
15005 return octave_value_list();
15006 }
15007 catch(...) {
15008 {
15009
15010 }
15011 {
15012
15013 }
15014 {
15015
15016 }
15017 {
15018
15019 }
15020 throw;
15021 }
15022}
15023
15024
15025SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
15026 PLFLT *arg1 = (PLFLT *) 0 ;
15027 PLINT arg2 ;
15028 PLINT arg3 ;
15029 PLFLT arg4 ;
15030 PLFLT arg5 ;
15031 PLFLT arg6 ;
15032 PLFLT arg7 ;
15033 PLFLT arg8 ;
15034 PLFLT arg9 ;
15035 PLFLT arg10 ;
15036 PLFLT arg11 ;
15037 PLFLT arg12 ;
15038 PLFLT arg13 ;
15039 Matrix temp1 ;
15040 double val4 ;
15041 int ecode4 = 0 ;
15042 double val5 ;
15043 int ecode5 = 0 ;
15044 double val6 ;
15045 int ecode6 = 0 ;
15046 double val7 ;
15047 int ecode7 = 0 ;
15048 double val8 ;
15049 int ecode8 = 0 ;
15050 double val9 ;
15051 int ecode9 = 0 ;
15052 double val10 ;
15053 int ecode10 = 0 ;
15054 double val11 ;
15055 int ecode11 = 0 ;
15056 double val12 ;
15057 int ecode12 = 0 ;
15058 double val13 ;
15059 int ecode13 = 0 ;
15060 octave_value_list _out;
15061 octave_value_list *_outp=&_out;
15062 octave_value _outv;
15063
15064 try {
15065 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
15066 SWIG_fail;
15067 }
15068 {
15069 if ( _n_dims( args(0) ) > 2 )
15070 {
15071 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15072 }
15073 temp1 = args(0).matrix_value();
15074 arg1 = &temp1( 0, 0 );
15075 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15076 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15077 }
15078 ecode4 = SWIG_AsVal_double(args(1), &val4);
15079 if (!SWIG_IsOK(ecode4)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15081 }
15082 arg4 = static_cast< PLFLT >(val4);
15083 ecode5 = SWIG_AsVal_double(args(2), &val5);
15084 if (!SWIG_IsOK(ecode5)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15086 }
15087 arg5 = static_cast< PLFLT >(val5);
15088 ecode6 = SWIG_AsVal_double(args(3), &val6);
15089 if (!SWIG_IsOK(ecode6)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15091 }
15092 arg6 = static_cast< PLFLT >(val6);
15093 ecode7 = SWIG_AsVal_double(args(4), &val7);
15094 if (!SWIG_IsOK(ecode7)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15096 }
15097 arg7 = static_cast< PLFLT >(val7);
15098 ecode8 = SWIG_AsVal_double(args(5), &val8);
15099 if (!SWIG_IsOK(ecode8)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15101 }
15102 arg8 = static_cast< PLFLT >(val8);
15103 ecode9 = SWIG_AsVal_double(args(6), &val9);
15104 if (!SWIG_IsOK(ecode9)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15106 }
15107 arg9 = static_cast< PLFLT >(val9);
15108 ecode10 = SWIG_AsVal_double(args(7), &val10);
15109 if (!SWIG_IsOK(ecode10)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15111 }
15112 arg10 = static_cast< PLFLT >(val10);
15113 ecode11 = SWIG_AsVal_double(args(8), &val11);
15114 if (!SWIG_IsOK(ecode11)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15116 }
15117 arg11 = static_cast< PLFLT >(val11);
15118 ecode12 = SWIG_AsVal_double(args(9), &val12);
15119 if (!SWIG_IsOK(ecode12)) {
15120 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15121 }
15122 arg12 = static_cast< PLFLT >(val12);
15123 ecode13 = SWIG_AsVal_double(args(10), &val13);
15124 if (!SWIG_IsOK(ecode13)) {
15125 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15126 }
15127 arg13 = static_cast< PLFLT >(val13);
15128 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15129 _outv = octave_value();
15130 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15131 {
15132
15133 }
15134 return _out;
15135 fail:
15136 {
15137
15138 }
15139 return octave_value_list();
15140 }
15141 catch(...) {
15142 {
15143
15144 }
15145 throw;
15146 }
15147}
15148
15149
15151 PLFLT *arg1 = (PLFLT *) 0 ;
15152 PLINT arg2 ;
15153 PLINT arg3 ;
15154 PLFLT arg4 ;
15155 PLFLT arg5 ;
15156 PLFLT arg6 ;
15157 PLFLT arg7 ;
15158 PLFLT arg8 ;
15159 PLFLT arg9 ;
15160 PLFLT arg10 ;
15161 PLFLT arg11 ;
15162 Matrix temp1 ;
15163 double val4 ;
15164 int ecode4 = 0 ;
15165 double val5 ;
15166 int ecode5 = 0 ;
15167 double val6 ;
15168 int ecode6 = 0 ;
15169 double val7 ;
15170 int ecode7 = 0 ;
15171 double val8 ;
15172 int ecode8 = 0 ;
15173 double val9 ;
15174 int ecode9 = 0 ;
15175 double val10 ;
15176 int ecode10 = 0 ;
15177 double val11 ;
15178 int ecode11 = 0 ;
15179 octave_value_list _out;
15180 octave_value_list *_outp=&_out;
15181 octave_value _outv;
15182
15183 try {
15184 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15185 SWIG_fail;
15186 }
15187 {
15188 if ( _n_dims( args(0) ) > 2 )
15189 {
15190 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15191 }
15192 temp1 = args(0).matrix_value();
15193 arg1 = &temp1( 0, 0 );
15194 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15195 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15196 }
15197 ecode4 = SWIG_AsVal_double(args(1), &val4);
15198 if (!SWIG_IsOK(ecode4)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15200 }
15201 arg4 = static_cast< PLFLT >(val4);
15202 ecode5 = SWIG_AsVal_double(args(2), &val5);
15203 if (!SWIG_IsOK(ecode5)) {
15204 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15205 }
15206 arg5 = static_cast< PLFLT >(val5);
15207 ecode6 = SWIG_AsVal_double(args(3), &val6);
15208 if (!SWIG_IsOK(ecode6)) {
15209 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15210 }
15211 arg6 = static_cast< PLFLT >(val6);
15212 ecode7 = SWIG_AsVal_double(args(4), &val7);
15213 if (!SWIG_IsOK(ecode7)) {
15214 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15215 }
15216 arg7 = static_cast< PLFLT >(val7);
15217 ecode8 = SWIG_AsVal_double(args(5), &val8);
15218 if (!SWIG_IsOK(ecode8)) {
15219 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15220 }
15221 arg8 = static_cast< PLFLT >(val8);
15222 ecode9 = SWIG_AsVal_double(args(6), &val9);
15223 if (!SWIG_IsOK(ecode9)) {
15224 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15225 }
15226 arg9 = static_cast< PLFLT >(val9);
15227 ecode10 = SWIG_AsVal_double(args(7), &val10);
15228 if (!SWIG_IsOK(ecode10)) {
15229 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15230 }
15231 arg10 = static_cast< PLFLT >(val10);
15232 ecode11 = SWIG_AsVal_double(args(8), &val11);
15233 if (!SWIG_IsOK(ecode11)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15235 }
15236 arg11 = static_cast< PLFLT >(val11);
15237 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15238 _outv = octave_value();
15239 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15240 {
15241
15242 }
15243 return _out;
15244 fail:
15245 {
15246
15247 }
15248 return octave_value_list();
15249 }
15250 catch(...) {
15251 {
15252
15253 }
15254 throw;
15255 }
15256}
15257
15258
15259SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15260 PLFLT *arg1 = (PLFLT *) 0 ;
15261 PLINT arg2 ;
15262 PLINT arg3 ;
15263 PLFLT arg4 ;
15264 PLFLT arg5 ;
15265 PLFLT arg6 ;
15266 PLFLT arg7 ;
15267 PLFLT arg8 ;
15268 PLFLT arg9 ;
15269 PLFLT arg10 ;
15270 PLFLT arg11 ;
15271 PLFLT *arg12 = (PLFLT *) 0 ;
15272 Matrix temp1 ;
15273 double val4 ;
15274 int ecode4 = 0 ;
15275 double val5 ;
15276 int ecode5 = 0 ;
15277 double val6 ;
15278 int ecode6 = 0 ;
15279 double val7 ;
15280 int ecode7 = 0 ;
15281 double val8 ;
15282 int ecode8 = 0 ;
15283 double val9 ;
15284 int ecode9 = 0 ;
15285 double val10 ;
15286 int ecode10 = 0 ;
15287 double val11 ;
15288 int ecode11 = 0 ;
15289 Matrix temp12 ;
15290 octave_value_list _out;
15291 octave_value_list *_outp=&_out;
15292 octave_value _outv;
15293
15294 try {
15295 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15296 SWIG_fail;
15297 }
15298 {
15299 if ( _n_dims( args(0) ) > 2 )
15300 {
15301 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15302 }
15303 temp1 = args(0).matrix_value();
15304 arg1 = &temp1( 0, 0 );
15305 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15306 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15307 }
15308 ecode4 = SWIG_AsVal_double(args(1), &val4);
15309 if (!SWIG_IsOK(ecode4)) {
15310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15311 }
15312 arg4 = static_cast< PLFLT >(val4);
15313 ecode5 = SWIG_AsVal_double(args(2), &val5);
15314 if (!SWIG_IsOK(ecode5)) {
15315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15316 }
15317 arg5 = static_cast< PLFLT >(val5);
15318 ecode6 = SWIG_AsVal_double(args(3), &val6);
15319 if (!SWIG_IsOK(ecode6)) {
15320 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15321 }
15322 arg6 = static_cast< PLFLT >(val6);
15323 ecode7 = SWIG_AsVal_double(args(4), &val7);
15324 if (!SWIG_IsOK(ecode7)) {
15325 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15326 }
15327 arg7 = static_cast< PLFLT >(val7);
15328 ecode8 = SWIG_AsVal_double(args(5), &val8);
15329 if (!SWIG_IsOK(ecode8)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15331 }
15332 arg8 = static_cast< PLFLT >(val8);
15333 ecode9 = SWIG_AsVal_double(args(6), &val9);
15334 if (!SWIG_IsOK(ecode9)) {
15335 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15336 }
15337 arg9 = static_cast< PLFLT >(val9);
15338 ecode10 = SWIG_AsVal_double(args(7), &val10);
15339 if (!SWIG_IsOK(ecode10)) {
15340 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15341 }
15342 arg10 = static_cast< PLFLT >(val10);
15343 ecode11 = SWIG_AsVal_double(args(8), &val11);
15344 if (!SWIG_IsOK(ecode11)) {
15345 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15346 }
15347 arg11 = static_cast< PLFLT >(val11);
15348 {
15349 if ( _n_dims( args(9) ) > 1 )
15350 {
15351 error( "argument must be a scalar or vector" ); SWIG_fail;
15352 }
15353 if ( _dim( args(9), 0 ) != 6 )
15354 {
15355 error( "argument vectors must have length of 6" ); SWIG_fail;
15356 }
15357 temp12 = args(9).matrix_value();
15358 arg12 = &temp12( 0, 0 );
15359 }
15360 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15361 _outv = octave_value();
15362 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15363 {
15364
15365 }
15366 {
15367
15368 }
15369 return _out;
15370 fail:
15371 {
15372
15373 }
15374 {
15375
15376 }
15377 return octave_value_list();
15378 }
15379 catch(...) {
15380 {
15381
15382 }
15383 {
15384
15385 }
15386 throw;
15387 }
15388}
15389
15390
15391SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15392 PLFLT *arg1 = (PLFLT *) 0 ;
15393 PLINT arg2 ;
15394 PLINT arg3 ;
15395 PLFLT arg4 ;
15396 PLFLT arg5 ;
15397 PLFLT arg6 ;
15398 PLFLT arg7 ;
15399 PLFLT arg8 ;
15400 PLFLT arg9 ;
15401 PLFLT arg10 ;
15402 PLFLT arg11 ;
15403 PLFLT *arg12 = (PLFLT *) 0 ;
15404 PLFLT *arg13 = (PLFLT *) 0 ;
15405 Matrix temp1 ;
15406 double val4 ;
15407 int ecode4 = 0 ;
15408 double val5 ;
15409 int ecode5 = 0 ;
15410 double val6 ;
15411 int ecode6 = 0 ;
15412 double val7 ;
15413 int ecode7 = 0 ;
15414 double val8 ;
15415 int ecode8 = 0 ;
15416 double val9 ;
15417 int ecode9 = 0 ;
15418 double val10 ;
15419 int ecode10 = 0 ;
15420 double val11 ;
15421 int ecode11 = 0 ;
15422 Matrix temp12 ;
15423 Matrix temp13 ;
15424 octave_value_list _out;
15425 octave_value_list *_outp=&_out;
15426 octave_value _outv;
15427
15428 try {
15429 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15430 SWIG_fail;
15431 }
15432 {
15433 if ( _n_dims( args(0) ) > 2 )
15434 {
15435 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15436 }
15437 temp1 = args(0).matrix_value();
15438 arg1 = &temp1( 0, 0 );
15439 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15440 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15441 }
15442 ecode4 = SWIG_AsVal_double(args(1), &val4);
15443 if (!SWIG_IsOK(ecode4)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15445 }
15446 arg4 = static_cast< PLFLT >(val4);
15447 ecode5 = SWIG_AsVal_double(args(2), &val5);
15448 if (!SWIG_IsOK(ecode5)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15450 }
15451 arg5 = static_cast< PLFLT >(val5);
15452 ecode6 = SWIG_AsVal_double(args(3), &val6);
15453 if (!SWIG_IsOK(ecode6)) {
15454 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15455 }
15456 arg6 = static_cast< PLFLT >(val6);
15457 ecode7 = SWIG_AsVal_double(args(4), &val7);
15458 if (!SWIG_IsOK(ecode7)) {
15459 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15460 }
15461 arg7 = static_cast< PLFLT >(val7);
15462 ecode8 = SWIG_AsVal_double(args(5), &val8);
15463 if (!SWIG_IsOK(ecode8)) {
15464 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15465 }
15466 arg8 = static_cast< PLFLT >(val8);
15467 ecode9 = SWIG_AsVal_double(args(6), &val9);
15468 if (!SWIG_IsOK(ecode9)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15470 }
15471 arg9 = static_cast< PLFLT >(val9);
15472 ecode10 = SWIG_AsVal_double(args(7), &val10);
15473 if (!SWIG_IsOK(ecode10)) {
15474 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15475 }
15476 arg10 = static_cast< PLFLT >(val10);
15477 ecode11 = SWIG_AsVal_double(args(8), &val11);
15478 if (!SWIG_IsOK(ecode11)) {
15479 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15480 }
15481 arg11 = static_cast< PLFLT >(val11);
15482 {
15483 if ( _n_dims( args(9) ) > 1 )
15484 {
15485 error( "argument must be a scalar or vector" ); SWIG_fail;
15486 }
15487 if ( _dim( args(9), 0 ) != Xlen )
15488 {
15489 error( "argument vectors must be same length" ); SWIG_fail;
15490 }
15491 temp12 = args(9).matrix_value();
15492 arg12 = &temp12( 0, 0 );
15493 }
15494 {
15495 if ( _n_dims( args(10) ) > 1 )
15496 {
15497 error( "argument must be a scalar or vector" ); SWIG_fail;
15498 }
15499 if ( _dim( args(10), 0 ) != Ylen )
15500 {
15501 error( "argument vectors must be same length" ); SWIG_fail;
15502 }
15503 temp13 = args(10).matrix_value();
15504 arg13 = &temp13( 0, 0 );
15505 }
15506 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15507 _outv = octave_value();
15508 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15509 {
15510
15511 }
15512 {
15513
15514 }
15515 {
15516
15517 }
15518 return _out;
15519 fail:
15520 {
15521
15522 }
15523 {
15524
15525 }
15526 {
15527
15528 }
15529 return octave_value_list();
15530 }
15531 catch(...) {
15532 {
15533
15534 }
15535 {
15536
15537 }
15538 {
15539
15540 }
15541 throw;
15542 }
15543}
15544
15545
15546SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15547 PLFLT *arg1 = (PLFLT *) 0 ;
15548 PLINT arg2 ;
15549 PLINT arg3 ;
15550 PLFLT arg4 ;
15551 PLFLT arg5 ;
15552 PLFLT arg6 ;
15553 PLFLT arg7 ;
15554 PLFLT arg8 ;
15555 PLFLT arg9 ;
15556 PLFLT arg10 ;
15557 PLFLT arg11 ;
15558 PLFLT *arg12 = (PLFLT *) 0 ;
15559 PLFLT *arg13 = (PLFLT *) 0 ;
15560 Matrix temp1 ;
15561 double val4 ;
15562 int ecode4 = 0 ;
15563 double val5 ;
15564 int ecode5 = 0 ;
15565 double val6 ;
15566 int ecode6 = 0 ;
15567 double val7 ;
15568 int ecode7 = 0 ;
15569 double val8 ;
15570 int ecode8 = 0 ;
15571 double val9 ;
15572 int ecode9 = 0 ;
15573 double val10 ;
15574 int ecode10 = 0 ;
15575 double val11 ;
15576 int ecode11 = 0 ;
15577 Matrix temp12 ;
15578 Matrix temp13 ;
15579 octave_value_list _out;
15580 octave_value_list *_outp=&_out;
15581 octave_value _outv;
15582
15583 try {
15584 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15585 SWIG_fail;
15586 }
15587 {
15588 if ( _n_dims( args(0) ) > 2 )
15589 {
15590 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15591 }
15592 temp1 = args(0).matrix_value();
15593 arg1 = &temp1( 0, 0 );
15594 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15595 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15596 }
15597 ecode4 = SWIG_AsVal_double(args(1), &val4);
15598 if (!SWIG_IsOK(ecode4)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15600 }
15601 arg4 = static_cast< PLFLT >(val4);
15602 ecode5 = SWIG_AsVal_double(args(2), &val5);
15603 if (!SWIG_IsOK(ecode5)) {
15604 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15605 }
15606 arg5 = static_cast< PLFLT >(val5);
15607 ecode6 = SWIG_AsVal_double(args(3), &val6);
15608 if (!SWIG_IsOK(ecode6)) {
15609 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15610 }
15611 arg6 = static_cast< PLFLT >(val6);
15612 ecode7 = SWIG_AsVal_double(args(4), &val7);
15613 if (!SWIG_IsOK(ecode7)) {
15614 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15615 }
15616 arg7 = static_cast< PLFLT >(val7);
15617 ecode8 = SWIG_AsVal_double(args(5), &val8);
15618 if (!SWIG_IsOK(ecode8)) {
15619 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15620 }
15621 arg8 = static_cast< PLFLT >(val8);
15622 ecode9 = SWIG_AsVal_double(args(6), &val9);
15623 if (!SWIG_IsOK(ecode9)) {
15624 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15625 }
15626 arg9 = static_cast< PLFLT >(val9);
15627 ecode10 = SWIG_AsVal_double(args(7), &val10);
15628 if (!SWIG_IsOK(ecode10)) {
15629 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15630 }
15631 arg10 = static_cast< PLFLT >(val10);
15632 ecode11 = SWIG_AsVal_double(args(8), &val11);
15633 if (!SWIG_IsOK(ecode11)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15635 }
15636 arg11 = static_cast< PLFLT >(val11);
15637 {
15638 if ( _n_dims( args(9) ) > 2 )
15639 {
15640 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15641 }
15642 temp12 = args(9).matrix_value();
15643 arg12 = &temp12( 0, 0 );
15644 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15645 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15646 }
15647 {
15648 if ( _n_dims( args(10) ) > 2 )
15649 {
15650 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15651 }
15652 temp13 = args(10).matrix_value();
15653 arg13 = &temp13( 0, 0 );
15654 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15655 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15656 }
15657 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15658 _outv = octave_value();
15659 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15660 {
15661
15662 }
15663 {
15664
15665 }
15666 {
15667
15668 }
15669 return _out;
15670 fail:
15671 {
15672
15673 }
15674 {
15675
15676 }
15677 {
15678
15679 }
15680 return octave_value_list();
15681 }
15682 catch(...) {
15683 {
15684
15685 }
15686 {
15687
15688 }
15689 {
15690
15691 }
15692 throw;
15693 }
15694}
15695
15696
15697SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15698 PLFLT *arg1 = (PLFLT *) 0 ;
15699 PLFLT *arg2 = (PLFLT *) 0 ;
15700 PLINT arg3 ;
15701 PLINT arg4 ;
15702 PLFLT arg5 ;
15703 PLFLT arg6 ;
15704 PLFLT arg7 ;
15705 PLFLT arg8 ;
15706 PLINT arg9 ;
15707 PLINT arg10 ;
15708 PLINT arg11 ;
15709 PLFLT arg12 ;
15710 PLFLT arg13 ;
15711 PLINT arg14 ;
15712 PLFLT arg15 ;
15713 PLINT arg16 ;
15714 PLINT *arg17 = (PLINT *) 0 ;
15715 char **arg18 = (char **) 0 ;
15716 PLINT arg19 ;
15717 char **arg20 = (char **) 0 ;
15718 PLFLT *arg21 = (PLFLT *) 0 ;
15719 PLINT *arg22 = (PLINT *) 0 ;
15720 PLINT *arg23 = (PLINT *) 0 ;
15721 PLFLT *arg24 = (PLFLT *) 0 ;
15722 PLFLT temp1 ;
15723 int res1 = SWIG_TMPOBJ ;
15724 PLFLT temp2 ;
15725 int res2 = SWIG_TMPOBJ ;
15726 int val3 ;
15727 int ecode3 = 0 ;
15728 int val4 ;
15729 int ecode4 = 0 ;
15730 double val5 ;
15731 int ecode5 = 0 ;
15732 double val6 ;
15733 int ecode6 = 0 ;
15734 double val7 ;
15735 int ecode7 = 0 ;
15736 double val8 ;
15737 int ecode8 = 0 ;
15738 int val9 ;
15739 int ecode9 = 0 ;
15740 int val10 ;
15741 int ecode10 = 0 ;
15742 int val11 ;
15743 int ecode11 = 0 ;
15744 double val12 ;
15745 int ecode12 = 0 ;
15746 double val13 ;
15747 int ecode13 = 0 ;
15748 int val14 ;
15749 int ecode14 = 0 ;
15750 double val15 ;
15751 int ecode15 = 0 ;
15752 Matrix temp16 ;
15753 Matrix temp21 ;
15754 Matrix temp22 ;
15755 Matrix temp23 ;
15756 Matrix temp24 ;
15757 octave_value_list _out;
15758 octave_value_list *_outp=&_out;
15759 octave_value _outv;
15760
15761 try {
15762 arg1 = &temp1;
15763 arg2 = &temp2;
15764 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15765 SWIG_fail;
15766 }
15767 ecode3 = SWIG_AsVal_int(args(0), &val3);
15768 if (!SWIG_IsOK(ecode3)) {
15769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15770 }
15771 arg3 = static_cast< PLINT >(val3);
15772 ecode4 = SWIG_AsVal_int(args(1), &val4);
15773 if (!SWIG_IsOK(ecode4)) {
15774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15775 }
15776 arg4 = static_cast< PLINT >(val4);
15777 ecode5 = SWIG_AsVal_double(args(2), &val5);
15778 if (!SWIG_IsOK(ecode5)) {
15779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15780 }
15781 arg5 = static_cast< PLFLT >(val5);
15782 ecode6 = SWIG_AsVal_double(args(3), &val6);
15783 if (!SWIG_IsOK(ecode6)) {
15784 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15785 }
15786 arg6 = static_cast< PLFLT >(val6);
15787 ecode7 = SWIG_AsVal_double(args(4), &val7);
15788 if (!SWIG_IsOK(ecode7)) {
15789 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15790 }
15791 arg7 = static_cast< PLFLT >(val7);
15792 ecode8 = SWIG_AsVal_double(args(5), &val8);
15793 if (!SWIG_IsOK(ecode8)) {
15794 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15795 }
15796 arg8 = static_cast< PLFLT >(val8);
15797 ecode9 = SWIG_AsVal_int(args(6), &val9);
15798 if (!SWIG_IsOK(ecode9)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15800 }
15801 arg9 = static_cast< PLINT >(val9);
15802 ecode10 = SWIG_AsVal_int(args(7), &val10);
15803 if (!SWIG_IsOK(ecode10)) {
15804 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15805 }
15806 arg10 = static_cast< PLINT >(val10);
15807 ecode11 = SWIG_AsVal_int(args(8), &val11);
15808 if (!SWIG_IsOK(ecode11)) {
15809 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15810 }
15811 arg11 = static_cast< PLINT >(val11);
15812 ecode12 = SWIG_AsVal_double(args(9), &val12);
15813 if (!SWIG_IsOK(ecode12)) {
15814 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15815 }
15816 arg12 = static_cast< PLFLT >(val12);
15817 ecode13 = SWIG_AsVal_double(args(10), &val13);
15818 if (!SWIG_IsOK(ecode13)) {
15819 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15820 }
15821 arg13 = static_cast< PLFLT >(val13);
15822 ecode14 = SWIG_AsVal_int(args(11), &val14);
15823 if (!SWIG_IsOK(ecode14)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15825 }
15826 arg14 = static_cast< PLINT >(val14);
15827 ecode15 = SWIG_AsVal_double(args(12), &val15);
15828 if (!SWIG_IsOK(ecode15)) {
15829 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15830 }
15831 arg15 = static_cast< PLFLT >(val15);
15832 {
15833 if ( _n_dims( args(13) ) > 1 )
15834 {
15835 error( "argument must be a scalar or vector" ); SWIG_fail;
15836 }
15837 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15838 arg17 = new PLINT[Alen];
15839 temp16 = args(13).matrix_value();
15840 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15841 }
15842 {
15843 charMatrix temp_matrix;
15844 Cell temp_cell;
15845 char *tmp_cstring;
15846 std::string str;
15847 size_t max_length = 0, non_blank_length;
15848 int i, ifcell;
15849 if ( _n_dims( args(14) ) > 2 )
15850 {
15851 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15852 }
15853#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15854 if ( !args(14).isempty() )
15855#else
15856 if ( !args(14).is_empty() )
15857#endif
15858 {
15859 if ( _dim( args(14), 0 ) != Alen )
15860 {
15861 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15862 }
15863 arg18 = new char*[Alen];
15864#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15865 ifcell = args(14).iscell();
15866#else
15867 ifcell = args(14).is_cell();
15868#endif
15869 if ( ifcell )
15870 {
15871 temp_cell = args(14).cell_value();
15872 }
15873 else
15874 {
15875 temp_matrix = args(14).char_matrix_value();
15876 // Allow one extra space for null termination.
15877 max_length = _dim( args(14), 1 ) + 1;
15878 }
15879
15880 for ( i = 0; i < Alen; i++ )
15881 {
15882 // Must copy string to "permanent" location because the string
15883 // location corresponding to tmp_cstring gets
15884 // overwritten for each iteration of loop.
15885 if ( ifcell )
15886 {
15887 if ( temp_cell.elem( i ).is_string() )
15888 {
15889 str = temp_cell.elem( i ).string_value();
15890 // leave room for null termination.
15891 max_length = str.size() + 1;
15892 tmp_cstring = (char *) str.c_str();
15893 }
15894 else
15895 {
15896 // Use null string if user attempts to pass a cell array
15897 // with a non-string element (likely an empty element
15898 // since that should be allowed by the PLplot interface
15899 // if that element is going to be unused).
15900 // leave room for null termination.
15901 max_length = 1;
15902 tmp_cstring = (char *) "";
15903 }
15904 }
15905 else
15906 {
15907 str = temp_matrix.row_as_string( i );
15908 tmp_cstring = (char *) str.c_str();
15909 }
15910 arg18[i] = new char[max_length];
15911 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15912 arg18[i][max_length - 1] = '\0';
15913 // All the trailing blank crapola should not be needed for
15914 // string cell arrays.
15915 if ( !ifcell )
15916 {
15917 // remove trailing-blank padding that is used by the
15918 // charMatrix class to insure all strings in a given
15919 // charMatrix instance have the same length.
15920 // This transformation also removes legitimate trailing
15921 // blanks but there is nothing we can do about that
15922 // for the charMatrix class.
15923
15924 // Look for trailing nulls first (just in case, although that
15925 // shouldn't happen if charMatrix implemented as documented)
15926 // before looking for trailing blanks.
15927 non_blank_length = max_length - 2;
15928 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15929 {
15930 non_blank_length--;
15931 }
15932 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15933 {
15934 non_blank_length--;
15935 }
15936 arg18[i][non_blank_length + 1] = '\0';
15937 }
15938 }
15939 }
15940 else
15941 {
15942 arg18 = NULL;
15943 }
15944 }
15945 {
15946 charMatrix temp_matrix;
15947 Cell temp_cell;
15948 char *tmp_cstring;
15949 std::string str;
15950 size_t max_length = 0, non_blank_length;
15951 int i, ifcell;
15952 if ( _n_dims( args(15) ) > 2 )
15953 {
15954 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15955 }
15956#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15957 if ( !args(15).isempty() )
15958#else
15959 if ( !args(15).is_empty() )
15960#endif
15961 {
15962 Alen = _dim( args(15), 0 );
15963 arg19 = Alen;
15964 arg20 = new char*[Alen];
15965#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15966 ifcell = args(15).iscell();
15967#else
15968 ifcell = args(15).is_cell();
15969#endif
15970 if ( ifcell )
15971 {
15972 temp_cell = args(15).cell_value();
15973 }
15974 else
15975 {
15976 temp_matrix = args(15).char_matrix_value();
15977 // Allow one extra space for null termination.
15978 max_length = _dim( args(15), 1 ) + 1;
15979 }
15980
15981 for ( i = 0; i < Alen; i++ )
15982 {
15983 // Must copy string to "permanent" location because the string
15984 // location corresponding to tmp_cstring gets
15985 // overwritten for each iteration of loop.
15986 if ( ifcell )
15987 {
15988 if ( temp_cell.elem( i ).is_string() )
15989 {
15990 str = temp_cell.elem( i ).string_value();
15991 // leave room for null termination.
15992 max_length = str.size() + 1;
15993 tmp_cstring = (char *) str.c_str();
15994 }
15995 else
15996 {
15997 // Use null string if user attempts to pass a cell array
15998 // with a non-string element (likely an empty element
15999 // since that should be allowed by the PLplot interface
16000 // if that element is going to be unused).
16001 // leave room for null termination.
16002 max_length = 1;
16003 tmp_cstring = (char *) "";
16004 }
16005 }
16006 else
16007 {
16008 str = temp_matrix.row_as_string( i );
16009 tmp_cstring = (char *) str.c_str();
16010 }
16011 arg20[i] = new char[max_length];
16012 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16013 arg20[i][max_length - 1] = '\0';
16014 // All the trailing blank crapola should not be needed for
16015 // string cell arrays.
16016 if ( !ifcell )
16017 {
16018 // remove trailing-blank padding that is used by the
16019 // charMatrix class to insure all strings in a given
16020 // charMatrix instance have the same length.
16021 // This transformation also removes legitimate trailing
16022 // blanks but there is nothing we can do about that
16023 // for the charMatrix class.
16024
16025 // Look for trailing nulls first (just in case, although that
16026 // shouldn't happen if charMatrix implemented as documented)
16027 // before looking for trailing blanks.
16028 non_blank_length = max_length - 2;
16029 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16030 {
16031 non_blank_length--;
16032 }
16033 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16034 {
16035 non_blank_length--;
16036 }
16037 arg20[i][non_blank_length + 1] = '\0';
16038 }
16039 }
16040 }
16041 else
16042 {
16043 arg19 = 0;
16044 arg20 = NULL;
16045 }
16046 }
16047 {
16048 if ( _n_dims( args(16) ) > 1 )
16049 {
16050 error( "argument must be a scalar or vector" ); SWIG_fail;
16051 }
16052 if ( _dim( args(16), 0 ) != Alen )
16053 {
16054 error( "argument vectors must be same length" ); SWIG_fail;
16055 }
16056 temp21 = args(16).matrix_value();
16057 arg21 = &temp21( 0, 0 );
16058 }
16059 {
16060 if ( _n_dims( args(17) ) > 1 )
16061 {
16062 error( "argument must be a scalar or vector" ); SWIG_fail;
16063 }
16064 if ( _dim( args(17), 0 ) != Alen )
16065 {
16066 error( "argument vectors must be same length" ); SWIG_fail;
16067 }
16068 temp22 = args(17).matrix_value();
16069 arg22 = new PLINT[Alen];
16070 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16071 }
16072 {
16073 int i;
16074 if ( _n_dims( args(18) ) > 1 )
16075 {
16076 error( "argument must be a scalar or vector" ); SWIG_fail;
16077 }
16078 if ( _dim( args(18), 0 ) != Alen )
16079 {
16080 error( "argument vectors must be same length" ); SWIG_fail;
16081 }
16082 Xlen = Alen;
16083 temp23 = args(18).matrix_value();
16084 arg23 = new PLINT[Alen];
16085 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16086 Ylen = -1;
16087 for ( i = 0; i < Xlen; i++ )
16088 if ( arg23[i] > Ylen )
16089 Ylen = arg23[i];
16090 }
16091 {
16092 if ( _n_dims( args(19) ) > 2 )
16093 {
16094 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16095 }
16096 if ( _dim( args(19), 0 ) != Xlen )
16097 {
16098 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16099 }
16100 if ( _dim( args(19), 1 ) != Ylen )
16101 {
16102 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16103 }
16104 temp24 = args(19).matrix_value();
16105 arg24 = &temp24( 0, 0 );
16106 }
16107 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);
16108 _outv = octave_value();
16109 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16110 if (SWIG_IsTmpObj(res1)) {
16111 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16112 } else {
16113 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16114 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16115 }
16116 if (SWIG_IsTmpObj(res2)) {
16117 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16118 } else {
16119 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16120 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16121 }
16122 {
16123 delete [] arg17;
16124 }
16125 {
16126 int i;
16127 if ( arg18 != NULL )
16128 {
16129 for ( i = 0; i < Alen; i++ )
16130 {
16131 delete[] arg18[i];
16132 }
16133 delete[] arg18;
16134 }
16135 }
16136 {
16137 int i;
16138 if ( arg20 != NULL )
16139 {
16140 for ( i = 0; i < Alen; i++ )
16141 {
16142 delete[] arg20[i];
16143 }
16144 delete[] arg20;
16145 }
16146 }
16147 {
16148
16149 }
16150 {
16151 delete [] arg22;
16152 }
16153 {
16154 delete [] arg23;
16155 }
16156 {
16157
16158 }
16159 return _out;
16160 fail:
16161 {
16162 delete [] arg17;
16163 }
16164 {
16165 int i;
16166 if ( arg18 != NULL )
16167 {
16168 for ( i = 0; i < Alen; i++ )
16169 {
16170 delete[] arg18[i];
16171 }
16172 delete[] arg18;
16173 }
16174 }
16175 {
16176 int i;
16177 if ( arg20 != NULL )
16178 {
16179 for ( i = 0; i < Alen; i++ )
16180 {
16181 delete[] arg20[i];
16182 }
16183 delete[] arg20;
16184 }
16185 }
16186 {
16187
16188 }
16189 {
16190 delete [] arg22;
16191 }
16192 {
16193 delete [] arg23;
16194 }
16195 {
16196
16197 }
16198 return octave_value_list();
16199 }
16200 catch(...) {
16201 {
16202 delete [] arg17;
16203 }
16204 {
16205 int i;
16206 if ( arg18 != NULL )
16207 {
16208 for ( i = 0; i < Alen; i++ )
16209 {
16210 delete[] arg18[i];
16211 }
16212 delete[] arg18;
16213 }
16214 }
16215 {
16216 int i;
16217 if ( arg20 != NULL )
16218 {
16219 for ( i = 0; i < Alen; i++ )
16220 {
16221 delete[] arg20[i];
16222 }
16223 delete[] arg20;
16224 }
16225 }
16226 {
16227
16228 }
16229 {
16230 delete [] arg22;
16231 }
16232 {
16233 delete [] arg23;
16234 }
16235 {
16236
16237 }
16238 throw;
16239 }
16240}
16241
16242
16243SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16244 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16245 int arg2 ;
16246 void *argp1 = 0 ;
16247 int res1 = 0 ;
16248 int val2 ;
16249 int ecode2 = 0 ;
16250 octave_value_list _out;
16251 octave_value_list *_outp=&_out;
16252 octave_value _outv;
16253
16254 try {
16255 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16256 SWIG_fail;
16257 }
16258 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16259 if (!SWIG_IsOK(res1)) {
16260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16261 }
16262 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16263 ecode2 = SWIG_AsVal_int(args(1), &val2);
16264 if (!SWIG_IsOK(ecode2)) {
16265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16266 }
16267 arg2 = static_cast< int >(val2);
16268 if (arg1) (arg1)->type = arg2;
16269 _outv = octave_value();
16270 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16271 return _out;
16272 fail:
16273 return octave_value_list();
16274 }
16275 catch(...) {
16276 throw;
16277 }
16278}
16279
16280
16281SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16282 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 octave_value_list _out;
16286 octave_value_list *_outp=&_out;
16287 octave_value _outv;
16288 int result;
16289
16290 try {
16291 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16292 SWIG_fail;
16293 }
16294 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16297 }
16298 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16299 result = (int) ((arg1)->type);
16300 _outv = SWIG_From_int(static_cast< int >(result));
16301 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16302 return _out;
16303 fail:
16304 return octave_value_list();
16305 }
16306 catch(...) {
16307 throw;
16308 }
16309}
16310
16311
16312SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16313 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16314 unsigned int arg2 ;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 unsigned int val2 ;
16318 int ecode2 = 0 ;
16319 octave_value_list _out;
16320 octave_value_list *_outp=&_out;
16321 octave_value _outv;
16322
16323 try {
16324 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16325 SWIG_fail;
16326 }
16327 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16328 if (!SWIG_IsOK(res1)) {
16329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16330 }
16331 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16332 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16333 if (!SWIG_IsOK(ecode2)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16335 }
16336 arg2 = static_cast< unsigned int >(val2);
16337 if (arg1) (arg1)->state = arg2;
16338 _outv = octave_value();
16339 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16340 return _out;
16341 fail:
16342 return octave_value_list();
16343 }
16344 catch(...) {
16345 throw;
16346 }
16347}
16348
16349
16350SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16351 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16352 void *argp1 = 0 ;
16353 int res1 = 0 ;
16354 octave_value_list _out;
16355 octave_value_list *_outp=&_out;
16356 octave_value _outv;
16357 unsigned int result;
16358
16359 try {
16360 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16361 SWIG_fail;
16362 }
16363 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16364 if (!SWIG_IsOK(res1)) {
16365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16366 }
16367 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16368 result = (unsigned int) ((arg1)->state);
16369 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16370 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16371 return _out;
16372 fail:
16373 return octave_value_list();
16374 }
16375 catch(...) {
16376 throw;
16377 }
16378}
16379
16380
16381SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16382 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16383 unsigned int arg2 ;
16384 void *argp1 = 0 ;
16385 int res1 = 0 ;
16386 unsigned int val2 ;
16387 int ecode2 = 0 ;
16388 octave_value_list _out;
16389 octave_value_list *_outp=&_out;
16390 octave_value _outv;
16391
16392 try {
16393 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16394 SWIG_fail;
16395 }
16396 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16397 if (!SWIG_IsOK(res1)) {
16398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16399 }
16400 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16401 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16402 if (!SWIG_IsOK(ecode2)) {
16403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16404 }
16405 arg2 = static_cast< unsigned int >(val2);
16406 if (arg1) (arg1)->keysym = arg2;
16407 _outv = octave_value();
16408 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16409 return _out;
16410 fail:
16411 return octave_value_list();
16412 }
16413 catch(...) {
16414 throw;
16415 }
16416}
16417
16418
16419SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16420 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16421 void *argp1 = 0 ;
16422 int res1 = 0 ;
16423 octave_value_list _out;
16424 octave_value_list *_outp=&_out;
16425 octave_value _outv;
16426 unsigned int result;
16427
16428 try {
16429 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16430 SWIG_fail;
16431 }
16432 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16433 if (!SWIG_IsOK(res1)) {
16434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16435 }
16436 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16437 result = (unsigned int) ((arg1)->keysym);
16438 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16439 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16440 return _out;
16441 fail:
16442 return octave_value_list();
16443 }
16444 catch(...) {
16445 throw;
16446 }
16447}
16448
16449
16450SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16451 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16452 unsigned int arg2 ;
16453 void *argp1 = 0 ;
16454 int res1 = 0 ;
16455 unsigned int val2 ;
16456 int ecode2 = 0 ;
16457 octave_value_list _out;
16458 octave_value_list *_outp=&_out;
16459 octave_value _outv;
16460
16461 try {
16462 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16463 SWIG_fail;
16464 }
16465 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16468 }
16469 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16470 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16471 if (!SWIG_IsOK(ecode2)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16473 }
16474 arg2 = static_cast< unsigned int >(val2);
16475 if (arg1) (arg1)->button = arg2;
16476 _outv = octave_value();
16477 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16478 return _out;
16479 fail:
16480 return octave_value_list();
16481 }
16482 catch(...) {
16483 throw;
16484 }
16485}
16486
16487
16488SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16489 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 octave_value_list _out;
16493 octave_value_list *_outp=&_out;
16494 octave_value _outv;
16495 unsigned int result;
16496
16497 try {
16498 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16499 SWIG_fail;
16500 }
16501 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16502 if (!SWIG_IsOK(res1)) {
16503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16504 }
16505 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16506 result = (unsigned int) ((arg1)->button);
16507 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16508 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16509 return _out;
16510 fail:
16511 return octave_value_list();
16512 }
16513 catch(...) {
16514 throw;
16515 }
16516}
16517
16518
16519SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16520 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16521 PLINT arg2 ;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 int val2 ;
16525 int ecode2 = 0 ;
16526 octave_value_list _out;
16527 octave_value_list *_outp=&_out;
16528 octave_value _outv;
16529
16530 try {
16531 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16532 SWIG_fail;
16533 }
16534 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16535 if (!SWIG_IsOK(res1)) {
16536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16537 }
16538 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16539 ecode2 = SWIG_AsVal_int(args(1), &val2);
16540 if (!SWIG_IsOK(ecode2)) {
16541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16542 }
16543 arg2 = static_cast< PLINT >(val2);
16544 if (arg1) (arg1)->subwindow = arg2;
16545 _outv = octave_value();
16546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16547 return _out;
16548 fail:
16549 return octave_value_list();
16550 }
16551 catch(...) {
16552 throw;
16553 }
16554}
16555
16556
16557SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16558 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16559 void *argp1 = 0 ;
16560 int res1 = 0 ;
16561 octave_value_list _out;
16562 octave_value_list *_outp=&_out;
16563 octave_value _outv;
16564 PLINT result;
16565
16566 try {
16567 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16568 SWIG_fail;
16569 }
16570 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16571 if (!SWIG_IsOK(res1)) {
16572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16573 }
16574 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16575 result = (PLINT) ((arg1)->subwindow);
16576 _outv = SWIG_From_int(static_cast< int >(result));
16577 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16578 return _out;
16579 fail:
16580 return octave_value_list();
16581 }
16582 catch(...) {
16583 throw;
16584 }
16585}
16586
16587
16588SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16589 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16590 char *arg2 = (char *) (char *)0 ;
16591 void *argp1 = 0 ;
16592 int res1 = 0 ;
16593 char temp2[16] ;
16594 int res2 ;
16595 octave_value_list _out;
16596 octave_value_list *_outp=&_out;
16597 octave_value _outv;
16598
16599 try {
16600 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16601 SWIG_fail;
16602 }
16603 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16604 if (!SWIG_IsOK(res1)) {
16605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16606 }
16607 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16608 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16609 if (!SWIG_IsOK(res2)) {
16610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16611 }
16612 arg2 = reinterpret_cast< char * >(temp2);
16613 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16614 else memset(arg1->string,0,16*sizeof(char));
16615 _outv = octave_value();
16616 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16617 return _out;
16618 fail:
16619 return octave_value_list();
16620 }
16621 catch(...) {
16622 throw;
16623 }
16624}
16625
16626
16627SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16628 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16629 void *argp1 = 0 ;
16630 int res1 = 0 ;
16631 octave_value_list _out;
16632 octave_value_list *_outp=&_out;
16633 octave_value _outv;
16634 char *result = 0 ;
16635
16636 try {
16637 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16638 SWIG_fail;
16639 }
16640 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16643 }
16644 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16645 result = (char *)(char *) ((arg1)->string);
16646 {
16647 size_t size = SWIG_strnlen(result, 16);
16648
16649
16650
16651 _outv = SWIG_FromCharPtrAndSize(result, size);
16652 }
16653 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16654 return _out;
16655 fail:
16656 return octave_value_list();
16657 }
16658 catch(...) {
16659 throw;
16660 }
16661}
16662
16663
16664SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16665 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16666 int arg2 ;
16667 void *argp1 = 0 ;
16668 int res1 = 0 ;
16669 int val2 ;
16670 int ecode2 = 0 ;
16671 octave_value_list _out;
16672 octave_value_list *_outp=&_out;
16673 octave_value _outv;
16674
16675 try {
16676 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16677 SWIG_fail;
16678 }
16679 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16680 if (!SWIG_IsOK(res1)) {
16681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16682 }
16683 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16684 ecode2 = SWIG_AsVal_int(args(1), &val2);
16685 if (!SWIG_IsOK(ecode2)) {
16686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16687 }
16688 arg2 = static_cast< int >(val2);
16689 if (arg1) (arg1)->pX = arg2;
16690 _outv = octave_value();
16691 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16692 return _out;
16693 fail:
16694 return octave_value_list();
16695 }
16696 catch(...) {
16697 throw;
16698 }
16699}
16700
16701
16702SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16703 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16704 void *argp1 = 0 ;
16705 int res1 = 0 ;
16706 octave_value_list _out;
16707 octave_value_list *_outp=&_out;
16708 octave_value _outv;
16709 int result;
16710
16711 try {
16712 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16713 SWIG_fail;
16714 }
16715 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16716 if (!SWIG_IsOK(res1)) {
16717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16718 }
16719 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16720 result = (int) ((arg1)->pX);
16721 _outv = SWIG_From_int(static_cast< int >(result));
16722 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16723 return _out;
16724 fail:
16725 return octave_value_list();
16726 }
16727 catch(...) {
16728 throw;
16729 }
16730}
16731
16732
16733SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16734 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16735 int arg2 ;
16736 void *argp1 = 0 ;
16737 int res1 = 0 ;
16738 int val2 ;
16739 int ecode2 = 0 ;
16740 octave_value_list _out;
16741 octave_value_list *_outp=&_out;
16742 octave_value _outv;
16743
16744 try {
16745 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16746 SWIG_fail;
16747 }
16748 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16749 if (!SWIG_IsOK(res1)) {
16750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16751 }
16752 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16753 ecode2 = SWIG_AsVal_int(args(1), &val2);
16754 if (!SWIG_IsOK(ecode2)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16756 }
16757 arg2 = static_cast< int >(val2);
16758 if (arg1) (arg1)->pY = arg2;
16759 _outv = octave_value();
16760 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16761 return _out;
16762 fail:
16763 return octave_value_list();
16764 }
16765 catch(...) {
16766 throw;
16767 }
16768}
16769
16770
16771SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16772 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 octave_value_list _out;
16776 octave_value_list *_outp=&_out;
16777 octave_value _outv;
16778 int result;
16779
16780 try {
16781 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16782 SWIG_fail;
16783 }
16784 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16785 if (!SWIG_IsOK(res1)) {
16786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16787 }
16788 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16789 result = (int) ((arg1)->pY);
16790 _outv = SWIG_From_int(static_cast< int >(result));
16791 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16792 return _out;
16793 fail:
16794 return octave_value_list();
16795 }
16796 catch(...) {
16797 throw;
16798 }
16799}
16800
16801
16802SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16803 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16804 PLFLT arg2 ;
16805 void *argp1 = 0 ;
16806 int res1 = 0 ;
16807 double val2 ;
16808 int ecode2 = 0 ;
16809 octave_value_list _out;
16810 octave_value_list *_outp=&_out;
16811 octave_value _outv;
16812
16813 try {
16814 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16815 SWIG_fail;
16816 }
16817 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16818 if (!SWIG_IsOK(res1)) {
16819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16820 }
16821 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16822 ecode2 = SWIG_AsVal_double(args(1), &val2);
16823 if (!SWIG_IsOK(ecode2)) {
16824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16825 }
16826 arg2 = static_cast< PLFLT >(val2);
16827 if (arg1) (arg1)->dX = arg2;
16828 _outv = octave_value();
16829 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16830 return _out;
16831 fail:
16832 return octave_value_list();
16833 }
16834 catch(...) {
16835 throw;
16836 }
16837}
16838
16839
16840SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16841 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 octave_value_list _out;
16845 octave_value_list *_outp=&_out;
16846 octave_value _outv;
16847 PLFLT result;
16848
16849 try {
16850 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16851 SWIG_fail;
16852 }
16853 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16856 }
16857 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16858 result = (PLFLT) ((arg1)->dX);
16859 _outv = SWIG_From_double(static_cast< double >(result));
16860 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16861 return _out;
16862 fail:
16863 return octave_value_list();
16864 }
16865 catch(...) {
16866 throw;
16867 }
16868}
16869
16870
16871SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16872 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16873 PLFLT arg2 ;
16874 void *argp1 = 0 ;
16875 int res1 = 0 ;
16876 double val2 ;
16877 int ecode2 = 0 ;
16878 octave_value_list _out;
16879 octave_value_list *_outp=&_out;
16880 octave_value _outv;
16881
16882 try {
16883 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16884 SWIG_fail;
16885 }
16886 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16887 if (!SWIG_IsOK(res1)) {
16888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16889 }
16890 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16891 ecode2 = SWIG_AsVal_double(args(1), &val2);
16892 if (!SWIG_IsOK(ecode2)) {
16893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16894 }
16895 arg2 = static_cast< PLFLT >(val2);
16896 if (arg1) (arg1)->dY = arg2;
16897 _outv = octave_value();
16898 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16899 return _out;
16900 fail:
16901 return octave_value_list();
16902 }
16903 catch(...) {
16904 throw;
16905 }
16906}
16907
16908
16909SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16910 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16911 void *argp1 = 0 ;
16912 int res1 = 0 ;
16913 octave_value_list _out;
16914 octave_value_list *_outp=&_out;
16915 octave_value _outv;
16916 PLFLT result;
16917
16918 try {
16919 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16920 SWIG_fail;
16921 }
16922 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16923 if (!SWIG_IsOK(res1)) {
16924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16925 }
16926 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16927 result = (PLFLT) ((arg1)->dY);
16928 _outv = SWIG_From_double(static_cast< double >(result));
16929 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16930 return _out;
16931 fail:
16932 return octave_value_list();
16933 }
16934 catch(...) {
16935 throw;
16936 }
16937}
16938
16939
16940SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16941 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16942 PLFLT arg2 ;
16943 void *argp1 = 0 ;
16944 int res1 = 0 ;
16945 double val2 ;
16946 int ecode2 = 0 ;
16947 octave_value_list _out;
16948 octave_value_list *_outp=&_out;
16949 octave_value _outv;
16950
16951 try {
16952 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16953 SWIG_fail;
16954 }
16955 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16956 if (!SWIG_IsOK(res1)) {
16957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16958 }
16959 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16960 ecode2 = SWIG_AsVal_double(args(1), &val2);
16961 if (!SWIG_IsOK(ecode2)) {
16962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16963 }
16964 arg2 = static_cast< PLFLT >(val2);
16965 if (arg1) (arg1)->wX = arg2;
16966 _outv = octave_value();
16967 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16968 return _out;
16969 fail:
16970 return octave_value_list();
16971 }
16972 catch(...) {
16973 throw;
16974 }
16975}
16976
16977
16978SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16979 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16980 void *argp1 = 0 ;
16981 int res1 = 0 ;
16982 octave_value_list _out;
16983 octave_value_list *_outp=&_out;
16984 octave_value _outv;
16985 PLFLT result;
16986
16987 try {
16988 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16989 SWIG_fail;
16990 }
16991 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16992 if (!SWIG_IsOK(res1)) {
16993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16994 }
16995 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16996 result = (PLFLT) ((arg1)->wX);
16997 _outv = SWIG_From_double(static_cast< double >(result));
16998 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16999 return _out;
17000 fail:
17001 return octave_value_list();
17002 }
17003 catch(...) {
17004 throw;
17005 }
17006}
17007
17008
17009SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
17010 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17011 PLFLT arg2 ;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 double val2 ;
17015 int ecode2 = 0 ;
17016 octave_value_list _out;
17017 octave_value_list *_outp=&_out;
17018 octave_value _outv;
17019
17020 try {
17021 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
17022 SWIG_fail;
17023 }
17024 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17027 }
17028 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17029 ecode2 = SWIG_AsVal_double(args(1), &val2);
17030 if (!SWIG_IsOK(ecode2)) {
17031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
17032 }
17033 arg2 = static_cast< PLFLT >(val2);
17034 if (arg1) (arg1)->wY = arg2;
17035 _outv = octave_value();
17036 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17037 return _out;
17038 fail:
17039 return octave_value_list();
17040 }
17041 catch(...) {
17042 throw;
17043 }
17044}
17045
17046
17047SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
17048 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17049 void *argp1 = 0 ;
17050 int res1 = 0 ;
17051 octave_value_list _out;
17052 octave_value_list *_outp=&_out;
17053 octave_value _outv;
17054 PLFLT result;
17055
17056 try {
17057 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
17058 SWIG_fail;
17059 }
17060 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17063 }
17064 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17065 result = (PLFLT) ((arg1)->wY);
17066 _outv = SWIG_From_double(static_cast< double >(result));
17067 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17068 return _out;
17069 fail:
17070 return octave_value_list();
17071 }
17072 catch(...) {
17073 throw;
17074 }
17075}
17076
17077
17078SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
17079 octave_value_list _out;
17080 octave_value_list *_outp=&_out;
17081 octave_value _outv;
17082 PLGraphicsIn *result = 0 ;
17083
17084 try {
17085 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17086 SWIG_fail;
17087 }
17088 result = (PLGraphicsIn *)new PLGraphicsIn();
17090 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17091 return _out;
17092 fail:
17093 return octave_value_list();
17094 }
17095 catch(...) {
17096 throw;
17097 }
17098}
17099
17100
17101SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17102 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17103 void *argp1 = 0 ;
17104 int res1 = 0 ;
17105 octave_value_list _out;
17106 octave_value_list *_outp=&_out;
17107 octave_value _outv;
17108
17109 try {
17110 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17111 SWIG_fail;
17112 }
17113 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17114 if (!SWIG_IsOK(res1)) {
17115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17116 }
17117 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17118 delete arg1;
17119 _outv = octave_value();
17120 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17121 return _out;
17122 fail:
17123 return octave_value_list();
17124 }
17125 catch(...) {
17126 throw;
17127 }
17128}
17129
17130
17146static const char *swig_PLGraphicsIn_base_names[] = {0};
17149
17151 PLINT arg1 ;
17152 PLINT arg2 ;
17153 int val1 ;
17154 int ecode1 = 0 ;
17155 int val2 ;
17156 int ecode2 = 0 ;
17157 octave_value_list _out;
17158 octave_value_list *_outp=&_out;
17159 octave_value _outv;
17160
17161 try {
17162 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17163 SWIG_fail;
17164 }
17165 ecode1 = SWIG_AsVal_int(args(0), &val1);
17166 if (!SWIG_IsOK(ecode1)) {
17167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17168 }
17169 arg1 = static_cast< PLINT >(val1);
17170 ecode2 = SWIG_AsVal_int(args(1), &val2);
17171 if (!SWIG_IsOK(ecode2)) {
17172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17173 }
17174 arg2 = static_cast< PLINT >(val2);
17175 pl_setcontlabelformat(arg1,arg2);
17176 _outv = octave_value();
17177 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17178 return _out;
17179 fail:
17180 return octave_value_list();
17181 }
17182 catch(...) {
17183 throw;
17184 }
17185}
17186
17187
17189 PLFLT arg1 ;
17190 PLFLT arg2 ;
17191 PLFLT arg3 ;
17192 PLINT arg4 ;
17193 double val1 ;
17194 int ecode1 = 0 ;
17195 double val2 ;
17196 int ecode2 = 0 ;
17197 double val3 ;
17198 int ecode3 = 0 ;
17199 int val4 ;
17200 int ecode4 = 0 ;
17201 octave_value_list _out;
17202 octave_value_list *_outp=&_out;
17203 octave_value _outv;
17204
17205 try {
17206 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17207 SWIG_fail;
17208 }
17209 ecode1 = SWIG_AsVal_double(args(0), &val1);
17210 if (!SWIG_IsOK(ecode1)) {
17211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17212 }
17213 arg1 = static_cast< PLFLT >(val1);
17214 ecode2 = SWIG_AsVal_double(args(1), &val2);
17215 if (!SWIG_IsOK(ecode2)) {
17216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17217 }
17218 arg2 = static_cast< PLFLT >(val2);
17219 ecode3 = SWIG_AsVal_double(args(2), &val3);
17220 if (!SWIG_IsOK(ecode3)) {
17221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17222 }
17223 arg3 = static_cast< PLFLT >(val3);
17224 ecode4 = SWIG_AsVal_int(args(3), &val4);
17225 if (!SWIG_IsOK(ecode4)) {
17226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17227 }
17228 arg4 = static_cast< PLINT >(val4);
17229 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17230 _outv = octave_value();
17231 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17232 return _out;
17233 fail:
17234 return octave_value_list();
17235 }
17236 catch(...) {
17237 throw;
17238 }
17239}
17240
17241
17243 PLINT arg1 ;
17244 int val1 ;
17245 int ecode1 = 0 ;
17246 octave_value_list _out;
17247 octave_value_list *_outp=&_out;
17248 octave_value _outv;
17249
17250 try {
17251 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17252 SWIG_fail;
17253 }
17254 ecode1 = SWIG_AsVal_int(args(0), &val1);
17255 if (!SWIG_IsOK(ecode1)) {
17256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17257 }
17258 arg1 = static_cast< PLINT >(val1);
17259 pladv(arg1);
17260 _outv = octave_value();
17261 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17262 return _out;
17263 fail:
17264 return octave_value_list();
17265 }
17266 catch(...) {
17267 throw;
17268 }
17269}
17270
17271
17273 PLFLT arg1 ;
17274 PLFLT arg2 ;
17275 PLFLT arg3 ;
17276 PLFLT arg4 ;
17277 PLFLT arg5 ;
17278 PLFLT arg6 ;
17279 PLFLT arg7 ;
17280 PLBOOL arg8 ;
17281 double val1 ;
17282 int ecode1 = 0 ;
17283 double val2 ;
17284 int ecode2 = 0 ;
17285 double val3 ;
17286 int ecode3 = 0 ;
17287 double val4 ;
17288 int ecode4 = 0 ;
17289 double val5 ;
17290 int ecode5 = 0 ;
17291 double val6 ;
17292 int ecode6 = 0 ;
17293 double val7 ;
17294 int ecode7 = 0 ;
17295 int val8 ;
17296 int ecode8 = 0 ;
17297 octave_value_list _out;
17298 octave_value_list *_outp=&_out;
17299 octave_value _outv;
17300
17301 try {
17302 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17303 SWIG_fail;
17304 }
17305 ecode1 = SWIG_AsVal_double(args(0), &val1);
17306 if (!SWIG_IsOK(ecode1)) {
17307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17308 }
17309 arg1 = static_cast< PLFLT >(val1);
17310 ecode2 = SWIG_AsVal_double(args(1), &val2);
17311 if (!SWIG_IsOK(ecode2)) {
17312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17313 }
17314 arg2 = static_cast< PLFLT >(val2);
17315 ecode3 = SWIG_AsVal_double(args(2), &val3);
17316 if (!SWIG_IsOK(ecode3)) {
17317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17318 }
17319 arg3 = static_cast< PLFLT >(val3);
17320 ecode4 = SWIG_AsVal_double(args(3), &val4);
17321 if (!SWIG_IsOK(ecode4)) {
17322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17323 }
17324 arg4 = static_cast< PLFLT >(val4);
17325 ecode5 = SWIG_AsVal_double(args(4), &val5);
17326 if (!SWIG_IsOK(ecode5)) {
17327 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17328 }
17329 arg5 = static_cast< PLFLT >(val5);
17330 ecode6 = SWIG_AsVal_double(args(5), &val6);
17331 if (!SWIG_IsOK(ecode6)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17333 }
17334 arg6 = static_cast< PLFLT >(val6);
17335 ecode7 = SWIG_AsVal_double(args(6), &val7);
17336 if (!SWIG_IsOK(ecode7)) {
17337 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17338 }
17339 arg7 = static_cast< PLFLT >(val7);
17340 ecode8 = SWIG_AsVal_int(args(7), &val8);
17341 if (!SWIG_IsOK(ecode8)) {
17342 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17343 }
17344 arg8 = static_cast< PLBOOL >(val8);
17345 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17346 _outv = octave_value();
17347 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17348 return _out;
17349 fail:
17350 return octave_value_list();
17351 }
17352 catch(...) {
17353 throw;
17354 }
17355}
17356
17357
17359 PLFLT arg1 ;
17360 PLFLT arg2 ;
17361 char *arg3 = (char *) 0 ;
17362 PLFLT arg4 ;
17363 PLINT arg5 ;
17364 char *arg6 = (char *) 0 ;
17365 PLFLT arg7 ;
17366 PLINT arg8 ;
17367 double val1 ;
17368 int ecode1 = 0 ;
17369 double val2 ;
17370 int ecode2 = 0 ;
17371 int res3 ;
17372 char *buf3 = 0 ;
17373 int alloc3 = 0 ;
17374 double val4 ;
17375 int ecode4 = 0 ;
17376 int val5 ;
17377 int ecode5 = 0 ;
17378 int res6 ;
17379 char *buf6 = 0 ;
17380 int alloc6 = 0 ;
17381 double val7 ;
17382 int ecode7 = 0 ;
17383 int val8 ;
17384 int ecode8 = 0 ;
17385 octave_value_list _out;
17386 octave_value_list *_outp=&_out;
17387 octave_value _outv;
17388
17389 try {
17390 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17391 SWIG_fail;
17392 }
17393 ecode1 = SWIG_AsVal_double(args(0), &val1);
17394 if (!SWIG_IsOK(ecode1)) {
17395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17396 }
17397 arg1 = static_cast< PLFLT >(val1);
17398 ecode2 = SWIG_AsVal_double(args(1), &val2);
17399 if (!SWIG_IsOK(ecode2)) {
17400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17401 }
17402 arg2 = static_cast< PLFLT >(val2);
17403 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17404 if (!SWIG_IsOK(res3)) {
17405 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17406 }
17407 arg3 = reinterpret_cast< char * >(buf3);
17408 ecode4 = SWIG_AsVal_double(args(3), &val4);
17409 if (!SWIG_IsOK(ecode4)) {
17410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17411 }
17412 arg4 = static_cast< PLFLT >(val4);
17413 ecode5 = SWIG_AsVal_int(args(4), &val5);
17414 if (!SWIG_IsOK(ecode5)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17416 }
17417 arg5 = static_cast< PLINT >(val5);
17418 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17419 if (!SWIG_IsOK(res6)) {
17420 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17421 }
17422 arg6 = reinterpret_cast< char * >(buf6);
17423 ecode7 = SWIG_AsVal_double(args(6), &val7);
17424 if (!SWIG_IsOK(ecode7)) {
17425 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17426 }
17427 arg7 = static_cast< PLFLT >(val7);
17428 ecode8 = SWIG_AsVal_int(args(7), &val8);
17429 if (!SWIG_IsOK(ecode8)) {
17430 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17431 }
17432 arg8 = static_cast< PLINT >(val8);
17433 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17434 _outv = octave_value();
17435 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17436 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17437 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17438 return _out;
17439 fail:
17440 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17441 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17442 return octave_value_list();
17443 }
17444 catch(...) {
17445 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17446 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17447 throw;
17448 }
17449}
17450
17451
17453 PLINT arg1 ;
17454 PLFLT *arg2 = (PLFLT *) 0 ;
17455 PLFLT *arg3 = (PLFLT *) 0 ;
17456 PLINT arg4 ;
17457 Matrix temp1 ;
17458 Matrix temp3 ;
17459 int val4 ;
17460 int ecode4 = 0 ;
17461 octave_value_list _out;
17462 octave_value_list *_outp=&_out;
17463 octave_value _outv;
17464
17465 try {
17466 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17467 SWIG_fail;
17468 }
17469 {
17470 if ( _n_dims( args(0) ) > 1 )
17471 {
17472 error( "argument must be a scalar or vector" ); SWIG_fail;
17473 }
17474 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17475 temp1 = args(0).matrix_value();
17476 arg2 = &temp1( 0, 0 );
17477 }
17478 {
17479 if ( _n_dims( args(1) ) > 1 )
17480 {
17481 error( "argument must be a scalar or vector" ); SWIG_fail;
17482 }
17483 if ( _dim( args(1), 0 ) != Alen )
17484 {
17485 error( "argument vectors must be same length" ); SWIG_fail;
17486 }
17487 temp3 = args(1).matrix_value();
17488 arg3 = &temp3( 0, 0 );
17489 }
17490 ecode4 = SWIG_AsVal_int(args(2), &val4);
17491 if (!SWIG_IsOK(ecode4)) {
17492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17493 }
17494 arg4 = static_cast< PLINT >(val4);
17495 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17496 _outv = octave_value();
17497 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17498 {
17499
17500 }
17501 {
17502
17503 }
17504 return _out;
17505 fail:
17506 {
17507
17508 }
17509 {
17510
17511 }
17512 return octave_value_list();
17513 }
17514 catch(...) {
17515 {
17516
17517 }
17518 {
17519
17520 }
17521 throw;
17522 }
17523}
17524
17525
17527 PLINT *arg1 = (PLINT *) 0 ;
17528 PLINT *arg2 = (PLINT *) 0 ;
17529 PLINT *arg3 = (PLINT *) 0 ;
17530 PLINT *arg4 = (PLINT *) 0 ;
17531 PLINT *arg5 = (PLINT *) 0 ;
17532 PLFLT *arg6 = (PLFLT *) 0 ;
17533 PLFLT arg7 ;
17534 PLINT temp1 ;
17535 int res1 = SWIG_TMPOBJ ;
17536 PLINT temp2 ;
17537 int res2 = SWIG_TMPOBJ ;
17538 PLINT temp3 ;
17539 int res3 = SWIG_TMPOBJ ;
17540 PLINT temp4 ;
17541 int res4 = SWIG_TMPOBJ ;
17542 PLINT temp5 ;
17543 int res5 = SWIG_TMPOBJ ;
17544 PLFLT temp6 ;
17545 int res6 = SWIG_TMPOBJ ;
17546 double val7 ;
17547 int ecode7 = 0 ;
17548 octave_value_list _out;
17549 octave_value_list *_outp=&_out;
17550 octave_value _outv;
17551
17552 try {
17553 arg1 = &temp1;
17554 arg2 = &temp2;
17555 arg3 = &temp3;
17556 arg4 = &temp4;
17557 arg5 = &temp5;
17558 arg6 = &temp6;
17559 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17560 SWIG_fail;
17561 }
17562 ecode7 = SWIG_AsVal_double(args(0), &val7);
17563 if (!SWIG_IsOK(ecode7)) {
17564 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17565 }
17566 arg7 = static_cast< PLFLT >(val7);
17567 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17568 _outv = octave_value();
17569 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17570 if (SWIG_IsTmpObj(res1)) {
17571 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17572 } else {
17573 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17574 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17575 }
17576 if (SWIG_IsTmpObj(res2)) {
17577 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17578 } else {
17579 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17580 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17581 }
17582 if (SWIG_IsTmpObj(res3)) {
17583 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17584 } else {
17585 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17586 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17587 }
17588 if (SWIG_IsTmpObj(res4)) {
17589 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17590 } else {
17591 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17592 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17593 }
17594 if (SWIG_IsTmpObj(res5)) {
17595 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17596 } else {
17597 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17598 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17599 }
17600 if (SWIG_IsTmpObj(res6)) {
17601 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17602 } else {
17603 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17604 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17605 }
17606 return _out;
17607 fail:
17608 return octave_value_list();
17609 }
17610 catch(...) {
17611 throw;
17612 }
17613}
17614
17615
17617 octave_value_list _out;
17618 octave_value_list *_outp=&_out;
17619 octave_value _outv;
17620
17621 try {
17622 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17623 SWIG_fail;
17624 }
17625 plbop();
17626 _outv = octave_value();
17627 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17628 return _out;
17629 fail:
17630 return octave_value_list();
17631 }
17632 catch(...) {
17633 throw;
17634 }
17635}
17636
17637
17639 char *arg1 = (char *) 0 ;
17640 PLFLT arg2 ;
17641 PLINT arg3 ;
17642 char *arg4 = (char *) 0 ;
17643 PLFLT arg5 ;
17644 PLINT arg6 ;
17645 int res1 ;
17646 char *buf1 = 0 ;
17647 int alloc1 = 0 ;
17648 double val2 ;
17649 int ecode2 = 0 ;
17650 int val3 ;
17651 int ecode3 = 0 ;
17652 int res4 ;
17653 char *buf4 = 0 ;
17654 int alloc4 = 0 ;
17655 double val5 ;
17656 int ecode5 = 0 ;
17657 int val6 ;
17658 int ecode6 = 0 ;
17659 octave_value_list _out;
17660 octave_value_list *_outp=&_out;
17661 octave_value _outv;
17662
17663 try {
17664 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17665 SWIG_fail;
17666 }
17667 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17668 if (!SWIG_IsOK(res1)) {
17669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17670 }
17671 arg1 = reinterpret_cast< char * >(buf1);
17672 ecode2 = SWIG_AsVal_double(args(1), &val2);
17673 if (!SWIG_IsOK(ecode2)) {
17674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17675 }
17676 arg2 = static_cast< PLFLT >(val2);
17677 ecode3 = SWIG_AsVal_int(args(2), &val3);
17678 if (!SWIG_IsOK(ecode3)) {
17679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17680 }
17681 arg3 = static_cast< PLINT >(val3);
17682 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17683 if (!SWIG_IsOK(res4)) {
17684 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17685 }
17686 arg4 = reinterpret_cast< char * >(buf4);
17687 ecode5 = SWIG_AsVal_double(args(4), &val5);
17688 if (!SWIG_IsOK(ecode5)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17690 }
17691 arg5 = static_cast< PLFLT >(val5);
17692 ecode6 = SWIG_AsVal_int(args(5), &val6);
17693 if (!SWIG_IsOK(ecode6)) {
17694 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17695 }
17696 arg6 = static_cast< PLINT >(val6);
17697 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17698 _outv = octave_value();
17699 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17700 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17701 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17702 return _out;
17703 fail:
17704 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17705 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17706 return octave_value_list();
17707 }
17708 catch(...) {
17709 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17710 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17711 throw;
17712 }
17713}
17714
17715
17717 char *arg1 = (char *) 0 ;
17718 char *arg2 = (char *) 0 ;
17719 PLFLT arg3 ;
17720 PLINT arg4 ;
17721 char *arg5 = (char *) 0 ;
17722 char *arg6 = (char *) 0 ;
17723 PLFLT arg7 ;
17724 PLINT arg8 ;
17725 char *arg9 = (char *) 0 ;
17726 char *arg10 = (char *) 0 ;
17727 PLFLT arg11 ;
17728 PLINT arg12 ;
17729 int res1 ;
17730 char *buf1 = 0 ;
17731 int alloc1 = 0 ;
17732 int res2 ;
17733 char *buf2 = 0 ;
17734 int alloc2 = 0 ;
17735 double val3 ;
17736 int ecode3 = 0 ;
17737 int val4 ;
17738 int ecode4 = 0 ;
17739 int res5 ;
17740 char *buf5 = 0 ;
17741 int alloc5 = 0 ;
17742 int res6 ;
17743 char *buf6 = 0 ;
17744 int alloc6 = 0 ;
17745 double val7 ;
17746 int ecode7 = 0 ;
17747 int val8 ;
17748 int ecode8 = 0 ;
17749 int res9 ;
17750 char *buf9 = 0 ;
17751 int alloc9 = 0 ;
17752 int res10 ;
17753 char *buf10 = 0 ;
17754 int alloc10 = 0 ;
17755 double val11 ;
17756 int ecode11 = 0 ;
17757 int val12 ;
17758 int ecode12 = 0 ;
17759 octave_value_list _out;
17760 octave_value_list *_outp=&_out;
17761 octave_value _outv;
17762
17763 try {
17764 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17765 SWIG_fail;
17766 }
17767 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17768 if (!SWIG_IsOK(res1)) {
17769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17770 }
17771 arg1 = reinterpret_cast< char * >(buf1);
17772 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17773 if (!SWIG_IsOK(res2)) {
17774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17775 }
17776 arg2 = reinterpret_cast< char * >(buf2);
17777 ecode3 = SWIG_AsVal_double(args(2), &val3);
17778 if (!SWIG_IsOK(ecode3)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17780 }
17781 arg3 = static_cast< PLFLT >(val3);
17782 ecode4 = SWIG_AsVal_int(args(3), &val4);
17783 if (!SWIG_IsOK(ecode4)) {
17784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17785 }
17786 arg4 = static_cast< PLINT >(val4);
17787 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17788 if (!SWIG_IsOK(res5)) {
17789 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17790 }
17791 arg5 = reinterpret_cast< char * >(buf5);
17792 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17793 if (!SWIG_IsOK(res6)) {
17794 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17795 }
17796 arg6 = reinterpret_cast< char * >(buf6);
17797 ecode7 = SWIG_AsVal_double(args(6), &val7);
17798 if (!SWIG_IsOK(ecode7)) {
17799 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17800 }
17801 arg7 = static_cast< PLFLT >(val7);
17802 ecode8 = SWIG_AsVal_int(args(7), &val8);
17803 if (!SWIG_IsOK(ecode8)) {
17804 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17805 }
17806 arg8 = static_cast< PLINT >(val8);
17807 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17808 if (!SWIG_IsOK(res9)) {
17809 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17810 }
17811 arg9 = reinterpret_cast< char * >(buf9);
17812 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17813 if (!SWIG_IsOK(res10)) {
17814 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17815 }
17816 arg10 = reinterpret_cast< char * >(buf10);
17817 ecode11 = SWIG_AsVal_double(args(10), &val11);
17818 if (!SWIG_IsOK(ecode11)) {
17819 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17820 }
17821 arg11 = static_cast< PLFLT >(val11);
17822 ecode12 = SWIG_AsVal_int(args(11), &val12);
17823 if (!SWIG_IsOK(ecode12)) {
17824 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17825 }
17826 arg12 = static_cast< PLINT >(val12);
17827 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);
17828 _outv = octave_value();
17829 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17830 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17831 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17832 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17833 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17834 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17835 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17836 return _out;
17837 fail:
17838 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17839 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17840 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17841 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17842 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17843 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17844 return octave_value_list();
17845 }
17846 catch(...) {
17847 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17848 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17849 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17850 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17851 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17852 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17853 throw;
17854 }
17855}
17856
17857
17859 PLFLT arg1 ;
17860 PLFLT arg2 ;
17861 PLFLT *arg3 = (PLFLT *) 0 ;
17862 PLFLT *arg4 = (PLFLT *) 0 ;
17863 PLINT *arg5 = (PLINT *) 0 ;
17864 double val1 ;
17865 int ecode1 = 0 ;
17866 double val2 ;
17867 int ecode2 = 0 ;
17868 PLFLT temp3 ;
17869 int res3 = SWIG_TMPOBJ ;
17870 PLFLT temp4 ;
17871 int res4 = SWIG_TMPOBJ ;
17872 PLINT temp5 ;
17873 int res5 = SWIG_TMPOBJ ;
17874 octave_value_list _out;
17875 octave_value_list *_outp=&_out;
17876 octave_value _outv;
17877
17878 try {
17879 arg3 = &temp3;
17880 arg4 = &temp4;
17881 arg5 = &temp5;
17882 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17883 SWIG_fail;
17884 }
17885 ecode1 = SWIG_AsVal_double(args(0), &val1);
17886 if (!SWIG_IsOK(ecode1)) {
17887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17888 }
17889 arg1 = static_cast< PLFLT >(val1);
17890 ecode2 = SWIG_AsVal_double(args(1), &val2);
17891 if (!SWIG_IsOK(ecode2)) {
17892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17893 }
17894 arg2 = static_cast< PLFLT >(val2);
17895 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17896 _outv = octave_value();
17897 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17898 if (SWIG_IsTmpObj(res3)) {
17899 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17900 } else {
17901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17902 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17903 }
17904 if (SWIG_IsTmpObj(res4)) {
17905 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17906 } else {
17907 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17908 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17909 }
17910 if (SWIG_IsTmpObj(res5)) {
17911 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17912 } else {
17913 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17914 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17915 }
17916 return _out;
17917 fail:
17918 return octave_value_list();
17919 }
17920 catch(...) {
17921 throw;
17922 }
17923}
17924
17925
17927 octave_value_list _out;
17928 octave_value_list *_outp=&_out;
17929 octave_value _outv;
17930
17931 try {
17932 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17933 SWIG_fail;
17934 }
17935 plclear();
17936 _outv = octave_value();
17937 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17938 return _out;
17939 fail:
17940 return octave_value_list();
17941 }
17942 catch(...) {
17943 throw;
17944 }
17945}
17946
17947
17949 PLINT arg1 ;
17950 int val1 ;
17951 int ecode1 = 0 ;
17952 octave_value_list _out;
17953 octave_value_list *_outp=&_out;
17954 octave_value _outv;
17955
17956 try {
17957 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17958 SWIG_fail;
17959 }
17960 ecode1 = SWIG_AsVal_int(args(0), &val1);
17961 if (!SWIG_IsOK(ecode1)) {
17962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17963 }
17964 arg1 = static_cast< PLINT >(val1);
17965 plcol0(arg1);
17966 _outv = octave_value();
17967 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17968 return _out;
17969 fail:
17970 return octave_value_list();
17971 }
17972 catch(...) {
17973 throw;
17974 }
17975}
17976
17977
17979 PLFLT arg1 ;
17980 double val1 ;
17981 int ecode1 = 0 ;
17982 octave_value_list _out;
17983 octave_value_list *_outp=&_out;
17984 octave_value _outv;
17985
17986 try {
17987 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17988 SWIG_fail;
17989 }
17990 ecode1 = SWIG_AsVal_double(args(0), &val1);
17991 if (!SWIG_IsOK(ecode1)) {
17992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17993 }
17994 arg1 = static_cast< PLFLT >(val1);
17995 plcol1(arg1);
17996 _outv = octave_value();
17997 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17998 return _out;
17999 fail:
18000 return octave_value_list();
18001 }
18002 catch(...) {
18003 throw;
18004 }
18005}
18006
18007
18009 PLFLT arg1 ;
18010 PLFLT arg2 ;
18011 PLFLT arg3 ;
18012 PLINT arg4 ;
18013 PLBOOL arg5 ;
18014 PLINT arg6 ;
18015 PLINT arg7 ;
18016 PLINT arg8 ;
18017 PLINT arg9 ;
18018 PLINT arg10 ;
18019 PLFLT arg11 ;
18020 double val1 ;
18021 int ecode1 = 0 ;
18022 double val2 ;
18023 int ecode2 = 0 ;
18024 double val3 ;
18025 int ecode3 = 0 ;
18026 int val4 ;
18027 int ecode4 = 0 ;
18028 int val5 ;
18029 int ecode5 = 0 ;
18030 int val6 ;
18031 int ecode6 = 0 ;
18032 int val7 ;
18033 int ecode7 = 0 ;
18034 int val8 ;
18035 int ecode8 = 0 ;
18036 int val9 ;
18037 int ecode9 = 0 ;
18038 int val10 ;
18039 int ecode10 = 0 ;
18040 double val11 ;
18041 int ecode11 = 0 ;
18042 octave_value_list _out;
18043 octave_value_list *_outp=&_out;
18044 octave_value _outv;
18045
18046 try {
18047 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
18048 SWIG_fail;
18049 }
18050 ecode1 = SWIG_AsVal_double(args(0), &val1);
18051 if (!SWIG_IsOK(ecode1)) {
18052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
18053 }
18054 arg1 = static_cast< PLFLT >(val1);
18055 ecode2 = SWIG_AsVal_double(args(1), &val2);
18056 if (!SWIG_IsOK(ecode2)) {
18057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
18058 }
18059 arg2 = static_cast< PLFLT >(val2);
18060 ecode3 = SWIG_AsVal_double(args(2), &val3);
18061 if (!SWIG_IsOK(ecode3)) {
18062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
18063 }
18064 arg3 = static_cast< PLFLT >(val3);
18065 ecode4 = SWIG_AsVal_int(args(3), &val4);
18066 if (!SWIG_IsOK(ecode4)) {
18067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
18068 }
18069 arg4 = static_cast< PLINT >(val4);
18070 ecode5 = SWIG_AsVal_int(args(4), &val5);
18071 if (!SWIG_IsOK(ecode5)) {
18072 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
18073 }
18074 arg5 = static_cast< PLBOOL >(val5);
18075 ecode6 = SWIG_AsVal_int(args(5), &val6);
18076 if (!SWIG_IsOK(ecode6)) {
18077 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
18078 }
18079 arg6 = static_cast< PLINT >(val6);
18080 ecode7 = SWIG_AsVal_int(args(6), &val7);
18081 if (!SWIG_IsOK(ecode7)) {
18082 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18083 }
18084 arg7 = static_cast< PLINT >(val7);
18085 ecode8 = SWIG_AsVal_int(args(7), &val8);
18086 if (!SWIG_IsOK(ecode8)) {
18087 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18088 }
18089 arg8 = static_cast< PLINT >(val8);
18090 ecode9 = SWIG_AsVal_int(args(8), &val9);
18091 if (!SWIG_IsOK(ecode9)) {
18092 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18093 }
18094 arg9 = static_cast< PLINT >(val9);
18095 ecode10 = SWIG_AsVal_int(args(9), &val10);
18096 if (!SWIG_IsOK(ecode10)) {
18097 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18098 }
18099 arg10 = static_cast< PLINT >(val10);
18100 ecode11 = SWIG_AsVal_double(args(10), &val11);
18101 if (!SWIG_IsOK(ecode11)) {
18102 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18103 }
18104 arg11 = static_cast< PLFLT >(val11);
18105 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18106 _outv = octave_value();
18107 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18108 return _out;
18109 fail:
18110 return octave_value_list();
18111 }
18112 catch(...) {
18113 throw;
18114 }
18115}
18116
18117
18119 PLINT arg1 ;
18120 PLINT arg2 ;
18121 PLINT arg3 ;
18122 PLINT arg4 ;
18123 PLINT arg5 ;
18124 PLFLT arg6 ;
18125 PLFLT *arg7 = (PLFLT *) 0 ;
18126 int val1 ;
18127 int ecode1 = 0 ;
18128 int val2 ;
18129 int ecode2 = 0 ;
18130 int val3 ;
18131 int ecode3 = 0 ;
18132 int val4 ;
18133 int ecode4 = 0 ;
18134 int val5 ;
18135 int ecode5 = 0 ;
18136 double val6 ;
18137 int ecode6 = 0 ;
18138 PLFLT temp7 ;
18139 int res7 = SWIG_TMPOBJ ;
18140 octave_value_list _out;
18141 octave_value_list *_outp=&_out;
18142 octave_value _outv;
18143
18144 try {
18145 arg7 = &temp7;
18146 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18147 SWIG_fail;
18148 }
18149 ecode1 = SWIG_AsVal_int(args(0), &val1);
18150 if (!SWIG_IsOK(ecode1)) {
18151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18152 }
18153 arg1 = static_cast< PLINT >(val1);
18154 ecode2 = SWIG_AsVal_int(args(1), &val2);
18155 if (!SWIG_IsOK(ecode2)) {
18156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18157 }
18158 arg2 = static_cast< PLINT >(val2);
18159 ecode3 = SWIG_AsVal_int(args(2), &val3);
18160 if (!SWIG_IsOK(ecode3)) {
18161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18162 }
18163 arg3 = static_cast< PLINT >(val3);
18164 ecode4 = SWIG_AsVal_int(args(3), &val4);
18165 if (!SWIG_IsOK(ecode4)) {
18166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18167 }
18168 arg4 = static_cast< PLINT >(val4);
18169 ecode5 = SWIG_AsVal_int(args(4), &val5);
18170 if (!SWIG_IsOK(ecode5)) {
18171 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18172 }
18173 arg5 = static_cast< PLINT >(val5);
18174 ecode6 = SWIG_AsVal_double(args(5), &val6);
18175 if (!SWIG_IsOK(ecode6)) {
18176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18177 }
18178 arg6 = static_cast< PLFLT >(val6);
18179 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18180 _outv = octave_value();
18181 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18182 if (SWIG_IsTmpObj(res7)) {
18183 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18184 } else {
18185 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18186 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18187 }
18188 return _out;
18189 fail:
18190 return octave_value_list();
18191 }
18192 catch(...) {
18193 throw;
18194 }
18195}
18196
18197
18199 PLINT arg1 ;
18200 PLBOOL arg2 ;
18201 int val1 ;
18202 int ecode1 = 0 ;
18203 int val2 ;
18204 int ecode2 = 0 ;
18205 octave_value_list _out;
18206 octave_value_list *_outp=&_out;
18207 octave_value _outv;
18208
18209 try {
18210 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18211 SWIG_fail;
18212 }
18213 ecode1 = SWIG_AsVal_int(args(0), &val1);
18214 if (!SWIG_IsOK(ecode1)) {
18215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18216 }
18217 arg1 = static_cast< PLINT >(val1);
18218 ecode2 = SWIG_AsVal_int(args(1), &val2);
18219 if (!SWIG_IsOK(ecode2)) {
18220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18221 }
18222 arg2 = static_cast< PLBOOL >(val2);
18223 plcpstrm(arg1,arg2);
18224 _outv = octave_value();
18225 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18226 return _out;
18227 fail:
18228 return octave_value_list();
18229 }
18230 catch(...) {
18231 throw;
18232 }
18233}
18234
18235
18237 octave_value_list _out;
18238 octave_value_list *_outp=&_out;
18239 octave_value _outv;
18240
18241 try {
18242 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18243 SWIG_fail;
18244 }
18245 plend();
18246 _outv = octave_value();
18247 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18248 return _out;
18249 fail:
18250 return octave_value_list();
18251 }
18252 catch(...) {
18253 throw;
18254 }
18255}
18256
18257
18259 octave_value_list _out;
18260 octave_value_list *_outp=&_out;
18261 octave_value _outv;
18262
18263 try {
18264 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18265 SWIG_fail;
18266 }
18267 plend1();
18268 _outv = octave_value();
18269 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18270 return _out;
18271 fail:
18272 return octave_value_list();
18273 }
18274 catch(...) {
18275 throw;
18276 }
18277}
18278
18279
18281 PLFLT arg1 ;
18282 PLFLT arg2 ;
18283 PLFLT arg3 ;
18284 PLFLT arg4 ;
18285 PLINT arg5 ;
18286 PLINT arg6 ;
18287 double val1 ;
18288 int ecode1 = 0 ;
18289 double val2 ;
18290 int ecode2 = 0 ;
18291 double val3 ;
18292 int ecode3 = 0 ;
18293 double val4 ;
18294 int ecode4 = 0 ;
18295 int val5 ;
18296 int ecode5 = 0 ;
18297 int val6 ;
18298 int ecode6 = 0 ;
18299 octave_value_list _out;
18300 octave_value_list *_outp=&_out;
18301 octave_value _outv;
18302
18303 try {
18304 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18305 SWIG_fail;
18306 }
18307 ecode1 = SWIG_AsVal_double(args(0), &val1);
18308 if (!SWIG_IsOK(ecode1)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18310 }
18311 arg1 = static_cast< PLFLT >(val1);
18312 ecode2 = SWIG_AsVal_double(args(1), &val2);
18313 if (!SWIG_IsOK(ecode2)) {
18314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18315 }
18316 arg2 = static_cast< PLFLT >(val2);
18317 ecode3 = SWIG_AsVal_double(args(2), &val3);
18318 if (!SWIG_IsOK(ecode3)) {
18319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18320 }
18321 arg3 = static_cast< PLFLT >(val3);
18322 ecode4 = SWIG_AsVal_double(args(3), &val4);
18323 if (!SWIG_IsOK(ecode4)) {
18324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18325 }
18326 arg4 = static_cast< PLFLT >(val4);
18327 ecode5 = SWIG_AsVal_int(args(4), &val5);
18328 if (!SWIG_IsOK(ecode5)) {
18329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18330 }
18331 arg5 = static_cast< PLINT >(val5);
18332 ecode6 = SWIG_AsVal_int(args(5), &val6);
18333 if (!SWIG_IsOK(ecode6)) {
18334 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18335 }
18336 arg6 = static_cast< PLINT >(val6);
18337 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18338 _outv = octave_value();
18339 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18340 return _out;
18341 fail:
18342 return octave_value_list();
18343 }
18344 catch(...) {
18345 throw;
18346 }
18347}
18348
18349
18351 PLFLT arg1 ;
18352 PLFLT arg2 ;
18353 PLFLT arg3 ;
18354 PLFLT arg4 ;
18355 PLINT arg5 ;
18356 PLINT arg6 ;
18357 double val1 ;
18358 int ecode1 = 0 ;
18359 double val2 ;
18360 int ecode2 = 0 ;
18361 double val3 ;
18362 int ecode3 = 0 ;
18363 double val4 ;
18364 int ecode4 = 0 ;
18365 int val5 ;
18366 int ecode5 = 0 ;
18367 int val6 ;
18368 int ecode6 = 0 ;
18369 octave_value_list _out;
18370 octave_value_list *_outp=&_out;
18371 octave_value _outv;
18372
18373 try {
18374 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18375 SWIG_fail;
18376 }
18377 ecode1 = SWIG_AsVal_double(args(0), &val1);
18378 if (!SWIG_IsOK(ecode1)) {
18379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18380 }
18381 arg1 = static_cast< PLFLT >(val1);
18382 ecode2 = SWIG_AsVal_double(args(1), &val2);
18383 if (!SWIG_IsOK(ecode2)) {
18384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18385 }
18386 arg2 = static_cast< PLFLT >(val2);
18387 ecode3 = SWIG_AsVal_double(args(2), &val3);
18388 if (!SWIG_IsOK(ecode3)) {
18389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18390 }
18391 arg3 = static_cast< PLFLT >(val3);
18392 ecode4 = SWIG_AsVal_double(args(3), &val4);
18393 if (!SWIG_IsOK(ecode4)) {
18394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18395 }
18396 arg4 = static_cast< PLFLT >(val4);
18397 ecode5 = SWIG_AsVal_int(args(4), &val5);
18398 if (!SWIG_IsOK(ecode5)) {
18399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18400 }
18401 arg5 = static_cast< PLINT >(val5);
18402 ecode6 = SWIG_AsVal_int(args(5), &val6);
18403 if (!SWIG_IsOK(ecode6)) {
18404 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18405 }
18406 arg6 = static_cast< PLINT >(val6);
18407 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18408 _outv = octave_value();
18409 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18410 return _out;
18411 fail:
18412 return octave_value_list();
18413 }
18414 catch(...) {
18415 throw;
18416 }
18417}
18418
18419
18421 octave_value_list _out;
18422 octave_value_list *_outp=&_out;
18423 octave_value _outv;
18424
18425 try {
18426 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18427 SWIG_fail;
18428 }
18429 pleop();
18430 _outv = octave_value();
18431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18432 return _out;
18433 fail:
18434 return octave_value_list();
18435 }
18436 catch(...) {
18437 throw;
18438 }
18439}
18440
18441
18443 PLINT arg1 ;
18444 PLFLT *arg2 = (PLFLT *) 0 ;
18445 PLFLT *arg3 = (PLFLT *) 0 ;
18446 PLFLT *arg4 = (PLFLT *) 0 ;
18447 Matrix temp1 ;
18448 Matrix temp3 ;
18449 Matrix temp4 ;
18450 octave_value_list _out;
18451 octave_value_list *_outp=&_out;
18452 octave_value _outv;
18453
18454 try {
18455 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18456 SWIG_fail;
18457 }
18458 {
18459 if ( _n_dims( args(0) ) > 1 )
18460 {
18461 error( "argument must be a scalar or vector" ); SWIG_fail;
18462 }
18463 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18464 temp1 = args(0).matrix_value();
18465 arg2 = &temp1( 0, 0 );
18466 }
18467 {
18468 if ( _n_dims( args(1) ) > 1 )
18469 {
18470 error( "argument must be a scalar or vector" ); SWIG_fail;
18471 }
18472 if ( _dim( args(1), 0 ) != Alen )
18473 {
18474 error( "argument vectors must be same length" ); SWIG_fail;
18475 }
18476 temp3 = args(1).matrix_value();
18477 arg3 = &temp3( 0, 0 );
18478 }
18479 {
18480 if ( _n_dims( args(2) ) > 1 )
18481 {
18482 error( "argument must be a scalar or vector" ); SWIG_fail;
18483 }
18484 if ( _dim( args(2), 0 ) != Alen )
18485 {
18486 error( "argument vectors must be same length" ); SWIG_fail;
18487 }
18488 temp4 = args(2).matrix_value();
18489 arg4 = &temp4( 0, 0 );
18490 }
18491 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18492 _outv = octave_value();
18493 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18494 {
18495
18496 }
18497 {
18498
18499 }
18500 {
18501
18502 }
18503 return _out;
18504 fail:
18505 {
18506
18507 }
18508 {
18509
18510 }
18511 {
18512
18513 }
18514 return octave_value_list();
18515 }
18516 catch(...) {
18517 {
18518
18519 }
18520 {
18521
18522 }
18523 {
18524
18525 }
18526 throw;
18527 }
18528}
18529
18530
18532 PLINT arg1 ;
18533 PLFLT *arg2 = (PLFLT *) 0 ;
18534 PLFLT *arg3 = (PLFLT *) 0 ;
18535 PLFLT *arg4 = (PLFLT *) 0 ;
18536 Matrix temp1 ;
18537 Matrix temp3 ;
18538 Matrix temp4 ;
18539 octave_value_list _out;
18540 octave_value_list *_outp=&_out;
18541 octave_value _outv;
18542
18543 try {
18544 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18545 SWIG_fail;
18546 }
18547 {
18548 if ( _n_dims( args(0) ) > 1 )
18549 {
18550 error( "argument must be a scalar or vector" ); SWIG_fail;
18551 }
18552 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18553 temp1 = args(0).matrix_value();
18554 arg2 = &temp1( 0, 0 );
18555 }
18556 {
18557 if ( _n_dims( args(1) ) > 1 )
18558 {
18559 error( "argument must be a scalar or vector" ); SWIG_fail;
18560 }
18561 if ( _dim( args(1), 0 ) != Alen )
18562 {
18563 error( "argument vectors must be same length" ); SWIG_fail;
18564 }
18565 temp3 = args(1).matrix_value();
18566 arg3 = &temp3( 0, 0 );
18567 }
18568 {
18569 if ( _n_dims( args(2) ) > 1 )
18570 {
18571 error( "argument must be a scalar or vector" ); SWIG_fail;
18572 }
18573 if ( _dim( args(2), 0 ) != Alen )
18574 {
18575 error( "argument vectors must be same length" ); SWIG_fail;
18576 }
18577 temp4 = args(2).matrix_value();
18578 arg4 = &temp4( 0, 0 );
18579 }
18580 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18581 _outv = octave_value();
18582 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18583 {
18584
18585 }
18586 {
18587
18588 }
18589 {
18590
18591 }
18592 return _out;
18593 fail:
18594 {
18595
18596 }
18597 {
18598
18599 }
18600 {
18601
18602 }
18603 return octave_value_list();
18604 }
18605 catch(...) {
18606 {
18607
18608 }
18609 {
18610
18611 }
18612 {
18613
18614 }
18615 throw;
18616 }
18617}
18618
18619
18621 octave_value_list _out;
18622 octave_value_list *_outp=&_out;
18623 octave_value _outv;
18624
18625 try {
18626 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18627 SWIG_fail;
18628 }
18629 plfamadv();
18630 _outv = octave_value();
18631 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18632 return _out;
18633 fail:
18634 return octave_value_list();
18635 }
18636 catch(...) {
18637 throw;
18638 }
18639}
18640
18641
18643 PLINT arg1 ;
18644 PLFLT *arg2 = (PLFLT *) 0 ;
18645 PLFLT *arg3 = (PLFLT *) 0 ;
18646 Matrix temp1 ;
18647 Matrix temp3 ;
18648 octave_value_list _out;
18649 octave_value_list *_outp=&_out;
18650 octave_value _outv;
18651
18652 try {
18653 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18654 SWIG_fail;
18655 }
18656 {
18657 if ( _n_dims( args(0) ) > 1 )
18658 {
18659 error( "argument must be a scalar or vector" ); SWIG_fail;
18660 }
18661 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18662 temp1 = args(0).matrix_value();
18663 arg2 = &temp1( 0, 0 );
18664 }
18665 {
18666 if ( _n_dims( args(1) ) > 1 )
18667 {
18668 error( "argument must be a scalar or vector" ); SWIG_fail;
18669 }
18670 if ( _dim( args(1), 0 ) != Alen )
18671 {
18672 error( "argument vectors must be same length" ); SWIG_fail;
18673 }
18674 temp3 = args(1).matrix_value();
18675 arg3 = &temp3( 0, 0 );
18676 }
18677 plfill(arg1,(double const *)arg2,(double const *)arg3);
18678 _outv = octave_value();
18679 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18680 {
18681
18682 }
18683 {
18684
18685 }
18686 return _out;
18687 fail:
18688 {
18689
18690 }
18691 {
18692
18693 }
18694 return octave_value_list();
18695 }
18696 catch(...) {
18697 {
18698
18699 }
18700 {
18701
18702 }
18703 throw;
18704 }
18705}
18706
18707
18709 PLINT arg1 ;
18710 PLFLT *arg2 = (PLFLT *) 0 ;
18711 PLFLT *arg3 = (PLFLT *) 0 ;
18712 PLFLT *arg4 = (PLFLT *) 0 ;
18713 Matrix temp1 ;
18714 Matrix temp3 ;
18715 Matrix temp4 ;
18716 octave_value_list _out;
18717 octave_value_list *_outp=&_out;
18718 octave_value _outv;
18719
18720 try {
18721 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18722 SWIG_fail;
18723 }
18724 {
18725 if ( _n_dims( args(0) ) > 1 )
18726 {
18727 error( "argument must be a scalar or vector" ); SWIG_fail;
18728 }
18729 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18730 temp1 = args(0).matrix_value();
18731 arg2 = &temp1( 0, 0 );
18732 }
18733 {
18734 if ( _n_dims( args(1) ) > 1 )
18735 {
18736 error( "argument must be a scalar or vector" ); SWIG_fail;
18737 }
18738 if ( _dim( args(1), 0 ) != Alen )
18739 {
18740 error( "argument vectors must be same length" ); SWIG_fail;
18741 }
18742 temp3 = args(1).matrix_value();
18743 arg3 = &temp3( 0, 0 );
18744 }
18745 {
18746 if ( _n_dims( args(2) ) > 1 )
18747 {
18748 error( "argument must be a scalar or vector" ); SWIG_fail;
18749 }
18750 if ( _dim( args(2), 0 ) != Alen )
18751 {
18752 error( "argument vectors must be same length" ); SWIG_fail;
18753 }
18754 temp4 = args(2).matrix_value();
18755 arg4 = &temp4( 0, 0 );
18756 }
18757 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18758 _outv = octave_value();
18759 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18760 {
18761
18762 }
18763 {
18764
18765 }
18766 {
18767
18768 }
18769 return _out;
18770 fail:
18771 {
18772
18773 }
18774 {
18775
18776 }
18777 {
18778
18779 }
18780 return octave_value_list();
18781 }
18782 catch(...) {
18783 {
18784
18785 }
18786 {
18787
18788 }
18789 {
18790
18791 }
18792 throw;
18793 }
18794}
18795
18796
18798 PLINT arg1 ;
18799 PLFLT *arg2 = (PLFLT *) 0 ;
18800 PLFLT *arg3 = (PLFLT *) 0 ;
18801 PLFLT arg4 ;
18802 Matrix temp1 ;
18803 Matrix temp3 ;
18804 double val4 ;
18805 int ecode4 = 0 ;
18806 octave_value_list _out;
18807 octave_value_list *_outp=&_out;
18808 octave_value _outv;
18809
18810 try {
18811 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18812 SWIG_fail;
18813 }
18814 {
18815 if ( _n_dims( args(0) ) > 1 )
18816 {
18817 error( "argument must be a scalar or vector" ); SWIG_fail;
18818 }
18819 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18820 temp1 = args(0).matrix_value();
18821 arg2 = &temp1( 0, 0 );
18822 }
18823 {
18824 if ( _n_dims( args(1) ) > 1 )
18825 {
18826 error( "argument must be a scalar or vector" ); SWIG_fail;
18827 }
18828 if ( _dim( args(1), 0 ) != Alen )
18829 {
18830 error( "argument vectors must be same length" ); SWIG_fail;
18831 }
18832 temp3 = args(1).matrix_value();
18833 arg3 = &temp3( 0, 0 );
18834 }
18835 ecode4 = SWIG_AsVal_double(args(2), &val4);
18836 if (!SWIG_IsOK(ecode4)) {
18837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18838 }
18839 arg4 = static_cast< PLFLT >(val4);
18840 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18841 _outv = octave_value();
18842 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18843 {
18844
18845 }
18846 {
18847
18848 }
18849 return _out;
18850 fail:
18851 {
18852
18853 }
18854 {
18855
18856 }
18857 return octave_value_list();
18858 }
18859 catch(...) {
18860 {
18861
18862 }
18863 {
18864
18865 }
18866 throw;
18867 }
18868}
18869
18870
18872 octave_value_list _out;
18873 octave_value_list *_outp=&_out;
18874 octave_value _outv;
18875
18876 try {
18877 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18878 SWIG_fail;
18879 }
18880 plflush();
18881 _outv = octave_value();
18882 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18883 return _out;
18884 fail:
18885 return octave_value_list();
18886 }
18887 catch(...) {
18888 throw;
18889 }
18890}
18891
18892
18894 PLINT arg1 ;
18895 int val1 ;
18896 int ecode1 = 0 ;
18897 octave_value_list _out;
18898 octave_value_list *_outp=&_out;
18899 octave_value _outv;
18900
18901 try {
18902 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18903 SWIG_fail;
18904 }
18905 ecode1 = SWIG_AsVal_int(args(0), &val1);
18906 if (!SWIG_IsOK(ecode1)) {
18907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18908 }
18909 arg1 = static_cast< PLINT >(val1);
18910 plfont(arg1);
18911 _outv = octave_value();
18912 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18913 return _out;
18914 fail:
18915 return octave_value_list();
18916 }
18917 catch(...) {
18918 throw;
18919 }
18920}
18921
18922
18924 PLINT arg1 ;
18925 int val1 ;
18926 int ecode1 = 0 ;
18927 octave_value_list _out;
18928 octave_value_list *_outp=&_out;
18929 octave_value _outv;
18930
18931 try {
18932 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18933 SWIG_fail;
18934 }
18935 ecode1 = SWIG_AsVal_int(args(0), &val1);
18936 if (!SWIG_IsOK(ecode1)) {
18937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18938 }
18939 arg1 = static_cast< PLINT >(val1);
18940 plfontld(arg1);
18941 _outv = octave_value();
18942 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18943 return _out;
18944 fail:
18945 return octave_value_list();
18946 }
18947 catch(...) {
18948 throw;
18949 }
18950}
18951
18952
18954 PLFLT *arg1 = (PLFLT *) 0 ;
18955 PLFLT *arg2 = (PLFLT *) 0 ;
18956 PLFLT temp1 ;
18957 int res1 = SWIG_TMPOBJ ;
18958 PLFLT temp2 ;
18959 int res2 = SWIG_TMPOBJ ;
18960 octave_value_list _out;
18961 octave_value_list *_outp=&_out;
18962 octave_value _outv;
18963
18964 try {
18965 arg1 = &temp1;
18966 arg2 = &temp2;
18967 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18968 SWIG_fail;
18969 }
18970 plgchr(arg1,arg2);
18971 _outv = octave_value();
18972 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18973 if (SWIG_IsTmpObj(res1)) {
18974 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18975 } else {
18976 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18977 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18978 }
18979 if (SWIG_IsTmpObj(res2)) {
18980 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18981 } else {
18982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18983 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18984 }
18985 return _out;
18986 fail:
18987 return octave_value_list();
18988 }
18989 catch(...) {
18990 throw;
18991 }
18992}
18993
18994
18996 PLINT arg1 ;
18997 PLINT *arg2 = (PLINT *) 0 ;
18998 PLINT *arg3 = (PLINT *) 0 ;
18999 PLINT *arg4 = (PLINT *) 0 ;
19000 int val1 ;
19001 int ecode1 = 0 ;
19002 PLINT temp2 ;
19003 int res2 = SWIG_TMPOBJ ;
19004 PLINT temp3 ;
19005 int res3 = SWIG_TMPOBJ ;
19006 PLINT temp4 ;
19007 int res4 = SWIG_TMPOBJ ;
19008 octave_value_list _out;
19009 octave_value_list *_outp=&_out;
19010 octave_value _outv;
19011
19012 try {
19013 arg2 = &temp2;
19014 arg3 = &temp3;
19015 arg4 = &temp4;
19016 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
19017 SWIG_fail;
19018 }
19019 ecode1 = SWIG_AsVal_int(args(0), &val1);
19020 if (!SWIG_IsOK(ecode1)) {
19021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
19022 }
19023 arg1 = static_cast< PLINT >(val1);
19024 plgcol0(arg1,arg2,arg3,arg4);
19025 _outv = octave_value();
19026 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19027 if (SWIG_IsTmpObj(res2)) {
19028 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19029 } else {
19030 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19031 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19032 }
19033 if (SWIG_IsTmpObj(res3)) {
19034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19035 } else {
19036 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19038 }
19039 if (SWIG_IsTmpObj(res4)) {
19040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19041 } else {
19042 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19044 }
19045 return _out;
19046 fail:
19047 return octave_value_list();
19048 }
19049 catch(...) {
19050 throw;
19051 }
19052}
19053
19054
19056 PLINT arg1 ;
19057 PLINT *arg2 = (PLINT *) 0 ;
19058 PLINT *arg3 = (PLINT *) 0 ;
19059 PLINT *arg4 = (PLINT *) 0 ;
19060 PLFLT *arg5 = (PLFLT *) 0 ;
19061 int val1 ;
19062 int ecode1 = 0 ;
19063 PLINT temp2 ;
19064 int res2 = SWIG_TMPOBJ ;
19065 PLINT temp3 ;
19066 int res3 = SWIG_TMPOBJ ;
19067 PLINT temp4 ;
19068 int res4 = SWIG_TMPOBJ ;
19069 PLFLT temp5 ;
19070 int res5 = SWIG_TMPOBJ ;
19071 octave_value_list _out;
19072 octave_value_list *_outp=&_out;
19073 octave_value _outv;
19074
19075 try {
19076 arg2 = &temp2;
19077 arg3 = &temp3;
19078 arg4 = &temp4;
19079 arg5 = &temp5;
19080 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19081 SWIG_fail;
19082 }
19083 ecode1 = SWIG_AsVal_int(args(0), &val1);
19084 if (!SWIG_IsOK(ecode1)) {
19085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19086 }
19087 arg1 = static_cast< PLINT >(val1);
19088 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19089 _outv = octave_value();
19090 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19091 if (SWIG_IsTmpObj(res2)) {
19092 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19093 } else {
19094 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19095 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19096 }
19097 if (SWIG_IsTmpObj(res3)) {
19098 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19099 } else {
19100 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19101 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19102 }
19103 if (SWIG_IsTmpObj(res4)) {
19104 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19105 } else {
19106 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19107 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19108 }
19109 if (SWIG_IsTmpObj(res5)) {
19110 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19111 } else {
19112 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19113 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19114 }
19115 return _out;
19116 fail:
19117 return octave_value_list();
19118 }
19119 catch(...) {
19120 throw;
19121 }
19122}
19123
19124
19126 PLINT *arg1 = (PLINT *) 0 ;
19127 PLINT *arg2 = (PLINT *) 0 ;
19128 PLINT *arg3 = (PLINT *) 0 ;
19129 PLINT temp1 ;
19130 int res1 = SWIG_TMPOBJ ;
19131 PLINT temp2 ;
19132 int res2 = SWIG_TMPOBJ ;
19133 PLINT temp3 ;
19134 int res3 = SWIG_TMPOBJ ;
19135 octave_value_list _out;
19136 octave_value_list *_outp=&_out;
19137 octave_value _outv;
19138
19139 try {
19140 arg1 = &temp1;
19141 arg2 = &temp2;
19142 arg3 = &temp3;
19143 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19144 SWIG_fail;
19145 }
19146 plgcolbg(arg1,arg2,arg3);
19147 _outv = octave_value();
19148 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19149 if (SWIG_IsTmpObj(res1)) {
19150 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19151 } else {
19152 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19153 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19154 }
19155 if (SWIG_IsTmpObj(res2)) {
19156 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19157 } else {
19158 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19159 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19160 }
19161 if (SWIG_IsTmpObj(res3)) {
19162 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19163 } else {
19164 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19165 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19166 }
19167 return _out;
19168 fail:
19169 return octave_value_list();
19170 }
19171 catch(...) {
19172 throw;
19173 }
19174}
19175
19176
19178 PLINT *arg1 = (PLINT *) 0 ;
19179 PLINT *arg2 = (PLINT *) 0 ;
19180 PLINT *arg3 = (PLINT *) 0 ;
19181 PLFLT *arg4 = (PLFLT *) 0 ;
19182 PLINT temp1 ;
19183 int res1 = SWIG_TMPOBJ ;
19184 PLINT temp2 ;
19185 int res2 = SWIG_TMPOBJ ;
19186 PLINT temp3 ;
19187 int res3 = SWIG_TMPOBJ ;
19188 PLFLT temp4 ;
19189 int res4 = SWIG_TMPOBJ ;
19190 octave_value_list _out;
19191 octave_value_list *_outp=&_out;
19192 octave_value _outv;
19193
19194 try {
19195 arg1 = &temp1;
19196 arg2 = &temp2;
19197 arg3 = &temp3;
19198 arg4 = &temp4;
19199 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19200 SWIG_fail;
19201 }
19202 plgcolbga(arg1,arg2,arg3,arg4);
19203 _outv = octave_value();
19204 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19205 if (SWIG_IsTmpObj(res1)) {
19206 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19207 } else {
19208 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19210 }
19211 if (SWIG_IsTmpObj(res2)) {
19212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19213 } else {
19214 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19215 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19216 }
19217 if (SWIG_IsTmpObj(res3)) {
19218 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19219 } else {
19220 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19221 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19222 }
19223 if (SWIG_IsTmpObj(res4)) {
19224 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19225 } else {
19226 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19227 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19228 }
19229 return _out;
19230 fail:
19231 return octave_value_list();
19232 }
19233 catch(...) {
19234 throw;
19235 }
19236}
19237
19238
19239SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19240 PLINT *arg1 = (PLINT *) 0 ;
19241 PLINT temp1 ;
19242 int res1 = SWIG_TMPOBJ ;
19243 octave_value_list _out;
19244 octave_value_list *_outp=&_out;
19245 octave_value _outv;
19246
19247 try {
19248 arg1 = &temp1;
19249 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19250 SWIG_fail;
19251 }
19252 plgcompression(arg1);
19253 _outv = octave_value();
19254 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19255 if (SWIG_IsTmpObj(res1)) {
19256 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19257 } else {
19258 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19260 }
19261 return _out;
19262 fail:
19263 return octave_value_list();
19264 }
19265 catch(...) {
19266 throw;
19267 }
19268}
19269
19270
19272 char *arg1 = (char *) 0 ;
19273 char local_string1[80] ;
19274 size_t local_string_length1 ;
19275 charMatrix local_charMatrix1 ;
19276 octave_value_list retval1 ;
19277 octave_value_list _out;
19278 octave_value_list *_outp=&_out;
19279 octave_value _outv;
19280
19281 try {
19282 {
19283 arg1 = local_string1;
19284 }
19285 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19286 SWIG_fail;
19287 }
19288 plgdev(arg1);
19289 _outv = octave_value();
19290 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19291 {
19292 local_string_length1 = strlen( local_string1 );
19293 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19294 local_charMatrix1.insert( local_string1, 0, 0 );
19295 retval1( 0 ) = octave_value( local_charMatrix1 );
19296 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19297 }
19298 return _out;
19299 fail:
19300 return octave_value_list();
19301 }
19302 catch(...) {
19303 throw;
19304 }
19305}
19306
19307
19309 PLFLT *arg1 = (PLFLT *) 0 ;
19310 PLFLT *arg2 = (PLFLT *) 0 ;
19311 PLFLT *arg3 = (PLFLT *) 0 ;
19312 PLFLT *arg4 = (PLFLT *) 0 ;
19313 PLFLT temp1 ;
19314 int res1 = SWIG_TMPOBJ ;
19315 PLFLT temp2 ;
19316 int res2 = SWIG_TMPOBJ ;
19317 PLFLT temp3 ;
19318 int res3 = SWIG_TMPOBJ ;
19319 PLFLT temp4 ;
19320 int res4 = SWIG_TMPOBJ ;
19321 octave_value_list _out;
19322 octave_value_list *_outp=&_out;
19323 octave_value _outv;
19324
19325 try {
19326 arg1 = &temp1;
19327 arg2 = &temp2;
19328 arg3 = &temp3;
19329 arg4 = &temp4;
19330 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19331 SWIG_fail;
19332 }
19333 plgdidev(arg1,arg2,arg3,arg4);
19334 _outv = octave_value();
19335 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19336 if (SWIG_IsTmpObj(res1)) {
19337 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19338 } else {
19339 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19340 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19341 }
19342 if (SWIG_IsTmpObj(res2)) {
19343 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19344 } else {
19345 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19346 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19347 }
19348 if (SWIG_IsTmpObj(res3)) {
19349 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19350 } else {
19351 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19352 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19353 }
19354 if (SWIG_IsTmpObj(res4)) {
19355 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19356 } else {
19357 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19358 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19359 }
19360 return _out;
19361 fail:
19362 return octave_value_list();
19363 }
19364 catch(...) {
19365 throw;
19366 }
19367}
19368
19369
19371 PLFLT *arg1 = (PLFLT *) 0 ;
19372 PLFLT temp1 ;
19373 int res1 = SWIG_TMPOBJ ;
19374 octave_value_list _out;
19375 octave_value_list *_outp=&_out;
19376 octave_value _outv;
19377
19378 try {
19379 arg1 = &temp1;
19380 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19381 SWIG_fail;
19382 }
19383 plgdiori(arg1);
19384 _outv = octave_value();
19385 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19386 if (SWIG_IsTmpObj(res1)) {
19387 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19388 } else {
19389 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19390 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19391 }
19392 return _out;
19393 fail:
19394 return octave_value_list();
19395 }
19396 catch(...) {
19397 throw;
19398 }
19399}
19400
19401
19403 PLFLT *arg1 = (PLFLT *) 0 ;
19404 PLFLT *arg2 = (PLFLT *) 0 ;
19405 PLFLT *arg3 = (PLFLT *) 0 ;
19406 PLFLT *arg4 = (PLFLT *) 0 ;
19407 PLFLT temp1 ;
19408 int res1 = SWIG_TMPOBJ ;
19409 PLFLT temp2 ;
19410 int res2 = SWIG_TMPOBJ ;
19411 PLFLT temp3 ;
19412 int res3 = SWIG_TMPOBJ ;
19413 PLFLT temp4 ;
19414 int res4 = SWIG_TMPOBJ ;
19415 octave_value_list _out;
19416 octave_value_list *_outp=&_out;
19417 octave_value _outv;
19418
19419 try {
19420 arg1 = &temp1;
19421 arg2 = &temp2;
19422 arg3 = &temp3;
19423 arg4 = &temp4;
19424 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19425 SWIG_fail;
19426 }
19427 plgdiplt(arg1,arg2,arg3,arg4);
19428 _outv = octave_value();
19429 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19430 if (SWIG_IsTmpObj(res1)) {
19431 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19432 } else {
19433 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19434 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19435 }
19436 if (SWIG_IsTmpObj(res2)) {
19437 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19438 } else {
19439 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19440 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19441 }
19442 if (SWIG_IsTmpObj(res3)) {
19443 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19444 } else {
19445 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19446 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19447 }
19448 if (SWIG_IsTmpObj(res4)) {
19449 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19450 } else {
19451 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19452 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19453 }
19454 return _out;
19455 fail:
19456 return octave_value_list();
19457 }
19458 catch(...) {
19459 throw;
19460 }
19461}
19462
19463
19465 PLINT *arg1 = (PLINT *) 0 ;
19466 PLINT *arg2 = (PLINT *) 0 ;
19467 PLINT *arg3 = (PLINT *) 0 ;
19468 PLINT temp1 ;
19469 int res1 = SWIG_TMPOBJ ;
19470 PLINT temp2 ;
19471 int res2 = SWIG_TMPOBJ ;
19472 PLINT temp3 ;
19473 int res3 = SWIG_TMPOBJ ;
19474 octave_value_list _out;
19475 octave_value_list *_outp=&_out;
19476 octave_value _outv;
19477
19478 try {
19479 arg1 = &temp1;
19480 arg2 = &temp2;
19481 arg3 = &temp3;
19482 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19483 SWIG_fail;
19484 }
19485 plgfam(arg1,arg2,arg3);
19486 _outv = octave_value();
19487 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19488 if (SWIG_IsTmpObj(res1)) {
19489 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19490 } else {
19491 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19492 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19493 }
19494 if (SWIG_IsTmpObj(res2)) {
19495 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19496 } else {
19497 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19498 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19499 }
19500 if (SWIG_IsTmpObj(res3)) {
19501 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19502 } else {
19503 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19504 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19505 }
19506 return _out;
19507 fail:
19508 return octave_value_list();
19509 }
19510 catch(...) {
19511 throw;
19512 }
19513}
19514
19515
19517 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19518 PLUNICODE temp1 ;
19519 int res1 = SWIG_TMPOBJ ;
19520 octave_value_list _out;
19521 octave_value_list *_outp=&_out;
19522 octave_value _outv;
19523
19524 try {
19525 arg1 = &temp1;
19526 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19527 SWIG_fail;
19528 }
19529 plgfci(arg1);
19530 _outv = octave_value();
19531 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19532 if (SWIG_IsTmpObj(res1)) {
19533 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19534 } else {
19535 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19536 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19537 }
19538 return _out;
19539 fail:
19540 return octave_value_list();
19541 }
19542 catch(...) {
19543 throw;
19544 }
19545}
19546
19547
19549 char *arg1 = (char *) 0 ;
19550 char local_string1[80] ;
19551 size_t local_string_length1 ;
19552 charMatrix local_charMatrix1 ;
19553 octave_value_list retval1 ;
19554 octave_value_list _out;
19555 octave_value_list *_outp=&_out;
19556 octave_value _outv;
19557
19558 try {
19559 {
19560 arg1 = local_string1;
19561 }
19562 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19563 SWIG_fail;
19564 }
19565 plgfnam(arg1);
19566 _outv = octave_value();
19567 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19568 {
19569 local_string_length1 = strlen( local_string1 );
19570 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19571 local_charMatrix1.insert( local_string1, 0, 0 );
19572 retval1( 0 ) = octave_value( local_charMatrix1 );
19573 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19574 }
19575 return _out;
19576 fail:
19577 return octave_value_list();
19578 }
19579 catch(...) {
19580 throw;
19581 }
19582}
19583
19584
19586 PLINT *arg1 = (PLINT *) 0 ;
19587 PLINT *arg2 = (PLINT *) 0 ;
19588 PLINT *arg3 = (PLINT *) 0 ;
19589 PLINT temp1 ;
19590 int res1 = SWIG_TMPOBJ ;
19591 PLINT temp2 ;
19592 int res2 = SWIG_TMPOBJ ;
19593 PLINT temp3 ;
19594 int res3 = SWIG_TMPOBJ ;
19595 octave_value_list _out;
19596 octave_value_list *_outp=&_out;
19597 octave_value _outv;
19598
19599 try {
19600 arg1 = &temp1;
19601 arg2 = &temp2;
19602 arg3 = &temp3;
19603 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19604 SWIG_fail;
19605 }
19606 plgfont(arg1,arg2,arg3);
19607 _outv = octave_value();
19608 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19609 if (SWIG_IsTmpObj(res1)) {
19610 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19611 } else {
19612 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19613 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19614 }
19615 if (SWIG_IsTmpObj(res2)) {
19616 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19617 } else {
19618 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19619 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19620 }
19621 if (SWIG_IsTmpObj(res3)) {
19622 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19623 } else {
19624 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19625 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19626 }
19627 return _out;
19628 fail:
19629 return octave_value_list();
19630 }
19631 catch(...) {
19632 throw;
19633 }
19634}
19635
19636
19638 PLINT *arg1 = (PLINT *) 0 ;
19639 PLINT temp1 ;
19640 int res1 = SWIG_TMPOBJ ;
19641 octave_value_list _out;
19642 octave_value_list *_outp=&_out;
19643 octave_value _outv;
19644
19645 try {
19646 arg1 = &temp1;
19647 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19648 SWIG_fail;
19649 }
19650 plglevel(arg1);
19651 _outv = octave_value();
19652 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19653 if (SWIG_IsTmpObj(res1)) {
19654 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19655 } else {
19656 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19657 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19658 }
19659 return _out;
19660 fail:
19661 return octave_value_list();
19662 }
19663 catch(...) {
19664 throw;
19665 }
19666}
19667
19668
19670 PLFLT *arg1 = (PLFLT *) 0 ;
19671 PLFLT *arg2 = (PLFLT *) 0 ;
19672 PLINT *arg3 = (PLINT *) 0 ;
19673 PLINT *arg4 = (PLINT *) 0 ;
19674 PLINT *arg5 = (PLINT *) 0 ;
19675 PLINT *arg6 = (PLINT *) 0 ;
19676 PLFLT temp1 ;
19677 int res1 = SWIG_TMPOBJ ;
19678 PLFLT temp2 ;
19679 int res2 = SWIG_TMPOBJ ;
19680 PLINT temp3 ;
19681 int res3 = SWIG_TMPOBJ ;
19682 PLINT temp4 ;
19683 int res4 = SWIG_TMPOBJ ;
19684 PLINT temp5 ;
19685 int res5 = SWIG_TMPOBJ ;
19686 PLINT temp6 ;
19687 int res6 = SWIG_TMPOBJ ;
19688 octave_value_list _out;
19689 octave_value_list *_outp=&_out;
19690 octave_value _outv;
19691
19692 try {
19693 arg1 = &temp1;
19694 arg2 = &temp2;
19695 arg3 = &temp3;
19696 arg4 = &temp4;
19697 arg5 = &temp5;
19698 arg6 = &temp6;
19699 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19700 SWIG_fail;
19701 }
19702 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19703 _outv = octave_value();
19704 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19705 if (SWIG_IsTmpObj(res1)) {
19706 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19707 } else {
19708 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19709 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19710 }
19711 if (SWIG_IsTmpObj(res2)) {
19712 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19713 } else {
19714 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19715 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19716 }
19717 if (SWIG_IsTmpObj(res3)) {
19718 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19719 } else {
19720 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19721 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19722 }
19723 if (SWIG_IsTmpObj(res4)) {
19724 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19725 } else {
19726 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19727 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19728 }
19729 if (SWIG_IsTmpObj(res5)) {
19730 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19731 } else {
19732 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19733 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19734 }
19735 if (SWIG_IsTmpObj(res6)) {
19736 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19737 } else {
19738 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19739 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19740 }
19741 return _out;
19742 fail:
19743 return octave_value_list();
19744 }
19745 catch(...) {
19746 throw;
19747 }
19748}
19749
19750
19752 octave_value_list _out;
19753 octave_value_list *_outp=&_out;
19754 octave_value _outv;
19755
19756 try {
19757 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19758 SWIG_fail;
19759 }
19760 plgra();
19761 _outv = octave_value();
19762 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19763 return _out;
19764 fail:
19765 return octave_value_list();
19766 }
19767 catch(...) {
19768 throw;
19769 }
19770}
19771
19772
19774 PLFLT *arg1 = (PLFLT *) 0 ;
19775 PLFLT *arg2 = (PLFLT *) 0 ;
19776 PLFLT *arg3 = (PLFLT *) 0 ;
19777 PLFLT *arg4 = (PLFLT *) 0 ;
19778 PLFLT temp1 ;
19779 int res1 = SWIG_TMPOBJ ;
19780 PLFLT temp2 ;
19781 int res2 = SWIG_TMPOBJ ;
19782 PLFLT temp3 ;
19783 int res3 = SWIG_TMPOBJ ;
19784 PLFLT temp4 ;
19785 int res4 = SWIG_TMPOBJ ;
19786 octave_value_list _out;
19787 octave_value_list *_outp=&_out;
19788 octave_value _outv;
19789
19790 try {
19791 arg1 = &temp1;
19792 arg2 = &temp2;
19793 arg3 = &temp3;
19794 arg4 = &temp4;
19795 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19796 SWIG_fail;
19797 }
19798 plgspa(arg1,arg2,arg3,arg4);
19799 _outv = octave_value();
19800 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19801 if (SWIG_IsTmpObj(res1)) {
19802 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19803 } else {
19804 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19805 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19806 }
19807 if (SWIG_IsTmpObj(res2)) {
19808 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19809 } else {
19810 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19811 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19812 }
19813 if (SWIG_IsTmpObj(res3)) {
19814 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19815 } else {
19816 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19817 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19818 }
19819 if (SWIG_IsTmpObj(res4)) {
19820 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19821 } else {
19822 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19823 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19824 }
19825 return _out;
19826 fail:
19827 return octave_value_list();
19828 }
19829 catch(...) {
19830 throw;
19831 }
19832}
19833
19834
19836 PLINT *arg1 = (PLINT *) 0 ;
19837 PLINT temp1 ;
19838 int res1 = SWIG_TMPOBJ ;
19839 octave_value_list _out;
19840 octave_value_list *_outp=&_out;
19841 octave_value _outv;
19842
19843 try {
19844 arg1 = &temp1;
19845 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19846 SWIG_fail;
19847 }
19848 plgstrm(arg1);
19849 _outv = octave_value();
19850 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19851 if (SWIG_IsTmpObj(res1)) {
19852 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19853 } else {
19854 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19855 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19856 }
19857 return _out;
19858 fail:
19859 return octave_value_list();
19860 }
19861 catch(...) {
19862 throw;
19863 }
19864}
19865
19866
19868 char *arg1 = (char *) 0 ;
19869 char local_string1[80] ;
19870 size_t local_string_length1 ;
19871 charMatrix local_charMatrix1 ;
19872 octave_value_list retval1 ;
19873 octave_value_list _out;
19874 octave_value_list *_outp=&_out;
19875 octave_value _outv;
19876
19877 try {
19878 {
19879 arg1 = local_string1;
19880 }
19881 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19882 SWIG_fail;
19883 }
19884 plgver(arg1);
19885 _outv = octave_value();
19886 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19887 {
19888 local_string_length1 = strlen( local_string1 );
19889 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19890 local_charMatrix1.insert( local_string1, 0, 0 );
19891 retval1( 0 ) = octave_value( local_charMatrix1 );
19892 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19893 }
19894 return _out;
19895 fail:
19896 return octave_value_list();
19897 }
19898 catch(...) {
19899 throw;
19900 }
19901}
19902
19903
19905 PLFLT *arg1 = (PLFLT *) 0 ;
19906 PLFLT *arg2 = (PLFLT *) 0 ;
19907 PLFLT *arg3 = (PLFLT *) 0 ;
19908 PLFLT *arg4 = (PLFLT *) 0 ;
19909 PLFLT temp1 ;
19910 int res1 = SWIG_TMPOBJ ;
19911 PLFLT temp2 ;
19912 int res2 = SWIG_TMPOBJ ;
19913 PLFLT temp3 ;
19914 int res3 = SWIG_TMPOBJ ;
19915 PLFLT temp4 ;
19916 int res4 = SWIG_TMPOBJ ;
19917 octave_value_list _out;
19918 octave_value_list *_outp=&_out;
19919 octave_value _outv;
19920
19921 try {
19922 arg1 = &temp1;
19923 arg2 = &temp2;
19924 arg3 = &temp3;
19925 arg4 = &temp4;
19926 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19927 SWIG_fail;
19928 }
19929 plgvpd(arg1,arg2,arg3,arg4);
19930 _outv = octave_value();
19931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19932 if (SWIG_IsTmpObj(res1)) {
19933 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19934 } else {
19935 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19936 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19937 }
19938 if (SWIG_IsTmpObj(res2)) {
19939 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19940 } else {
19941 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19942 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19943 }
19944 if (SWIG_IsTmpObj(res3)) {
19945 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19946 } else {
19947 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19948 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19949 }
19950 if (SWIG_IsTmpObj(res4)) {
19951 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19952 } else {
19953 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19954 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19955 }
19956 return _out;
19957 fail:
19958 return octave_value_list();
19959 }
19960 catch(...) {
19961 throw;
19962 }
19963}
19964
19965
19967 PLFLT *arg1 = (PLFLT *) 0 ;
19968 PLFLT *arg2 = (PLFLT *) 0 ;
19969 PLFLT *arg3 = (PLFLT *) 0 ;
19970 PLFLT *arg4 = (PLFLT *) 0 ;
19971 PLFLT temp1 ;
19972 int res1 = SWIG_TMPOBJ ;
19973 PLFLT temp2 ;
19974 int res2 = SWIG_TMPOBJ ;
19975 PLFLT temp3 ;
19976 int res3 = SWIG_TMPOBJ ;
19977 PLFLT temp4 ;
19978 int res4 = SWIG_TMPOBJ ;
19979 octave_value_list _out;
19980 octave_value_list *_outp=&_out;
19981 octave_value _outv;
19982
19983 try {
19984 arg1 = &temp1;
19985 arg2 = &temp2;
19986 arg3 = &temp3;
19987 arg4 = &temp4;
19988 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19989 SWIG_fail;
19990 }
19991 plgvpw(arg1,arg2,arg3,arg4);
19992 _outv = octave_value();
19993 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19994 if (SWIG_IsTmpObj(res1)) {
19995 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19996 } else {
19997 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19998 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19999 }
20000 if (SWIG_IsTmpObj(res2)) {
20001 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20002 } else {
20003 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20004 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20005 }
20006 if (SWIG_IsTmpObj(res3)) {
20007 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
20008 } else {
20009 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20010 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
20011 }
20012 if (SWIG_IsTmpObj(res4)) {
20013 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20014 } else {
20015 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20016 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20017 }
20018 return _out;
20019 fail:
20020 return octave_value_list();
20021 }
20022 catch(...) {
20023 throw;
20024 }
20025}
20026
20027
20029 PLINT *arg1 = (PLINT *) 0 ;
20030 PLINT *arg2 = (PLINT *) 0 ;
20031 PLINT temp1 ;
20032 int res1 = SWIG_TMPOBJ ;
20033 PLINT temp2 ;
20034 int res2 = SWIG_TMPOBJ ;
20035 octave_value_list _out;
20036 octave_value_list *_outp=&_out;
20037 octave_value _outv;
20038
20039 try {
20040 arg1 = &temp1;
20041 arg2 = &temp2;
20042 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
20043 SWIG_fail;
20044 }
20045 plgxax(arg1,arg2);
20046 _outv = octave_value();
20047 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20048 if (SWIG_IsTmpObj(res1)) {
20049 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20050 } else {
20051 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20052 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20053 }
20054 if (SWIG_IsTmpObj(res2)) {
20055 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20056 } else {
20057 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20058 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20059 }
20060 return _out;
20061 fail:
20062 return octave_value_list();
20063 }
20064 catch(...) {
20065 throw;
20066 }
20067}
20068
20069
20071 PLINT *arg1 = (PLINT *) 0 ;
20072 PLINT *arg2 = (PLINT *) 0 ;
20073 PLINT temp1 ;
20074 int res1 = SWIG_TMPOBJ ;
20075 PLINT temp2 ;
20076 int res2 = SWIG_TMPOBJ ;
20077 octave_value_list _out;
20078 octave_value_list *_outp=&_out;
20079 octave_value _outv;
20080
20081 try {
20082 arg1 = &temp1;
20083 arg2 = &temp2;
20084 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20085 SWIG_fail;
20086 }
20087 plgyax(arg1,arg2);
20088 _outv = octave_value();
20089 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20090 if (SWIG_IsTmpObj(res1)) {
20091 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20092 } else {
20093 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20094 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20095 }
20096 if (SWIG_IsTmpObj(res2)) {
20097 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20098 } else {
20099 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20100 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20101 }
20102 return _out;
20103 fail:
20104 return octave_value_list();
20105 }
20106 catch(...) {
20107 throw;
20108 }
20109}
20110
20111
20113 PLINT *arg1 = (PLINT *) 0 ;
20114 PLINT *arg2 = (PLINT *) 0 ;
20115 PLINT temp1 ;
20116 int res1 = SWIG_TMPOBJ ;
20117 PLINT temp2 ;
20118 int res2 = SWIG_TMPOBJ ;
20119 octave_value_list _out;
20120 octave_value_list *_outp=&_out;
20121 octave_value _outv;
20122
20123 try {
20124 arg1 = &temp1;
20125 arg2 = &temp2;
20126 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20127 SWIG_fail;
20128 }
20129 plgzax(arg1,arg2);
20130 _outv = octave_value();
20131 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20132 if (SWIG_IsTmpObj(res1)) {
20133 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20134 } else {
20135 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20136 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20137 }
20138 if (SWIG_IsTmpObj(res2)) {
20139 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20140 } else {
20141 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20142 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20143 }
20144 return _out;
20145 fail:
20146 return octave_value_list();
20147 }
20148 catch(...) {
20149 throw;
20150 }
20151}
20152
20153
20155 PLINT arg1 ;
20156 PLFLT *arg2 = (PLFLT *) 0 ;
20157 PLFLT arg3 ;
20158 PLFLT arg4 ;
20159 PLINT arg5 ;
20160 PLINT arg6 ;
20161 Matrix temp1 ;
20162 double val3 ;
20163 int ecode3 = 0 ;
20164 double val4 ;
20165 int ecode4 = 0 ;
20166 int val5 ;
20167 int ecode5 = 0 ;
20168 int val6 ;
20169 int ecode6 = 0 ;
20170 octave_value_list _out;
20171 octave_value_list *_outp=&_out;
20172 octave_value _outv;
20173
20174 try {
20175 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20176 SWIG_fail;
20177 }
20178 {
20179 if ( _n_dims( args(0) ) > 1 )
20180 {
20181 error( "argument must be a scalar or vector" ); SWIG_fail;
20182 }
20183 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20184 temp1 = args(0).matrix_value();
20185 arg2 = &temp1( 0, 0 );
20186 }
20187 ecode3 = SWIG_AsVal_double(args(1), &val3);
20188 if (!SWIG_IsOK(ecode3)) {
20189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20190 }
20191 arg3 = static_cast< PLFLT >(val3);
20192 ecode4 = SWIG_AsVal_double(args(2), &val4);
20193 if (!SWIG_IsOK(ecode4)) {
20194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20195 }
20196 arg4 = static_cast< PLFLT >(val4);
20197 ecode5 = SWIG_AsVal_int(args(3), &val5);
20198 if (!SWIG_IsOK(ecode5)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20200 }
20201 arg5 = static_cast< PLINT >(val5);
20202 ecode6 = SWIG_AsVal_int(args(4), &val6);
20203 if (!SWIG_IsOK(ecode6)) {
20204 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20205 }
20206 arg6 = static_cast< PLINT >(val6);
20207 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20208 _outv = octave_value();
20209 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20210 {
20211
20212 }
20213 return _out;
20214 fail:
20215 {
20216
20217 }
20218 return octave_value_list();
20219 }
20220 catch(...) {
20221 {
20222
20223 }
20224 throw;
20225 }
20226}
20227
20228
20230 PLFLT arg1 ;
20231 PLFLT arg2 ;
20232 PLFLT arg3 ;
20233 PLFLT *arg4 = (PLFLT *) 0 ;
20234 PLFLT *arg5 = (PLFLT *) 0 ;
20235 PLFLT *arg6 = (PLFLT *) 0 ;
20236 double val1 ;
20237 int ecode1 = 0 ;
20238 double val2 ;
20239 int ecode2 = 0 ;
20240 double val3 ;
20241 int ecode3 = 0 ;
20242 PLFLT temp4 ;
20243 int res4 = SWIG_TMPOBJ ;
20244 PLFLT temp5 ;
20245 int res5 = SWIG_TMPOBJ ;
20246 PLFLT temp6 ;
20247 int res6 = SWIG_TMPOBJ ;
20248 octave_value_list _out;
20249 octave_value_list *_outp=&_out;
20250 octave_value _outv;
20251
20252 try {
20253 arg4 = &temp4;
20254 arg5 = &temp5;
20255 arg6 = &temp6;
20256 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20257 SWIG_fail;
20258 }
20259 ecode1 = SWIG_AsVal_double(args(0), &val1);
20260 if (!SWIG_IsOK(ecode1)) {
20261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20262 }
20263 arg1 = static_cast< PLFLT >(val1);
20264 ecode2 = SWIG_AsVal_double(args(1), &val2);
20265 if (!SWIG_IsOK(ecode2)) {
20266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20267 }
20268 arg2 = static_cast< PLFLT >(val2);
20269 ecode3 = SWIG_AsVal_double(args(2), &val3);
20270 if (!SWIG_IsOK(ecode3)) {
20271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20272 }
20273 arg3 = static_cast< PLFLT >(val3);
20274 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20275 _outv = octave_value();
20276 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20277 if (SWIG_IsTmpObj(res4)) {
20278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20279 } else {
20280 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20282 }
20283 if (SWIG_IsTmpObj(res5)) {
20284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20285 } else {
20286 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20288 }
20289 if (SWIG_IsTmpObj(res6)) {
20290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20291 } else {
20292 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20294 }
20295 return _out;
20296 fail:
20297 return octave_value_list();
20298 }
20299 catch(...) {
20300 throw;
20301 }
20302}
20303
20304
20306 octave_value_list _out;
20307 octave_value_list *_outp=&_out;
20308 octave_value _outv;
20309
20310 try {
20311 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20312 SWIG_fail;
20313 }
20314 plinit();
20315 _outv = octave_value();
20316 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20317 return _out;
20318 fail:
20319 return octave_value_list();
20320 }
20321 catch(...) {
20322 throw;
20323 }
20324}
20325
20326
20328 PLFLT arg1 ;
20329 PLFLT arg2 ;
20330 PLFLT arg3 ;
20331 PLFLT arg4 ;
20332 double val1 ;
20333 int ecode1 = 0 ;
20334 double val2 ;
20335 int ecode2 = 0 ;
20336 double val3 ;
20337 int ecode3 = 0 ;
20338 double val4 ;
20339 int ecode4 = 0 ;
20340 octave_value_list _out;
20341 octave_value_list *_outp=&_out;
20342 octave_value _outv;
20343
20344 try {
20345 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20346 SWIG_fail;
20347 }
20348 ecode1 = SWIG_AsVal_double(args(0), &val1);
20349 if (!SWIG_IsOK(ecode1)) {
20350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20351 }
20352 arg1 = static_cast< PLFLT >(val1);
20353 ecode2 = SWIG_AsVal_double(args(1), &val2);
20354 if (!SWIG_IsOK(ecode2)) {
20355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20356 }
20357 arg2 = static_cast< PLFLT >(val2);
20358 ecode3 = SWIG_AsVal_double(args(2), &val3);
20359 if (!SWIG_IsOK(ecode3)) {
20360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20361 }
20362 arg3 = static_cast< PLFLT >(val3);
20363 ecode4 = SWIG_AsVal_double(args(3), &val4);
20364 if (!SWIG_IsOK(ecode4)) {
20365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20366 }
20367 arg4 = static_cast< PLFLT >(val4);
20368 pljoin(arg1,arg2,arg3,arg4);
20369 _outv = octave_value();
20370 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20371 return _out;
20372 fail:
20373 return octave_value_list();
20374 }
20375 catch(...) {
20376 throw;
20377 }
20378}
20379
20380
20382 char *arg1 = (char *) 0 ;
20383 char *arg2 = (char *) 0 ;
20384 char *arg3 = (char *) 0 ;
20385 int res1 ;
20386 char *buf1 = 0 ;
20387 int alloc1 = 0 ;
20388 int res2 ;
20389 char *buf2 = 0 ;
20390 int alloc2 = 0 ;
20391 int res3 ;
20392 char *buf3 = 0 ;
20393 int alloc3 = 0 ;
20394 octave_value_list _out;
20395 octave_value_list *_outp=&_out;
20396 octave_value _outv;
20397
20398 try {
20399 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20400 SWIG_fail;
20401 }
20402 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20405 }
20406 arg1 = reinterpret_cast< char * >(buf1);
20407 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20408 if (!SWIG_IsOK(res2)) {
20409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20410 }
20411 arg2 = reinterpret_cast< char * >(buf2);
20412 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20413 if (!SWIG_IsOK(res3)) {
20414 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20415 }
20416 arg3 = reinterpret_cast< char * >(buf3);
20417 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20418 _outv = octave_value();
20419 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20420 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20421 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20422 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20423 return _out;
20424 fail:
20425 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20426 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20427 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20428 return octave_value_list();
20429 }
20430 catch(...) {
20431 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20432 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20433 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20434 throw;
20435 }
20436}
20437
20438
20440 PLFLT *arg1 = (PLFLT *) 0 ;
20441 PLFLT *arg2 = (PLFLT *) 0 ;
20442 PLINT arg3 ;
20443 PLINT arg4 ;
20444 PLFLT arg5 ;
20445 PLFLT arg6 ;
20446 PLFLT arg7 ;
20447 PLINT arg8 ;
20448 PLINT arg9 ;
20449 PLINT arg10 ;
20450 PLINT arg11 ;
20451 PLINT arg12 ;
20452 PLINT arg13 ;
20453 PLINT *arg14 = (PLINT *) 0 ;
20454 PLFLT arg15 ;
20455 PLFLT arg16 ;
20456 PLFLT arg17 ;
20457 PLFLT arg18 ;
20458 PLINT *arg19 = (PLINT *) 0 ;
20459 char **arg20 = (char **) 0 ;
20460 PLINT *arg21 = (PLINT *) 0 ;
20461 PLINT *arg22 = (PLINT *) 0 ;
20462 PLFLT *arg23 = (PLFLT *) 0 ;
20463 PLFLT *arg24 = (PLFLT *) 0 ;
20464 PLINT *arg25 = (PLINT *) 0 ;
20465 PLINT *arg26 = (PLINT *) 0 ;
20466 PLFLT *arg27 = (PLFLT *) 0 ;
20467 PLINT *arg28 = (PLINT *) 0 ;
20468 PLFLT *arg29 = (PLFLT *) 0 ;
20469 PLINT *arg30 = (PLINT *) 0 ;
20470 char **arg31 = (char **) 0 ;
20471 PLFLT temp1 ;
20472 int res1 = SWIG_TMPOBJ ;
20473 PLFLT temp2 ;
20474 int res2 = SWIG_TMPOBJ ;
20475 int val3 ;
20476 int ecode3 = 0 ;
20477 int val4 ;
20478 int ecode4 = 0 ;
20479 double val5 ;
20480 int ecode5 = 0 ;
20481 double val6 ;
20482 int ecode6 = 0 ;
20483 double val7 ;
20484 int ecode7 = 0 ;
20485 int val8 ;
20486 int ecode8 = 0 ;
20487 int val9 ;
20488 int ecode9 = 0 ;
20489 int val10 ;
20490 int ecode10 = 0 ;
20491 int val11 ;
20492 int ecode11 = 0 ;
20493 int val12 ;
20494 int ecode12 = 0 ;
20495 Matrix temp13 ;
20496 double val15 ;
20497 int ecode15 = 0 ;
20498 double val16 ;
20499 int ecode16 = 0 ;
20500 double val17 ;
20501 int ecode17 = 0 ;
20502 double val18 ;
20503 int ecode18 = 0 ;
20504 Matrix temp19 ;
20505 Matrix temp21 ;
20506 Matrix temp22 ;
20507 Matrix temp23 ;
20508 Matrix temp24 ;
20509 Matrix temp25 ;
20510 Matrix temp26 ;
20511 Matrix temp27 ;
20512 Matrix temp28 ;
20513 Matrix temp29 ;
20514 Matrix temp30 ;
20515 octave_value_list _out;
20516 octave_value_list *_outp=&_out;
20517 octave_value _outv;
20518
20519 try {
20520 arg1 = &temp1;
20521 arg2 = &temp2;
20522 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20523 SWIG_fail;
20524 }
20525 ecode3 = SWIG_AsVal_int(args(0), &val3);
20526 if (!SWIG_IsOK(ecode3)) {
20527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20528 }
20529 arg3 = static_cast< PLINT >(val3);
20530 ecode4 = SWIG_AsVal_int(args(1), &val4);
20531 if (!SWIG_IsOK(ecode4)) {
20532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20533 }
20534 arg4 = static_cast< PLINT >(val4);
20535 ecode5 = SWIG_AsVal_double(args(2), &val5);
20536 if (!SWIG_IsOK(ecode5)) {
20537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20538 }
20539 arg5 = static_cast< PLFLT >(val5);
20540 ecode6 = SWIG_AsVal_double(args(3), &val6);
20541 if (!SWIG_IsOK(ecode6)) {
20542 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20543 }
20544 arg6 = static_cast< PLFLT >(val6);
20545 ecode7 = SWIG_AsVal_double(args(4), &val7);
20546 if (!SWIG_IsOK(ecode7)) {
20547 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20548 }
20549 arg7 = static_cast< PLFLT >(val7);
20550 ecode8 = SWIG_AsVal_int(args(5), &val8);
20551 if (!SWIG_IsOK(ecode8)) {
20552 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20553 }
20554 arg8 = static_cast< PLINT >(val8);
20555 ecode9 = SWIG_AsVal_int(args(6), &val9);
20556 if (!SWIG_IsOK(ecode9)) {
20557 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20558 }
20559 arg9 = static_cast< PLINT >(val9);
20560 ecode10 = SWIG_AsVal_int(args(7), &val10);
20561 if (!SWIG_IsOK(ecode10)) {
20562 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20563 }
20564 arg10 = static_cast< PLINT >(val10);
20565 ecode11 = SWIG_AsVal_int(args(8), &val11);
20566 if (!SWIG_IsOK(ecode11)) {
20567 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20568 }
20569 arg11 = static_cast< PLINT >(val11);
20570 ecode12 = SWIG_AsVal_int(args(9), &val12);
20571 if (!SWIG_IsOK(ecode12)) {
20572 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20573 }
20574 arg12 = static_cast< PLINT >(val12);
20575 {
20576 if ( _n_dims( args(10) ) > 1 )
20577 {
20578 error( "argument must be a scalar or vector" ); SWIG_fail;
20579 }
20580 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20581 arg14 = new PLINT[Alen];
20582 temp13 = args(10).matrix_value();
20583 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20584 }
20585 ecode15 = SWIG_AsVal_double(args(11), &val15);
20586 if (!SWIG_IsOK(ecode15)) {
20587 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20588 }
20589 arg15 = static_cast< PLFLT >(val15);
20590 ecode16 = SWIG_AsVal_double(args(12), &val16);
20591 if (!SWIG_IsOK(ecode16)) {
20592 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20593 }
20594 arg16 = static_cast< PLFLT >(val16);
20595 ecode17 = SWIG_AsVal_double(args(13), &val17);
20596 if (!SWIG_IsOK(ecode17)) {
20597 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20598 }
20599 arg17 = static_cast< PLFLT >(val17);
20600 ecode18 = SWIG_AsVal_double(args(14), &val18);
20601 if (!SWIG_IsOK(ecode18)) {
20602 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20603 }
20604 arg18 = static_cast< PLFLT >(val18);
20605 {
20606 if ( _n_dims( args(15) ) > 1 )
20607 {
20608 error( "argument must be a scalar or vector" ); SWIG_fail;
20609 }
20610 if ( _dim( args(15), 0 ) != Alen )
20611 {
20612 error( "argument vectors must be same length" ); SWIG_fail;
20613 }
20614 temp19 = args(15).matrix_value();
20615 arg19 = new PLINT[Alen];
20616 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20617 }
20618 {
20619 charMatrix temp_matrix;
20620 Cell temp_cell;
20621 char *tmp_cstring;
20622 std::string str;
20623 size_t max_length = 0, non_blank_length;
20624 int i, ifcell;
20625 if ( _n_dims( args(16) ) > 2 )
20626 {
20627 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20628 }
20629#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20630 if ( !args(16).isempty() )
20631#else
20632 if ( !args(16).is_empty() )
20633#endif
20634 {
20635 if ( _dim( args(16), 0 ) != Alen )
20636 {
20637 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20638 }
20639 arg20 = new char*[Alen];
20640#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20641 ifcell = args(16).iscell();
20642#else
20643 ifcell = args(16).is_cell();
20644#endif
20645 if ( ifcell )
20646 {
20647 temp_cell = args(16).cell_value();
20648 }
20649 else
20650 {
20651 temp_matrix = args(16).char_matrix_value();
20652 // Allow one extra space for null termination.
20653 max_length = _dim( args(16), 1 ) + 1;
20654 }
20655
20656 for ( i = 0; i < Alen; i++ )
20657 {
20658 // Must copy string to "permanent" location because the string
20659 // location corresponding to tmp_cstring gets
20660 // overwritten for each iteration of loop.
20661 if ( ifcell )
20662 {
20663 if ( temp_cell.elem( i ).is_string() )
20664 {
20665 str = temp_cell.elem( i ).string_value();
20666 // leave room for null termination.
20667 max_length = str.size() + 1;
20668 tmp_cstring = (char *) str.c_str();
20669 }
20670 else
20671 {
20672 // Use null string if user attempts to pass a cell array
20673 // with a non-string element (likely an empty element
20674 // since that should be allowed by the PLplot interface
20675 // if that element is going to be unused).
20676 // leave room for null termination.
20677 max_length = 1;
20678 tmp_cstring = (char *) "";
20679 }
20680 }
20681 else
20682 {
20683 str = temp_matrix.row_as_string( i );
20684 tmp_cstring = (char *) str.c_str();
20685 }
20686 arg20[i] = new char[max_length];
20687 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20688 arg20[i][max_length - 1] = '\0';
20689 // All the trailing blank crapola should not be needed for
20690 // string cell arrays.
20691 if ( !ifcell )
20692 {
20693 // remove trailing-blank padding that is used by the
20694 // charMatrix class to insure all strings in a given
20695 // charMatrix instance have the same length.
20696 // This transformation also removes legitimate trailing
20697 // blanks but there is nothing we can do about that
20698 // for the charMatrix class.
20699
20700 // Look for trailing nulls first (just in case, although that
20701 // shouldn't happen if charMatrix implemented as documented)
20702 // before looking for trailing blanks.
20703 non_blank_length = max_length - 2;
20704 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20705 {
20706 non_blank_length--;
20707 }
20708 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20709 {
20710 non_blank_length--;
20711 }
20712 arg20[i][non_blank_length + 1] = '\0';
20713 }
20714 }
20715 }
20716 else
20717 {
20718 arg20 = NULL;
20719 }
20720 }
20721 {
20722 if ( _n_dims( args(17) ) > 1 )
20723 {
20724 error( "argument must be a scalar or vector" ); SWIG_fail;
20725 }
20726#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20727 if ( !args(17).isempty() )
20728#else
20729 if ( !args(17).is_empty() )
20730#endif
20731 {
20732 if ( _dim( args(17), 0 ) != Alen )
20733 {
20734 error( "argument vectors must be same length" ); SWIG_fail;
20735 }
20736 temp21 = args(17).matrix_value();
20737 arg21 = new PLINT[Alen];
20738 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20739 }
20740 else
20741 {
20742 arg21 = NULL;
20743 }
20744 }
20745 {
20746 if ( _n_dims( args(18) ) > 1 )
20747 {
20748 error( "argument must be a scalar or vector" ); SWIG_fail;
20749 }
20750#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20751 if ( !args(18).isempty() )
20752#else
20753 if ( !args(18).is_empty() )
20754#endif
20755 {
20756 if ( _dim( args(18), 0 ) != Alen )
20757 {
20758 error( "argument vectors must be same length" ); SWIG_fail;
20759 }
20760 temp22 = args(18).matrix_value();
20761 arg22 = new PLINT[Alen];
20762 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20763 }
20764 else
20765 {
20766 arg22 = NULL;
20767 }
20768 }
20769 {
20770 if ( _n_dims( args(19) ) > 1 )
20771 {
20772 error( "argument must be a scalar or vector" ); SWIG_fail;
20773 }
20774#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20775 if ( !args(19).isempty() )
20776#else
20777 if ( !args(19).is_empty() )
20778#endif
20779 {
20780 if ( _dim( args(19), 0 ) != Alen )
20781 {
20782 error( "argument vectors must be same length" ); SWIG_fail;
20783 }
20784 temp23 = args(19).matrix_value();
20785 arg23 = &temp23( 0, 0 );
20786 }
20787 else
20788 {
20789 arg23 = NULL;
20790 }
20791 }
20792 {
20793 if ( _n_dims( args(20) ) > 1 )
20794 {
20795 error( "argument must be a scalar or vector" ); SWIG_fail;
20796 }
20797#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20798 if ( !args(20).isempty() )
20799#else
20800 if ( !args(20).is_empty() )
20801#endif
20802 {
20803 if ( _dim( args(20), 0 ) != Alen )
20804 {
20805 error( "argument vectors must be same length" ); SWIG_fail;
20806 }
20807 temp24 = args(20).matrix_value();
20808 arg24 = &temp24( 0, 0 );
20809 }
20810 else
20811 {
20812 arg24 = NULL;
20813 }
20814 }
20815 {
20816 if ( _n_dims( args(21) ) > 1 )
20817 {
20818 error( "argument must be a scalar or vector" ); SWIG_fail;
20819 }
20820#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20821 if ( !args(21).isempty() )
20822#else
20823 if ( !args(21).is_empty() )
20824#endif
20825 {
20826 if ( _dim( args(21), 0 ) != Alen )
20827 {
20828 error( "argument vectors must be same length" ); SWIG_fail;
20829 }
20830 temp25 = args(21).matrix_value();
20831 arg25 = new PLINT[Alen];
20832 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20833 }
20834 else
20835 {
20836 arg25 = NULL;
20837 }
20838 }
20839 {
20840 if ( _n_dims( args(22) ) > 1 )
20841 {
20842 error( "argument must be a scalar or vector" ); SWIG_fail;
20843 }
20844#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20845 if ( !args(22).isempty() )
20846#else
20847 if ( !args(22).is_empty() )
20848#endif
20849 {
20850 if ( _dim( args(22), 0 ) != Alen )
20851 {
20852 error( "argument vectors must be same length" ); SWIG_fail;
20853 }
20854 temp26 = args(22).matrix_value();
20855 arg26 = new PLINT[Alen];
20856 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20857 }
20858 else
20859 {
20860 arg26 = NULL;
20861 }
20862 }
20863 {
20864 if ( _n_dims( args(23) ) > 1 )
20865 {
20866 error( "argument must be a scalar or vector" ); SWIG_fail;
20867 }
20868#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20869 if ( !args(23).isempty() )
20870#else
20871 if ( !args(23).is_empty() )
20872#endif
20873 {
20874 if ( _dim( args(23), 0 ) != Alen )
20875 {
20876 error( "argument vectors must be same length" ); SWIG_fail;
20877 }
20878 temp27 = args(23).matrix_value();
20879 arg27 = &temp27( 0, 0 );
20880 }
20881 else
20882 {
20883 arg27 = NULL;
20884 }
20885 }
20886 {
20887 if ( _n_dims( args(24) ) > 1 )
20888 {
20889 error( "argument must be a scalar or vector" ); SWIG_fail;
20890 }
20891#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20892 if ( !args(24).isempty() )
20893#else
20894 if ( !args(24).is_empty() )
20895#endif
20896 {
20897 if ( _dim( args(24), 0 ) != Alen )
20898 {
20899 error( "argument vectors must be same length" ); SWIG_fail;
20900 }
20901 temp28 = args(24).matrix_value();
20902 arg28 = new PLINT[Alen];
20903 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20904 }
20905 else
20906 {
20907 arg28 = NULL;
20908 }
20909 }
20910 {
20911 if ( _n_dims( args(25) ) > 1 )
20912 {
20913 error( "argument must be a scalar or vector" ); SWIG_fail;
20914 }
20915#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20916 if ( !args(25).isempty() )
20917#else
20918 if ( !args(25).is_empty() )
20919#endif
20920 {
20921 if ( _dim( args(25), 0 ) != Alen )
20922 {
20923 error( "argument vectors must be same length" ); SWIG_fail;
20924 }
20925 temp29 = args(25).matrix_value();
20926 arg29 = &temp29( 0, 0 );
20927 }
20928 else
20929 {
20930 arg29 = NULL;
20931 }
20932 }
20933 {
20934 if ( _n_dims( args(26) ) > 1 )
20935 {
20936 error( "argument must be a scalar or vector" ); SWIG_fail;
20937 }
20938#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20939 if ( !args(26).isempty() )
20940#else
20941 if ( !args(26).is_empty() )
20942#endif
20943 {
20944 if ( _dim( args(26), 0 ) != Alen )
20945 {
20946 error( "argument vectors must be same length" ); SWIG_fail;
20947 }
20948 temp30 = args(26).matrix_value();
20949 arg30 = new PLINT[Alen];
20950 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20951 }
20952 else
20953 {
20954 arg30 = NULL;
20955 }
20956 }
20957 {
20958 charMatrix temp_matrix;
20959 Cell temp_cell;
20960 char *tmp_cstring;
20961 std::string str;
20962 size_t max_length = 0, non_blank_length;
20963 int i, ifcell;
20964 if ( _n_dims( args(27) ) > 2 )
20965 {
20966 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20967 }
20968#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20969 if ( !args(27).isempty() )
20970#else
20971 if ( !args(27).is_empty() )
20972#endif
20973 {
20974 if ( _dim( args(27), 0 ) != Alen )
20975 {
20976 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20977 }
20978 arg31 = new char*[Alen];
20979#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20980 ifcell = args(27).iscell();
20981#else
20982 ifcell = args(27).is_cell();
20983#endif
20984 if ( ifcell )
20985 {
20986 temp_cell = args(27).cell_value();
20987 }
20988 else
20989 {
20990 temp_matrix = args(27).char_matrix_value();
20991 // Allow one extra space for null termination.
20992 max_length = _dim( args(27), 1 ) + 1;
20993 }
20994
20995 for ( i = 0; i < Alen; i++ )
20996 {
20997 // Must copy string to "permanent" location because the string
20998 // location corresponding to tmp_cstring gets
20999 // overwritten for each iteration of loop.
21000 if ( ifcell )
21001 {
21002 if ( temp_cell.elem( i ).is_string() )
21003 {
21004 str = temp_cell.elem( i ).string_value();
21005 // leave room for null termination.
21006 max_length = str.size() + 1;
21007 tmp_cstring = (char *) str.c_str();
21008 }
21009 else
21010 {
21011 // Use null string if user attempts to pass a cell array
21012 // with a non-string element (likely an empty element
21013 // since that should be allowed by the PLplot interface
21014 // if that element is going to be unused).
21015 // leave room for null termination.
21016 max_length = 1;
21017 tmp_cstring = (char *) "";
21018 }
21019 }
21020 else
21021 {
21022 str = temp_matrix.row_as_string( i );
21023 tmp_cstring = (char *) str.c_str();
21024 }
21025 arg31[i] = new char[max_length];
21026 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21027 arg31[i][max_length - 1] = '\0';
21028 // All the trailing blank crapola should not be needed for
21029 // string cell arrays.
21030 if ( !ifcell )
21031 {
21032 // remove trailing-blank padding that is used by the
21033 // charMatrix class to insure all strings in a given
21034 // charMatrix instance have the same length.
21035 // This transformation also removes legitimate trailing
21036 // blanks but there is nothing we can do about that
21037 // for the charMatrix class.
21038
21039 // Look for trailing nulls first (just in case, although that
21040 // shouldn't happen if charMatrix implemented as documented)
21041 // before looking for trailing blanks.
21042 non_blank_length = max_length - 2;
21043 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
21044 {
21045 non_blank_length--;
21046 }
21047 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
21048 {
21049 non_blank_length--;
21050 }
21051 arg31[i][non_blank_length + 1] = '\0';
21052 }
21053 }
21054 }
21055 else
21056 {
21057 arg31 = NULL;
21058 }
21059 }
21060 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);
21061 _outv = octave_value();
21062 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21063 if (SWIG_IsTmpObj(res1)) {
21064 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21065 } else {
21066 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21067 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21068 }
21069 if (SWIG_IsTmpObj(res2)) {
21070 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21071 } else {
21072 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21073 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21074 }
21075 {
21076 delete [] arg14;
21077 }
21078 {
21079 delete [] arg19;
21080 }
21081 {
21082 int i;
21083 if ( arg20 != NULL )
21084 {
21085 for ( i = 0; i < Alen; i++ )
21086 {
21087 delete[] arg20[i];
21088 }
21089 delete[] arg20;
21090 }
21091 }
21092 {
21093 if ( arg21 != NULL )
21094 delete [] arg21;
21095 }
21096 {
21097 if ( arg22 != NULL )
21098 delete [] arg22;
21099 }
21100 {
21101
21102 }
21103 {
21104
21105 }
21106 {
21107 if ( arg25 != NULL )
21108 delete [] arg25;
21109 }
21110 {
21111 if ( arg26 != NULL )
21112 delete [] arg26;
21113 }
21114 {
21115
21116 }
21117 {
21118 if ( arg28 != NULL )
21119 delete [] arg28;
21120 }
21121 {
21122
21123 }
21124 {
21125 if ( arg30 != NULL )
21126 delete [] arg30;
21127 }
21128 {
21129 int i;
21130 if ( arg31 != NULL )
21131 {
21132 for ( i = 0; i < Alen; i++ )
21133 {
21134 delete[] arg31[i];
21135 }
21136 delete[] arg31;
21137 }
21138 }
21139 return _out;
21140 fail:
21141 {
21142 delete [] arg14;
21143 }
21144 {
21145 delete [] arg19;
21146 }
21147 {
21148 int i;
21149 if ( arg20 != NULL )
21150 {
21151 for ( i = 0; i < Alen; i++ )
21152 {
21153 delete[] arg20[i];
21154 }
21155 delete[] arg20;
21156 }
21157 }
21158 {
21159 if ( arg21 != NULL )
21160 delete [] arg21;
21161 }
21162 {
21163 if ( arg22 != NULL )
21164 delete [] arg22;
21165 }
21166 {
21167
21168 }
21169 {
21170
21171 }
21172 {
21173 if ( arg25 != NULL )
21174 delete [] arg25;
21175 }
21176 {
21177 if ( arg26 != NULL )
21178 delete [] arg26;
21179 }
21180 {
21181
21182 }
21183 {
21184 if ( arg28 != NULL )
21185 delete [] arg28;
21186 }
21187 {
21188
21189 }
21190 {
21191 if ( arg30 != NULL )
21192 delete [] arg30;
21193 }
21194 {
21195 int i;
21196 if ( arg31 != NULL )
21197 {
21198 for ( i = 0; i < Alen; i++ )
21199 {
21200 delete[] arg31[i];
21201 }
21202 delete[] arg31;
21203 }
21204 }
21205 return octave_value_list();
21206 }
21207 catch(...) {
21208 {
21209 delete [] arg14;
21210 }
21211 {
21212 delete [] arg19;
21213 }
21214 {
21215 int i;
21216 if ( arg20 != NULL )
21217 {
21218 for ( i = 0; i < Alen; i++ )
21219 {
21220 delete[] arg20[i];
21221 }
21222 delete[] arg20;
21223 }
21224 }
21225 {
21226 if ( arg21 != NULL )
21227 delete [] arg21;
21228 }
21229 {
21230 if ( arg22 != NULL )
21231 delete [] arg22;
21232 }
21233 {
21234
21235 }
21236 {
21237
21238 }
21239 {
21240 if ( arg25 != NULL )
21241 delete [] arg25;
21242 }
21243 {
21244 if ( arg26 != NULL )
21245 delete [] arg26;
21246 }
21247 {
21248
21249 }
21250 {
21251 if ( arg28 != NULL )
21252 delete [] arg28;
21253 }
21254 {
21255
21256 }
21257 {
21258 if ( arg30 != NULL )
21259 delete [] arg30;
21260 }
21261 {
21262 int i;
21263 if ( arg31 != NULL )
21264 {
21265 for ( i = 0; i < Alen; i++ )
21266 {
21267 delete[] arg31[i];
21268 }
21269 delete[] arg31;
21270 }
21271 }
21272 throw;
21273 }
21274}
21275
21276
21278 PLFLT arg1 ;
21279 PLFLT arg2 ;
21280 PLFLT arg3 ;
21281 double val1 ;
21282 int ecode1 = 0 ;
21283 double val2 ;
21284 int ecode2 = 0 ;
21285 double val3 ;
21286 int ecode3 = 0 ;
21287 octave_value_list _out;
21288 octave_value_list *_outp=&_out;
21289 octave_value _outv;
21290
21291 try {
21292 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21293 SWIG_fail;
21294 }
21295 ecode1 = SWIG_AsVal_double(args(0), &val1);
21296 if (!SWIG_IsOK(ecode1)) {
21297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21298 }
21299 arg1 = static_cast< PLFLT >(val1);
21300 ecode2 = SWIG_AsVal_double(args(1), &val2);
21301 if (!SWIG_IsOK(ecode2)) {
21302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21303 }
21304 arg2 = static_cast< PLFLT >(val2);
21305 ecode3 = SWIG_AsVal_double(args(2), &val3);
21306 if (!SWIG_IsOK(ecode3)) {
21307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21308 }
21309 arg3 = static_cast< PLFLT >(val3);
21310 pllightsource(arg1,arg2,arg3);
21311 _outv = octave_value();
21312 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21313 return _out;
21314 fail:
21315 return octave_value_list();
21316 }
21317 catch(...) {
21318 throw;
21319 }
21320}
21321
21322
21324 PLINT arg1 ;
21325 PLFLT *arg2 = (PLFLT *) 0 ;
21326 PLFLT *arg3 = (PLFLT *) 0 ;
21327 Matrix temp1 ;
21328 Matrix temp3 ;
21329 octave_value_list _out;
21330 octave_value_list *_outp=&_out;
21331 octave_value _outv;
21332
21333 try {
21334 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21335 SWIG_fail;
21336 }
21337 {
21338 if ( _n_dims( args(0) ) > 1 )
21339 {
21340 error( "argument must be a scalar or vector" ); SWIG_fail;
21341 }
21342 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21343 temp1 = args(0).matrix_value();
21344 arg2 = &temp1( 0, 0 );
21345 }
21346 {
21347 if ( _n_dims( args(1) ) > 1 )
21348 {
21349 error( "argument must be a scalar or vector" ); SWIG_fail;
21350 }
21351 if ( _dim( args(1), 0 ) != Alen )
21352 {
21353 error( "argument vectors must be same length" ); SWIG_fail;
21354 }
21355 temp3 = args(1).matrix_value();
21356 arg3 = &temp3( 0, 0 );
21357 }
21358 plline(arg1,(double const *)arg2,(double const *)arg3);
21359 _outv = octave_value();
21360 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21361 {
21362
21363 }
21364 {
21365
21366 }
21367 return _out;
21368 fail:
21369 {
21370
21371 }
21372 {
21373
21374 }
21375 return octave_value_list();
21376 }
21377 catch(...) {
21378 {
21379
21380 }
21381 {
21382
21383 }
21384 throw;
21385 }
21386}
21387
21388
21390 PLINT arg1 ;
21391 PLFLT *arg2 = (PLFLT *) 0 ;
21392 PLFLT *arg3 = (PLFLT *) 0 ;
21393 PLFLT *arg4 = (PLFLT *) 0 ;
21394 Matrix temp1 ;
21395 Matrix temp3 ;
21396 Matrix temp4 ;
21397 octave_value_list _out;
21398 octave_value_list *_outp=&_out;
21399 octave_value _outv;
21400
21401 try {
21402 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21403 SWIG_fail;
21404 }
21405 {
21406 if ( _n_dims( args(0) ) > 1 )
21407 {
21408 error( "argument must be a scalar or vector" ); SWIG_fail;
21409 }
21410 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21411 temp1 = args(0).matrix_value();
21412 arg2 = &temp1( 0, 0 );
21413 }
21414 {
21415 if ( _n_dims( args(1) ) > 1 )
21416 {
21417 error( "argument must be a scalar or vector" ); SWIG_fail;
21418 }
21419 if ( _dim( args(1), 0 ) != Alen )
21420 {
21421 error( "argument vectors must be same length" ); SWIG_fail;
21422 }
21423 temp3 = args(1).matrix_value();
21424 arg3 = &temp3( 0, 0 );
21425 }
21426 {
21427 if ( _n_dims( args(2) ) > 1 )
21428 {
21429 error( "argument must be a scalar or vector" ); SWIG_fail;
21430 }
21431 if ( _dim( args(2), 0 ) != Alen )
21432 {
21433 error( "argument vectors must be same length" ); SWIG_fail;
21434 }
21435 temp4 = args(2).matrix_value();
21436 arg4 = &temp4( 0, 0 );
21437 }
21438 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21439 _outv = octave_value();
21440 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21441 {
21442
21443 }
21444 {
21445
21446 }
21447 {
21448
21449 }
21450 return _out;
21451 fail:
21452 {
21453
21454 }
21455 {
21456
21457 }
21458 {
21459
21460 }
21461 return octave_value_list();
21462 }
21463 catch(...) {
21464 {
21465
21466 }
21467 {
21468
21469 }
21470 {
21471
21472 }
21473 throw;
21474 }
21475}
21476
21477
21479 PLINT arg1 ;
21480 int val1 ;
21481 int ecode1 = 0 ;
21482 octave_value_list _out;
21483 octave_value_list *_outp=&_out;
21484 octave_value _outv;
21485
21486 try {
21487 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21488 SWIG_fail;
21489 }
21490 ecode1 = SWIG_AsVal_int(args(0), &val1);
21491 if (!SWIG_IsOK(ecode1)) {
21492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21493 }
21494 arg1 = static_cast< PLINT >(val1);
21495 pllsty(arg1);
21496 _outv = octave_value();
21497 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21498 return _out;
21499 fail:
21500 return octave_value_list();
21501 }
21502 catch(...) {
21503 throw;
21504 }
21505}
21506
21507
21509 PLINT *arg1 = (PLINT *) 0 ;
21510 PLINT temp1 ;
21511 int res1 = SWIG_TMPOBJ ;
21512 octave_value_list _out;
21513 octave_value_list *_outp=&_out;
21514 octave_value _outv;
21515
21516 try {
21517 arg1 = &temp1;
21518 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21519 SWIG_fail;
21520 }
21521 plmkstrm(arg1);
21522 _outv = octave_value();
21523 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21524 if (SWIG_IsTmpObj(res1)) {
21525 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21526 } else {
21527 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21528 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21529 }
21530 return _out;
21531 fail:
21532 return octave_value_list();
21533 }
21534 catch(...) {
21535 throw;
21536 }
21537}
21538
21539
21541 char *arg1 = (char *) 0 ;
21542 PLFLT arg2 ;
21543 PLFLT arg3 ;
21544 PLFLT arg4 ;
21545 char *arg5 = (char *) 0 ;
21546 int res1 ;
21547 char *buf1 = 0 ;
21548 int alloc1 = 0 ;
21549 double val2 ;
21550 int ecode2 = 0 ;
21551 double val3 ;
21552 int ecode3 = 0 ;
21553 double val4 ;
21554 int ecode4 = 0 ;
21555 int res5 ;
21556 char *buf5 = 0 ;
21557 int alloc5 = 0 ;
21558 octave_value_list _out;
21559 octave_value_list *_outp=&_out;
21560 octave_value _outv;
21561
21562 try {
21563 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21564 SWIG_fail;
21565 }
21566 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21567 if (!SWIG_IsOK(res1)) {
21568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21569 }
21570 arg1 = reinterpret_cast< char * >(buf1);
21571 ecode2 = SWIG_AsVal_double(args(1), &val2);
21572 if (!SWIG_IsOK(ecode2)) {
21573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21574 }
21575 arg2 = static_cast< PLFLT >(val2);
21576 ecode3 = SWIG_AsVal_double(args(2), &val3);
21577 if (!SWIG_IsOK(ecode3)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21579 }
21580 arg3 = static_cast< PLFLT >(val3);
21581 ecode4 = SWIG_AsVal_double(args(3), &val4);
21582 if (!SWIG_IsOK(ecode4)) {
21583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21584 }
21585 arg4 = static_cast< PLFLT >(val4);
21586 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21587 if (!SWIG_IsOK(res5)) {
21588 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21589 }
21590 arg5 = reinterpret_cast< char * >(buf5);
21591 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21592 _outv = octave_value();
21593 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21594 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21595 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21596 return _out;
21597 fail:
21598 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21599 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21600 return octave_value_list();
21601 }
21602 catch(...) {
21603 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21604 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21605 throw;
21606 }
21607}
21608
21609
21611 char *arg1 = (char *) 0 ;
21612 PLFLT arg2 ;
21613 PLFLT arg3 ;
21614 PLFLT arg4 ;
21615 char *arg5 = (char *) 0 ;
21616 int res1 ;
21617 char *buf1 = 0 ;
21618 int alloc1 = 0 ;
21619 double val2 ;
21620 int ecode2 = 0 ;
21621 double val3 ;
21622 int ecode3 = 0 ;
21623 double val4 ;
21624 int ecode4 = 0 ;
21625 int res5 ;
21626 char *buf5 = 0 ;
21627 int alloc5 = 0 ;
21628 octave_value_list _out;
21629 octave_value_list *_outp=&_out;
21630 octave_value _outv;
21631
21632 try {
21633 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21634 SWIG_fail;
21635 }
21636 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21637 if (!SWIG_IsOK(res1)) {
21638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21639 }
21640 arg1 = reinterpret_cast< char * >(buf1);
21641 ecode2 = SWIG_AsVal_double(args(1), &val2);
21642 if (!SWIG_IsOK(ecode2)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21644 }
21645 arg2 = static_cast< PLFLT >(val2);
21646 ecode3 = SWIG_AsVal_double(args(2), &val3);
21647 if (!SWIG_IsOK(ecode3)) {
21648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21649 }
21650 arg3 = static_cast< PLFLT >(val3);
21651 ecode4 = SWIG_AsVal_double(args(3), &val4);
21652 if (!SWIG_IsOK(ecode4)) {
21653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21654 }
21655 arg4 = static_cast< PLFLT >(val4);
21656 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21657 if (!SWIG_IsOK(res5)) {
21658 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21659 }
21660 arg5 = reinterpret_cast< char * >(buf5);
21661 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21662 _outv = octave_value();
21663 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21664 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21665 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21666 return _out;
21667 fail:
21668 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21669 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21670 return octave_value_list();
21671 }
21672 catch(...) {
21673 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21674 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21675 throw;
21676 }
21677}
21678
21679
21681 int *arg1 = (int *) 0 ;
21682 char **arg2 = (char **) 0 ;
21683 PLINT arg3 ;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 void *argp2 = 0 ;
21687 int res2 = 0 ;
21688 int val3 ;
21689 int ecode3 = 0 ;
21690 octave_value_list _out;
21691 octave_value_list *_outp=&_out;
21692 octave_value _outv;
21693 PLINT result;
21694
21695 try {
21696 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21697 SWIG_fail;
21698 }
21699 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21702 }
21703 arg1 = reinterpret_cast< int * >(argp1);
21704 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21705 if (!SWIG_IsOK(res2)) {
21706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21707 }
21708 arg2 = reinterpret_cast< char ** >(argp2);
21709 ecode3 = SWIG_AsVal_int(args(2), &val3);
21710 if (!SWIG_IsOK(ecode3)) {
21711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21712 }
21713 arg3 = static_cast< PLINT >(val3);
21714 result = (PLINT)plparseopts(arg1,arg2,arg3);
21715 _outv = SWIG_From_int(static_cast< int >(result));
21716 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21717 return _out;
21718 fail:
21719 return octave_value_list();
21720 }
21721 catch(...) {
21722 throw;
21723 }
21724}
21725
21726
21728 PLINT arg1 ;
21729 PLINT *arg2 = (PLINT *) 0 ;
21730 PLINT *arg3 = (PLINT *) 0 ;
21731 Matrix temp1 ;
21732 Matrix temp3 ;
21733 octave_value_list _out;
21734 octave_value_list *_outp=&_out;
21735 octave_value _outv;
21736
21737 try {
21738 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21739 SWIG_fail;
21740 }
21741 {
21742 if ( _n_dims( args(0) ) > 1 )
21743 {
21744 error( "argument must be a scalar or vector" ); SWIG_fail;
21745 }
21746 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21747 arg2 = new PLINT[Alen];
21748 temp1 = args(0).matrix_value();
21749 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21750 }
21751 {
21752 if ( _n_dims( args(1) ) > 1 )
21753 {
21754 error( "argument must be a scalar or vector" ); SWIG_fail;
21755 }
21756 if ( _dim( args(1), 0 ) != Alen )
21757 {
21758 error( "argument vectors must be same length" ); SWIG_fail;
21759 }
21760 temp3 = args(1).matrix_value();
21761 arg3 = new PLINT[Alen];
21762 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21763 }
21764 plpat(arg1,(int const *)arg2,(int const *)arg3);
21765 _outv = octave_value();
21766 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21767 {
21768 delete [] arg2;
21769 }
21770 {
21771 delete [] arg3;
21772 }
21773 return _out;
21774 fail:
21775 {
21776 delete [] arg2;
21777 }
21778 {
21779 delete [] arg3;
21780 }
21781 return octave_value_list();
21782 }
21783 catch(...) {
21784 {
21785 delete [] arg2;
21786 }
21787 {
21788 delete [] arg3;
21789 }
21790 throw;
21791 }
21792}
21793
21794
21796 PLINT arg1 ;
21797 PLFLT arg2 ;
21798 PLFLT arg3 ;
21799 PLFLT arg4 ;
21800 PLFLT arg5 ;
21801 int val1 ;
21802 int ecode1 = 0 ;
21803 double val2 ;
21804 int ecode2 = 0 ;
21805 double val3 ;
21806 int ecode3 = 0 ;
21807 double val4 ;
21808 int ecode4 = 0 ;
21809 double val5 ;
21810 int ecode5 = 0 ;
21811 octave_value_list _out;
21812 octave_value_list *_outp=&_out;
21813 octave_value _outv;
21814
21815 try {
21816 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21817 SWIG_fail;
21818 }
21819 ecode1 = SWIG_AsVal_int(args(0), &val1);
21820 if (!SWIG_IsOK(ecode1)) {
21821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21822 }
21823 arg1 = static_cast< PLINT >(val1);
21824 ecode2 = SWIG_AsVal_double(args(1), &val2);
21825 if (!SWIG_IsOK(ecode2)) {
21826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21827 }
21828 arg2 = static_cast< PLFLT >(val2);
21829 ecode3 = SWIG_AsVal_double(args(2), &val3);
21830 if (!SWIG_IsOK(ecode3)) {
21831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21832 }
21833 arg3 = static_cast< PLFLT >(val3);
21834 ecode4 = SWIG_AsVal_double(args(3), &val4);
21835 if (!SWIG_IsOK(ecode4)) {
21836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21837 }
21838 arg4 = static_cast< PLFLT >(val4);
21839 ecode5 = SWIG_AsVal_double(args(4), &val5);
21840 if (!SWIG_IsOK(ecode5)) {
21841 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21842 }
21843 arg5 = static_cast< PLFLT >(val5);
21844 plpath(arg1,arg2,arg3,arg4,arg5);
21845 _outv = octave_value();
21846 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21847 return _out;
21848 fail:
21849 return octave_value_list();
21850 }
21851 catch(...) {
21852 throw;
21853 }
21854}
21855
21856
21858 PLINT arg1 ;
21859 PLFLT *arg2 = (PLFLT *) 0 ;
21860 PLFLT *arg3 = (PLFLT *) 0 ;
21861 PLINT arg4 ;
21862 Matrix temp1 ;
21863 Matrix temp3 ;
21864 int val4 ;
21865 int ecode4 = 0 ;
21866 octave_value_list _out;
21867 octave_value_list *_outp=&_out;
21868 octave_value _outv;
21869
21870 try {
21871 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21872 SWIG_fail;
21873 }
21874 {
21875 if ( _n_dims( args(0) ) > 1 )
21876 {
21877 error( "argument must be a scalar or vector" ); SWIG_fail;
21878 }
21879 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21880 temp1 = args(0).matrix_value();
21881 arg2 = &temp1( 0, 0 );
21882 }
21883 {
21884 if ( _n_dims( args(1) ) > 1 )
21885 {
21886 error( "argument must be a scalar or vector" ); SWIG_fail;
21887 }
21888 if ( _dim( args(1), 0 ) != Alen )
21889 {
21890 error( "argument vectors must be same length" ); SWIG_fail;
21891 }
21892 temp3 = args(1).matrix_value();
21893 arg3 = &temp3( 0, 0 );
21894 }
21895 ecode4 = SWIG_AsVal_int(args(2), &val4);
21896 if (!SWIG_IsOK(ecode4)) {
21897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21898 }
21899 arg4 = static_cast< PLINT >(val4);
21900 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21901 _outv = octave_value();
21902 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21903 {
21904
21905 }
21906 {
21907
21908 }
21909 return _out;
21910 fail:
21911 {
21912
21913 }
21914 {
21915
21916 }
21917 return octave_value_list();
21918 }
21919 catch(...) {
21920 {
21921
21922 }
21923 {
21924
21925 }
21926 throw;
21927 }
21928}
21929
21930
21932 PLINT arg1 ;
21933 PLFLT *arg2 = (PLFLT *) 0 ;
21934 PLFLT *arg3 = (PLFLT *) 0 ;
21935 PLFLT *arg4 = (PLFLT *) 0 ;
21936 PLINT arg5 ;
21937 Matrix temp1 ;
21938 Matrix temp3 ;
21939 Matrix temp4 ;
21940 int val5 ;
21941 int ecode5 = 0 ;
21942 octave_value_list _out;
21943 octave_value_list *_outp=&_out;
21944 octave_value _outv;
21945
21946 try {
21947 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21948 SWIG_fail;
21949 }
21950 {
21951 if ( _n_dims( args(0) ) > 1 )
21952 {
21953 error( "argument must be a scalar or vector" ); SWIG_fail;
21954 }
21955 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21956 temp1 = args(0).matrix_value();
21957 arg2 = &temp1( 0, 0 );
21958 }
21959 {
21960 if ( _n_dims( args(1) ) > 1 )
21961 {
21962 error( "argument must be a scalar or vector" ); SWIG_fail;
21963 }
21964 if ( _dim( args(1), 0 ) != Alen )
21965 {
21966 error( "argument vectors must be same length" ); SWIG_fail;
21967 }
21968 temp3 = args(1).matrix_value();
21969 arg3 = &temp3( 0, 0 );
21970 }
21971 {
21972 if ( _n_dims( args(2) ) > 1 )
21973 {
21974 error( "argument must be a scalar or vector" ); SWIG_fail;
21975 }
21976 if ( _dim( args(2), 0 ) != Alen )
21977 {
21978 error( "argument vectors must be same length" ); SWIG_fail;
21979 }
21980 temp4 = args(2).matrix_value();
21981 arg4 = &temp4( 0, 0 );
21982 }
21983 ecode5 = SWIG_AsVal_int(args(3), &val5);
21984 if (!SWIG_IsOK(ecode5)) {
21985 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21986 }
21987 arg5 = static_cast< PLINT >(val5);
21988 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21989 _outv = octave_value();
21990 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21991 {
21992
21993 }
21994 {
21995
21996 }
21997 {
21998
21999 }
22000 return _out;
22001 fail:
22002 {
22003
22004 }
22005 {
22006
22007 }
22008 {
22009
22010 }
22011 return octave_value_list();
22012 }
22013 catch(...) {
22014 {
22015
22016 }
22017 {
22018
22019 }
22020 {
22021
22022 }
22023 throw;
22024 }
22025}
22026
22027
22029 PLINT arg1 ;
22030 PLFLT *arg2 = (PLFLT *) 0 ;
22031 PLFLT *arg3 = (PLFLT *) 0 ;
22032 PLFLT *arg4 = (PLFLT *) 0 ;
22033 PLBOOL *arg5 = (PLBOOL *) 0 ;
22034 PLBOOL arg6 ;
22035 Matrix temp1 ;
22036 Matrix temp3 ;
22037 Matrix temp4 ;
22038 Matrix temp5 ;
22039 int val6 ;
22040 int ecode6 = 0 ;
22041 octave_value_list _out;
22042 octave_value_list *_outp=&_out;
22043 octave_value _outv;
22044
22045 try {
22046 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
22047 SWIG_fail;
22048 }
22049 {
22050 if ( _n_dims( args(0) ) > 1 )
22051 {
22052 error( "argument must be a scalar or vector" ); SWIG_fail;
22053 }
22054 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22055 temp1 = args(0).matrix_value();
22056 arg2 = &temp1( 0, 0 );
22057 }
22058 {
22059 if ( _n_dims( args(1) ) > 1 )
22060 {
22061 error( "argument must be a scalar or vector" ); SWIG_fail;
22062 }
22063 if ( _dim( args(1), 0 ) != Alen )
22064 {
22065 error( "argument vectors must be same length" ); SWIG_fail;
22066 }
22067 temp3 = args(1).matrix_value();
22068 arg3 = &temp3( 0, 0 );
22069 }
22070 {
22071 if ( _n_dims( args(2) ) > 1 )
22072 {
22073 error( "argument must be a scalar or vector" ); SWIG_fail;
22074 }
22075 if ( _dim( args(2), 0 ) != Alen )
22076 {
22077 error( "argument vectors must be same length" ); SWIG_fail;
22078 }
22079 temp4 = args(2).matrix_value();
22080 arg4 = &temp4( 0, 0 );
22081 }
22082 {
22083 if ( _n_dims( args(3) ) > 1 )
22084 {
22085 error( "argument must be a scalar or vector" ); SWIG_fail;
22086 }
22087 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22088 {
22089 error( "argument vector must be same length or one less" ); SWIG_fail;
22090 }
22091 temp5 = args(3).matrix_value();
22092 arg5 = new PLINT[Alen];
22093 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22094 }
22095 ecode6 = SWIG_AsVal_int(args(4), &val6);
22096 if (!SWIG_IsOK(ecode6)) {
22097 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22098 }
22099 arg6 = static_cast< PLBOOL >(val6);
22100 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22101 _outv = octave_value();
22102 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22103 {
22104
22105 }
22106 {
22107
22108 }
22109 {
22110
22111 }
22112 {
22113 delete [] arg5;
22114 }
22115 return _out;
22116 fail:
22117 {
22118
22119 }
22120 {
22121
22122 }
22123 {
22124
22125 }
22126 {
22127 delete [] arg5;
22128 }
22129 return octave_value_list();
22130 }
22131 catch(...) {
22132 {
22133
22134 }
22135 {
22136
22137 }
22138 {
22139
22140 }
22141 {
22142 delete [] arg5;
22143 }
22144 throw;
22145 }
22146}
22147
22148
22150 PLINT arg1 ;
22151 PLINT arg2 ;
22152 int val1 ;
22153 int ecode1 = 0 ;
22154 int val2 ;
22155 int ecode2 = 0 ;
22156 octave_value_list _out;
22157 octave_value_list *_outp=&_out;
22158 octave_value _outv;
22159
22160 try {
22161 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22162 SWIG_fail;
22163 }
22164 ecode1 = SWIG_AsVal_int(args(0), &val1);
22165 if (!SWIG_IsOK(ecode1)) {
22166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22167 }
22168 arg1 = static_cast< PLINT >(val1);
22169 ecode2 = SWIG_AsVal_int(args(1), &val2);
22170 if (!SWIG_IsOK(ecode2)) {
22171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22172 }
22173 arg2 = static_cast< PLINT >(val2);
22174 plprec(arg1,arg2);
22175 _outv = octave_value();
22176 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22177 return _out;
22178 fail:
22179 return octave_value_list();
22180 }
22181 catch(...) {
22182 throw;
22183 }
22184}
22185
22186
22188 PLINT arg1 ;
22189 int val1 ;
22190 int ecode1 = 0 ;
22191 octave_value_list _out;
22192 octave_value_list *_outp=&_out;
22193 octave_value _outv;
22194
22195 try {
22196 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22197 SWIG_fail;
22198 }
22199 ecode1 = SWIG_AsVal_int(args(0), &val1);
22200 if (!SWIG_IsOK(ecode1)) {
22201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22202 }
22203 arg1 = static_cast< PLINT >(val1);
22204 plpsty(arg1);
22205 _outv = octave_value();
22206 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22207 return _out;
22208 fail:
22209 return octave_value_list();
22210 }
22211 catch(...) {
22212 throw;
22213 }
22214}
22215
22216
22218 PLFLT arg1 ;
22219 PLFLT arg2 ;
22220 PLFLT arg3 ;
22221 PLFLT arg4 ;
22222 PLFLT arg5 ;
22223 char *arg6 = (char *) 0 ;
22224 double val1 ;
22225 int ecode1 = 0 ;
22226 double val2 ;
22227 int ecode2 = 0 ;
22228 double val3 ;
22229 int ecode3 = 0 ;
22230 double val4 ;
22231 int ecode4 = 0 ;
22232 double val5 ;
22233 int ecode5 = 0 ;
22234 int res6 ;
22235 char *buf6 = 0 ;
22236 int alloc6 = 0 ;
22237 octave_value_list _out;
22238 octave_value_list *_outp=&_out;
22239 octave_value _outv;
22240
22241 try {
22242 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22243 SWIG_fail;
22244 }
22245 ecode1 = SWIG_AsVal_double(args(0), &val1);
22246 if (!SWIG_IsOK(ecode1)) {
22247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22248 }
22249 arg1 = static_cast< PLFLT >(val1);
22250 ecode2 = SWIG_AsVal_double(args(1), &val2);
22251 if (!SWIG_IsOK(ecode2)) {
22252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22253 }
22254 arg2 = static_cast< PLFLT >(val2);
22255 ecode3 = SWIG_AsVal_double(args(2), &val3);
22256 if (!SWIG_IsOK(ecode3)) {
22257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22258 }
22259 arg3 = static_cast< PLFLT >(val3);
22260 ecode4 = SWIG_AsVal_double(args(3), &val4);
22261 if (!SWIG_IsOK(ecode4)) {
22262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22263 }
22264 arg4 = static_cast< PLFLT >(val4);
22265 ecode5 = SWIG_AsVal_double(args(4), &val5);
22266 if (!SWIG_IsOK(ecode5)) {
22267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22268 }
22269 arg5 = static_cast< PLFLT >(val5);
22270 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22271 if (!SWIG_IsOK(res6)) {
22272 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22273 }
22274 arg6 = reinterpret_cast< char * >(buf6);
22275 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22276 _outv = octave_value();
22277 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22278 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22279 return _out;
22280 fail:
22281 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22282 return octave_value_list();
22283 }
22284 catch(...) {
22285 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22286 throw;
22287 }
22288}
22289
22290
22292 PLFLT arg1 ;
22293 PLFLT arg2 ;
22294 PLFLT arg3 ;
22295 PLFLT arg4 ;
22296 PLFLT arg5 ;
22297 PLFLT arg6 ;
22298 PLFLT arg7 ;
22299 PLFLT arg8 ;
22300 PLFLT arg9 ;
22301 PLFLT arg10 ;
22302 char *arg11 = (char *) 0 ;
22303 double val1 ;
22304 int ecode1 = 0 ;
22305 double val2 ;
22306 int ecode2 = 0 ;
22307 double val3 ;
22308 int ecode3 = 0 ;
22309 double val4 ;
22310 int ecode4 = 0 ;
22311 double val5 ;
22312 int ecode5 = 0 ;
22313 double val6 ;
22314 int ecode6 = 0 ;
22315 double val7 ;
22316 int ecode7 = 0 ;
22317 double val8 ;
22318 int ecode8 = 0 ;
22319 double val9 ;
22320 int ecode9 = 0 ;
22321 double val10 ;
22322 int ecode10 = 0 ;
22323 int res11 ;
22324 char *buf11 = 0 ;
22325 int alloc11 = 0 ;
22326 octave_value_list _out;
22327 octave_value_list *_outp=&_out;
22328 octave_value _outv;
22329
22330 try {
22331 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22332 SWIG_fail;
22333 }
22334 ecode1 = SWIG_AsVal_double(args(0), &val1);
22335 if (!SWIG_IsOK(ecode1)) {
22336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22337 }
22338 arg1 = static_cast< PLFLT >(val1);
22339 ecode2 = SWIG_AsVal_double(args(1), &val2);
22340 if (!SWIG_IsOK(ecode2)) {
22341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22342 }
22343 arg2 = static_cast< PLFLT >(val2);
22344 ecode3 = SWIG_AsVal_double(args(2), &val3);
22345 if (!SWIG_IsOK(ecode3)) {
22346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22347 }
22348 arg3 = static_cast< PLFLT >(val3);
22349 ecode4 = SWIG_AsVal_double(args(3), &val4);
22350 if (!SWIG_IsOK(ecode4)) {
22351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22352 }
22353 arg4 = static_cast< PLFLT >(val4);
22354 ecode5 = SWIG_AsVal_double(args(4), &val5);
22355 if (!SWIG_IsOK(ecode5)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22357 }
22358 arg5 = static_cast< PLFLT >(val5);
22359 ecode6 = SWIG_AsVal_double(args(5), &val6);
22360 if (!SWIG_IsOK(ecode6)) {
22361 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22362 }
22363 arg6 = static_cast< PLFLT >(val6);
22364 ecode7 = SWIG_AsVal_double(args(6), &val7);
22365 if (!SWIG_IsOK(ecode7)) {
22366 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22367 }
22368 arg7 = static_cast< PLFLT >(val7);
22369 ecode8 = SWIG_AsVal_double(args(7), &val8);
22370 if (!SWIG_IsOK(ecode8)) {
22371 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22372 }
22373 arg8 = static_cast< PLFLT >(val8);
22374 ecode9 = SWIG_AsVal_double(args(8), &val9);
22375 if (!SWIG_IsOK(ecode9)) {
22376 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22377 }
22378 arg9 = static_cast< PLFLT >(val9);
22379 ecode10 = SWIG_AsVal_double(args(9), &val10);
22380 if (!SWIG_IsOK(ecode10)) {
22381 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22382 }
22383 arg10 = static_cast< PLFLT >(val10);
22384 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22385 if (!SWIG_IsOK(res11)) {
22386 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22387 }
22388 arg11 = reinterpret_cast< char * >(buf11);
22389 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22390 _outv = octave_value();
22391 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22392 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22393 return _out;
22394 fail:
22395 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22396 return octave_value_list();
22397 }
22398 catch(...) {
22399 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22400 throw;
22401 }
22402}
22403
22404
22406 octave_value_list _out;
22407 octave_value_list *_outp=&_out;
22408 octave_value _outv;
22409 PLFLT result;
22410
22411 try {
22412 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22413 SWIG_fail;
22414 }
22415 result = (PLFLT)plrandd();
22416 _outv = SWIG_From_double(static_cast< double >(result));
22417 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22418 return _out;
22419 fail:
22420 return octave_value_list();
22421 }
22422 catch(...) {
22423 throw;
22424 }
22425}
22426
22427
22429 octave_value_list _out;
22430 octave_value_list *_outp=&_out;
22431 octave_value _outv;
22432
22433 try {
22434 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22435 SWIG_fail;
22436 }
22437 plreplot();
22438 _outv = octave_value();
22439 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22440 return _out;
22441 fail:
22442 return octave_value_list();
22443 }
22444 catch(...) {
22445 throw;
22446 }
22447}
22448
22449
22451 PLFLT arg1 ;
22452 PLFLT arg2 ;
22453 PLFLT arg3 ;
22454 PLFLT *arg4 = (PLFLT *) 0 ;
22455 PLFLT *arg5 = (PLFLT *) 0 ;
22456 PLFLT *arg6 = (PLFLT *) 0 ;
22457 double val1 ;
22458 int ecode1 = 0 ;
22459 double val2 ;
22460 int ecode2 = 0 ;
22461 double val3 ;
22462 int ecode3 = 0 ;
22463 PLFLT temp4 ;
22464 int res4 = SWIG_TMPOBJ ;
22465 PLFLT temp5 ;
22466 int res5 = SWIG_TMPOBJ ;
22467 PLFLT temp6 ;
22468 int res6 = SWIG_TMPOBJ ;
22469 octave_value_list _out;
22470 octave_value_list *_outp=&_out;
22471 octave_value _outv;
22472
22473 try {
22474 arg4 = &temp4;
22475 arg5 = &temp5;
22476 arg6 = &temp6;
22477 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22478 SWIG_fail;
22479 }
22480 ecode1 = SWIG_AsVal_double(args(0), &val1);
22481 if (!SWIG_IsOK(ecode1)) {
22482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22483 }
22484 arg1 = static_cast< PLFLT >(val1);
22485 ecode2 = SWIG_AsVal_double(args(1), &val2);
22486 if (!SWIG_IsOK(ecode2)) {
22487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22488 }
22489 arg2 = static_cast< PLFLT >(val2);
22490 ecode3 = SWIG_AsVal_double(args(2), &val3);
22491 if (!SWIG_IsOK(ecode3)) {
22492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22493 }
22494 arg3 = static_cast< PLFLT >(val3);
22495 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22496 _outv = octave_value();
22497 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22498 if (SWIG_IsTmpObj(res4)) {
22499 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22500 } else {
22501 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22502 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22503 }
22504 if (SWIG_IsTmpObj(res5)) {
22505 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22506 } else {
22507 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22508 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22509 }
22510 if (SWIG_IsTmpObj(res6)) {
22511 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22512 } else {
22513 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22514 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22515 }
22516 return _out;
22517 fail:
22518 return octave_value_list();
22519 }
22520 catch(...) {
22521 throw;
22522 }
22523}
22524
22525
22527 PLFLT arg1 ;
22528 PLFLT arg2 ;
22529 double val1 ;
22530 int ecode1 = 0 ;
22531 double val2 ;
22532 int ecode2 = 0 ;
22533 octave_value_list _out;
22534 octave_value_list *_outp=&_out;
22535 octave_value _outv;
22536
22537 try {
22538 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22539 SWIG_fail;
22540 }
22541 ecode1 = SWIG_AsVal_double(args(0), &val1);
22542 if (!SWIG_IsOK(ecode1)) {
22543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22544 }
22545 arg1 = static_cast< PLFLT >(val1);
22546 ecode2 = SWIG_AsVal_double(args(1), &val2);
22547 if (!SWIG_IsOK(ecode2)) {
22548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22549 }
22550 arg2 = static_cast< PLFLT >(val2);
22551 plschr(arg1,arg2);
22552 _outv = octave_value();
22553 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22554 return _out;
22555 fail:
22556 return octave_value_list();
22557 }
22558 catch(...) {
22559 throw;
22560 }
22561}
22562
22563
22565 PLINT *arg1 = (PLINT *) 0 ;
22566 PLINT *arg2 = (PLINT *) 0 ;
22567 PLINT *arg3 = (PLINT *) 0 ;
22568 PLINT arg4 ;
22569 Matrix temp1 ;
22570 Matrix temp2 ;
22571 Matrix temp3 ;
22572 octave_value_list _out;
22573 octave_value_list *_outp=&_out;
22574 octave_value _outv;
22575
22576 try {
22577 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22578 SWIG_fail;
22579 }
22580 {
22581 if ( _n_dims( args(0) ) > 1 )
22582 {
22583 error( "argument must be a scalar or vector" ); SWIG_fail;
22584 }
22585 Alen = (PLINT) ( _dim( args(0), 0 ) );
22586 temp1 = args(0).matrix_value();
22587 arg1 = new PLINT[Alen];
22588 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22589 }
22590 {
22591 if ( _n_dims( args(1) ) > 1 )
22592 {
22593 error( "argument must be a scalar or vector" ); SWIG_fail;
22594 }
22595 if ( _dim( args(1), 0 ) != Alen )
22596 {
22597 error( "argument vectors must be same length" ); SWIG_fail;
22598 }
22599 temp2 = args(1).matrix_value();
22600 arg2 = new PLINT[Alen];
22601 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22602 }
22603 {
22604 if ( _n_dims( args(2) ) > 1 )
22605 {
22606 error( "argument must be a scalar or vector" ); SWIG_fail;
22607 }
22608 if ( _dim( args(2), 0 ) != Alen )
22609 {
22610 error( "argument vectors must be same length" ); SWIG_fail;
22611 }
22612 temp3 = args(2).matrix_value();
22613 arg3 = new PLINT[Alen];
22614 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22615 arg4 = Alen;
22616 }
22617 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22618 _outv = octave_value();
22619 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22620 {
22621 delete [] arg1;
22622 }
22623 {
22624 delete [] arg2;
22625 }
22626 {
22627 delete [] arg3;
22628 }
22629 return _out;
22630 fail:
22631 {
22632 delete [] arg1;
22633 }
22634 {
22635 delete [] arg2;
22636 }
22637 {
22638 delete [] arg3;
22639 }
22640 return octave_value_list();
22641 }
22642 catch(...) {
22643 {
22644 delete [] arg1;
22645 }
22646 {
22647 delete [] arg2;
22648 }
22649 {
22650 delete [] arg3;
22651 }
22652 throw;
22653 }
22654}
22655
22656
22658 PLINT *arg1 = (PLINT *) 0 ;
22659 PLINT *arg2 = (PLINT *) 0 ;
22660 PLINT *arg3 = (PLINT *) 0 ;
22661 PLFLT *arg4 = (PLFLT *) 0 ;
22662 PLINT arg5 ;
22663 Matrix temp1 ;
22664 Matrix temp2 ;
22665 Matrix temp3 ;
22666 Matrix temp4 ;
22667 octave_value_list _out;
22668 octave_value_list *_outp=&_out;
22669 octave_value _outv;
22670
22671 try {
22672 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22673 SWIG_fail;
22674 }
22675 {
22676 if ( _n_dims( args(0) ) > 1 )
22677 {
22678 error( "argument must be a scalar or vector" ); SWIG_fail;
22679 }
22680 Alen = (PLINT) ( _dim( args(0), 0 ) );
22681 temp1 = args(0).matrix_value();
22682 arg1 = new PLINT[Alen];
22683 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22684 }
22685 {
22686 if ( _n_dims( args(1) ) > 1 )
22687 {
22688 error( "argument must be a scalar or vector" ); SWIG_fail;
22689 }
22690 if ( _dim( args(1), 0 ) != Alen )
22691 {
22692 error( "argument vectors must be same length" ); SWIG_fail;
22693 }
22694 temp2 = args(1).matrix_value();
22695 arg2 = new PLINT[Alen];
22696 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22697 }
22698 {
22699 if ( _n_dims( args(2) ) > 1 )
22700 {
22701 error( "argument must be a scalar or vector" ); SWIG_fail;
22702 }
22703 if ( _dim( args(2), 0 ) != Alen )
22704 {
22705 error( "argument vectors must be same length" ); SWIG_fail;
22706 }
22707 temp3 = args(2).matrix_value();
22708 arg3 = new PLINT[Alen];
22709 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22710 }
22711 {
22712 if ( _n_dims( args(3) ) > 1 )
22713 {
22714 error( "argument must be a scalar or vector" ); SWIG_fail;
22715 }
22716 if ( _dim( args(3), 0 ) != Alen )
22717 {
22718 error( "argument vectors must be same length" ); SWIG_fail;
22719 }
22720 temp4 = args(3).matrix_value();
22721 arg4 = &temp4( 0, 0 );
22722 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22723 }
22724 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22725 _outv = octave_value();
22726 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22727 {
22728 delete [] arg1;
22729 }
22730 {
22731 delete [] arg2;
22732 }
22733 {
22734 delete [] arg3;
22735 }
22736 {
22737
22738 }
22739 return _out;
22740 fail:
22741 {
22742 delete [] arg1;
22743 }
22744 {
22745 delete [] arg2;
22746 }
22747 {
22748 delete [] arg3;
22749 }
22750 {
22751
22752 }
22753 return octave_value_list();
22754 }
22755 catch(...) {
22756 {
22757 delete [] arg1;
22758 }
22759 {
22760 delete [] arg2;
22761 }
22762 {
22763 delete [] arg3;
22764 }
22765 {
22766
22767 }
22768 throw;
22769 }
22770}
22771
22772
22774 PLINT arg1 ;
22775 int val1 ;
22776 int ecode1 = 0 ;
22777 octave_value_list _out;
22778 octave_value_list *_outp=&_out;
22779 octave_value _outv;
22780
22781 try {
22782 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22783 SWIG_fail;
22784 }
22785 ecode1 = SWIG_AsVal_int(args(0), &val1);
22786 if (!SWIG_IsOK(ecode1)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22788 }
22789 arg1 = static_cast< PLINT >(val1);
22790 plscmap0n(arg1);
22791 _outv = octave_value();
22792 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22793 return _out;
22794 fail:
22795 return octave_value_list();
22796 }
22797 catch(...) {
22798 throw;
22799 }
22800}
22801
22802
22804 PLINT *arg1 = (PLINT *) 0 ;
22805 PLINT *arg2 = (PLINT *) 0 ;
22806 PLINT *arg3 = (PLINT *) 0 ;
22807 PLINT arg4 ;
22808 Matrix temp1 ;
22809 Matrix temp2 ;
22810 Matrix temp3 ;
22811 octave_value_list _out;
22812 octave_value_list *_outp=&_out;
22813 octave_value _outv;
22814
22815 try {
22816 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22817 SWIG_fail;
22818 }
22819 {
22820 if ( _n_dims( args(0) ) > 1 )
22821 {
22822 error( "argument must be a scalar or vector" ); SWIG_fail;
22823 }
22824 Alen = (PLINT) ( _dim( args(0), 0 ) );
22825 temp1 = args(0).matrix_value();
22826 arg1 = new PLINT[Alen];
22827 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22828 }
22829 {
22830 if ( _n_dims( args(1) ) > 1 )
22831 {
22832 error( "argument must be a scalar or vector" ); SWIG_fail;
22833 }
22834 if ( _dim( args(1), 0 ) != Alen )
22835 {
22836 error( "argument vectors must be same length" ); SWIG_fail;
22837 }
22838 temp2 = args(1).matrix_value();
22839 arg2 = new PLINT[Alen];
22840 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22841 }
22842 {
22843 if ( _n_dims( args(2) ) > 1 )
22844 {
22845 error( "argument must be a scalar or vector" ); SWIG_fail;
22846 }
22847 if ( _dim( args(2), 0 ) != Alen )
22848 {
22849 error( "argument vectors must be same length" ); SWIG_fail;
22850 }
22851 temp3 = args(2).matrix_value();
22852 arg3 = new PLINT[Alen];
22853 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22854 arg4 = Alen;
22855 }
22856 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22857 _outv = octave_value();
22858 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22859 {
22860 delete [] arg1;
22861 }
22862 {
22863 delete [] arg2;
22864 }
22865 {
22866 delete [] arg3;
22867 }
22868 return _out;
22869 fail:
22870 {
22871 delete [] arg1;
22872 }
22873 {
22874 delete [] arg2;
22875 }
22876 {
22877 delete [] arg3;
22878 }
22879 return octave_value_list();
22880 }
22881 catch(...) {
22882 {
22883 delete [] arg1;
22884 }
22885 {
22886 delete [] arg2;
22887 }
22888 {
22889 delete [] arg3;
22890 }
22891 throw;
22892 }
22893}
22894
22895
22897 PLINT *arg1 = (PLINT *) 0 ;
22898 PLINT *arg2 = (PLINT *) 0 ;
22899 PLINT *arg3 = (PLINT *) 0 ;
22900 PLFLT *arg4 = (PLFLT *) 0 ;
22901 PLINT arg5 ;
22902 Matrix temp1 ;
22903 Matrix temp2 ;
22904 Matrix temp3 ;
22905 Matrix temp4 ;
22906 octave_value_list _out;
22907 octave_value_list *_outp=&_out;
22908 octave_value _outv;
22909
22910 try {
22911 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22912 SWIG_fail;
22913 }
22914 {
22915 if ( _n_dims( args(0) ) > 1 )
22916 {
22917 error( "argument must be a scalar or vector" ); SWIG_fail;
22918 }
22919 Alen = (PLINT) ( _dim( args(0), 0 ) );
22920 temp1 = args(0).matrix_value();
22921 arg1 = new PLINT[Alen];
22922 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22923 }
22924 {
22925 if ( _n_dims( args(1) ) > 1 )
22926 {
22927 error( "argument must be a scalar or vector" ); SWIG_fail;
22928 }
22929 if ( _dim( args(1), 0 ) != Alen )
22930 {
22931 error( "argument vectors must be same length" ); SWIG_fail;
22932 }
22933 temp2 = args(1).matrix_value();
22934 arg2 = new PLINT[Alen];
22935 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22936 }
22937 {
22938 if ( _n_dims( args(2) ) > 1 )
22939 {
22940 error( "argument must be a scalar or vector" ); SWIG_fail;
22941 }
22942 if ( _dim( args(2), 0 ) != Alen )
22943 {
22944 error( "argument vectors must be same length" ); SWIG_fail;
22945 }
22946 temp3 = args(2).matrix_value();
22947 arg3 = new PLINT[Alen];
22948 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22949 }
22950 {
22951 if ( _n_dims( args(3) ) > 1 )
22952 {
22953 error( "argument must be a scalar or vector" ); SWIG_fail;
22954 }
22955 if ( _dim( args(3), 0 ) != Alen )
22956 {
22957 error( "argument vectors must be same length" ); SWIG_fail;
22958 }
22959 temp4 = args(3).matrix_value();
22960 arg4 = &temp4( 0, 0 );
22961 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22962 }
22963 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22964 _outv = octave_value();
22965 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22966 {
22967 delete [] arg1;
22968 }
22969 {
22970 delete [] arg2;
22971 }
22972 {
22973 delete [] arg3;
22974 }
22975 {
22976
22977 }
22978 return _out;
22979 fail:
22980 {
22981 delete [] arg1;
22982 }
22983 {
22984 delete [] arg2;
22985 }
22986 {
22987 delete [] arg3;
22988 }
22989 {
22990
22991 }
22992 return octave_value_list();
22993 }
22994 catch(...) {
22995 {
22996 delete [] arg1;
22997 }
22998 {
22999 delete [] arg2;
23000 }
23001 {
23002 delete [] arg3;
23003 }
23004 {
23005
23006 }
23007 throw;
23008 }
23009}
23010
23011
23013 PLBOOL arg1 ;
23014 PLINT arg2 ;
23015 PLFLT *arg3 = (PLFLT *) 0 ;
23016 PLFLT *arg4 = (PLFLT *) 0 ;
23017 PLFLT *arg5 = (PLFLT *) 0 ;
23018 PLFLT *arg6 = (PLFLT *) 0 ;
23019 PLBOOL *arg7 = (PLBOOL *) 0 ;
23020 int val1 ;
23021 int ecode1 = 0 ;
23022 Matrix temp2 ;
23023 Matrix temp4 ;
23024 Matrix temp5 ;
23025 Matrix temp6 ;
23026 Matrix temp7 ;
23027 octave_value_list _out;
23028 octave_value_list *_outp=&_out;
23029 octave_value _outv;
23030
23031 try {
23032 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
23033 SWIG_fail;
23034 }
23035 ecode1 = SWIG_AsVal_int(args(0), &val1);
23036 if (!SWIG_IsOK(ecode1)) {
23037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
23038 }
23039 arg1 = static_cast< PLBOOL >(val1);
23040 {
23041 if ( _n_dims( args(1) ) > 1 )
23042 {
23043 error( "argument must be a scalar or vector" ); SWIG_fail;
23044 }
23045 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23046 temp2 = args(1).matrix_value();
23047 arg3 = &temp2( 0, 0 );
23048 }
23049 {
23050 if ( _n_dims( args(2) ) > 1 )
23051 {
23052 error( "argument must be a scalar or vector" ); SWIG_fail;
23053 }
23054 if ( _dim( args(2), 0 ) != Alen )
23055 {
23056 error( "argument vectors must be same length" ); SWIG_fail;
23057 }
23058 temp4 = args(2).matrix_value();
23059 arg4 = &temp4( 0, 0 );
23060 }
23061 {
23062 if ( _n_dims( args(3) ) > 1 )
23063 {
23064 error( "argument must be a scalar or vector" ); SWIG_fail;
23065 }
23066 if ( _dim( args(3), 0 ) != Alen )
23067 {
23068 error( "argument vectors must be same length" ); SWIG_fail;
23069 }
23070 temp5 = args(3).matrix_value();
23071 arg5 = &temp5( 0, 0 );
23072 }
23073 {
23074 if ( _n_dims( args(4) ) > 1 )
23075 {
23076 error( "argument must be a scalar or vector" ); SWIG_fail;
23077 }
23078 if ( _dim( args(4), 0 ) != Alen )
23079 {
23080 error( "argument vectors must be same length" ); SWIG_fail;
23081 }
23082 temp6 = args(4).matrix_value();
23083 arg6 = &temp6( 0, 0 );
23084 }
23085 {
23086 if ( _n_dims( args(5) ) > 1 )
23087 {
23088 error( "argument must be a scalar or vector" ); SWIG_fail;
23089 }
23090 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23091 {
23092 error( "argument vector must be same length or one less" ); SWIG_fail;
23093 }
23094 temp7 = args(5).matrix_value();
23095 arg7 = new PLINT[Alen];
23096 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23097 }
23098 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23099 _outv = octave_value();
23100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23101 {
23102
23103 }
23104 {
23105
23106 }
23107 {
23108
23109 }
23110 {
23111
23112 }
23113 {
23114 delete [] arg7;
23115 }
23116 return _out;
23117 fail:
23118 {
23119
23120 }
23121 {
23122
23123 }
23124 {
23125
23126 }
23127 {
23128
23129 }
23130 {
23131 delete [] arg7;
23132 }
23133 return octave_value_list();
23134 }
23135 catch(...) {
23136 {
23137
23138 }
23139 {
23140
23141 }
23142 {
23143
23144 }
23145 {
23146
23147 }
23148 {
23149 delete [] arg7;
23150 }
23151 throw;
23152 }
23153}
23154
23155
23157 PLBOOL arg1 ;
23158 PLINT arg2 ;
23159 PLFLT *arg3 = (PLFLT *) 0 ;
23160 PLFLT *arg4 = (PLFLT *) 0 ;
23161 PLFLT *arg5 = (PLFLT *) 0 ;
23162 PLFLT *arg6 = (PLFLT *) 0 ;
23163 PLFLT *arg7 = (PLFLT *) 0 ;
23164 PLBOOL *arg8 = (PLBOOL *) 0 ;
23165 int val1 ;
23166 int ecode1 = 0 ;
23167 Matrix temp2 ;
23168 Matrix temp4 ;
23169 Matrix temp5 ;
23170 Matrix temp6 ;
23171 Matrix temp7 ;
23172 Matrix temp8 ;
23173 octave_value_list _out;
23174 octave_value_list *_outp=&_out;
23175 octave_value _outv;
23176
23177 try {
23178 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23179 SWIG_fail;
23180 }
23181 ecode1 = SWIG_AsVal_int(args(0), &val1);
23182 if (!SWIG_IsOK(ecode1)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23184 }
23185 arg1 = static_cast< PLBOOL >(val1);
23186 {
23187 if ( _n_dims( args(1) ) > 1 )
23188 {
23189 error( "argument must be a scalar or vector" ); SWIG_fail;
23190 }
23191 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23192 temp2 = args(1).matrix_value();
23193 arg3 = &temp2( 0, 0 );
23194 }
23195 {
23196 if ( _n_dims( args(2) ) > 1 )
23197 {
23198 error( "argument must be a scalar or vector" ); SWIG_fail;
23199 }
23200 if ( _dim( args(2), 0 ) != Alen )
23201 {
23202 error( "argument vectors must be same length" ); SWIG_fail;
23203 }
23204 temp4 = args(2).matrix_value();
23205 arg4 = &temp4( 0, 0 );
23206 }
23207 {
23208 if ( _n_dims( args(3) ) > 1 )
23209 {
23210 error( "argument must be a scalar or vector" ); SWIG_fail;
23211 }
23212 if ( _dim( args(3), 0 ) != Alen )
23213 {
23214 error( "argument vectors must be same length" ); SWIG_fail;
23215 }
23216 temp5 = args(3).matrix_value();
23217 arg5 = &temp5( 0, 0 );
23218 }
23219 {
23220 if ( _n_dims( args(4) ) > 1 )
23221 {
23222 error( "argument must be a scalar or vector" ); SWIG_fail;
23223 }
23224 if ( _dim( args(4), 0 ) != Alen )
23225 {
23226 error( "argument vectors must be same length" ); SWIG_fail;
23227 }
23228 temp6 = args(4).matrix_value();
23229 arg6 = &temp6( 0, 0 );
23230 }
23231 {
23232 if ( _n_dims( args(5) ) > 1 )
23233 {
23234 error( "argument must be a scalar or vector" ); SWIG_fail;
23235 }
23236 if ( _dim( args(5), 0 ) != Alen )
23237 {
23238 error( "argument vectors must be same length" ); SWIG_fail;
23239 }
23240 temp7 = args(5).matrix_value();
23241 arg7 = &temp7( 0, 0 );
23242 }
23243 {
23244 if ( _n_dims( args(6) ) > 1 )
23245 {
23246 error( "argument must be a scalar or vector" ); SWIG_fail;
23247 }
23248 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23249 {
23250 error( "argument vector must be same length or one less" ); SWIG_fail;
23251 }
23252 temp8 = args(6).matrix_value();
23253 arg8 = new PLINT[Alen];
23254 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23255 }
23256 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23257 _outv = octave_value();
23258 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23259 {
23260
23261 }
23262 {
23263
23264 }
23265 {
23266
23267 }
23268 {
23269
23270 }
23271 {
23272
23273 }
23274 {
23275 delete [] arg8;
23276 }
23277 return _out;
23278 fail:
23279 {
23280
23281 }
23282 {
23283
23284 }
23285 {
23286
23287 }
23288 {
23289
23290 }
23291 {
23292
23293 }
23294 {
23295 delete [] arg8;
23296 }
23297 return octave_value_list();
23298 }
23299 catch(...) {
23300 {
23301
23302 }
23303 {
23304
23305 }
23306 {
23307
23308 }
23309 {
23310
23311 }
23312 {
23313
23314 }
23315 {
23316 delete [] arg8;
23317 }
23318 throw;
23319 }
23320}
23321
23322
23324 PLINT arg1 ;
23325 int val1 ;
23326 int ecode1 = 0 ;
23327 octave_value_list _out;
23328 octave_value_list *_outp=&_out;
23329 octave_value _outv;
23330
23331 try {
23332 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23333 SWIG_fail;
23334 }
23335 ecode1 = SWIG_AsVal_int(args(0), &val1);
23336 if (!SWIG_IsOK(ecode1)) {
23337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23338 }
23339 arg1 = static_cast< PLINT >(val1);
23340 plscmap1n(arg1);
23341 _outv = octave_value();
23342 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23343 return _out;
23344 fail:
23345 return octave_value_list();
23346 }
23347 catch(...) {
23348 throw;
23349 }
23350}
23351
23352
23354 PLFLT arg1 ;
23355 PLFLT arg2 ;
23356 double val1 ;
23357 int ecode1 = 0 ;
23358 double val2 ;
23359 int ecode2 = 0 ;
23360 octave_value_list _out;
23361 octave_value_list *_outp=&_out;
23362 octave_value _outv;
23363
23364 try {
23365 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23366 SWIG_fail;
23367 }
23368 ecode1 = SWIG_AsVal_double(args(0), &val1);
23369 if (!SWIG_IsOK(ecode1)) {
23370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23371 }
23372 arg1 = static_cast< PLFLT >(val1);
23373 ecode2 = SWIG_AsVal_double(args(1), &val2);
23374 if (!SWIG_IsOK(ecode2)) {
23375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23376 }
23377 arg2 = static_cast< PLFLT >(val2);
23378 plscmap1_range(arg1,arg2);
23379 _outv = octave_value();
23380 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23381 return _out;
23382 fail:
23383 return octave_value_list();
23384 }
23385 catch(...) {
23386 throw;
23387 }
23388}
23389
23390
23392 PLFLT *arg1 = (PLFLT *) 0 ;
23393 PLFLT *arg2 = (PLFLT *) 0 ;
23394 PLFLT temp1 ;
23395 int res1 = SWIG_TMPOBJ ;
23396 PLFLT temp2 ;
23397 int res2 = SWIG_TMPOBJ ;
23398 octave_value_list _out;
23399 octave_value_list *_outp=&_out;
23400 octave_value _outv;
23401
23402 try {
23403 arg1 = &temp1;
23404 arg2 = &temp2;
23405 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23406 SWIG_fail;
23407 }
23408 plgcmap1_range(arg1,arg2);
23409 _outv = octave_value();
23410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23411 if (SWIG_IsTmpObj(res1)) {
23412 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23413 } else {
23414 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23415 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23416 }
23417 if (SWIG_IsTmpObj(res2)) {
23418 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23419 } else {
23420 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23421 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23422 }
23423 return _out;
23424 fail:
23425 return octave_value_list();
23426 }
23427 catch(...) {
23428 throw;
23429 }
23430}
23431
23432
23434 PLINT arg1 ;
23435 PLINT arg2 ;
23436 PLINT arg3 ;
23437 PLINT arg4 ;
23438 int val1 ;
23439 int ecode1 = 0 ;
23440 int val2 ;
23441 int ecode2 = 0 ;
23442 int val3 ;
23443 int ecode3 = 0 ;
23444 int val4 ;
23445 int ecode4 = 0 ;
23446 octave_value_list _out;
23447 octave_value_list *_outp=&_out;
23448 octave_value _outv;
23449
23450 try {
23451 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23452 SWIG_fail;
23453 }
23454 ecode1 = SWIG_AsVal_int(args(0), &val1);
23455 if (!SWIG_IsOK(ecode1)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23457 }
23458 arg1 = static_cast< PLINT >(val1);
23459 ecode2 = SWIG_AsVal_int(args(1), &val2);
23460 if (!SWIG_IsOK(ecode2)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23462 }
23463 arg2 = static_cast< PLINT >(val2);
23464 ecode3 = SWIG_AsVal_int(args(2), &val3);
23465 if (!SWIG_IsOK(ecode3)) {
23466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23467 }
23468 arg3 = static_cast< PLINT >(val3);
23469 ecode4 = SWIG_AsVal_int(args(3), &val4);
23470 if (!SWIG_IsOK(ecode4)) {
23471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23472 }
23473 arg4 = static_cast< PLINT >(val4);
23474 plscol0(arg1,arg2,arg3,arg4);
23475 _outv = octave_value();
23476 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23477 return _out;
23478 fail:
23479 return octave_value_list();
23480 }
23481 catch(...) {
23482 throw;
23483 }
23484}
23485
23486
23488 PLINT arg1 ;
23489 PLINT arg2 ;
23490 PLINT arg3 ;
23491 PLINT arg4 ;
23492 PLFLT arg5 ;
23493 int val1 ;
23494 int ecode1 = 0 ;
23495 int val2 ;
23496 int ecode2 = 0 ;
23497 int val3 ;
23498 int ecode3 = 0 ;
23499 int val4 ;
23500 int ecode4 = 0 ;
23501 double val5 ;
23502 int ecode5 = 0 ;
23503 octave_value_list _out;
23504 octave_value_list *_outp=&_out;
23505 octave_value _outv;
23506
23507 try {
23508 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23509 SWIG_fail;
23510 }
23511 ecode1 = SWIG_AsVal_int(args(0), &val1);
23512 if (!SWIG_IsOK(ecode1)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23514 }
23515 arg1 = static_cast< PLINT >(val1);
23516 ecode2 = SWIG_AsVal_int(args(1), &val2);
23517 if (!SWIG_IsOK(ecode2)) {
23518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23519 }
23520 arg2 = static_cast< PLINT >(val2);
23521 ecode3 = SWIG_AsVal_int(args(2), &val3);
23522 if (!SWIG_IsOK(ecode3)) {
23523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23524 }
23525 arg3 = static_cast< PLINT >(val3);
23526 ecode4 = SWIG_AsVal_int(args(3), &val4);
23527 if (!SWIG_IsOK(ecode4)) {
23528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23529 }
23530 arg4 = static_cast< PLINT >(val4);
23531 ecode5 = SWIG_AsVal_double(args(4), &val5);
23532 if (!SWIG_IsOK(ecode5)) {
23533 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23534 }
23535 arg5 = static_cast< PLFLT >(val5);
23536 plscol0a(arg1,arg2,arg3,arg4,arg5);
23537 _outv = octave_value();
23538 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23539 return _out;
23540 fail:
23541 return octave_value_list();
23542 }
23543 catch(...) {
23544 throw;
23545 }
23546}
23547
23548
23550 PLINT arg1 ;
23551 PLINT arg2 ;
23552 PLINT arg3 ;
23553 int val1 ;
23554 int ecode1 = 0 ;
23555 int val2 ;
23556 int ecode2 = 0 ;
23557 int val3 ;
23558 int ecode3 = 0 ;
23559 octave_value_list _out;
23560 octave_value_list *_outp=&_out;
23561 octave_value _outv;
23562
23563 try {
23564 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23565 SWIG_fail;
23566 }
23567 ecode1 = SWIG_AsVal_int(args(0), &val1);
23568 if (!SWIG_IsOK(ecode1)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23570 }
23571 arg1 = static_cast< PLINT >(val1);
23572 ecode2 = SWIG_AsVal_int(args(1), &val2);
23573 if (!SWIG_IsOK(ecode2)) {
23574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23575 }
23576 arg2 = static_cast< PLINT >(val2);
23577 ecode3 = SWIG_AsVal_int(args(2), &val3);
23578 if (!SWIG_IsOK(ecode3)) {
23579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23580 }
23581 arg3 = static_cast< PLINT >(val3);
23582 plscolbg(arg1,arg2,arg3);
23583 _outv = octave_value();
23584 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23585 return _out;
23586 fail:
23587 return octave_value_list();
23588 }
23589 catch(...) {
23590 throw;
23591 }
23592}
23593
23594
23596 PLINT arg1 ;
23597 PLINT arg2 ;
23598 PLINT arg3 ;
23599 PLFLT arg4 ;
23600 int val1 ;
23601 int ecode1 = 0 ;
23602 int val2 ;
23603 int ecode2 = 0 ;
23604 int val3 ;
23605 int ecode3 = 0 ;
23606 double val4 ;
23607 int ecode4 = 0 ;
23608 octave_value_list _out;
23609 octave_value_list *_outp=&_out;
23610 octave_value _outv;
23611
23612 try {
23613 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23614 SWIG_fail;
23615 }
23616 ecode1 = SWIG_AsVal_int(args(0), &val1);
23617 if (!SWIG_IsOK(ecode1)) {
23618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23619 }
23620 arg1 = static_cast< PLINT >(val1);
23621 ecode2 = SWIG_AsVal_int(args(1), &val2);
23622 if (!SWIG_IsOK(ecode2)) {
23623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23624 }
23625 arg2 = static_cast< PLINT >(val2);
23626 ecode3 = SWIG_AsVal_int(args(2), &val3);
23627 if (!SWIG_IsOK(ecode3)) {
23628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23629 }
23630 arg3 = static_cast< PLINT >(val3);
23631 ecode4 = SWIG_AsVal_double(args(3), &val4);
23632 if (!SWIG_IsOK(ecode4)) {
23633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23634 }
23635 arg4 = static_cast< PLFLT >(val4);
23636 plscolbga(arg1,arg2,arg3,arg4);
23637 _outv = octave_value();
23638 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23639 return _out;
23640 fail:
23641 return octave_value_list();
23642 }
23643 catch(...) {
23644 throw;
23645 }
23646}
23647
23648
23650 PLINT arg1 ;
23651 int val1 ;
23652 int ecode1 = 0 ;
23653 octave_value_list _out;
23654 octave_value_list *_outp=&_out;
23655 octave_value _outv;
23656
23657 try {
23658 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23659 SWIG_fail;
23660 }
23661 ecode1 = SWIG_AsVal_int(args(0), &val1);
23662 if (!SWIG_IsOK(ecode1)) {
23663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23664 }
23665 arg1 = static_cast< PLINT >(val1);
23666 plscolor(arg1);
23667 _outv = octave_value();
23668 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23669 return _out;
23670 fail:
23671 return octave_value_list();
23672 }
23673 catch(...) {
23674 throw;
23675 }
23676}
23677
23678
23680 PLINT arg1 ;
23681 int val1 ;
23682 int ecode1 = 0 ;
23683 octave_value_list _out;
23684 octave_value_list *_outp=&_out;
23685 octave_value _outv;
23686
23687 try {
23688 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23689 SWIG_fail;
23690 }
23691 ecode1 = SWIG_AsVal_int(args(0), &val1);
23692 if (!SWIG_IsOK(ecode1)) {
23693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23694 }
23695 arg1 = static_cast< PLINT >(val1);
23696 plscompression(arg1);
23697 _outv = octave_value();
23698 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23699 return _out;
23700 fail:
23701 return octave_value_list();
23702 }
23703 catch(...) {
23704 throw;
23705 }
23706}
23707
23708
23710 char *arg1 = (char *) 0 ;
23711 int res1 ;
23712 char *buf1 = 0 ;
23713 int alloc1 = 0 ;
23714 octave_value_list _out;
23715 octave_value_list *_outp=&_out;
23716 octave_value _outv;
23717
23718 try {
23719 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23720 SWIG_fail;
23721 }
23722 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23723 if (!SWIG_IsOK(res1)) {
23724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23725 }
23726 arg1 = reinterpret_cast< char * >(buf1);
23727 plsdev((char const *)arg1);
23728 _outv = octave_value();
23729 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23730 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23731 return _out;
23732 fail:
23733 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23734 return octave_value_list();
23735 }
23736 catch(...) {
23737 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23738 throw;
23739 }
23740}
23741
23742
23744 PLFLT arg1 ;
23745 PLFLT arg2 ;
23746 PLFLT arg3 ;
23747 PLFLT arg4 ;
23748 double val1 ;
23749 int ecode1 = 0 ;
23750 double val2 ;
23751 int ecode2 = 0 ;
23752 double val3 ;
23753 int ecode3 = 0 ;
23754 double val4 ;
23755 int ecode4 = 0 ;
23756 octave_value_list _out;
23757 octave_value_list *_outp=&_out;
23758 octave_value _outv;
23759
23760 try {
23761 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23762 SWIG_fail;
23763 }
23764 ecode1 = SWIG_AsVal_double(args(0), &val1);
23765 if (!SWIG_IsOK(ecode1)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23767 }
23768 arg1 = static_cast< PLFLT >(val1);
23769 ecode2 = SWIG_AsVal_double(args(1), &val2);
23770 if (!SWIG_IsOK(ecode2)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23772 }
23773 arg2 = static_cast< PLFLT >(val2);
23774 ecode3 = SWIG_AsVal_double(args(2), &val3);
23775 if (!SWIG_IsOK(ecode3)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23777 }
23778 arg3 = static_cast< PLFLT >(val3);
23779 ecode4 = SWIG_AsVal_double(args(3), &val4);
23780 if (!SWIG_IsOK(ecode4)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23782 }
23783 arg4 = static_cast< PLFLT >(val4);
23784 plsdidev(arg1,arg2,arg3,arg4);
23785 _outv = octave_value();
23786 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23787 return _out;
23788 fail:
23789 return octave_value_list();
23790 }
23791 catch(...) {
23792 throw;
23793 }
23794}
23795
23796
23798 PLINT arg1 ;
23799 PLINT arg2 ;
23800 PLINT arg3 ;
23801 PLINT arg4 ;
23802 PLFLT arg5 ;
23803 PLFLT arg6 ;
23804 int val1 ;
23805 int ecode1 = 0 ;
23806 int val2 ;
23807 int ecode2 = 0 ;
23808 int val3 ;
23809 int ecode3 = 0 ;
23810 int val4 ;
23811 int ecode4 = 0 ;
23812 double val5 ;
23813 int ecode5 = 0 ;
23814 double val6 ;
23815 int ecode6 = 0 ;
23816 octave_value_list _out;
23817 octave_value_list *_outp=&_out;
23818 octave_value _outv;
23819
23820 try {
23821 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23822 SWIG_fail;
23823 }
23824 ecode1 = SWIG_AsVal_int(args(0), &val1);
23825 if (!SWIG_IsOK(ecode1)) {
23826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23827 }
23828 arg1 = static_cast< PLINT >(val1);
23829 ecode2 = SWIG_AsVal_int(args(1), &val2);
23830 if (!SWIG_IsOK(ecode2)) {
23831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23832 }
23833 arg2 = static_cast< PLINT >(val2);
23834 ecode3 = SWIG_AsVal_int(args(2), &val3);
23835 if (!SWIG_IsOK(ecode3)) {
23836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23837 }
23838 arg3 = static_cast< PLINT >(val3);
23839 ecode4 = SWIG_AsVal_int(args(3), &val4);
23840 if (!SWIG_IsOK(ecode4)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23842 }
23843 arg4 = static_cast< PLINT >(val4);
23844 ecode5 = SWIG_AsVal_double(args(4), &val5);
23845 if (!SWIG_IsOK(ecode5)) {
23846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23847 }
23848 arg5 = static_cast< PLFLT >(val5);
23849 ecode6 = SWIG_AsVal_double(args(5), &val6);
23850 if (!SWIG_IsOK(ecode6)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23852 }
23853 arg6 = static_cast< PLFLT >(val6);
23854 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23855 _outv = octave_value();
23856 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23857 return _out;
23858 fail:
23859 return octave_value_list();
23860 }
23861 catch(...) {
23862 throw;
23863 }
23864}
23865
23866
23868 PLFLT arg1 ;
23869 double val1 ;
23870 int ecode1 = 0 ;
23871 octave_value_list _out;
23872 octave_value_list *_outp=&_out;
23873 octave_value _outv;
23874
23875 try {
23876 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23877 SWIG_fail;
23878 }
23879 ecode1 = SWIG_AsVal_double(args(0), &val1);
23880 if (!SWIG_IsOK(ecode1)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23882 }
23883 arg1 = static_cast< PLFLT >(val1);
23884 plsdiori(arg1);
23885 _outv = octave_value();
23886 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23887 return _out;
23888 fail:
23889 return octave_value_list();
23890 }
23891 catch(...) {
23892 throw;
23893 }
23894}
23895
23896
23898 PLFLT arg1 ;
23899 PLFLT arg2 ;
23900 PLFLT arg3 ;
23901 PLFLT arg4 ;
23902 double val1 ;
23903 int ecode1 = 0 ;
23904 double val2 ;
23905 int ecode2 = 0 ;
23906 double val3 ;
23907 int ecode3 = 0 ;
23908 double val4 ;
23909 int ecode4 = 0 ;
23910 octave_value_list _out;
23911 octave_value_list *_outp=&_out;
23912 octave_value _outv;
23913
23914 try {
23915 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23916 SWIG_fail;
23917 }
23918 ecode1 = SWIG_AsVal_double(args(0), &val1);
23919 if (!SWIG_IsOK(ecode1)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23921 }
23922 arg1 = static_cast< PLFLT >(val1);
23923 ecode2 = SWIG_AsVal_double(args(1), &val2);
23924 if (!SWIG_IsOK(ecode2)) {
23925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23926 }
23927 arg2 = static_cast< PLFLT >(val2);
23928 ecode3 = SWIG_AsVal_double(args(2), &val3);
23929 if (!SWIG_IsOK(ecode3)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23931 }
23932 arg3 = static_cast< PLFLT >(val3);
23933 ecode4 = SWIG_AsVal_double(args(3), &val4);
23934 if (!SWIG_IsOK(ecode4)) {
23935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23936 }
23937 arg4 = static_cast< PLFLT >(val4);
23938 plsdiplt(arg1,arg2,arg3,arg4);
23939 _outv = octave_value();
23940 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23941 return _out;
23942 fail:
23943 return octave_value_list();
23944 }
23945 catch(...) {
23946 throw;
23947 }
23948}
23949
23950
23952 PLFLT arg1 ;
23953 PLFLT arg2 ;
23954 PLFLT arg3 ;
23955 PLFLT arg4 ;
23956 double val1 ;
23957 int ecode1 = 0 ;
23958 double val2 ;
23959 int ecode2 = 0 ;
23960 double val3 ;
23961 int ecode3 = 0 ;
23962 double val4 ;
23963 int ecode4 = 0 ;
23964 octave_value_list _out;
23965 octave_value_list *_outp=&_out;
23966 octave_value _outv;
23967
23968 try {
23969 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23970 SWIG_fail;
23971 }
23972 ecode1 = SWIG_AsVal_double(args(0), &val1);
23973 if (!SWIG_IsOK(ecode1)) {
23974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23975 }
23976 arg1 = static_cast< PLFLT >(val1);
23977 ecode2 = SWIG_AsVal_double(args(1), &val2);
23978 if (!SWIG_IsOK(ecode2)) {
23979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23980 }
23981 arg2 = static_cast< PLFLT >(val2);
23982 ecode3 = SWIG_AsVal_double(args(2), &val3);
23983 if (!SWIG_IsOK(ecode3)) {
23984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23985 }
23986 arg3 = static_cast< PLFLT >(val3);
23987 ecode4 = SWIG_AsVal_double(args(3), &val4);
23988 if (!SWIG_IsOK(ecode4)) {
23989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23990 }
23991 arg4 = static_cast< PLFLT >(val4);
23992 plsdiplz(arg1,arg2,arg3,arg4);
23993 _outv = octave_value();
23994 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23995 return _out;
23996 fail:
23997 return octave_value_list();
23998 }
23999 catch(...) {
24000 throw;
24001 }
24002}
24003
24004
24006 unsigned int arg1 ;
24007 unsigned int val1 ;
24008 int ecode1 = 0 ;
24009 octave_value_list _out;
24010 octave_value_list *_outp=&_out;
24011 octave_value _outv;
24012
24013 try {
24014 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
24015 SWIG_fail;
24016 }
24017 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24018 if (!SWIG_IsOK(ecode1)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
24020 }
24021 arg1 = static_cast< unsigned int >(val1);
24022 plseed(arg1);
24023 _outv = octave_value();
24024 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24025 return _out;
24026 fail:
24027 return octave_value_list();
24028 }
24029 catch(...) {
24030 throw;
24031 }
24032}
24033
24034
24036 char arg1 ;
24037 char val1 ;
24038 int ecode1 = 0 ;
24039 octave_value_list _out;
24040 octave_value_list *_outp=&_out;
24041 octave_value _outv;
24042
24043 try {
24044 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
24045 SWIG_fail;
24046 }
24047 ecode1 = SWIG_AsVal_char(args(0), &val1);
24048 if (!SWIG_IsOK(ecode1)) {
24049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
24050 }
24051 arg1 = static_cast< char >(val1);
24052 plsesc(arg1);
24053 _outv = octave_value();
24054 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24055 return _out;
24056 fail:
24057 return octave_value_list();
24058 }
24059 catch(...) {
24060 throw;
24061 }
24062}
24063
24064
24065SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
24066 char *arg1 = (char *) 0 ;
24067 char *arg2 = (char *) 0 ;
24068 int res1 ;
24069 char *buf1 = 0 ;
24070 int alloc1 = 0 ;
24071 int res2 ;
24072 char *buf2 = 0 ;
24073 int alloc2 = 0 ;
24074 octave_value_list _out;
24075 octave_value_list *_outp=&_out;
24076 octave_value _outv;
24077 PLINT result;
24078
24079 try {
24080 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24081 SWIG_fail;
24082 }
24083 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24084 if (!SWIG_IsOK(res1)) {
24085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24086 }
24087 arg1 = reinterpret_cast< char * >(buf1);
24088 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24089 if (!SWIG_IsOK(res2)) {
24090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24091 }
24092 arg2 = reinterpret_cast< char * >(buf2);
24093 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24094 _outv = SWIG_From_int(static_cast< int >(result));
24095 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24096 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24097 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24098 return _out;
24099 fail:
24100 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24101 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24102 return octave_value_list();
24103 }
24104 catch(...) {
24105 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24106 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24107 throw;
24108 }
24109}
24110
24111
24113 PLINT arg1 ;
24114 PLINT arg2 ;
24115 PLINT arg3 ;
24116 int val1 ;
24117 int ecode1 = 0 ;
24118 int val2 ;
24119 int ecode2 = 0 ;
24120 int val3 ;
24121 int ecode3 = 0 ;
24122 octave_value_list _out;
24123 octave_value_list *_outp=&_out;
24124 octave_value _outv;
24125
24126 try {
24127 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24128 SWIG_fail;
24129 }
24130 ecode1 = SWIG_AsVal_int(args(0), &val1);
24131 if (!SWIG_IsOK(ecode1)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24133 }
24134 arg1 = static_cast< PLINT >(val1);
24135 ecode2 = SWIG_AsVal_int(args(1), &val2);
24136 if (!SWIG_IsOK(ecode2)) {
24137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24138 }
24139 arg2 = static_cast< PLINT >(val2);
24140 ecode3 = SWIG_AsVal_int(args(2), &val3);
24141 if (!SWIG_IsOK(ecode3)) {
24142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24143 }
24144 arg3 = static_cast< PLINT >(val3);
24145 plsfam(arg1,arg2,arg3);
24146 _outv = octave_value();
24147 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24148 return _out;
24149 fail:
24150 return octave_value_list();
24151 }
24152 catch(...) {
24153 throw;
24154 }
24155}
24156
24157
24159 PLUNICODE arg1 ;
24160 unsigned int val1 ;
24161 int ecode1 = 0 ;
24162 octave_value_list _out;
24163 octave_value_list *_outp=&_out;
24164 octave_value _outv;
24165
24166 try {
24167 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24168 SWIG_fail;
24169 }
24170 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24171 if (!SWIG_IsOK(ecode1)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24173 }
24174 arg1 = static_cast< PLUNICODE >(val1);
24175 plsfci(arg1);
24176 _outv = octave_value();
24177 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24178 return _out;
24179 fail:
24180 return octave_value_list();
24181 }
24182 catch(...) {
24183 throw;
24184 }
24185}
24186
24187
24189 char *arg1 = (char *) 0 ;
24190 int res1 ;
24191 char *buf1 = 0 ;
24192 int alloc1 = 0 ;
24193 octave_value_list _out;
24194 octave_value_list *_outp=&_out;
24195 octave_value _outv;
24196
24197 try {
24198 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24199 SWIG_fail;
24200 }
24201 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24202 if (!SWIG_IsOK(res1)) {
24203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24204 }
24205 arg1 = reinterpret_cast< char * >(buf1);
24206 plsfnam((char const *)arg1);
24207 _outv = octave_value();
24208 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24209 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24210 return _out;
24211 fail:
24212 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24213 return octave_value_list();
24214 }
24215 catch(...) {
24216 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24217 throw;
24218 }
24219}
24220
24221
24223 PLINT arg1 ;
24224 PLINT arg2 ;
24225 PLINT arg3 ;
24226 int val1 ;
24227 int ecode1 = 0 ;
24228 int val2 ;
24229 int ecode2 = 0 ;
24230 int val3 ;
24231 int ecode3 = 0 ;
24232 octave_value_list _out;
24233 octave_value_list *_outp=&_out;
24234 octave_value _outv;
24235
24236 try {
24237 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24238 SWIG_fail;
24239 }
24240 ecode1 = SWIG_AsVal_int(args(0), &val1);
24241 if (!SWIG_IsOK(ecode1)) {
24242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24243 }
24244 arg1 = static_cast< PLINT >(val1);
24245 ecode2 = SWIG_AsVal_int(args(1), &val2);
24246 if (!SWIG_IsOK(ecode2)) {
24247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24248 }
24249 arg2 = static_cast< PLINT >(val2);
24250 ecode3 = SWIG_AsVal_int(args(2), &val3);
24251 if (!SWIG_IsOK(ecode3)) {
24252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24253 }
24254 arg3 = static_cast< PLINT >(val3);
24255 plsfont(arg1,arg2,arg3);
24256 _outv = octave_value();
24257 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24258 return _out;
24259 fail:
24260 return octave_value_list();
24261 }
24262 catch(...) {
24263 throw;
24264 }
24265}
24266
24267
24269 label_func arg1 = (label_func) 0 ;
24270 PLPointer arg2 = (PLPointer) 0 ;
24271 int res2 ;
24272 octave_value_list _out;
24273 octave_value_list *_outp=&_out;
24274 octave_value _outv;
24275
24276 try {
24277 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24278 SWIG_fail;
24279 }
24280 {
24281 octave_value obj = args(0);
24282#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24283 if ( !obj.isempty() )
24284#else
24285 if ( !obj.is_empty() )
24286#endif
24287 {
24288 if ( obj.is_function_handle() || obj.is_inline_function() )
24289 {
24290 fcnLabelFunc = obj.function_value();
24291 }
24292 else if ( obj.is_string() )
24293 {
24294 nameLabelFunc = obj.string_value();
24295 fcnLabelFunc = NULL;
24296 }
24297 arg1 = labelfunc_octave;
24298 }
24299 else
24300 {
24301 arg1 = NULL;
24302 }
24303 }
24304 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24305 if (!SWIG_IsOK(res2)) {
24306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24307 }
24308 plslabelfunc(arg1,arg2);
24309 _outv = octave_value();
24310 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24311 return _out;
24312 fail:
24313 return octave_value_list();
24314 }
24315 catch(...) {
24316 throw;
24317 }
24318}
24319
24320
24322 PLFLT arg1 ;
24323 PLFLT arg2 ;
24324 double val1 ;
24325 int ecode1 = 0 ;
24326 double val2 ;
24327 int ecode2 = 0 ;
24328 octave_value_list _out;
24329 octave_value_list *_outp=&_out;
24330 octave_value _outv;
24331
24332 try {
24333 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24334 SWIG_fail;
24335 }
24336 ecode1 = SWIG_AsVal_double(args(0), &val1);
24337 if (!SWIG_IsOK(ecode1)) {
24338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24339 }
24340 arg1 = static_cast< PLFLT >(val1);
24341 ecode2 = SWIG_AsVal_double(args(1), &val2);
24342 if (!SWIG_IsOK(ecode2)) {
24343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24344 }
24345 arg2 = static_cast< PLFLT >(val2);
24346 plsmaj(arg1,arg2);
24347 _outv = octave_value();
24348 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24349 return _out;
24350 fail:
24351 return octave_value_list();
24352 }
24353 catch(...) {
24354 throw;
24355 }
24356}
24357
24358
24360 PLFLT arg1 ;
24361 PLFLT arg2 ;
24362 double val1 ;
24363 int ecode1 = 0 ;
24364 double val2 ;
24365 int ecode2 = 0 ;
24366 octave_value_list _out;
24367 octave_value_list *_outp=&_out;
24368 octave_value _outv;
24369
24370 try {
24371 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24372 SWIG_fail;
24373 }
24374 ecode1 = SWIG_AsVal_double(args(0), &val1);
24375 if (!SWIG_IsOK(ecode1)) {
24376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24377 }
24378 arg1 = static_cast< PLFLT >(val1);
24379 ecode2 = SWIG_AsVal_double(args(1), &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24382 }
24383 arg2 = static_cast< PLFLT >(val2);
24384 plsmin(arg1,arg2);
24385 _outv = octave_value();
24386 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24387 return _out;
24388 fail:
24389 return octave_value_list();
24390 }
24391 catch(...) {
24392 throw;
24393 }
24394}
24395
24396
24398 PLINT arg1 ;
24399 int val1 ;
24400 int ecode1 = 0 ;
24401 octave_value_list _out;
24402 octave_value_list *_outp=&_out;
24403 octave_value _outv;
24404
24405 try {
24406 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24407 SWIG_fail;
24408 }
24409 ecode1 = SWIG_AsVal_int(args(0), &val1);
24410 if (!SWIG_IsOK(ecode1)) {
24411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24412 }
24413 arg1 = static_cast< PLINT >(val1);
24414 plsori(arg1);
24415 _outv = octave_value();
24416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24417 return _out;
24418 fail:
24419 return octave_value_list();
24420 }
24421 catch(...) {
24422 throw;
24423 }
24424}
24425
24426
24428 PLFLT arg1 ;
24429 PLFLT arg2 ;
24430 PLINT arg3 ;
24431 PLINT arg4 ;
24432 PLINT arg5 ;
24433 PLINT arg6 ;
24434 double val1 ;
24435 int ecode1 = 0 ;
24436 double val2 ;
24437 int ecode2 = 0 ;
24438 int val3 ;
24439 int ecode3 = 0 ;
24440 int val4 ;
24441 int ecode4 = 0 ;
24442 int val5 ;
24443 int ecode5 = 0 ;
24444 int val6 ;
24445 int ecode6 = 0 ;
24446 octave_value_list _out;
24447 octave_value_list *_outp=&_out;
24448 octave_value _outv;
24449
24450 try {
24451 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24452 SWIG_fail;
24453 }
24454 ecode1 = SWIG_AsVal_double(args(0), &val1);
24455 if (!SWIG_IsOK(ecode1)) {
24456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24457 }
24458 arg1 = static_cast< PLFLT >(val1);
24459 ecode2 = SWIG_AsVal_double(args(1), &val2);
24460 if (!SWIG_IsOK(ecode2)) {
24461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24462 }
24463 arg2 = static_cast< PLFLT >(val2);
24464 ecode3 = SWIG_AsVal_int(args(2), &val3);
24465 if (!SWIG_IsOK(ecode3)) {
24466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24467 }
24468 arg3 = static_cast< PLINT >(val3);
24469 ecode4 = SWIG_AsVal_int(args(3), &val4);
24470 if (!SWIG_IsOK(ecode4)) {
24471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24472 }
24473 arg4 = static_cast< PLINT >(val4);
24474 ecode5 = SWIG_AsVal_int(args(4), &val5);
24475 if (!SWIG_IsOK(ecode5)) {
24476 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24477 }
24478 arg5 = static_cast< PLINT >(val5);
24479 ecode6 = SWIG_AsVal_int(args(5), &val6);
24480 if (!SWIG_IsOK(ecode6)) {
24481 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24482 }
24483 arg6 = static_cast< PLINT >(val6);
24484 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24485 _outv = octave_value();
24486 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24487 return _out;
24488 fail:
24489 return octave_value_list();
24490 }
24491 catch(...) {
24492 throw;
24493 }
24494}
24495
24496
24498 char *arg1 = (char *) 0 ;
24499 int res1 ;
24500 char *buf1 = 0 ;
24501 int alloc1 = 0 ;
24502 octave_value_list _out;
24503 octave_value_list *_outp=&_out;
24504 octave_value _outv;
24505
24506 try {
24507 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24508 SWIG_fail;
24509 }
24510 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24513 }
24514 arg1 = reinterpret_cast< char * >(buf1);
24515 plspal0((char const *)arg1);
24516 _outv = octave_value();
24517 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24518 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24519 return _out;
24520 fail:
24521 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24522 return octave_value_list();
24523 }
24524 catch(...) {
24525 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24526 throw;
24527 }
24528}
24529
24530
24532 char *arg1 = (char *) 0 ;
24533 PLBOOL arg2 ;
24534 int res1 ;
24535 char *buf1 = 0 ;
24536 int alloc1 = 0 ;
24537 int val2 ;
24538 int ecode2 = 0 ;
24539 octave_value_list _out;
24540 octave_value_list *_outp=&_out;
24541 octave_value _outv;
24542
24543 try {
24544 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24545 SWIG_fail;
24546 }
24547 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24548 if (!SWIG_IsOK(res1)) {
24549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24550 }
24551 arg1 = reinterpret_cast< char * >(buf1);
24552 ecode2 = SWIG_AsVal_int(args(1), &val2);
24553 if (!SWIG_IsOK(ecode2)) {
24554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24555 }
24556 arg2 = static_cast< PLBOOL >(val2);
24557 plspal1((char const *)arg1,arg2);
24558 _outv = octave_value();
24559 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24560 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24561 return _out;
24562 fail:
24563 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24564 return octave_value_list();
24565 }
24566 catch(...) {
24567 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24568 throw;
24569 }
24570}
24571
24572
24574 PLBOOL arg1 ;
24575 int val1 ;
24576 int ecode1 = 0 ;
24577 octave_value_list _out;
24578 octave_value_list *_outp=&_out;
24579 octave_value _outv;
24580
24581 try {
24582 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24583 SWIG_fail;
24584 }
24585 ecode1 = SWIG_AsVal_int(args(0), &val1);
24586 if (!SWIG_IsOK(ecode1)) {
24587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24588 }
24589 arg1 = static_cast< PLBOOL >(val1);
24590 plspause(arg1);
24591 _outv = octave_value();
24592 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24593 return _out;
24594 fail:
24595 return octave_value_list();
24596 }
24597 catch(...) {
24598 throw;
24599 }
24600}
24601
24602
24603SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24604 PLINT arg1 ;
24605 int val1 ;
24606 int ecode1 = 0 ;
24607 octave_value_list _out;
24608 octave_value_list *_outp=&_out;
24609 octave_value _outv;
24610
24611 try {
24612 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24613 SWIG_fail;
24614 }
24615 ecode1 = SWIG_AsVal_int(args(0), &val1);
24616 if (!SWIG_IsOK(ecode1)) {
24617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24618 }
24619 arg1 = static_cast< PLINT >(val1);
24620 plsstrm(arg1);
24621 _outv = octave_value();
24622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24623 return _out;
24624 fail:
24625 return octave_value_list();
24626 }
24627 catch(...) {
24628 throw;
24629 }
24630}
24631
24632
24634 PLINT arg1 ;
24635 PLINT arg2 ;
24636 int val1 ;
24637 int ecode1 = 0 ;
24638 int val2 ;
24639 int ecode2 = 0 ;
24640 octave_value_list _out;
24641 octave_value_list *_outp=&_out;
24642 octave_value _outv;
24643
24644 try {
24645 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24646 SWIG_fail;
24647 }
24648 ecode1 = SWIG_AsVal_int(args(0), &val1);
24649 if (!SWIG_IsOK(ecode1)) {
24650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24651 }
24652 arg1 = static_cast< PLINT >(val1);
24653 ecode2 = SWIG_AsVal_int(args(1), &val2);
24654 if (!SWIG_IsOK(ecode2)) {
24655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24656 }
24657 arg2 = static_cast< PLINT >(val2);
24658 plssub(arg1,arg2);
24659 _outv = octave_value();
24660 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24661 return _out;
24662 fail:
24663 return octave_value_list();
24664 }
24665 catch(...) {
24666 throw;
24667 }
24668}
24669
24670
24672 PLFLT arg1 ;
24673 PLFLT arg2 ;
24674 double val1 ;
24675 int ecode1 = 0 ;
24676 double val2 ;
24677 int ecode2 = 0 ;
24678 octave_value_list _out;
24679 octave_value_list *_outp=&_out;
24680 octave_value _outv;
24681
24682 try {
24683 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24684 SWIG_fail;
24685 }
24686 ecode1 = SWIG_AsVal_double(args(0), &val1);
24687 if (!SWIG_IsOK(ecode1)) {
24688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24689 }
24690 arg1 = static_cast< PLFLT >(val1);
24691 ecode2 = SWIG_AsVal_double(args(1), &val2);
24692 if (!SWIG_IsOK(ecode2)) {
24693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24694 }
24695 arg2 = static_cast< PLFLT >(val2);
24696 plssym(arg1,arg2);
24697 _outv = octave_value();
24698 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24699 return _out;
24700 fail:
24701 return octave_value_list();
24702 }
24703 catch(...) {
24704 throw;
24705 }
24706}
24707
24708
24710 PLINT arg1 ;
24711 PLINT arg2 ;
24712 int val1 ;
24713 int ecode1 = 0 ;
24714 int val2 ;
24715 int ecode2 = 0 ;
24716 octave_value_list _out;
24717 octave_value_list *_outp=&_out;
24718 octave_value _outv;
24719
24720 try {
24721 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24722 SWIG_fail;
24723 }
24724 ecode1 = SWIG_AsVal_int(args(0), &val1);
24725 if (!SWIG_IsOK(ecode1)) {
24726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24727 }
24728 arg1 = static_cast< PLINT >(val1);
24729 ecode2 = SWIG_AsVal_int(args(1), &val2);
24730 if (!SWIG_IsOK(ecode2)) {
24731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24732 }
24733 arg2 = static_cast< PLINT >(val2);
24734 plstar(arg1,arg2);
24735 _outv = octave_value();
24736 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24737 return _out;
24738 fail:
24739 return octave_value_list();
24740 }
24741 catch(...) {
24742 throw;
24743 }
24744}
24745
24746
24748 char *arg1 = (char *) 0 ;
24749 PLINT arg2 ;
24750 PLINT arg3 ;
24751 int res1 ;
24752 char *buf1 = 0 ;
24753 int alloc1 = 0 ;
24754 int val2 ;
24755 int ecode2 = 0 ;
24756 int val3 ;
24757 int ecode3 = 0 ;
24758 octave_value_list _out;
24759 octave_value_list *_outp=&_out;
24760 octave_value _outv;
24761
24762 try {
24763 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24764 SWIG_fail;
24765 }
24766 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24769 }
24770 arg1 = reinterpret_cast< char * >(buf1);
24771 ecode2 = SWIG_AsVal_int(args(1), &val2);
24772 if (!SWIG_IsOK(ecode2)) {
24773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24774 }
24775 arg2 = static_cast< PLINT >(val2);
24776 ecode3 = SWIG_AsVal_int(args(2), &val3);
24777 if (!SWIG_IsOK(ecode3)) {
24778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24779 }
24780 arg3 = static_cast< PLINT >(val3);
24781 plstart((char const *)arg1,arg2,arg3);
24782 _outv = octave_value();
24783 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24784 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24785 return _out;
24786 fail:
24787 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24788 return octave_value_list();
24789 }
24790 catch(...) {
24791 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24792 throw;
24793 }
24794}
24795
24796
24798 ct_func arg1 = (ct_func) 0 ;
24799 PLPointer arg2 = (PLPointer) 0 ;
24800 int res2 ;
24801 octave_value_list _out;
24802 octave_value_list *_outp=&_out;
24803 octave_value _outv;
24804
24805 try {
24806 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24807 SWIG_fail;
24808 }
24809 {
24810 octave_value obj = args(0);
24811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24812 if ( !obj.isempty() )
24813#else
24814 if ( !obj.is_empty() )
24815#endif
24816 {
24817 if ( obj.is_function_handle() || obj.is_inline_function() )
24818 {
24819 fcnCoordTrans = obj.function_value();
24820 }
24821 else if ( obj.is_string() )
24822 {
24823 nameCoordTrans = obj.string_value();
24824 fcnCoordTrans = NULL;
24825 }
24826 arg1 = ct_octave;
24827 }
24828 else
24829 {
24830 arg1 = NULL;
24831 }
24832 }
24833 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24834 if (!SWIG_IsOK(res2)) {
24835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24836 }
24837 plstransform(arg1,arg2);
24838 _outv = octave_value();
24839 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24840 return _out;
24841 fail:
24842 return octave_value_list();
24843 }
24844 catch(...) {
24845 throw;
24846 }
24847}
24848
24849
24851 PLINT arg1 ;
24852 PLFLT *arg2 = (PLFLT *) 0 ;
24853 PLFLT *arg3 = (PLFLT *) 0 ;
24854 char *arg4 = (char *) 0 ;
24855 Matrix temp1 ;
24856 Matrix temp3 ;
24857 int res4 ;
24858 char *buf4 = 0 ;
24859 int alloc4 = 0 ;
24860 octave_value_list _out;
24861 octave_value_list *_outp=&_out;
24862 octave_value _outv;
24863
24864 try {
24865 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24866 SWIG_fail;
24867 }
24868 {
24869 if ( _n_dims( args(0) ) > 1 )
24870 {
24871 error( "argument must be a scalar or vector" ); SWIG_fail;
24872 }
24873 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24874 temp1 = args(0).matrix_value();
24875 arg2 = &temp1( 0, 0 );
24876 }
24877 {
24878 if ( _n_dims( args(1) ) > 1 )
24879 {
24880 error( "argument must be a scalar or vector" ); SWIG_fail;
24881 }
24882 if ( _dim( args(1), 0 ) != Alen )
24883 {
24884 error( "argument vectors must be same length" ); SWIG_fail;
24885 }
24886 temp3 = args(1).matrix_value();
24887 arg3 = &temp3( 0, 0 );
24888 }
24889 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24890 if (!SWIG_IsOK(res4)) {
24891 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24892 }
24893 arg4 = reinterpret_cast< char * >(buf4);
24894 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24895 _outv = octave_value();
24896 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24897 {
24898
24899 }
24900 {
24901
24902 }
24903 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24904 return _out;
24905 fail:
24906 {
24907
24908 }
24909 {
24910
24911 }
24912 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24913 return octave_value_list();
24914 }
24915 catch(...) {
24916 {
24917
24918 }
24919 {
24920
24921 }
24922 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24923 throw;
24924 }
24925}
24926
24927
24929 PLINT arg1 ;
24930 PLFLT *arg2 = (PLFLT *) 0 ;
24931 PLFLT *arg3 = (PLFLT *) 0 ;
24932 PLFLT *arg4 = (PLFLT *) 0 ;
24933 char *arg5 = (char *) 0 ;
24934 Matrix temp1 ;
24935 Matrix temp3 ;
24936 Matrix temp4 ;
24937 int res5 ;
24938 char *buf5 = 0 ;
24939 int alloc5 = 0 ;
24940 octave_value_list _out;
24941 octave_value_list *_outp=&_out;
24942 octave_value _outv;
24943
24944 try {
24945 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24946 SWIG_fail;
24947 }
24948 {
24949 if ( _n_dims( args(0) ) > 1 )
24950 {
24951 error( "argument must be a scalar or vector" ); SWIG_fail;
24952 }
24953 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24954 temp1 = args(0).matrix_value();
24955 arg2 = &temp1( 0, 0 );
24956 }
24957 {
24958 if ( _n_dims( args(1) ) > 1 )
24959 {
24960 error( "argument must be a scalar or vector" ); SWIG_fail;
24961 }
24962 if ( _dim( args(1), 0 ) != Alen )
24963 {
24964 error( "argument vectors must be same length" ); SWIG_fail;
24965 }
24966 temp3 = args(1).matrix_value();
24967 arg3 = &temp3( 0, 0 );
24968 }
24969 {
24970 if ( _n_dims( args(2) ) > 1 )
24971 {
24972 error( "argument must be a scalar or vector" ); SWIG_fail;
24973 }
24974 if ( _dim( args(2), 0 ) != Alen )
24975 {
24976 error( "argument vectors must be same length" ); SWIG_fail;
24977 }
24978 temp4 = args(2).matrix_value();
24979 arg4 = &temp4( 0, 0 );
24980 }
24981 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24982 if (!SWIG_IsOK(res5)) {
24983 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24984 }
24985 arg5 = reinterpret_cast< char * >(buf5);
24986 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24987 _outv = octave_value();
24988 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24989 {
24990
24991 }
24992 {
24993
24994 }
24995 {
24996
24997 }
24998 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24999 return _out;
25000 fail:
25001 {
25002
25003 }
25004 {
25005
25006 }
25007 {
25008
25009 }
25010 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25011 return octave_value_list();
25012 }
25013 catch(...) {
25014 {
25015
25016 }
25017 {
25018
25019 }
25020 {
25021
25022 }
25023 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25024 throw;
25025 }
25026}
25027
25028
25030 PLINT arg1 ;
25031 PLINT arg2 ;
25032 PLFLT arg3 ;
25033 PLFLT arg4 ;
25034 int val1 ;
25035 int ecode1 = 0 ;
25036 int val2 ;
25037 int ecode2 = 0 ;
25038 double val3 ;
25039 int ecode3 = 0 ;
25040 double val4 ;
25041 int ecode4 = 0 ;
25042 octave_value_list _out;
25043 octave_value_list *_outp=&_out;
25044 octave_value _outv;
25045
25046 try {
25047 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
25048 SWIG_fail;
25049 }
25050 ecode1 = SWIG_AsVal_int(args(0), &val1);
25051 if (!SWIG_IsOK(ecode1)) {
25052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
25053 }
25054 arg1 = static_cast< PLINT >(val1);
25055 ecode2 = SWIG_AsVal_int(args(1), &val2);
25056 if (!SWIG_IsOK(ecode2)) {
25057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
25058 }
25059 arg2 = static_cast< PLINT >(val2);
25060 ecode3 = SWIG_AsVal_double(args(2), &val3);
25061 if (!SWIG_IsOK(ecode3)) {
25062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
25063 }
25064 arg3 = static_cast< PLFLT >(val3);
25065 ecode4 = SWIG_AsVal_double(args(3), &val4);
25066 if (!SWIG_IsOK(ecode4)) {
25067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
25068 }
25069 arg4 = static_cast< PLFLT >(val4);
25070 plstripa(arg1,arg2,arg3,arg4);
25071 _outv = octave_value();
25072 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25073 return _out;
25074 fail:
25075 return octave_value_list();
25076 }
25077 catch(...) {
25078 throw;
25079 }
25080}
25081
25082
25084 PLINT arg1 ;
25085 int val1 ;
25086 int ecode1 = 0 ;
25087 octave_value_list _out;
25088 octave_value_list *_outp=&_out;
25089 octave_value _outv;
25090
25091 try {
25092 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25093 SWIG_fail;
25094 }
25095 ecode1 = SWIG_AsVal_int(args(0), &val1);
25096 if (!SWIG_IsOK(ecode1)) {
25097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25098 }
25099 arg1 = static_cast< PLINT >(val1);
25100 plstripd(arg1);
25101 _outv = octave_value();
25102 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25103 return _out;
25104 fail:
25105 return octave_value_list();
25106 }
25107 catch(...) {
25108 throw;
25109 }
25110}
25111
25112
25114 PLINT arg1 ;
25115 PLINT *arg2 = (PLINT *) 0 ;
25116 PLINT *arg3 = (PLINT *) 0 ;
25117 Matrix temp1 ;
25118 Matrix temp3 ;
25119 octave_value_list _out;
25120 octave_value_list *_outp=&_out;
25121 octave_value _outv;
25122
25123 try {
25124 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25125 SWIG_fail;
25126 }
25127 {
25128 if ( _n_dims( args(0) ) > 1 )
25129 {
25130 error( "argument must be a scalar or vector" ); SWIG_fail;
25131 }
25132 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25133 arg2 = new PLINT[Alen];
25134 temp1 = args(0).matrix_value();
25135 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25136 }
25137 {
25138 if ( _n_dims( args(1) ) > 1 )
25139 {
25140 error( "argument must be a scalar or vector" ); SWIG_fail;
25141 }
25142 if ( _dim( args(1), 0 ) != Alen )
25143 {
25144 error( "argument vectors must be same length" ); SWIG_fail;
25145 }
25146 temp3 = args(1).matrix_value();
25147 arg3 = new PLINT[Alen];
25148 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25149 }
25150 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25151 _outv = octave_value();
25152 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25153 {
25154 delete [] arg2;
25155 }
25156 {
25157 delete [] arg3;
25158 }
25159 return _out;
25160 fail:
25161 {
25162 delete [] arg2;
25163 }
25164 {
25165 delete [] arg3;
25166 }
25167 return octave_value_list();
25168 }
25169 catch(...) {
25170 {
25171 delete [] arg2;
25172 }
25173 {
25174 delete [] arg3;
25175 }
25176 throw;
25177 }
25178}
25179
25180
25182 PLFLT *arg1 = (PLFLT *) 0 ;
25183 PLFLT *arg2 = (PLFLT *) 0 ;
25184 PLINT arg3 ;
25185 PLBOOL arg4 ;
25186 Matrix temp1 ;
25187 Matrix temp2 ;
25188 int val4 ;
25189 int ecode4 = 0 ;
25190 octave_value_list _out;
25191 octave_value_list *_outp=&_out;
25192 octave_value _outv;
25193
25194 try {
25195 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25196 SWIG_fail;
25197 }
25198 {
25199 if ( _n_dims( args(0) ) > 1 )
25200 {
25201 error( "argument must be a scalar or vector" ); SWIG_fail;
25202 }
25203#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25204 if ( !args(0).isempty() )
25205#else
25206 if ( !args(0).is_empty() )
25207#endif
25208 {
25209 Alen = (PLINT) ( _dim( args(0), 0 ) );
25210 temp1 = args(0).matrix_value();
25211 arg1 = &temp1( 0, 0 );
25212 }
25213 else
25214 {
25215 arg1 = NULL;
25216 Alen = 0;
25217 }
25218 }
25219 {
25220 if ( _n_dims( args(1) ) > 1 )
25221 {
25222 error( "argument must be a scalar or vector" ); SWIG_fail;
25223 }
25224#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25225 if ( !args(1).isempty() )
25226#else
25227 if ( !args(1).is_empty() )
25228#endif
25229 {
25230 if ( _dim( args(1), 0 ) != Alen )
25231 {
25232 error( "argument vectors must be same length" ); SWIG_fail;
25233 }
25234 temp2 = args(1).matrix_value();
25235 arg2 = &temp2( 0, 0 );
25236 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25237 }
25238 else
25239 {
25240 arg2 = NULL;
25241 arg3 = 0;
25242 }
25243 }
25244 ecode4 = SWIG_AsVal_int(args(2), &val4);
25245 if (!SWIG_IsOK(ecode4)) {
25246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25247 }
25248 arg4 = static_cast< PLBOOL >(val4);
25249 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25250 _outv = octave_value();
25251 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25252 {
25253
25254 }
25255 {
25256
25257 }
25258 return _out;
25259 fail:
25260 {
25261
25262 }
25263 {
25264
25265 }
25266 return octave_value_list();
25267 }
25268 catch(...) {
25269 {
25270
25271 }
25272 {
25273
25274 }
25275 throw;
25276 }
25277}
25278
25279
25281 PLFLT arg1 ;
25282 PLFLT arg2 ;
25283 PLFLT arg3 ;
25284 PLFLT arg4 ;
25285 double val1 ;
25286 int ecode1 = 0 ;
25287 double val2 ;
25288 int ecode2 = 0 ;
25289 double val3 ;
25290 int ecode3 = 0 ;
25291 double val4 ;
25292 int ecode4 = 0 ;
25293 octave_value_list _out;
25294 octave_value_list *_outp=&_out;
25295 octave_value _outv;
25296
25297 try {
25298 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25299 SWIG_fail;
25300 }
25301 ecode1 = SWIG_AsVal_double(args(0), &val1);
25302 if (!SWIG_IsOK(ecode1)) {
25303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25304 }
25305 arg1 = static_cast< PLFLT >(val1);
25306 ecode2 = SWIG_AsVal_double(args(1), &val2);
25307 if (!SWIG_IsOK(ecode2)) {
25308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25309 }
25310 arg2 = static_cast< PLFLT >(val2);
25311 ecode3 = SWIG_AsVal_double(args(2), &val3);
25312 if (!SWIG_IsOK(ecode3)) {
25313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25314 }
25315 arg3 = static_cast< PLFLT >(val3);
25316 ecode4 = SWIG_AsVal_double(args(3), &val4);
25317 if (!SWIG_IsOK(ecode4)) {
25318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25319 }
25320 arg4 = static_cast< PLFLT >(val4);
25321 plsvpa(arg1,arg2,arg3,arg4);
25322 _outv = octave_value();
25323 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25324 return _out;
25325 fail:
25326 return octave_value_list();
25327 }
25328 catch(...) {
25329 throw;
25330 }
25331}
25332
25333
25335 PLINT arg1 ;
25336 PLINT arg2 ;
25337 int val1 ;
25338 int ecode1 = 0 ;
25339 int val2 ;
25340 int ecode2 = 0 ;
25341 octave_value_list _out;
25342 octave_value_list *_outp=&_out;
25343 octave_value _outv;
25344
25345 try {
25346 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25347 SWIG_fail;
25348 }
25349 ecode1 = SWIG_AsVal_int(args(0), &val1);
25350 if (!SWIG_IsOK(ecode1)) {
25351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25352 }
25353 arg1 = static_cast< PLINT >(val1);
25354 ecode2 = SWIG_AsVal_int(args(1), &val2);
25355 if (!SWIG_IsOK(ecode2)) {
25356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25357 }
25358 arg2 = static_cast< PLINT >(val2);
25359 plsxax(arg1,arg2);
25360 _outv = octave_value();
25361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25362 return _out;
25363 fail:
25364 return octave_value_list();
25365 }
25366 catch(...) {
25367 throw;
25368 }
25369}
25370
25371
25373 PLINT arg1 ;
25374 PLINT arg2 ;
25375 int val1 ;
25376 int ecode1 = 0 ;
25377 int val2 ;
25378 int ecode2 = 0 ;
25379 octave_value_list _out;
25380 octave_value_list *_outp=&_out;
25381 octave_value _outv;
25382
25383 try {
25384 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25385 SWIG_fail;
25386 }
25387 ecode1 = SWIG_AsVal_int(args(0), &val1);
25388 if (!SWIG_IsOK(ecode1)) {
25389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25390 }
25391 arg1 = static_cast< PLINT >(val1);
25392 ecode2 = SWIG_AsVal_int(args(1), &val2);
25393 if (!SWIG_IsOK(ecode2)) {
25394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25395 }
25396 arg2 = static_cast< PLINT >(val2);
25397 plsyax(arg1,arg2);
25398 _outv = octave_value();
25399 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25400 return _out;
25401 fail:
25402 return octave_value_list();
25403 }
25404 catch(...) {
25405 throw;
25406 }
25407}
25408
25409
25411 PLINT arg1 ;
25412 PLFLT *arg2 = (PLFLT *) 0 ;
25413 PLFLT *arg3 = (PLFLT *) 0 ;
25414 PLINT arg4 ;
25415 Matrix temp1 ;
25416 Matrix temp3 ;
25417 int val4 ;
25418 int ecode4 = 0 ;
25419 octave_value_list _out;
25420 octave_value_list *_outp=&_out;
25421 octave_value _outv;
25422
25423 try {
25424 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25425 SWIG_fail;
25426 }
25427 {
25428 if ( _n_dims( args(0) ) > 1 )
25429 {
25430 error( "argument must be a scalar or vector" ); SWIG_fail;
25431 }
25432 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25433 temp1 = args(0).matrix_value();
25434 arg2 = &temp1( 0, 0 );
25435 }
25436 {
25437 if ( _n_dims( args(1) ) > 1 )
25438 {
25439 error( "argument must be a scalar or vector" ); SWIG_fail;
25440 }
25441 if ( _dim( args(1), 0 ) != Alen )
25442 {
25443 error( "argument vectors must be same length" ); SWIG_fail;
25444 }
25445 temp3 = args(1).matrix_value();
25446 arg3 = &temp3( 0, 0 );
25447 }
25448 ecode4 = SWIG_AsVal_int(args(2), &val4);
25449 if (!SWIG_IsOK(ecode4)) {
25450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25451 }
25452 arg4 = static_cast< PLINT >(val4);
25453 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25454 _outv = octave_value();
25455 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25456 {
25457
25458 }
25459 {
25460
25461 }
25462 return _out;
25463 fail:
25464 {
25465
25466 }
25467 {
25468
25469 }
25470 return octave_value_list();
25471 }
25472 catch(...) {
25473 {
25474
25475 }
25476 {
25477
25478 }
25479 throw;
25480 }
25481}
25482
25483
25485 PLINT arg1 ;
25486 PLINT arg2 ;
25487 int val1 ;
25488 int ecode1 = 0 ;
25489 int val2 ;
25490 int ecode2 = 0 ;
25491 octave_value_list _out;
25492 octave_value_list *_outp=&_out;
25493 octave_value _outv;
25494
25495 try {
25496 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25497 SWIG_fail;
25498 }
25499 ecode1 = SWIG_AsVal_int(args(0), &val1);
25500 if (!SWIG_IsOK(ecode1)) {
25501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25502 }
25503 arg1 = static_cast< PLINT >(val1);
25504 ecode2 = SWIG_AsVal_int(args(1), &val2);
25505 if (!SWIG_IsOK(ecode2)) {
25506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25507 }
25508 arg2 = static_cast< PLINT >(val2);
25509 plszax(arg1,arg2);
25510 _outv = octave_value();
25511 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25512 return _out;
25513 fail:
25514 return octave_value_list();
25515 }
25516 catch(...) {
25517 throw;
25518 }
25519}
25520
25521
25523 octave_value_list _out;
25524 octave_value_list *_outp=&_out;
25525 octave_value _outv;
25526
25527 try {
25528 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25529 SWIG_fail;
25530 }
25531 pltext();
25532 _outv = octave_value();
25533 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25534 return _out;
25535 fail:
25536 return octave_value_list();
25537 }
25538 catch(...) {
25539 throw;
25540 }
25541}
25542
25543
25545 char *arg1 = (char *) 0 ;
25546 int res1 ;
25547 char *buf1 = 0 ;
25548 int alloc1 = 0 ;
25549 octave_value_list _out;
25550 octave_value_list *_outp=&_out;
25551 octave_value _outv;
25552
25553 try {
25554 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25555 SWIG_fail;
25556 }
25557 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25558 if (!SWIG_IsOK(res1)) {
25559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25560 }
25561 arg1 = reinterpret_cast< char * >(buf1);
25562 pltimefmt((char const *)arg1);
25563 _outv = octave_value();
25564 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25565 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25566 return _out;
25567 fail:
25568 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25569 return octave_value_list();
25570 }
25571 catch(...) {
25572 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25573 throw;
25574 }
25575}
25576
25577
25579 PLFLT arg1 ;
25580 double val1 ;
25581 int ecode1 = 0 ;
25582 octave_value_list _out;
25583 octave_value_list *_outp=&_out;
25584 octave_value _outv;
25585
25586 try {
25587 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25588 SWIG_fail;
25589 }
25590 ecode1 = SWIG_AsVal_double(args(0), &val1);
25591 if (!SWIG_IsOK(ecode1)) {
25592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25593 }
25594 arg1 = static_cast< PLFLT >(val1);
25595 plvasp(arg1);
25596 _outv = octave_value();
25597 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25598 return _out;
25599 fail:
25600 return octave_value_list();
25601 }
25602 catch(...) {
25603 throw;
25604 }
25605}
25606
25607
25609 PLFLT arg1 ;
25610 PLFLT arg2 ;
25611 PLFLT arg3 ;
25612 PLFLT arg4 ;
25613 PLFLT arg5 ;
25614 double val1 ;
25615 int ecode1 = 0 ;
25616 double val2 ;
25617 int ecode2 = 0 ;
25618 double val3 ;
25619 int ecode3 = 0 ;
25620 double val4 ;
25621 int ecode4 = 0 ;
25622 double val5 ;
25623 int ecode5 = 0 ;
25624 octave_value_list _out;
25625 octave_value_list *_outp=&_out;
25626 octave_value _outv;
25627
25628 try {
25629 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25630 SWIG_fail;
25631 }
25632 ecode1 = SWIG_AsVal_double(args(0), &val1);
25633 if (!SWIG_IsOK(ecode1)) {
25634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25635 }
25636 arg1 = static_cast< PLFLT >(val1);
25637 ecode2 = SWIG_AsVal_double(args(1), &val2);
25638 if (!SWIG_IsOK(ecode2)) {
25639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25640 }
25641 arg2 = static_cast< PLFLT >(val2);
25642 ecode3 = SWIG_AsVal_double(args(2), &val3);
25643 if (!SWIG_IsOK(ecode3)) {
25644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25645 }
25646 arg3 = static_cast< PLFLT >(val3);
25647 ecode4 = SWIG_AsVal_double(args(3), &val4);
25648 if (!SWIG_IsOK(ecode4)) {
25649 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25650 }
25651 arg4 = static_cast< PLFLT >(val4);
25652 ecode5 = SWIG_AsVal_double(args(4), &val5);
25653 if (!SWIG_IsOK(ecode5)) {
25654 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25655 }
25656 arg5 = static_cast< PLFLT >(val5);
25657 plvpas(arg1,arg2,arg3,arg4,arg5);
25658 _outv = octave_value();
25659 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25660 return _out;
25661 fail:
25662 return octave_value_list();
25663 }
25664 catch(...) {
25665 throw;
25666 }
25667}
25668
25669
25671 PLFLT arg1 ;
25672 PLFLT arg2 ;
25673 PLFLT arg3 ;
25674 PLFLT arg4 ;
25675 double val1 ;
25676 int ecode1 = 0 ;
25677 double val2 ;
25678 int ecode2 = 0 ;
25679 double val3 ;
25680 int ecode3 = 0 ;
25681 double val4 ;
25682 int ecode4 = 0 ;
25683 octave_value_list _out;
25684 octave_value_list *_outp=&_out;
25685 octave_value _outv;
25686
25687 try {
25688 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25689 SWIG_fail;
25690 }
25691 ecode1 = SWIG_AsVal_double(args(0), &val1);
25692 if (!SWIG_IsOK(ecode1)) {
25693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25694 }
25695 arg1 = static_cast< PLFLT >(val1);
25696 ecode2 = SWIG_AsVal_double(args(1), &val2);
25697 if (!SWIG_IsOK(ecode2)) {
25698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25699 }
25700 arg2 = static_cast< PLFLT >(val2);
25701 ecode3 = SWIG_AsVal_double(args(2), &val3);
25702 if (!SWIG_IsOK(ecode3)) {
25703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25704 }
25705 arg3 = static_cast< PLFLT >(val3);
25706 ecode4 = SWIG_AsVal_double(args(3), &val4);
25707 if (!SWIG_IsOK(ecode4)) {
25708 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25709 }
25710 arg4 = static_cast< PLFLT >(val4);
25711 plvpor(arg1,arg2,arg3,arg4);
25712 _outv = octave_value();
25713 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25714 return _out;
25715 fail:
25716 return octave_value_list();
25717 }
25718 catch(...) {
25719 throw;
25720 }
25721}
25722
25723
25725 octave_value_list _out;
25726 octave_value_list *_outp=&_out;
25727 octave_value _outv;
25728
25729 try {
25730 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25731 SWIG_fail;
25732 }
25733 plvsta();
25734 _outv = octave_value();
25735 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25736 return _out;
25737 fail:
25738 return octave_value_list();
25739 }
25740 catch(...) {
25741 throw;
25742 }
25743}
25744
25745
25747 PLFLT arg1 ;
25748 PLFLT arg2 ;
25749 PLFLT arg3 ;
25750 PLFLT arg4 ;
25751 PLFLT arg5 ;
25752 PLFLT arg6 ;
25753 PLFLT arg7 ;
25754 PLFLT arg8 ;
25755 PLFLT arg9 ;
25756 PLFLT arg10 ;
25757 PLFLT arg11 ;
25758 double val1 ;
25759 int ecode1 = 0 ;
25760 double val2 ;
25761 int ecode2 = 0 ;
25762 double val3 ;
25763 int ecode3 = 0 ;
25764 double val4 ;
25765 int ecode4 = 0 ;
25766 double val5 ;
25767 int ecode5 = 0 ;
25768 double val6 ;
25769 int ecode6 = 0 ;
25770 double val7 ;
25771 int ecode7 = 0 ;
25772 double val8 ;
25773 int ecode8 = 0 ;
25774 double val9 ;
25775 int ecode9 = 0 ;
25776 double val10 ;
25777 int ecode10 = 0 ;
25778 double val11 ;
25779 int ecode11 = 0 ;
25780 octave_value_list _out;
25781 octave_value_list *_outp=&_out;
25782 octave_value _outv;
25783
25784 try {
25785 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25786 SWIG_fail;
25787 }
25788 ecode1 = SWIG_AsVal_double(args(0), &val1);
25789 if (!SWIG_IsOK(ecode1)) {
25790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25791 }
25792 arg1 = static_cast< PLFLT >(val1);
25793 ecode2 = SWIG_AsVal_double(args(1), &val2);
25794 if (!SWIG_IsOK(ecode2)) {
25795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25796 }
25797 arg2 = static_cast< PLFLT >(val2);
25798 ecode3 = SWIG_AsVal_double(args(2), &val3);
25799 if (!SWIG_IsOK(ecode3)) {
25800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25801 }
25802 arg3 = static_cast< PLFLT >(val3);
25803 ecode4 = SWIG_AsVal_double(args(3), &val4);
25804 if (!SWIG_IsOK(ecode4)) {
25805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25806 }
25807 arg4 = static_cast< PLFLT >(val4);
25808 ecode5 = SWIG_AsVal_double(args(4), &val5);
25809 if (!SWIG_IsOK(ecode5)) {
25810 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25811 }
25812 arg5 = static_cast< PLFLT >(val5);
25813 ecode6 = SWIG_AsVal_double(args(5), &val6);
25814 if (!SWIG_IsOK(ecode6)) {
25815 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25816 }
25817 arg6 = static_cast< PLFLT >(val6);
25818 ecode7 = SWIG_AsVal_double(args(6), &val7);
25819 if (!SWIG_IsOK(ecode7)) {
25820 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25821 }
25822 arg7 = static_cast< PLFLT >(val7);
25823 ecode8 = SWIG_AsVal_double(args(7), &val8);
25824 if (!SWIG_IsOK(ecode8)) {
25825 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25826 }
25827 arg8 = static_cast< PLFLT >(val8);
25828 ecode9 = SWIG_AsVal_double(args(8), &val9);
25829 if (!SWIG_IsOK(ecode9)) {
25830 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25831 }
25832 arg9 = static_cast< PLFLT >(val9);
25833 ecode10 = SWIG_AsVal_double(args(9), &val10);
25834 if (!SWIG_IsOK(ecode10)) {
25835 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25836 }
25837 arg10 = static_cast< PLFLT >(val10);
25838 ecode11 = SWIG_AsVal_double(args(10), &val11);
25839 if (!SWIG_IsOK(ecode11)) {
25840 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25841 }
25842 arg11 = static_cast< PLFLT >(val11);
25843 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25844 _outv = octave_value();
25845 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25846 return _out;
25847 fail:
25848 return octave_value_list();
25849 }
25850 catch(...) {
25851 throw;
25852 }
25853}
25854
25855
25857 PLFLT arg1 ;
25858 double val1 ;
25859 int ecode1 = 0 ;
25860 octave_value_list _out;
25861 octave_value_list *_outp=&_out;
25862 octave_value _outv;
25863
25864 try {
25865 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25866 SWIG_fail;
25867 }
25868 ecode1 = SWIG_AsVal_double(args(0), &val1);
25869 if (!SWIG_IsOK(ecode1)) {
25870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25871 }
25872 arg1 = static_cast< PLFLT >(val1);
25873 plwidth(arg1);
25874 _outv = octave_value();
25875 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25876 return _out;
25877 fail:
25878 return octave_value_list();
25879 }
25880 catch(...) {
25881 throw;
25882 }
25883}
25884
25885
25887 PLFLT arg1 ;
25888 PLFLT arg2 ;
25889 PLFLT arg3 ;
25890 PLFLT arg4 ;
25891 double val1 ;
25892 int ecode1 = 0 ;
25893 double val2 ;
25894 int ecode2 = 0 ;
25895 double val3 ;
25896 int ecode3 = 0 ;
25897 double val4 ;
25898 int ecode4 = 0 ;
25899 octave_value_list _out;
25900 octave_value_list *_outp=&_out;
25901 octave_value _outv;
25902
25903 try {
25904 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25905 SWIG_fail;
25906 }
25907 ecode1 = SWIG_AsVal_double(args(0), &val1);
25908 if (!SWIG_IsOK(ecode1)) {
25909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25910 }
25911 arg1 = static_cast< PLFLT >(val1);
25912 ecode2 = SWIG_AsVal_double(args(1), &val2);
25913 if (!SWIG_IsOK(ecode2)) {
25914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25915 }
25916 arg2 = static_cast< PLFLT >(val2);
25917 ecode3 = SWIG_AsVal_double(args(2), &val3);
25918 if (!SWIG_IsOK(ecode3)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25920 }
25921 arg3 = static_cast< PLFLT >(val3);
25922 ecode4 = SWIG_AsVal_double(args(3), &val4);
25923 if (!SWIG_IsOK(ecode4)) {
25924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25925 }
25926 arg4 = static_cast< PLFLT >(val4);
25927 plwind(arg1,arg2,arg3,arg4);
25928 _outv = octave_value();
25929 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25930 return _out;
25931 fail:
25932 return octave_value_list();
25933 }
25934 catch(...) {
25935 throw;
25936 }
25937}
25938
25939
25941 PLBOOL arg1 ;
25942 PLBOOL *arg2 = (PLBOOL *) 0 ;
25943 int val1 ;
25944 int ecode1 = 0 ;
25945 PLBOOL temp2 ;
25946 int res2 = SWIG_TMPOBJ ;
25947 octave_value_list _out;
25948 octave_value_list *_outp=&_out;
25949 octave_value _outv;
25950
25951 try {
25952 arg2 = &temp2;
25953 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25954 SWIG_fail;
25955 }
25956 ecode1 = SWIG_AsVal_int(args(0), &val1);
25957 if (!SWIG_IsOK(ecode1)) {
25958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25959 }
25960 arg1 = static_cast< PLBOOL >(val1);
25961 plxormod(arg1,arg2);
25962 _outv = octave_value();
25963 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25964 if (SWIG_IsTmpObj(res2)) {
25965 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25966 } else {
25967 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25969 }
25970 return _out;
25971 fail:
25972 return octave_value_list();
25973 }
25974 catch(...) {
25975 throw;
25976 }
25977}
25978
25979
25981 mapform_func arg1 = (mapform_func) 0 ;
25982 char *arg2 = (char *) 0 ;
25983 PLFLT arg3 ;
25984 PLFLT arg4 ;
25985 PLFLT arg5 ;
25986 PLFLT arg6 ;
25987 int res2 ;
25988 char *buf2 = 0 ;
25989 int alloc2 = 0 ;
25990 double val3 ;
25991 int ecode3 = 0 ;
25992 double val4 ;
25993 int ecode4 = 0 ;
25994 double val5 ;
25995 int ecode5 = 0 ;
25996 double val6 ;
25997 int ecode6 = 0 ;
25998 octave_value_list _out;
25999 octave_value_list *_outp=&_out;
26000 octave_value _outv;
26001
26002 try {
26003 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
26004 SWIG_fail;
26005 }
26006 {
26007 octave_value obj = args(0);
26008#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26009 if ( !obj.isempty() )
26010#else
26011 if ( !obj.is_empty() )
26012#endif
26013 {
26014 if ( obj.is_function_handle() || obj.is_inline_function() )
26015 {
26016 fcnMapForm = obj.function_value();
26017 }
26018 else if ( obj.is_string() )
26019 {
26020 nameMapForm = obj.string_value();
26021 fcnMapForm = NULL;
26022 }
26023 arg1 = mapform_octave;
26024 }
26025 else
26026 {
26027 arg1 = NULL;
26028 }
26029 }
26030 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26031 if (!SWIG_IsOK(res2)) {
26032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
26033 }
26034 arg2 = reinterpret_cast< char * >(buf2);
26035 ecode3 = SWIG_AsVal_double(args(2), &val3);
26036 if (!SWIG_IsOK(ecode3)) {
26037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
26038 }
26039 arg3 = static_cast< PLFLT >(val3);
26040 ecode4 = SWIG_AsVal_double(args(3), &val4);
26041 if (!SWIG_IsOK(ecode4)) {
26042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
26043 }
26044 arg4 = static_cast< PLFLT >(val4);
26045 ecode5 = SWIG_AsVal_double(args(4), &val5);
26046 if (!SWIG_IsOK(ecode5)) {
26047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
26048 }
26049 arg5 = static_cast< PLFLT >(val5);
26050 ecode6 = SWIG_AsVal_double(args(5), &val6);
26051 if (!SWIG_IsOK(ecode6)) {
26052 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
26053 }
26054 arg6 = static_cast< PLFLT >(val6);
26055 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
26056 _outv = octave_value();
26057 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26058 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26059 return _out;
26060 fail:
26061 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26062 return octave_value_list();
26063 }
26064 catch(...) {
26065 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26066 throw;
26067 }
26068}
26069
26070
26072 mapform_func arg1 = (mapform_func) 0 ;
26073 char *arg2 = (char *) 0 ;
26074 PLFLT arg3 ;
26075 PLFLT arg4 ;
26076 PLFLT arg5 ;
26077 PLFLT arg6 ;
26078 PLINT *arg7 = (PLINT *) 0 ;
26079 PLINT arg8 ;
26080 int res2 ;
26081 char *buf2 = 0 ;
26082 int alloc2 = 0 ;
26083 double val3 ;
26084 int ecode3 = 0 ;
26085 double val4 ;
26086 int ecode4 = 0 ;
26087 double val5 ;
26088 int ecode5 = 0 ;
26089 double val6 ;
26090 int ecode6 = 0 ;
26091 Matrix temp7 ;
26092 octave_value_list _out;
26093 octave_value_list *_outp=&_out;
26094 octave_value _outv;
26095
26096 try {
26097 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26098 SWIG_fail;
26099 }
26100 {
26101 octave_value obj = args(0);
26102#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26103 if ( !obj.isempty() )
26104#else
26105 if ( !obj.is_empty() )
26106#endif
26107 {
26108 if ( obj.is_function_handle() || obj.is_inline_function() )
26109 {
26110 fcnMapForm = obj.function_value();
26111 }
26112 else if ( obj.is_string() )
26113 {
26114 nameMapForm = obj.string_value();
26115 fcnMapForm = NULL;
26116 }
26117 arg1 = mapform_octave;
26118 }
26119 else
26120 {
26121 arg1 = NULL;
26122 }
26123 }
26124 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26125 if (!SWIG_IsOK(res2)) {
26126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26127 }
26128 arg2 = reinterpret_cast< char * >(buf2);
26129 ecode3 = SWIG_AsVal_double(args(2), &val3);
26130 if (!SWIG_IsOK(ecode3)) {
26131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26132 }
26133 arg3 = static_cast< PLFLT >(val3);
26134 ecode4 = SWIG_AsVal_double(args(3), &val4);
26135 if (!SWIG_IsOK(ecode4)) {
26136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26137 }
26138 arg4 = static_cast< PLFLT >(val4);
26139 ecode5 = SWIG_AsVal_double(args(4), &val5);
26140 if (!SWIG_IsOK(ecode5)) {
26141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26142 }
26143 arg5 = static_cast< PLFLT >(val5);
26144 ecode6 = SWIG_AsVal_double(args(5), &val6);
26145 if (!SWIG_IsOK(ecode6)) {
26146 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26147 }
26148 arg6 = static_cast< PLFLT >(val6);
26149 {
26150 if ( _n_dims( args(6) ) > 1 )
26151 {
26152 error( "argument must be a scalar or vector" ); SWIG_fail;
26153 }
26154#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26155 if ( !args(6).isempty() )
26156#else
26157 if ( !args(6).is_empty() )
26158#endif
26159 {
26160 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26161 temp7 = args(6).matrix_value();
26162 arg7 = new PLINT[arg8];
26163 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26164 }
26165 else
26166 {
26167 arg7 = NULL;
26168 arg8 = 0;
26169 }
26170 }
26171 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26172 _outv = octave_value();
26173 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26174 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26175 {
26176 delete [] arg7;
26177 }
26178 return _out;
26179 fail:
26180 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26181 {
26182 delete [] arg7;
26183 }
26184 return octave_value_list();
26185 }
26186 catch(...) {
26187 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26188 {
26189 delete [] arg7;
26190 }
26191 throw;
26192 }
26193}
26194
26195
26197 mapform_func arg1 = (mapform_func) 0 ;
26198 char *arg2 = (char *) 0 ;
26199 char *arg3 = (char *) 0 ;
26200 PLFLT arg4 ;
26201 PLFLT arg5 ;
26202 PLFLT arg6 ;
26203 PLFLT arg7 ;
26204 PLINT *arg8 = (PLINT *) 0 ;
26205 PLINT arg9 ;
26206 int res2 ;
26207 char *buf2 = 0 ;
26208 int alloc2 = 0 ;
26209 int res3 ;
26210 char *buf3 = 0 ;
26211 int alloc3 = 0 ;
26212 double val4 ;
26213 int ecode4 = 0 ;
26214 double val5 ;
26215 int ecode5 = 0 ;
26216 double val6 ;
26217 int ecode6 = 0 ;
26218 double val7 ;
26219 int ecode7 = 0 ;
26220 Matrix temp8 ;
26221 octave_value_list _out;
26222 octave_value_list *_outp=&_out;
26223 octave_value _outv;
26224
26225 try {
26226 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26227 SWIG_fail;
26228 }
26229 {
26230 octave_value obj = args(0);
26231#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26232 if ( !obj.isempty() )
26233#else
26234 if ( !obj.is_empty() )
26235#endif
26236 {
26237 if ( obj.is_function_handle() || obj.is_inline_function() )
26238 {
26239 fcnMapForm = obj.function_value();
26240 }
26241 else if ( obj.is_string() )
26242 {
26243 nameMapForm = obj.string_value();
26244 fcnMapForm = NULL;
26245 }
26246 arg1 = mapform_octave;
26247 }
26248 else
26249 {
26250 arg1 = NULL;
26251 }
26252 }
26253 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26254 if (!SWIG_IsOK(res2)) {
26255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26256 }
26257 arg2 = reinterpret_cast< char * >(buf2);
26258 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26259 if (!SWIG_IsOK(res3)) {
26260 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26261 }
26262 arg3 = reinterpret_cast< char * >(buf3);
26263 ecode4 = SWIG_AsVal_double(args(3), &val4);
26264 if (!SWIG_IsOK(ecode4)) {
26265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26266 }
26267 arg4 = static_cast< PLFLT >(val4);
26268 ecode5 = SWIG_AsVal_double(args(4), &val5);
26269 if (!SWIG_IsOK(ecode5)) {
26270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26271 }
26272 arg5 = static_cast< PLFLT >(val5);
26273 ecode6 = SWIG_AsVal_double(args(5), &val6);
26274 if (!SWIG_IsOK(ecode6)) {
26275 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26276 }
26277 arg6 = static_cast< PLFLT >(val6);
26278 ecode7 = SWIG_AsVal_double(args(6), &val7);
26279 if (!SWIG_IsOK(ecode7)) {
26280 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26281 }
26282 arg7 = static_cast< PLFLT >(val7);
26283 {
26284 if ( _n_dims( args(7) ) > 1 )
26285 {
26286 error( "argument must be a scalar or vector" ); SWIG_fail;
26287 }
26288#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26289 if ( !args(7).isempty() )
26290#else
26291 if ( !args(7).is_empty() )
26292#endif
26293 {
26294 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26295 temp8 = args(7).matrix_value();
26296 arg8 = new PLINT[arg9];
26297 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26298 }
26299 else
26300 {
26301 arg8 = NULL;
26302 arg9 = 0;
26303 }
26304 }
26305 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26306 _outv = octave_value();
26307 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26308 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26309 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26310 {
26311 delete [] arg8;
26312 }
26313 return _out;
26314 fail:
26315 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26316 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26317 {
26318 delete [] arg8;
26319 }
26320 return octave_value_list();
26321 }
26322 catch(...) {
26323 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26324 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26325 {
26326 delete [] arg8;
26327 }
26328 throw;
26329 }
26330}
26331
26332
26334 mapform_func arg1 = (mapform_func) 0 ;
26335 char *arg2 = (char *) 0 ;
26336 PLFLT arg3 ;
26337 PLFLT arg4 ;
26338 PLFLT arg5 ;
26339 char *arg6 = (char *) 0 ;
26340 PLFLT arg7 ;
26341 PLFLT arg8 ;
26342 PLFLT arg9 ;
26343 PLFLT arg10 ;
26344 PLINT arg11 ;
26345 int res2 ;
26346 char *buf2 = 0 ;
26347 int alloc2 = 0 ;
26348 double val3 ;
26349 int ecode3 = 0 ;
26350 double val4 ;
26351 int ecode4 = 0 ;
26352 double val5 ;
26353 int ecode5 = 0 ;
26354 int res6 ;
26355 char *buf6 = 0 ;
26356 int alloc6 = 0 ;
26357 double val7 ;
26358 int ecode7 = 0 ;
26359 double val8 ;
26360 int ecode8 = 0 ;
26361 double val9 ;
26362 int ecode9 = 0 ;
26363 double val10 ;
26364 int ecode10 = 0 ;
26365 int val11 ;
26366 int ecode11 = 0 ;
26367 octave_value_list _out;
26368 octave_value_list *_outp=&_out;
26369 octave_value _outv;
26370
26371 try {
26372 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26373 SWIG_fail;
26374 }
26375 {
26376 octave_value obj = args(0);
26377#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26378 if ( !obj.isempty() )
26379#else
26380 if ( !obj.is_empty() )
26381#endif
26382 {
26383 if ( obj.is_function_handle() || obj.is_inline_function() )
26384 {
26385 fcnMapForm = obj.function_value();
26386 }
26387 else if ( obj.is_string() )
26388 {
26389 nameMapForm = obj.string_value();
26390 fcnMapForm = NULL;
26391 }
26392 arg1 = mapform_octave;
26393 }
26394 else
26395 {
26396 arg1 = NULL;
26397 }
26398 }
26399 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26400 if (!SWIG_IsOK(res2)) {
26401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26402 }
26403 arg2 = reinterpret_cast< char * >(buf2);
26404 ecode3 = SWIG_AsVal_double(args(2), &val3);
26405 if (!SWIG_IsOK(ecode3)) {
26406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26407 }
26408 arg3 = static_cast< PLFLT >(val3);
26409 ecode4 = SWIG_AsVal_double(args(3), &val4);
26410 if (!SWIG_IsOK(ecode4)) {
26411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26412 }
26413 arg4 = static_cast< PLFLT >(val4);
26414 ecode5 = SWIG_AsVal_double(args(4), &val5);
26415 if (!SWIG_IsOK(ecode5)) {
26416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26417 }
26418 arg5 = static_cast< PLFLT >(val5);
26419 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26420 if (!SWIG_IsOK(res6)) {
26421 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26422 }
26423 arg6 = reinterpret_cast< char * >(buf6);
26424 ecode7 = SWIG_AsVal_double(args(6), &val7);
26425 if (!SWIG_IsOK(ecode7)) {
26426 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26427 }
26428 arg7 = static_cast< PLFLT >(val7);
26429 ecode8 = SWIG_AsVal_double(args(7), &val8);
26430 if (!SWIG_IsOK(ecode8)) {
26431 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26432 }
26433 arg8 = static_cast< PLFLT >(val8);
26434 ecode9 = SWIG_AsVal_double(args(8), &val9);
26435 if (!SWIG_IsOK(ecode9)) {
26436 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26437 }
26438 arg9 = static_cast< PLFLT >(val9);
26439 ecode10 = SWIG_AsVal_double(args(9), &val10);
26440 if (!SWIG_IsOK(ecode10)) {
26441 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26442 }
26443 arg10 = static_cast< PLFLT >(val10);
26444 ecode11 = SWIG_AsVal_int(args(10), &val11);
26445 if (!SWIG_IsOK(ecode11)) {
26446 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26447 }
26448 arg11 = static_cast< PLINT >(val11);
26449 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26450 _outv = octave_value();
26451 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26452 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26453 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26454 return _out;
26455 fail:
26456 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26457 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26458 return octave_value_list();
26459 }
26460 catch(...) {
26461 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26462 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26463 throw;
26464 }
26465}
26466
26467
26469 mapform_func arg1 = (mapform_func) 0 ;
26470 char *arg2 = (char *) 0 ;
26471 PLFLT arg3 ;
26472 PLFLT arg4 ;
26473 PLFLT arg5 ;
26474 PLFLT arg6 ;
26475 PLINT *arg7 = (PLINT *) 0 ;
26476 PLINT arg8 ;
26477 int res2 ;
26478 char *buf2 = 0 ;
26479 int alloc2 = 0 ;
26480 double val3 ;
26481 int ecode3 = 0 ;
26482 double val4 ;
26483 int ecode4 = 0 ;
26484 double val5 ;
26485 int ecode5 = 0 ;
26486 double val6 ;
26487 int ecode6 = 0 ;
26488 Matrix temp7 ;
26489 octave_value_list _out;
26490 octave_value_list *_outp=&_out;
26491 octave_value _outv;
26492
26493 try {
26494 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26495 SWIG_fail;
26496 }
26497 {
26498 octave_value obj = args(0);
26499#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26500 if ( !obj.isempty() )
26501#else
26502 if ( !obj.is_empty() )
26503#endif
26504 {
26505 if ( obj.is_function_handle() || obj.is_inline_function() )
26506 {
26507 fcnMapForm = obj.function_value();
26508 }
26509 else if ( obj.is_string() )
26510 {
26511 nameMapForm = obj.string_value();
26512 fcnMapForm = NULL;
26513 }
26514 arg1 = mapform_octave;
26515 }
26516 else
26517 {
26518 arg1 = NULL;
26519 }
26520 }
26521 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26522 if (!SWIG_IsOK(res2)) {
26523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26524 }
26525 arg2 = reinterpret_cast< char * >(buf2);
26526 ecode3 = SWIG_AsVal_double(args(2), &val3);
26527 if (!SWIG_IsOK(ecode3)) {
26528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26529 }
26530 arg3 = static_cast< PLFLT >(val3);
26531 ecode4 = SWIG_AsVal_double(args(3), &val4);
26532 if (!SWIG_IsOK(ecode4)) {
26533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26534 }
26535 arg4 = static_cast< PLFLT >(val4);
26536 ecode5 = SWIG_AsVal_double(args(4), &val5);
26537 if (!SWIG_IsOK(ecode5)) {
26538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26539 }
26540 arg5 = static_cast< PLFLT >(val5);
26541 ecode6 = SWIG_AsVal_double(args(5), &val6);
26542 if (!SWIG_IsOK(ecode6)) {
26543 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26544 }
26545 arg6 = static_cast< PLFLT >(val6);
26546 {
26547 if ( _n_dims( args(6) ) > 1 )
26548 {
26549 error( "argument must be a scalar or vector" ); SWIG_fail;
26550 }
26551#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26552 if ( !args(6).isempty() )
26553#else
26554 if ( !args(6).is_empty() )
26555#endif
26556 {
26557 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26558 temp7 = args(6).matrix_value();
26559 arg7 = new PLINT[arg8];
26560 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26561 }
26562 else
26563 {
26564 arg7 = NULL;
26565 arg8 = 0;
26566 }
26567 }
26568 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26569 _outv = octave_value();
26570 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26571 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26572 {
26573 delete [] arg7;
26574 }
26575 return _out;
26576 fail:
26577 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26578 {
26579 delete [] arg7;
26580 }
26581 return octave_value_list();
26582 }
26583 catch(...) {
26584 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26585 {
26586 delete [] arg7;
26587 }
26588 throw;
26589 }
26590}
26591
26592
26594 mapform_func arg1 = (mapform_func) 0 ;
26595 PLFLT arg2 ;
26596 PLFLT arg3 ;
26597 PLFLT arg4 ;
26598 PLFLT arg5 ;
26599 PLFLT arg6 ;
26600 PLFLT arg7 ;
26601 double val2 ;
26602 int ecode2 = 0 ;
26603 double val3 ;
26604 int ecode3 = 0 ;
26605 double val4 ;
26606 int ecode4 = 0 ;
26607 double val5 ;
26608 int ecode5 = 0 ;
26609 double val6 ;
26610 int ecode6 = 0 ;
26611 double val7 ;
26612 int ecode7 = 0 ;
26613 octave_value_list _out;
26614 octave_value_list *_outp=&_out;
26615 octave_value _outv;
26616
26617 try {
26618 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26619 SWIG_fail;
26620 }
26621 {
26622 octave_value obj = args(0);
26623#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26624 if ( !obj.isempty() )
26625#else
26626 if ( !obj.is_empty() )
26627#endif
26628 {
26629 if ( obj.is_function_handle() || obj.is_inline_function() )
26630 {
26631 fcnMapForm = obj.function_value();
26632 }
26633 else if ( obj.is_string() )
26634 {
26635 nameMapForm = obj.string_value();
26636 fcnMapForm = NULL;
26637 }
26638 arg1 = mapform_octave;
26639 }
26640 else
26641 {
26642 arg1 = NULL;
26643 }
26644 }
26645 ecode2 = SWIG_AsVal_double(args(1), &val2);
26646 if (!SWIG_IsOK(ecode2)) {
26647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26648 }
26649 arg2 = static_cast< PLFLT >(val2);
26650 ecode3 = SWIG_AsVal_double(args(2), &val3);
26651 if (!SWIG_IsOK(ecode3)) {
26652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26653 }
26654 arg3 = static_cast< PLFLT >(val3);
26655 ecode4 = SWIG_AsVal_double(args(3), &val4);
26656 if (!SWIG_IsOK(ecode4)) {
26657 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26658 }
26659 arg4 = static_cast< PLFLT >(val4);
26660 ecode5 = SWIG_AsVal_double(args(4), &val5);
26661 if (!SWIG_IsOK(ecode5)) {
26662 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26663 }
26664 arg5 = static_cast< PLFLT >(val5);
26665 ecode6 = SWIG_AsVal_double(args(5), &val6);
26666 if (!SWIG_IsOK(ecode6)) {
26667 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26668 }
26669 arg6 = static_cast< PLFLT >(val6);
26670 ecode7 = SWIG_AsVal_double(args(6), &val7);
26671 if (!SWIG_IsOK(ecode7)) {
26672 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26673 }
26674 arg7 = static_cast< PLFLT >(val7);
26675 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26676 _outv = octave_value();
26677 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26678 return _out;
26679 fail:
26680 return octave_value_list();
26681 }
26682 catch(...) {
26683 throw;
26684 }
26685}
26686
26687
26689 octave_value_list _out;
26690 octave_value_list *_outp=&_out;
26691 octave_value _outv;
26692
26693 try {
26694 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26695 SWIG_fail;
26696 }
26697 plClearOpts();
26698 _outv = octave_value();
26699 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26700 return _out;
26701 fail:
26702 return octave_value_list();
26703 }
26704 catch(...) {
26705 throw;
26706 }
26707}
26708
26709
26711 octave_value_list _out;
26712 octave_value_list *_outp=&_out;
26713 octave_value _outv;
26714
26715 try {
26716 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26717 SWIG_fail;
26718 }
26719 plResetOpts();
26720 _outv = octave_value();
26721 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26722 return _out;
26723 fail:
26724 return octave_value_list();
26725 }
26726 catch(...) {
26727 throw;
26728 }
26729}
26730
26731
26733 char *arg1 = (char *) 0 ;
26734 char *arg2 = (char *) 0 ;
26735 int res1 ;
26736 char *buf1 = 0 ;
26737 int alloc1 = 0 ;
26738 int res2 ;
26739 char *buf2 = 0 ;
26740 int alloc2 = 0 ;
26741 octave_value_list _out;
26742 octave_value_list *_outp=&_out;
26743 octave_value _outv;
26744
26745 try {
26746 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26747 SWIG_fail;
26748 }
26749 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26750 if (!SWIG_IsOK(res1)) {
26751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26752 }
26753 arg1 = reinterpret_cast< char * >(buf1);
26754 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26755 if (!SWIG_IsOK(res2)) {
26756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26757 }
26758 arg2 = reinterpret_cast< char * >(buf2);
26759 plSetUsage((char const *)arg1,(char const *)arg2);
26760 _outv = octave_value();
26761 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26762 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26763 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26764 return _out;
26765 fail:
26766 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26767 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26768 return octave_value_list();
26769 }
26770 catch(...) {
26771 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26772 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26773 throw;
26774 }
26775}
26776
26777
26779 octave_value_list _out;
26780 octave_value_list *_outp=&_out;
26781 octave_value _outv;
26782
26783 try {
26784 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26785 SWIG_fail;
26786 }
26787 plOptUsage();
26788 _outv = octave_value();
26789 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26790 return _out;
26791 fail:
26792 return octave_value_list();
26793 }
26794 catch(...) {
26795 throw;
26796 }
26797}
26798
26799
26800
26801static const struct swig_octave_member swig_globals[] = {
26802{"testppchar",_wrap_testppchar,0,0,2,0},
26803{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26804{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26805{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26806{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26807{"plcont0",_wrap_plcont0,0,0,2,0},
26808{"plcont1",_wrap_plcont1,0,0,2,0},
26809{"plcont2",_wrap_plcont2,0,0,2,0},
26810{"plcont2p",_wrap_plcont2p,0,0,2,0},
26811{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26812{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26813{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26814{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26815{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26816{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26817{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26818{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26819{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26820{"plshade1",_wrap_plshade1,0,0,2,0},
26821{"plshade2",_wrap_plshade2,0,0,2,0},
26822{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26823{"plshadesx",_wrap_plshadesx,0,0,2,0},
26824{"plshades1",_wrap_plshades1,0,0,2,0},
26825{"plshades2",_wrap_plshades2,0,0,2,0},
26826{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26827{"plvect1",_wrap_plvect1,0,0,2,0},
26828{"plvect2",_wrap_plvect2,0,0,2,0},
26829{"pplimage",_wrap_pplimage,0,0,2,0},
26830{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26831{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26832{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26833{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26834{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26835{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26836{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26837{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26838{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26839{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26840{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26841{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26842{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26843{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26844{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26845{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26846{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26847{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26848{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26849{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26850{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26851{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26852{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26853{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26854{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26855{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26856{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26857{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26858{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26859{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26860{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26863{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26864{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26865{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26866{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26867{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26868{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26869{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26870{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26871{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26872{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26873{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26874{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26875{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26876{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26877{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26878{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26879{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26880{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26881{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26882{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26883{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26884{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26885{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26886{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26887{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26888{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26889{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26890{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26891{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26892{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26893{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26894{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26895{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26896{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26897{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26898{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26899{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26900{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26901{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26902{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26903{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26904{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26905{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26906{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26907{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26908{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26909{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26910{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26911{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26912{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26913{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26914{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26915{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26916{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26917{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26918{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26919{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26920{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26921{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26922{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26923{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26924{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26925{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26926{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26927{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26928{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26929{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26930{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26931{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26932{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26933{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26934{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26935{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26936{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26937{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26938{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26939{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26940{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26941{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26942{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26943{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26944{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26945{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26946{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26947{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26948{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26949{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26950{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26951{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26952{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26953{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26954{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26955{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26956{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26957{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26958{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26959{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26960{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26961{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26962{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26963{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26964{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26965{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26966{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26967{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26968{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26969{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26970{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26971{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26972{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26973{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26974{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26975{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26976{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26977{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26978{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26979{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26980{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26981{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26982{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26983{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26984{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26985{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26986{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26987{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26988{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26989{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26990{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26991{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26992{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26993{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26994{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26995{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26996{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26997{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26998{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26999{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
27000{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
27001{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
27002{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
27003{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
27004{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
27005{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
27006{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
27007{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
27008{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
27009{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
27010{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
27011{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
27012{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
27013{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
27014{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
27015{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
27016{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
27017{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
27018{0,0,0,0,0,0}
27019};
27020
27021/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
27022
27023static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
27024static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
27025static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
27026static 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};
27027static 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};
27028static 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};
27029static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
27030static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
27031static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
27032
27044
27045static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
27046static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
27047static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
27051static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
27052static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
27053static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
27054
27066
27067
27068/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
27069
27070/* -----------------------------------------------------------------------------
27071 * Type initialization:
27072 * This problem is tough by the requirement that no dynamic
27073 * memory is used. Also, since swig_type_info structures store pointers to
27074 * swig_cast_info structures and swig_cast_info structures store pointers back
27075 * to swig_type_info structures, we need some lookup code at initialization.
27076 * The idea is that swig generates all the structures that are needed.
27077 * The runtime then collects these partially filled structures.
27078 * The SWIG_InitializeModule function takes these initial arrays out of
27079 * swig_module, and does all the lookup, filling in the swig_module.types
27080 * array with the correct data and linking the correct swig_cast_info
27081 * structures together.
27082 *
27083 * The generated swig_type_info structures are assigned statically to an initial
27084 * array. We just loop through that array, and handle each type individually.
27085 * First we lookup if this type has been already loaded, and if so, use the
27086 * loaded structure instead of the generated one. Then we have to fill in the
27087 * cast linked list. The cast data is initially stored in something like a
27088 * two-dimensional array. Each row corresponds to a type (there are the same
27089 * number of rows as there are in the swig_type_initial array). Each entry in
27090 * a column is one of the swig_cast_info structures for that type.
27091 * The cast_initial array is actually an array of arrays, because each row has
27092 * a variable number of columns. So to actually build the cast linked list,
27093 * we find the array of casts associated with the type, and loop through it
27094 * adding the casts to the list. The one last trick we need to do is making
27095 * sure the type pointer in the swig_cast_info struct is correct.
27096 *
27097 * First off, we lookup the cast->type name to see if it is already loaded.
27098 * There are three cases to handle:
27099 * 1) If the cast->type has already been loaded AND the type we are adding
27100 * casting info to has not been loaded (it is in this module), THEN we
27101 * replace the cast->type pointer with the type pointer that has already
27102 * been loaded.
27103 * 2) If BOTH types (the one we are adding casting info to, and the
27104 * cast->type) are loaded, THEN the cast info has already been loaded by
27105 * the previous module so we just ignore it.
27106 * 3) Finally, if cast->type has not already been loaded, then we add that
27107 * swig_cast_info to the linked list (because the cast->type) pointer will
27108 * be correct.
27109 * ----------------------------------------------------------------------------- */
27110
27111#ifdef __cplusplus
27112extern "C" {
27113#if 0
27114} /* c-mode */
27115#endif
27116#endif
27117
27118#if 0
27119#define SWIGRUNTIME_DEBUG
27120#endif
27121
27122#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27123#define SWIG_INIT_CLIENT_DATA_TYPE void *
27124#endif
27125
27126SWIGRUNTIME void
27128 size_t i;
27129 swig_module_info *module_head, *iter;
27130 int init;
27131
27132 /* check to see if the circular list has been setup, if not, set it up */
27133 if (swig_module.next==0) {
27134 /* Initialize the swig_module */
27138 init = 1;
27139 } else {
27140 init = 0;
27141 }
27142
27143 /* Try and load any already created modules */
27144 module_head = SWIG_GetModule(clientdata);
27145 if (!module_head) {
27146 /* This is the first module loaded for this interpreter */
27147 /* so set the swig module into the interpreter */
27148 SWIG_SetModule(clientdata, &swig_module);
27149 } else {
27150 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27151 iter=module_head;
27152 do {
27153 if (iter==&swig_module) {
27154 /* Our module is already in the list, so there's nothing more to do. */
27155 return;
27156 }
27157 iter=iter->next;
27158 } while (iter!= module_head);
27159
27160 /* otherwise we must add our module into the list */
27161 swig_module.next = module_head->next;
27162 module_head->next = &swig_module;
27163 }
27164
27165 /* When multiple interpreters are used, a module could have already been initialized in
27166 a different interpreter, but not yet have a pointer in this interpreter.
27167 In this case, we do not want to continue adding types... everything should be
27168 set up already */
27169 if (init == 0) return;
27170
27171 /* Now work on filling in swig_module.types */
27172#ifdef SWIGRUNTIME_DEBUG
27173 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27174#endif
27175 for (i = 0; i < swig_module.size; ++i) {
27176 swig_type_info *type = 0;
27177 swig_type_info *ret;
27178 swig_cast_info *cast;
27179
27180#ifdef SWIGRUNTIME_DEBUG
27181 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27182#endif
27183
27184 /* if there is another module already loaded */
27185 if (swig_module.next != &swig_module) {
27187 }
27188 if (type) {
27189 /* Overwrite clientdata field */
27190#ifdef SWIGRUNTIME_DEBUG
27191 printf("SWIG_InitializeModule: found type %s\n", type->name);
27192#endif
27194 type->clientdata = swig_module.type_initial[i]->clientdata;
27195#ifdef SWIGRUNTIME_DEBUG
27196 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27197#endif
27198 }
27199 } else {
27200 type = swig_module.type_initial[i];
27201 }
27202
27203 /* Insert casting types */
27204 cast = swig_module.cast_initial[i];
27205 while (cast->type) {
27206
27207 /* Don't need to add information already in the list */
27208 ret = 0;
27209#ifdef SWIGRUNTIME_DEBUG
27210 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27211#endif
27212 if (swig_module.next != &swig_module) {
27214#ifdef SWIGRUNTIME_DEBUG
27215 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27216#endif
27217 }
27218 if (ret) {
27219 if (type == swig_module.type_initial[i]) {
27220#ifdef SWIGRUNTIME_DEBUG
27221 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27222#endif
27223 cast->type = ret;
27224 ret = 0;
27225 } else {
27226 /* Check for casting already in the list */
27227 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27228#ifdef SWIGRUNTIME_DEBUG
27229 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27230#endif
27231 if (!ocast) ret = 0;
27232 }
27233 }
27234
27235 if (!ret) {
27236#ifdef SWIGRUNTIME_DEBUG
27237 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27238#endif
27239 if (type->cast) {
27240 type->cast->prev = cast;
27241 cast->next = type->cast;
27242 }
27243 type->cast = cast;
27244 }
27245 cast++;
27246 }
27247 /* Set entry in modules->types array equal to the type */
27248 swig_module.types[i] = type;
27249 }
27250 swig_module.types[i] = 0;
27251
27252#ifdef SWIGRUNTIME_DEBUG
27253 printf("**** SWIG_InitializeModule: Cast List ******\n");
27254 for (i = 0; i < swig_module.size; ++i) {
27255 int j = 0;
27257 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27258 while (cast->type) {
27259 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27260 cast++;
27261 ++j;
27262 }
27263 printf("---- Total casts: %d\n",j);
27264 }
27265 printf("**** SWIG_InitializeModule: Cast List ******\n");
27266#endif
27267}
27268
27269/* This function will propagate the clientdata field of type to
27270* any new swig_type_info structures that have been added into the list
27271* of equivalent types. It is like calling
27272* SWIG_TypeClientData(type, clientdata) a second time.
27273*/
27274SWIGRUNTIME void
27276 size_t i;
27277 swig_cast_info *equiv;
27278 static int init_run = 0;
27279
27280 if (init_run) return;
27281 init_run = 1;
27282
27283 for (i = 0; i < swig_module.size; i++) {
27284 if (swig_module.types[i]->clientdata) {
27285 equiv = swig_module.types[i]->cast;
27286 while (equiv) {
27287 if (!equiv->converter) {
27288 if (equiv->type && !equiv->type->clientdata)
27290 }
27291 equiv = equiv->next;
27292 }
27293 }
27294 }
27295}
27296
27297#ifdef __cplusplus
27298#if 0
27299{ /* c-mode */
27300#endif
27301}
27302#endif
27303
27304
27305
27306static bool SWIG_init_user(octave_swig_type* module_ns);
27307
27309 bool retn = false;
27310 {
27311#if SWIG_OCTAVE_PREREQ(6,0,0)
27312#elif SWIG_OCTAVE_PREREQ(4,2,0)
27313 octave::unwind_protect frame;
27314 frame.protect_var(discard_error_messages); discard_error_messages = true;
27315 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27316#elif SWIG_OCTAVE_PREREQ(3,3,50)
27317 unwind_protect frame;
27318 frame.protect_var(error_state); error_state = 0;
27319 frame.protect_var(warning_state); warning_state = 0;
27320 frame.protect_var(discard_error_messages); discard_error_messages = true;
27321 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27322#else
27323 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27324 unwind_protect_int(error_state); error_state = 0;
27325 unwind_protect_int(warning_state); warning_state = 0;
27326 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27327 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27328#endif
27329#if SWIG_OCTAVE_PREREQ(4,2,0)
27330 try {
27331#if SWIG_OCTAVE_PREREQ(4,4,0)
27332 octave::feval(name, octave_value_list(), 0);
27333#else
27334 feval(name, octave_value_list(), 0);
27335#endif
27336 retn = true;
27337 } catch (octave::execution_exception&) { }
27338#else
27339 feval(name, octave_value_list(), 0);
27340 retn = (error_state == 0);
27341#endif
27342#if !SWIG_OCTAVE_PREREQ(3,3,50)
27343 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27344#endif
27345 }
27346 if (!retn) {
27347 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27348 }
27349 return retn;
27350}
27351
27352SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27353 bool retn = false;
27354 {
27355#if SWIG_OCTAVE_PREREQ(6,0,0)
27356#elif SWIG_OCTAVE_PREREQ(4,2,0)
27357 octave::unwind_protect frame;
27358 frame.protect_var(discard_error_messages); discard_error_messages = true;
27359 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27360#elif SWIG_OCTAVE_PREREQ(3,3,50)
27361 unwind_protect frame;
27362 frame.protect_var(error_state); error_state = 0;
27363 frame.protect_var(warning_state); warning_state = 0;
27364 frame.protect_var(discard_error_messages); discard_error_messages = true;
27365 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27366#else
27367 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27368 unwind_protect_int(error_state); error_state = 0;
27369 unwind_protect_int(warning_state); warning_state = 0;
27370 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27371 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27372#endif
27373 octave_value_list args;
27374 args.append(name);
27375 args.append(octloadfcn->fcn_file_name());
27376#if SWIG_OCTAVE_PREREQ(4,2,0)
27377 try {
27378#if SWIG_OCTAVE_PREREQ(4,4,0)
27379 octave::feval("autoload", args, 0);
27380#else
27381 feval("autoload", args, 0);
27382#endif
27383 retn = true;
27384 } catch (octave::execution_exception&) { }
27385#else
27386 feval("autoload", args, 0);
27387 retn = (error_state == 0);
27388#endif
27389#if !SWIG_OCTAVE_PREREQ(3,3,50)
27390 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27391#endif
27392 }
27393 if (!retn) {
27394 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27395 }
27396 return retn;
27397}
27398
27399static const char *const subclass_usage = "-*- texinfo -*- \n\
27400@deftypefn {Loadable Function} {} subclass()\n\
27401@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27402Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27403\n\
27404See the SWIG manual for usage examples.\n\
27405@end deftypefn";
27406
27407DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27409 for (int j = 0; j < args.length(); ++j) {
27410 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27411 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27412 octave_swig_type *ost = osr->get_ptr();
27413 if (!ost->is_owned()) {
27414 error("subclass: cannot subclass object not constructed on octave side");
27415 return octave_value_list();
27416 }
27417 top->merge(*ost);
27418 } else if (args(j).is_function_handle()) {
27419 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27420 } else if (args(j).is_string()) {
27421 if (j + 1 >= args.length()) {
27422 error("subclass: member assignments must be of string,value form");
27423 return octave_value_list();
27424 }
27425 top->assign(args(j).string_value(), args(j + 1));
27426 ++j;
27427 } else {
27428 error("subclass: invalid arguments to subclass()");
27429 return octave_value_list();
27430 }
27431 }
27432 return octave_value(Swig::swig_value_ref(top));
27433}
27434
27435static const char *const swig_type_usage = "-*- texinfo -*- \n\
27436@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27437Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27438@end deftypefn";
27439
27440DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27441 if (args.length() != 1) {
27442 error("swig_type: must be called with only a single object");
27443 return octave_value_list();
27444 }
27446 if (!ost) {
27447 error("swig_type: object is not a swig_ref");
27448 return octave_value_list();
27449 }
27450 return octave_value(ost->swig_type_name());
27451}
27452
27453static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27454@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27455Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27456otherwise return `<unknown>'.\n\
27457@end deftypefn";
27458
27459DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27460 if (args.length() != 1 || !args(0).is_string()) {
27461 error("swig_typequery: must be called with single string argument");
27462 return octave_value_list();
27463 }
27464 swig_module_info *module = SWIG_GetModule(0);
27465 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27466 if (!type)
27467 return octave_value("<unknown>");
27468 return octave_value(type->name);
27469}
27470
27471static const char *const swig_this_usage = "-*- texinfo -*- \n\
27472@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27473Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27474@end deftypefn";
27475
27476DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27477 if (args.length() != 1) {
27478 error("swig_this: must be called with only a single object");
27479 return octave_value_list();
27480 }
27481 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27482 return octave_value(octave_uint64(0));
27484 if (!ost) {
27485 error("swig_this: object is not a swig_ref");
27486 return octave_value_list();
27487 }
27488 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27489}
27490
27491static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27492@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27493Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27494@end deftypefn";
27495
27496DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27497 if (args.length() != 3) {
27498 error("swig_octave_prereq: must be called with 3 arguments");
27499 return octave_value_list();
27500 }
27501 const int major = args(0).int_value();
27502 const int minor = args(1).int_value();
27503 const int patch = args(2).int_value();
27504 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27505 return octave_value(prereq);
27506}
27507
27508static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27509@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27510Exit Octave without performing any memory cleanup.\n\
27511@end deftypefn";
27512
27513DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27514 if (args.length() > 1) {
27515 error("swig_exit: must be called with at most one arguments");
27516 return octave_value_list();
27517 }
27518 int exit_status = 0;
27519 if (args.length() == 1) {
27520 exit_status = args(0).int_value();
27521 }
27522 ::_Exit(exit_status);
27523 return octave_value();
27524}
27525
27526static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27527@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27528Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27529@end deftypefn";
27530
27532
27533 static octave_swig_type* module_ns = 0;
27534
27535 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27536 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27537 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27538 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27539 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27540 // can be turned off with macro definition.
27541#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27542#if !SWIG_OCTAVE_PREREQ(4,4,0)
27543#if SWIG_OCTAVE_PREREQ(3,2,0)
27544 octave_exit = ::_Exit;
27545#endif
27546#endif
27547#endif
27548
27549 // check for no input and output args
27550 if (args.length() != 0 || nargout != 0) {
27551 print_usage();
27552 return octave_value_list();
27553 }
27554
27555 // create module on first function call
27556 if (!module_ns) {
27557
27558 // workaround bug in octave where installing global variable of custom type and then
27559 // exiting without explicitly clearing the variable causes octave to segfault.
27560#if SWIG_OCTAVE_PREREQ(3,2,0)
27561 octave_value_list eval_args;
27562 eval_args.append("base");
27563 eval_args.append("function __swig_atexit__; "
27564 " if mislocked() "
27565 " clear -all; "
27566 " else "
27567 " mlock(); "
27568 " endif; "
27569 "endfunction; "
27570 "__swig_atexit__; "
27571 "atexit(\"__swig_atexit__\", false); "
27572 "atexit(\"__swig_atexit__\")");
27573#if SWIG_OCTAVE_PREREQ(4,4,0)
27574 octave::feval("evalin", eval_args, 0);
27575#else
27576 feval("evalin", eval_args, 0);
27577#endif
27578#endif
27579
27580#if SWIG_OCTAVE_PREREQ(4,4,0)
27581 {
27582 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27583 string_vector types = typeinfo.installed_type_names();
27584 bool register_octave_swig_ref = true;
27585 bool register_octave_swig_packed = true;
27586 for (int i = 0; i < types.numel(); ++i) {
27587 if (types(i) == octave_swig_ref::static_type_name()) {
27588 register_octave_swig_ref = false;
27589 octave_swig_ref::set_type_id(i);
27590 }
27591 if (types(i) == octave_swig_packed::static_type_name()) {
27592 register_octave_swig_packed = false;
27593 octave_swig_packed::set_type_id(i);
27594 }
27595 }
27596 if (register_octave_swig_ref) {
27597 octave_swig_ref::register_type();
27598 }
27599 if (register_octave_swig_packed) {
27600 octave_swig_packed::register_type();
27601 }
27602 }
27603#else
27604 octave_swig_ref::register_type();
27605 octave_swig_packed::register_type();
27606#endif
27609
27610#if SWIG_OCTAVE_PREREQ(8,0,0)
27611 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27612 octave_function *me = tree_eval.current_function();
27613#elif SWIG_OCTAVE_PREREQ(6,0,0)
27614 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27615 octave::call_stack& stack = tree_eval.get_call_stack();
27616 octave_function *me = stack.current_function();
27617#elif SWIG_OCTAVE_PREREQ(4,4,0)
27618 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27619 octave_function *me = stack.current();
27620#else
27621 octave_function *me = octave_call_stack::current();
27622#endif
27623
27624 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27625 return octave_value_list();
27626 }
27627 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27628 return octave_value_list();
27629 }
27630 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27631 return octave_value_list();
27632 }
27633 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27634 return octave_value_list();
27635 }
27636 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27637 return octave_value_list();
27638 }
27639 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27640 return octave_value_list();
27641 }
27642
27643 octave_swig_type* cvar_ns=0;
27644 if (std::string(SWIG_global_name) != ".") {
27645 cvar_ns=new octave_swig_type;
27646 for (int j=0;swig_globals[j].name;++j)
27647 if (swig_globals[j].get_method)
27648 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27649 }
27650
27651 module_ns=new octave_swig_type(0, 0, 0, true);
27652 if (std::string(SWIG_global_name) != ".") {
27653 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27654 }
27655 else {
27656 for (int j=0;swig_globals[j].name;++j)
27657 if (swig_globals[j].get_method)
27658 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27659 }
27660 for (int j=0;swig_globals[j].name;++j)
27661 if (swig_globals[j].method)
27662 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27663
27664 // * need better solution here; swig_type -> octave_class mapping is
27665 // * really n-to-1, in some cases such as template partial spec, etc.
27666 // * see failing tests.
27667 for (int j=0;swig_types[j];++j)
27668 if (swig_types[j]->clientdata) {
27670 module_ns->assign(c->name,
27672 (new octave_swig_type(0,swig_types[j])));
27673 }
27674
27675 if (!SWIG_init_user(module_ns)) {
27676 delete module_ns;
27677 module_ns=0;
27678 return octave_value_list();
27679 }
27680
27681 SWIG_InstallOps(octave_swig_ref::static_type_id());
27682
27684 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27685 if (mb->second.first && mb->second.first->method) {
27686 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27687 return octave_value_list();
27688 }
27689 }
27690 }
27691
27692#if SWIG_OCTAVE_PREREQ(4,4,0)
27693 octave::interpreter::the_interpreter()->mlock();
27694#elif SWIG_OCTAVE_PREREQ(3,2,0)
27695 mlock();
27696#else
27697 mlock(me->name());
27698#endif
27699
27700 }
27701
27703 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27704 if (mb->second.second.is_defined()) {
27705 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27706 SWIG_Octave_LinkGlobalValue(mb->first);
27707 }
27708 }
27709
27712
27713 return octave_value_list();
27714
27715}
27716
27717
27718static bool SWIG_init_user(octave_swig_type* module_ns)
27719{
27720 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27721 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27722 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27723 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27724 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27725 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27726 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27727 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27728 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27729 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27730 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27731 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27732 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27733 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27734 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27735 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27736 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27737 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27738 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27739 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27740 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27741 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27742 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27743 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27744 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27745 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27746 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27747 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27748 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27749 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27750 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27751 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27752 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27753 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27754 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27755 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27756 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27757 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27758 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27759 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27760 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27761 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27762 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27763 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27764 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27765 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27766 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27767 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27768 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27769 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27770 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27771 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27772 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27773 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27774 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27775 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27811 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27812 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27813 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27814 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27815 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27816 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27817 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27818 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27819 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27820 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27821 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27822 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27823 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27824 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27825 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27826 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27827 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27828 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27829 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27830 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27831 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27832 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27833 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27834 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27835 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27836 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27837 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27838 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27839 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27840 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27841 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27842 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27843 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27844 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27845 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27846 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27847 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27848 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27849 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27850 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27851 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27852 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27853 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27854 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27855 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27856 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27857 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27858 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27859 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27860 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27861 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27862 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27863 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27864 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27865 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27866 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27867 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27868 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27869 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27870 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27871 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27872 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27873 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27874 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27875 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27876 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27877 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27878 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27879 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27880 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27881 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27882 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27883 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27884 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27885 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27886 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27887 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27888 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27889 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27890 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27891 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27892 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27893 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27894 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27895 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27896 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27897 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27898 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27899 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27900 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27901 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27902 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27903 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27904 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27905 return true;
27906}
27907
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