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.2.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040201
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
154/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
155 * if you're missing it.
156 */
157#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
158 (defined __cplusplus && __cplusplus >= 201103L) || \
159 defined SWIG_HAVE_SNPRINTF) && \
160 !defined SWIG_NO_SNPRINTF
161# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
162# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
163#else
164/* Fallback versions ignore the buffer size, but most of our uses either have a
165 * fixed maximum possible size or dynamically allocate a buffer that's large
166 * enough.
167 */
168# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
169# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
170#endif
171
172//
173// This header includes all C++ headers required for generated Octave wrapper code.
174// Using a single header file allows pre-compilation of Octave headers, as follows:
175// * Check out this header file:
176// swig -octave -co octheaders.hpp
177// * Pre-compile header file into octheaders.hpp.gch:
178// g++ -c ... octheaders.hpp
179// * Use pre-compiled header file:
180// g++ -c -include octheaders.hpp ...
181//
182
183#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
184#define SWIG_OCTAVE_OCTHEADERS_HPP
185
186// Required C++ headers
187#include <cstdlib>
188#include <climits>
189#include <iostream>
190#include <exception>
191#include <functional>
192#include <complex>
193#include <string>
194#include <vector>
195#include <map>
196
197// Minimal headers to define Octave version
198#include <octave/oct.h>
199#include <octave/version.h>
200
201// Macro for enabling features which require Octave version >= major.minor.patch
202// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
203#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
204 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
205
206// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
207#if !defined(OCTAVE_MAJOR_VERSION)
208
209# if !defined(OCTAVE_API_VERSION_NUMBER)
210
211// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
212// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
213# include <octave/ov.h>
214# if defined(octave_ov_h)
215# define OCTAVE_MAJOR_VERSION 3
216# define OCTAVE_MINOR_VERSION 8
217# define OCTAVE_PATCH_VERSION 0
218# else
219
220// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
221# define ComplexLU __ignore
222# include <octave/CmplxLU.h>
223# undef ComplexLU
224# if defined(octave_Complex_LU_h)
225
226// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
227# define OCTAVE_MAJOR_VERSION 3
228# define OCTAVE_MINOR_VERSION 1
229# define OCTAVE_PATCH_VERSION 99
230
231# else
232
233// OCTAVE_API_VERSION_NUMBER == 37
234# define OCTAVE_MAJOR_VERSION 3
235# define OCTAVE_MINOR_VERSION 2
236# define OCTAVE_PATCH_VERSION 0
237
238# endif // defined(octave_Complex_LU_h)
239
240# endif // defined(octave_ov_h)
241
242// Correlation between Octave API and version numbers extracted from Octave's
243// ChangeLogs; version is the *earliest* released Octave with that API number
244# elif OCTAVE_API_VERSION_NUMBER >= 48
245# define OCTAVE_MAJOR_VERSION 3
246# define OCTAVE_MINOR_VERSION 6
247# define OCTAVE_PATCH_VERSION 0
248
249# elif OCTAVE_API_VERSION_NUMBER >= 45
250# define OCTAVE_MAJOR_VERSION 3
251# define OCTAVE_MINOR_VERSION 4
252# define OCTAVE_PATCH_VERSION 1
253
254# elif OCTAVE_API_VERSION_NUMBER >= 42
255# define OCTAVE_MAJOR_VERSION 3
256# define OCTAVE_MINOR_VERSION 3
257# define OCTAVE_PATCH_VERSION 54
258
259# elif OCTAVE_API_VERSION_NUMBER >= 41
260# define OCTAVE_MAJOR_VERSION 3
261# define OCTAVE_MINOR_VERSION 3
262# define OCTAVE_PATCH_VERSION 53
263
264# elif OCTAVE_API_VERSION_NUMBER >= 40
265# define OCTAVE_MAJOR_VERSION 3
266# define OCTAVE_MINOR_VERSION 3
267# define OCTAVE_PATCH_VERSION 52
268
269# elif OCTAVE_API_VERSION_NUMBER >= 39
270# define OCTAVE_MAJOR_VERSION 3
271# define OCTAVE_MINOR_VERSION 3
272# define OCTAVE_PATCH_VERSION 51
273
274# else // OCTAVE_API_VERSION_NUMBER == 38
275# define OCTAVE_MAJOR_VERSION 3
276# define OCTAVE_MINOR_VERSION 3
277# define OCTAVE_PATCH_VERSION 50
278
279# endif // !defined(OCTAVE_API_VERSION_NUMBER)
280
281#endif // !defined(OCTAVE_MAJOR_VERSION)
282
283// Required Octave headers
284#include <octave/Cell.h>
285#include <octave/dynamic-ld.h>
286#include <octave/oct-env.h>
287#include <octave/oct-map.h>
288#include <octave/ov-scalar.h>
289#include <octave/ov-fcn-handle.h>
290#include <octave/parse.h>
291#if SWIG_OCTAVE_PREREQ(4,2,0)
292#include <octave/interpreter.h>
293#else
294#include <octave/toplev.h>
295#endif
296#include <octave/unwind-prot.h>
297#if SWIG_OCTAVE_PREREQ(4,2,0)
298#include <octave/call-stack.h>
299#endif
300
301#endif // !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
302
303/* -----------------------------------------------------------------------------
304 * swigrun.swg
305 *
306 * This file contains generic C API SWIG runtime support for pointer
307 * type checking.
308 * ----------------------------------------------------------------------------- */
309
310/* This should only be incremented when either the layout of swig_type_info changes,
311 or for whatever reason, the runtime changes incompatibly */
312#define SWIG_RUNTIME_VERSION "4"
313
314/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
315#ifdef SWIG_TYPE_TABLE
316# define SWIG_QUOTE_STRING(x) #x
317# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
318# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
319#else
320# define SWIG_TYPE_TABLE_NAME
321#endif
322
323/*
324 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
325 creating a static or dynamic library from the SWIG runtime code.
326 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
327
328 But only do this if strictly necessary, ie, if you have problems
329 with your compiler or suchlike.
330*/
331
332#ifndef SWIGRUNTIME
333# define SWIGRUNTIME SWIGINTERN
334#endif
335
336#ifndef SWIGRUNTIMEINLINE
337# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
338#endif
339
340/* Generic buffer size */
341#ifndef SWIG_BUFFER_SIZE
342# define SWIG_BUFFER_SIZE 1024
343#endif
344
345/* Flags for pointer conversions */
346#define SWIG_POINTER_DISOWN 0x1
347#define SWIG_CAST_NEW_MEMORY 0x2
348#define SWIG_POINTER_NO_NULL 0x4
349#define SWIG_POINTER_CLEAR 0x8
350#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
351
352/* Flags for new pointer objects */
353#define SWIG_POINTER_OWN 0x1
354
355
356/*
357 Flags/methods for returning states.
358
359 The SWIG conversion methods, as ConvertPtr, return an integer
360 that tells if the conversion was successful or not. And if not,
361 an error code can be returned (see swigerrors.swg for the codes).
362
363 Use the following macros/flags to set or process the returning
364 states.
365
366 In old versions of SWIG, code such as the following was usually written:
367
368 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
369 // success code
370 } else {
371 //fail code
372 }
373
374 Now you can be more explicit:
375
376 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
377 if (SWIG_IsOK(res)) {
378 // success code
379 } else {
380 // fail code
381 }
382
383 which is the same really, but now you can also do
384
385 Type *ptr;
386 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
387 if (SWIG_IsOK(res)) {
388 // success code
389 if (SWIG_IsNewObj(res) {
390 ...
391 delete *ptr;
392 } else {
393 ...
394 }
395 } else {
396 // fail code
397 }
398
399 I.e., now SWIG_ConvertPtr can return new objects and you can
400 identify the case and take care of the deallocation. Of course that
401 also requires SWIG_ConvertPtr to return new result values, such as
402
403 int SWIG_ConvertPtr(obj, ptr,...) {
404 if (<obj is ok>) {
405 if (<need new object>) {
406 *ptr = <ptr to new allocated object>;
407 return SWIG_NEWOBJ;
408 } else {
409 *ptr = <ptr to old object>;
410 return SWIG_OLDOBJ;
411 }
412 } else {
413 return SWIG_BADOBJ;
414 }
415 }
416
417 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
418 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
419 SWIG errors code.
420
421 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
422 allows returning the 'cast rank', for example, if you have this
423
424 int food(double)
425 int fooi(int);
426
427 and you call
428
429 food(1) // cast rank '1' (1 -> 1.0)
430 fooi(1) // cast rank '0'
431
432 just use the SWIG_AddCast()/SWIG_CheckState()
433*/
434
435#define SWIG_OK (0)
436/* Runtime errors are < 0 */
437#define SWIG_ERROR (-1)
438/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
439/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
440/* Errors < -200 are generic runtime specific errors */
441#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
442
443#define SWIG_IsOK(r) (r >= 0)
444#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
445
446/* The CastRankLimit says how many bits are used for the cast rank */
447#define SWIG_CASTRANKLIMIT (1 << 8)
448/* The NewMask denotes the object was created (using new/malloc) */
449#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
450/* The TmpMask is for in/out typemaps that use temporary objects */
451#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
452/* Simple returning values */
453#define SWIG_BADOBJ (SWIG_ERROR)
454#define SWIG_OLDOBJ (SWIG_OK)
455#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
456#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
457/* Check, add and del object mask methods */
458#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
459#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
460#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
461#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
462#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
463#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
464
465/* Cast-Rank Mode */
466#if defined(SWIG_CASTRANK_MODE)
467# ifndef SWIG_TypeRank
468# define SWIG_TypeRank unsigned long
469# endif
470# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
471# define SWIG_MAXCASTRANK (2)
472# endif
473# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
474# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
476 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
477}
479 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
480}
481#else /* no cast-rank mode */
482# define SWIG_AddCast(r) (r)
483# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
484#endif
485
486
487#include <string.h>
488
489#ifdef __cplusplus
490extern "C" {
491#endif
492
493typedef void *(*swig_converter_func)(void *, int *);
494typedef struct swig_type_info *(*swig_dycast_func)(void **);
495
496/* Structure to store information on one type */
497typedef struct swig_type_info {
498 const char *name; /* mangled name of this type */
499 const char *str; /* human readable name of this type */
500 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
501 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
502 void *clientdata; /* language specific type data */
503 int owndata; /* flag if the structure owns the clientdata */
505
506/* Structure to store a type and conversion function used for casting */
507typedef struct swig_cast_info {
508 swig_type_info *type; /* pointer to type that is equivalent to this type */
509 swig_converter_func converter; /* function to cast the void pointers */
510 struct swig_cast_info *next; /* pointer to next cast in linked list */
511 struct swig_cast_info *prev; /* pointer to the previous cast */
513
514/* Structure used to store module information
515 * Each module generates one structure like this, and the runtime collects
516 * all of these structures and stores them in a circularly linked list.*/
517typedef struct swig_module_info {
518 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
519 size_t size; /* Number of types in this module */
520 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
521 swig_type_info **type_initial; /* Array of initially generated type structures */
522 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
523 void *clientdata; /* Language specific module data */
525
526/*
527 Compare two type names skipping the space characters, therefore
528 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
529
530 Return 0 when the two name types are equivalent, as in
531 strncmp, but skipping ' '.
532*/
533SWIGRUNTIME int
534SWIG_TypeNameComp(const char *f1, const char *l1,
535 const char *f2, const char *l2) {
536 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
537 while ((*f1 == ' ') && (f1 != l1)) ++f1;
538 while ((*f2 == ' ') && (f2 != l2)) ++f2;
539 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
540 }
541 return (int)((l1 - f1) - (l2 - f2));
542}
543
544/*
545 Check type equivalence in a name list like <name1>|<name2>|...
546 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
547*/
548SWIGRUNTIME int
549SWIG_TypeCmp(const char *nb, const char *tb) {
550 int equiv = 1;
551 const char* te = tb + strlen(tb);
552 const char* ne = nb;
553 while (equiv != 0 && *ne) {
554 for (nb = ne; *ne; ++ne) {
555 if (*ne == '|') break;
556 }
557 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
558 if (*ne) ++ne;
559 }
560 return equiv;
561}
562
563/*
564 Check type equivalence in a name list like <name1>|<name2>|...
565 Return 0 if not equal, 1 if equal
566*/
567SWIGRUNTIME int
568SWIG_TypeEquiv(const char *nb, const char *tb) {
569 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
570}
571
572/*
573 Check the typename
574*/
576SWIG_TypeCheck(const char *c, swig_type_info *ty) {
577 if (ty) {
578 swig_cast_info *iter = ty->cast;
579 while (iter) {
580 if (strcmp(iter->type->name, c) == 0) {
581 if (iter == ty->cast)
582 return iter;
583 /* Move iter to the top of the linked list */
584 iter->prev->next = iter->next;
585 if (iter->next)
586 iter->next->prev = iter->prev;
587 iter->next = ty->cast;
588 iter->prev = 0;
589 if (ty->cast) ty->cast->prev = iter;
590 ty->cast = iter;
591 return iter;
592 }
593 iter = iter->next;
594 }
595 }
596 return 0;
597}
598
599/*
600 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
601*/
604 if (ty) {
605 swig_cast_info *iter = ty->cast;
606 while (iter) {
607 if (iter->type == from) {
608 if (iter == ty->cast)
609 return iter;
610 /* Move iter to the top of the linked list */
611 iter->prev->next = iter->next;
612 if (iter->next)
613 iter->next->prev = iter->prev;
614 iter->next = ty->cast;
615 iter->prev = 0;
616 if (ty->cast) ty->cast->prev = iter;
617 ty->cast = iter;
618 return iter;
619 }
620 iter = iter->next;
621 }
622 }
623 return 0;
624}
625
626/*
627 Cast a pointer up an inheritance hierarchy
628*/
630SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
631 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
632}
633
634/*
635 Dynamic pointer casting. Down an inheritance hierarchy
636*/
639 swig_type_info *lastty = ty;
640 if (!ty || !ty->dcast) return ty;
641 while (ty && (ty->dcast)) {
642 ty = (*ty->dcast)(ptr);
643 if (ty) lastty = ty;
644 }
645 return lastty;
646}
647
648/*
649 Return the name associated with this type
650*/
651SWIGRUNTIMEINLINE const char *
653 return ty->name;
654}
655
656/*
657 Return the pretty name associated with this type,
658 that is an unmangled type name in a form presentable to the user.
659*/
660SWIGRUNTIME const char *
662 /* The "str" field contains the equivalent pretty names of the
663 type, separated by vertical-bar characters. Choose the last
664 name. It should be the most specific; a fully resolved name
665 but not necessarily with default template parameters expanded. */
666 if (!type) return NULL;
667 if (type->str != NULL) {
668 const char *last_name = type->str;
669 const char *s;
670 for (s = type->str; *s; s++)
671 if (*s == '|') last_name = s+1;
672 return last_name;
673 }
674 else
675 return type->name;
676}
677
678/*
679 Set the clientdata field for a type
680*/
681SWIGRUNTIME void
683 swig_cast_info *cast = ti->cast;
684 /* if (ti->clientdata == clientdata) return; */
686
687 while (cast) {
688 if (!cast->converter) {
689 swig_type_info *tc = cast->type;
690 if (!tc->clientdata) {
692 }
693 }
694 cast = cast->next;
695 }
696}
697SWIGRUNTIME void
702
703/*
704 Search for a swig_type_info structure only by mangled name
705 Search is a O(log #types)
706
707 We start searching at module start, and finish searching when start == end.
708 Note: if start == end at the beginning of the function, we go all the way around
709 the circular list.
710*/
713 swig_module_info *end,
714 const char *name) {
715 swig_module_info *iter = start;
716 do {
717 if (iter->size) {
718 size_t l = 0;
719 size_t r = iter->size - 1;
720 do {
721 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
722 size_t i = (l + r) >> 1;
723 const char *iname = iter->types[i]->name;
724 if (iname) {
725 int compare = strcmp(name, iname);
726 if (compare == 0) {
727 return iter->types[i];
728 } else if (compare < 0) {
729 if (i) {
730 r = i - 1;
731 } else {
732 break;
733 }
734 } else if (compare > 0) {
735 l = i + 1;
736 }
737 } else {
738 break; /* should never happen */
739 }
740 } while (l <= r);
741 }
742 iter = iter->next;
743 } while (iter != end);
744 return 0;
745}
746
747/*
748 Search for a swig_type_info structure for either a mangled name or a human readable name.
749 It first searches the mangled names of the types, which is a O(log #types)
750 If a type is not found it then searches the human readable names, which is O(#types).
751
752 We start searching at module start, and finish searching when start == end.
753 Note: if start == end at the beginning of the function, we go all the way around
754 the circular list.
755*/
758 swig_module_info *end,
759 const char *name) {
760 /* STEP 1: Search the name field using binary search */
762 if (ret) {
763 return ret;
764 } else {
765 /* STEP 2: If the type hasn't been found, do a complete search
766 of the str field (the human readable name) */
767 swig_module_info *iter = start;
768 do {
769 size_t i = 0;
770 for (; i < iter->size; ++i) {
771 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
772 return iter->types[i];
773 }
774 iter = iter->next;
775 } while (iter != end);
776 }
777
778 /* neither found a match */
779 return 0;
780}
781
782/*
783 Pack binary data into a string
784*/
785SWIGRUNTIME char *
786SWIG_PackData(char *c, void *ptr, size_t sz) {
787 static const char hex[17] = "0123456789abcdef";
788 const unsigned char *u = (unsigned char *) ptr;
789 const unsigned char *eu = u + sz;
790 for (; u != eu; ++u) {
791 unsigned char uu = *u;
792 *(c++) = hex[(uu & 0xf0) >> 4];
793 *(c++) = hex[uu & 0xf];
794 }
795 return c;
796}
797
798/*
799 Unpack binary data from a string
800*/
801SWIGRUNTIME const char *
802SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
803 unsigned char *u = (unsigned char *) ptr;
804 const unsigned char *eu = u + sz;
805 for (; u != eu; ++u) {
806 char d = *(c++);
807 unsigned char uu;
808 if ((d >= '0') && (d <= '9'))
809 uu = (unsigned char)((d - '0') << 4);
810 else if ((d >= 'a') && (d <= 'f'))
811 uu = (unsigned char)((d - ('a'-10)) << 4);
812 else
813 return (char *) 0;
814 d = *(c++);
815 if ((d >= '0') && (d <= '9'))
816 uu |= (unsigned char)(d - '0');
817 else if ((d >= 'a') && (d <= 'f'))
818 uu |= (unsigned char)(d - ('a'-10));
819 else
820 return (char *) 0;
821 *u = uu;
822 }
823 return c;
824}
825
826/*
827 Pack 'void *' into a string buffer.
828*/
829SWIGRUNTIME char *
830SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
831 char *r = buff;
832 if ((2*sizeof(void *) + 2) > bsz) return 0;
833 *(r++) = '_';
834 r = SWIG_PackData(r,&ptr,sizeof(void *));
835 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
836 strcpy(r,name);
837 return buff;
838}
839
840SWIGRUNTIME const char *
841SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
842 if (*c != '_') {
843 if (strcmp(c,"NULL") == 0) {
844 *ptr = (void *) 0;
845 return name;
846 } else {
847 return 0;
848 }
849 }
850 return SWIG_UnpackData(++c,ptr,sizeof(void *));
851}
852
853SWIGRUNTIME char *
854SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
855 char *r = buff;
856 size_t lname = (name ? strlen(name) : 0);
857 if ((2*sz + 2 + lname) > bsz) return 0;
858 *(r++) = '_';
859 r = SWIG_PackData(r,ptr,sz);
860 if (lname) {
861 strncpy(r,name,lname+1);
862 } else {
863 *r = 0;
864 }
865 return buff;
866}
867
868SWIGRUNTIME const char *
869SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
870 if (*c != '_') {
871 if (strcmp(c,"NULL") == 0) {
872 memset(ptr,0,sz);
873 return name;
874 } else {
875 return 0;
876 }
877 }
878 return SWIG_UnpackData(++c,ptr,sz);
879}
880
881#ifdef __cplusplus
882}
883#endif
884
885/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
886#define SWIG_UnknownError -1
887#define SWIG_IOError -2
888#define SWIG_RuntimeError -3
889#define SWIG_IndexError -4
890#define SWIG_TypeError -5
891#define SWIG_DivisionByZero -6
892#define SWIG_OverflowError -7
893#define SWIG_SyntaxError -8
894#define SWIG_ValueError -9
895#define SWIG_SystemError -10
896#define SWIG_AttributeError -11
897#define SWIG_MemoryError -12
898#define SWIG_NullReferenceError -13
899
900
901#if !SWIG_OCTAVE_PREREQ(3,2,0)
902#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
903#else
904#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
905#endif
906
907SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
908 if (num_args > max_args && !varargs)
909 error("function %s takes at most %i arguments", func_name, max_args);
910 else if (num_args < min_args)
911 error("function %s requires at least %i arguments", func_name, min_args);
912 else
913 return true;
914 return false;
915}
916
917SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
918 ovl->append(ov);
919 return ovl;
920}
921
922SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
923 switch (code) {
924 case SWIG_MemoryError:
925 return "SWIG_MemoryError";
926 case SWIG_IOError:
927 return "SWIG_IOError";
929 return "SWIG_RuntimeError";
930 case SWIG_IndexError:
931 return "SWIG_IndexError";
932 case SWIG_TypeError:
933 return "SWIG_TypeError";
935 return "SWIG_DivisionByZero";
937 return "SWIG_OverflowError";
938 case SWIG_SyntaxError:
939 return "SWIG_SyntaxError";
940 case SWIG_ValueError:
941 return "SWIG_ValueError";
942 case SWIG_SystemError:
943 return "SWIG_SystemError";
945 return "SWIG_AttributeError";
946 }
947 return "SWIG unknown error";
948}
949
950SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
951 octave_value type(SWIG_ErrorType(code));
952 std::string r = msg;
953 r += " (" + type.string_value() + ")";
954 error("%s", r.c_str());
955 return octave_value(r);
956}
957
958#define SWIG_fail goto fail
959
960#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
961#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
962#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
963#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
964#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
965#define swig_owntype int
966
967#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
968#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
969
970#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
971#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
972
973#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
974#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
975
976#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
977#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
978#define SWIG_MODULE_CLIENTDATA_TYPE void*
979
980#define Octave_Error_Occurred() 0
981#define SWIG_Octave_AddErrorMsg(msg) {;}
982
985
986// For backward compatibility only
987#define SWIG_POINTER_EXCEPTION 0
988#define SWIG_arg_fail(arg) 0
989
990// Runtime API implementation
991
992typedef octave_value_list(*octave_func) (const octave_value_list &, int);
993class octave_swig_type;
994
995namespace Swig {
996
997#ifdef SWIG_DIRECTORS
998
999 class Director;
1000
1001 typedef std::map < void *, Director * > rtdir_map;
1002 SWIGINTERN rtdir_map* get_rtdir_map();
1003 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
1004 SWIGINTERNINLINE void erase_rtdir(void *vptr);
1005 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
1006
1007 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
1008 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
1009 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
1010
1011#endif
1012
1013 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
1015 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
1016}
1017
1018#ifdef SWIG_DIRECTORS
1019SWIGRUNTIME void swig_acquire_ownership(void *vptr);
1020SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
1021SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
1022#endif
1023
1025 const char *name;
1029 int flags; // 1 static, 2 global
1030 const char *doc;
1031 bool is_static() const {
1032 return flags &1;
1033 } bool is_global() const {
1034 return flags &2;
1035 }
1036 };
1037
1049
1050#if SWIG_OCTAVE_PREREQ(4,4,0)
1051 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1052 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1053#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1054 class octave_swig_bound_func : public octave_function {
1055 public:
1056
1057 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1058 { }
1059
1060 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1061 : octave_function("", ""), method(_method), first_args(_first_args)
1062 { }
1063
1064 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1065
1066 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1067
1068 ~octave_swig_bound_func(void) = default;
1069
1070 bool is_function(void) const { return true; }
1071
1072 octave_function* function_value(bool = false) { return this; }
1073
1074#if SWIG_OCTAVE_PREREQ(6,0,0)
1075 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1076 return execute(tw,nargout,args);
1077 }
1078#endif
1079#if SWIG_OCTAVE_PREREQ(6,0,0)
1080 octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1081#else
1082 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1083#endif
1084 octave_value_list all_args;
1085 all_args.append(first_args);
1086 all_args.append(args);
1087 return method->call(tw, nargout, all_args);
1088 }
1089
1090 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1091 octave_value_list ovl = subsref(ops, idx, 1);
1092 return ovl.length() ? ovl(0) : octave_value();
1093 }
1094
1095 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1096 assert(ops.size() > 0);
1097 assert(ops.size() == idx.size());
1098 if (ops != "(")
1099 error("invalid function call");
1100 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1101 return call(tw, nargout, *idx.begin());
1102 }
1103
1104 protected:
1105
1106 octave_function* method;
1107 octave_value_list first_args;
1108
1109 std::set<std::string> dispatch_classes;
1110
1111 };
1112#else
1113#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1114#endif
1115
1116 // octave_swig_type plays the role of both the shadow class and the class
1117 // representation within Octave, since there is no support for classes.
1118 //
1119 // These should really be decoupled, with the class support added to Octave
1120 // and the shadow class given by an m-file script. That would dramatically
1121 // reduce the runtime complexity, and be more in line w/ other modules.
1122
1123 class octave_swig_type:public octave_base_value {
1124 struct cpp_ptr {
1125 void *ptr;
1127 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1128 }};
1129 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1130
1132
1133 const swig_type_info *construct_type; // type of special type object
1134 std::vector < type_ptr_pair > types; // our c++ base classes
1135 int thisown; // whether we call c++ destructors when we die
1136
1137 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1138 typedef std::map < std::string, member_value_pair > member_map;
1141
1142 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1143 if (!type->clientdata)
1144 return 0;
1145 swig_octave_class *c = (swig_octave_class *) type->clientdata;
1146 const swig_octave_member *m;
1147 for (m = c->members; m->name; ++m)
1148 if (m->name == name)
1149 return m;
1150 for (int j = 0; c->base_names[j]; ++j) {
1151 if (!c->base[j]) {
1152 if (!module)
1153 module = SWIG_GetModule(0);
1154 assert(module);
1155 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1156 }
1157 if (!c->base[j])
1158 return 0;
1159 if ((m = find_member(c->base[j], name)))
1160 return m;
1161 }
1162 return 0;
1163 }
1164
1165 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1166 member_map::iterator it = members.find(name);
1167 if (it != members.end())
1168 return &it->second;
1169 const swig_octave_member *m;
1170 for (unsigned int j = 0; j < types.size(); ++j)
1171 if ((m = find_member(types[j].first, name)))
1172 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1173 if (!insert_if_not_found)
1174 return 0;
1175 return &members[name];
1176 }
1177
1178 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1179 if (!base) {
1180 for (unsigned int j = 0; j < types.size(); ++j) {
1181 assert(types[j].first->clientdata);
1182 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1183 if (cj->name == name)
1184 return types[j].first;
1185 }
1186 return 0;
1187 }
1188 assert(base->clientdata);
1190 for (int j = 0; c->base_names[j]; ++j) {
1191 if (!c->base[j]) {
1192 if (!module)
1193 module = SWIG_GetModule(0);
1194 assert(module);
1195 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1196 }
1197 if (!c->base[j])
1198 return 0;
1199 assert(c->base[j]->clientdata);
1201 if (cj->name == name)
1202 return c->base[j];
1203 }
1204 return 0;
1205 }
1206
1207 void load_members(const swig_octave_class* c,member_map& out) const {
1208 for (const swig_octave_member *m = c->members; m->name; ++m) {
1209 if (out.find(m->name) == out.end())
1210 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1211 }
1212 for (int j = 0; c->base_names[j]; ++j) {
1213 if (!c->base[j]) {
1214 if (!module)
1215 module = SWIG_GetModule(0);
1216 assert(module);
1217 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1218 }
1219 if (!c->base[j])
1220 continue;
1221 assert(c->base[j]->clientdata);
1222 const swig_octave_class *cj =
1223 (const swig_octave_class *) c->base[j]->clientdata;
1224 load_members(cj,out);
1225 }
1226 }
1227
1228 void load_members(member_map& out) const {
1229 out=members;
1230 for (unsigned int j = 0; j < types.size(); ++j)
1231 if (types[j].first->clientdata)
1232 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1233 }
1234
1235 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1236 if (m->second.is_defined())
1237 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1238 else if (m->first && m->first->method)
1239 return m->first->method(args, nargout);
1240 error("member not defined or not invocable");
1241 return octave_value_list();
1242 }
1243
1244 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1245 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1246 member_value_pair *m = nc_this->find_member(symbol, false);
1247 if (!m || m->first->is_static() || m->first->is_global())
1248 return false;
1249 octave_value_list args;
1250 args.append(nc_this->as_value());
1251 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1252 if (argout.length() < 1)
1253 return false;
1254 ret = argout(0);
1255 return true;
1256 }
1257
1258 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1259 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1260 member_value_pair *m = nc_this->find_member(symbol, false);
1261 if (!m || m->first->is_static() || m->first->is_global())
1262 return false;
1263 octave_value_list args;
1264 args.append(nc_this->as_value());
1265 args.append(make_value_hack(rhs));
1266 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1267 if (argout.length() < 1)
1268 return false;
1269 ret = argout(0);
1270 return true;
1271 }
1272
1273 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1274 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1275 member_value_pair *m = nc_this->find_member(symbol, false);
1276 if (!m || m->first->is_static() || m->first->is_global())
1277 return false;
1278 octave_value_list args;
1279 args.append(nc_this->as_value());
1280 args.append(rhs);
1281 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1282 if (argout.length() >= 1)
1283 ret = argout(0);
1284 return true;
1285 }
1286
1287 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1288 if (m->second.is_defined()) {
1289 if (m->second.is_function() || m->second.is_function_handle()) {
1290 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1291 } else {
1292 return m->second;
1293 }
1294 } else if (m->first) {
1295 if (m->first->get_method)
1296 return m->first->get_method(args, 1);
1297 else if (m->first->method)
1298 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1299 }
1300 error("undefined member");
1301 return octave_value_list();
1302 }
1303
1304 static octave_value make_value_hack(const octave_base_value &x) {
1305#if SWIG_OCTAVE_PREREQ(9,0,0)
1306 ((octave_swig_type &) x).m_count++;
1307#else
1308 ((octave_swig_type &) x).count++;
1309#endif
1310 return octave_value((octave_base_value *) &x);
1311 }
1312
1315 public:
1316
1317 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1318 bool _always_static = false)
1319 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1320 always_static(_always_static) {
1321 if (_type || _ptr)
1322 types.push_back(std::make_pair(_type, _ptr));
1323#ifdef SWIG_DIRECTORS
1324 if (_ptr) {
1325 Swig::Director *d = Swig::get_rtdir(_ptr);
1326 if (d)
1327 Swig::swig_director_set_self(d, this);
1328 }
1329#endif
1330 }
1331
1333 if (thisown) {
1334#if SWIG_OCTAVE_PREREQ(9,0,0)
1335 ++m_count;
1336#else
1337 ++count;
1338#endif
1339 for (unsigned int j = 0; j < types.size(); ++j) {
1340 if (!types[j].first || !types[j].first->clientdata)
1341 continue;
1342 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1343 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1344 c->destructor(as_value(), 0);
1345 }
1346 }
1347 }
1348#ifdef SWIG_DIRECTORS
1349 for (unsigned int j = 0; j < types.size(); ++j)
1350 Swig::erase_rtdir(types[j].second.ptr);
1351#endif
1352 }
1353
1354 dim_vector dims(void) const {
1355 octave_value out;
1356 if (!dispatch_unary_op("__dims__", out))
1357 return dim_vector(1,1);
1358
1359 // Return value should be cell or matrix of integers
1360#if SWIG_OCTAVE_PREREQ(4,4,0)
1361 if (out.iscell()) {
1362#else
1363 if (out.is_cell()) {
1364#endif
1365 const Cell & c=out.cell_value();
1366 int ndim = c.rows();
1367 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1368
1369 dim_vector d;
1370 d.resize(ndim < 2 ? 2 : ndim);
1371 d(0) = d(1) = 1;
1372
1373 // Fill in dim_vector
1374 for (int k=0;k<ndim;k++) {
1375 const octave_value& obj = c(k);
1376#if SWIG_OCTAVE_PREREQ(6,0,0)
1377 try {
1378 d.elem(k) = obj.int_value();
1379 }
1380 catch (octave::execution_exception& oee) {
1381 // __dims__ should return a cell filled with integers
1382 return dim_vector(1,1);
1383 }
1384#else
1385 d.elem(k) = obj.int_value();
1386
1387 // __dims__ should return a cell filled with integers
1388 if (error_state) return dim_vector(1,1);
1389#endif
1390 }
1391 return d;
1392#if SWIG_OCTAVE_PREREQ(4,4,0)
1393 } else if (out.is_matrix_type() || out.isnumeric() ) {
1394#else
1395 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1396#endif
1397 if (out.rows()==1 || out.columns()==1) {
1398#if SWIG_OCTAVE_PREREQ(6,0,0)
1399 Array<int> a;
1400 try {
1401 a = out.int_vector_value();
1402 }
1403 catch (octave::execution_exception& oee) {
1404 return dim_vector(1,1);
1405 }
1406#else
1407 Array<int> a = out.int_vector_value();
1408 if (error_state) return dim_vector(1,1);
1409#endif
1410 dim_vector d;
1411 d.resize(a.numel() < 2 ? 2 : a.numel());
1412 d(0) = d(1) = 1;
1413 for (int k=0;k<a.numel();k++) {
1414 d.elem(k) = a(k);
1415 }
1416 return d;
1417 } else {
1418 return dim_vector(1,1);
1419 }
1420 } else {
1421 return dim_vector(1,1);
1422 }
1423 }
1424
1425 octave_value as_value() {
1426#if SWIG_OCTAVE_PREREQ(9,0,0)
1427 ++m_count;
1428#else
1429 ++count;
1430#endif
1431 return Swig::swig_value_ref(this);
1432 }
1433
1434 void incref() {
1435#if SWIG_OCTAVE_PREREQ(9,0,0)
1436 ++m_count;
1437#else
1438 ++count;
1439#endif
1440 }
1441
1442 void decref() {
1443#if SWIG_OCTAVE_PREREQ(9,0,0)
1444 if (!--m_count)
1445#else
1446 if (!--count)
1447#endif
1448 delete this;
1449 }
1450
1451 size_t swig_this() const {
1452 if (!types.size())
1453 return (size_t) this;
1454 return (size_t) types[0].second.ptr;
1455 }
1456 const char* help_text() const {
1457 if (!types.size())
1458 return 0;
1459 if (!types[0].first->clientdata)
1460 return 0;
1461 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1462 return c->constructor_doc;
1463 }
1464
1465 std::string swig_type_name() const {
1466 // * need some way to manually name subclasses.
1467 // * eg optional first arg to subclass(), or named_subclass()
1468 std::string ret;
1469 for (unsigned int j = 0; j < types.size(); ++j) {
1470 if (j)
1471 ret += "_";
1472 if (types[j].first->clientdata) {
1473 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1474 ret += c->name;
1475 } else
1476 ret += types[j].first->name;
1477 }
1478 return ret;
1479 }
1480
1482 rhs.thisown = 0;
1483 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1484 assert(!rhs.types[j].second.destroyed);
1485#ifdef SWIG_DIRECTORS
1486 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1487 if (d)
1488 Swig::swig_director_set_self(d, this);
1489#endif
1490 }
1491 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1492 members.insert(rhs.members.begin(), rhs.members.end());
1493#if SWIG_OCTAVE_PREREQ(4,4,0)
1494 assign(rhs.swig_type_name(), rhs.as_value());
1495#else
1496 rhs.types.clear();
1497 rhs.members.clear();
1498#endif
1499 }
1500
1501 typedef member_map::const_iterator swig_member_const_iterator;
1504
1505 int cast(void **vptr, swig_type_info *type, int *own, int flags) {
1506 int res = SWIG_ERROR;
1507 int clear_pointer = 0;
1508
1509 if (own)
1510 *own = 0;
1511 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !thisown) {
1513 } else {
1514 if (own)
1515 *own = *own | thisown;
1516 if (flags & SWIG_POINTER_DISOWN) {
1517 thisown = 0;
1518 }
1519 if (flags & SWIG_POINTER_CLEAR) {
1520 clear_pointer = 1;
1521 }
1522 }
1523
1524 if (!type && types.size()) {
1525 if (vptr) {
1526 *vptr = types[0].second.ptr;
1527 if (clear_pointer)
1528 types[0].second.ptr = 0;
1529 }
1530 return SWIG_OK;
1531 }
1532 for (unsigned int j = 0; j < types.size(); ++j)
1533 if (type == types[j].first) {
1534 if (vptr) {
1535 *vptr = types[j].second.ptr;
1536 if (clear_pointer)
1537 types[j].second.ptr = 0;
1538 }
1539 return SWIG_OK;
1540 }
1541 for (unsigned int j = 0; j < types.size(); ++j) {
1542 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1543 if (!tc)
1544 continue;
1545 if (vptr) {
1546 int newmemory = 0;
1547 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1548 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1549 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1550 if (own)
1551 *own = *own | SWIG_CAST_NEW_MEMORY;
1552 }
1553 if (clear_pointer)
1554 types[j].second.ptr = 0;
1555 }
1556 res = SWIG_OK;
1557 break;
1558 }
1559 return res;
1560 }
1561
1562 bool is_owned() const {
1563 return thisown;
1564 }
1565
1566#ifdef SWIG_DIRECTORS
1567 void director_destroyed(Swig::Director *d) {
1568 bool found = false;
1569 for (unsigned int j = 0; j < types.size(); ++j) {
1570 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1571 if (dj == d) {
1572 types[j].second.destroyed = true;
1573 found = true;
1574 }
1575 }
1576 assert(found);
1577 }
1578#endif
1579
1580 void assign(const std::string &name, const octave_value &ov) {
1581 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1582 }
1583
1584 void assign(const std::string &name, const swig_octave_member *m) {
1585 members[name] = std::make_pair(m, octave_value());
1586 }
1587
1588 octave_base_value *clone() const {
1589 // pass-by-value is probably not desired, and is harder;
1590 // requires calling copy constructors of contained types etc.
1591 assert(0);
1592 *(int *) 0 = 0;
1593 return 0;
1594 }
1595
1596 octave_base_value *empty_clone() const {
1597 return new octave_swig_type();
1598 }
1599
1600 bool is_defined() const {
1601 return true;
1602 }
1603
1604#if SWIG_OCTAVE_PREREQ(6,0,0)
1605 virtual bool isstruct() const {
1606#else
1607 virtual bool is_map() const {
1608#endif
1609 return true;
1610 }
1611
1612 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1613 octave_value_list ovl = subsref(ops, idx, 1);
1614 return ovl.length()? ovl(0) : octave_value();
1615 }
1616
1617 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1618 assert(ops.size() > 0);
1619 assert(ops.size() == idx.size());
1620
1621 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1622 int skip = 0;
1623 octave_value_list sub_ovl;
1624
1625 // constructor invocation
1626 if (ops[skip] == '(' && construct_type) {
1627 assert(construct_type->clientdata);
1628 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1629 if (!c->constructor) {
1630 error("cannot create instance");
1631 return octave_value_list();
1632 }
1633 octave_value_list args;
1634 if (c->director)
1635 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1636 args.append(*idx_it++);
1637 ++skip;
1638 sub_ovl = c->constructor(args, nargout);
1639 }
1640 // member dereference or invocation
1641 else if (ops[skip] == '.') {
1642 std::string subname;
1643 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1644 for (;;) {
1645 octave_value_list subname_ovl(*idx_it++);
1646 ++skip;
1647 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1648 subname = subname_ovl(0).string_value();
1649
1650 const swig_type_info *next_base = find_base(subname, base);
1651 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1652 break;
1653 base = next_base;
1654 }
1655
1656 member_value_pair tmp, *m = &tmp;
1657 if (!base || !(m->first = find_member(base, subname)))
1658 m = find_member(subname, false);
1659 if (!m) {
1660 error("member not found");
1661 return octave_value_list();
1662 }
1663
1664 octave_value_list args;
1665 if (!always_static &&
1666 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1667 args.append(as_value());
1668 if (skip < (int) ops.size() && ops[skip] == '(' &&
1669 ((m->first && m->first->method) || m->second.is_function() ||
1670 m->second.is_function_handle())) {
1671 args.append(*idx_it++);
1672 ++skip;
1673 sub_ovl = member_invoke(m, args, nargout);
1674 } else {
1675 sub_ovl = member_deref(m, args);
1676 }
1677 }
1678 // index operator
1679 else {
1680 if (ops[skip] == '(' || ops[skip] == '{') {
1681 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1682 octave_value_list args;
1683 args.append(*idx_it++);
1684 ++skip;
1685 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1686 error("error evaluating index operator");
1687 return octave_value_list();
1688 }
1689 } else {
1690 error("unsupported subsref");
1691 return octave_value_list();
1692 }
1693 }
1694
1695 if (skip >= (int) ops.size())
1696 return sub_ovl;
1697 if (sub_ovl.length() < 1) {
1698 error("bad subs ref");
1699 return octave_value_list();
1700 }
1701 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1702 }
1703
1704 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1705 assert(ops.size() > 0);
1706 assert(ops.size() == idx.size());
1707
1708 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1709 int skip = 0;
1710
1711 if (ops.size() > 1) {
1712 std::list < octave_value_list >::const_iterator last = idx.end();
1713 --last;
1714 std::list < octave_value_list > next_idx(idx.begin(), last);
1715 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1716 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1717 }
1718
1719 else if (ops[skip] == '(' || ops[skip] == '{') {
1720 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1721 member_value_pair *m = find_member(op_name, false);
1722 if (m) {
1723 octave_value_list args;
1724 args.append(as_value());
1725 args.append(*idx_it);
1726 args.append(rhs);
1727 member_invoke(m, args, 1);
1728 } else
1729 error("%s member not found", op_name);
1730 }
1731
1732 else if (ops[skip] == '.') {
1733 octave_value_list subname_ovl(*idx_it++);
1734 ++skip;
1735 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1736 std::string subname = subname_ovl(0).string_value();
1737
1738 member_value_pair *m = find_member(subname, true);
1739 if (!m->first || !m->first->set_method) {
1740 m->first = 0;
1741 m->second = rhs;
1742 } else if (m->first->set_method) {
1743 octave_value_list args;
1744 if (!m->first->is_static() && !m->first->is_global())
1745 args.append(as_value());
1746 args.append(rhs);
1747 m->first->set_method(args, 1);
1748 } else
1749 error("member not assignable");
1750 } else
1751 error("unsupported subsasgn");
1752
1753 return as_value();
1754 }
1755
1756#if SWIG_OCTAVE_PREREQ(4,4,0)
1757 virtual bool isobject() const {
1758#else
1759 virtual bool is_object() const {
1760#endif
1761 return true;
1762 }
1763
1764 virtual bool is_string() const {
1765 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1766 return !!nc_this->find_member("__str__", false);
1767 }
1768
1769 virtual std::string string_value(bool force = false) const {
1770 octave_value ret;
1771 if (!dispatch_unary_op("__str__", ret)) {
1772 error("__str__ method not defined");
1773 return std::string();
1774 }
1775 if (!ret.is_string()) {
1776 error("__str__ method did not return a string");
1777 return std::string();
1778 }
1779 return ret.string_value();
1780 }
1781
1782 virtual double scalar_value(bool frc_str_conv = false) const {
1783 octave_value ret;
1784 if (!dispatch_unary_op("__float__", ret)) {
1785 error("__float__ method not defined");
1786 }
1787 return ret.scalar_value();
1788 }
1789
1790#if SWIG_OCTAVE_PREREQ(4,2,0)
1791 virtual octave_value as_double(void) const {
1792 octave_value ret;
1793 if (!dispatch_unary_op("__float__", ret)) {
1794 error("__float__ method not defined");
1795 }
1796 return ret.as_double();
1797 }
1798
1799 virtual octave_value as_single(void) const {
1800 octave_value ret;
1801 if (!dispatch_unary_op("__float__", ret)) {
1802 error("__float__ method not defined");
1803 }
1804 return ret.as_single();
1805 }
1806#endif
1807
1808#if SWIG_OCTAVE_PREREQ(3,8,0)
1809 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1810 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1811 octave_value ret;
1812 if (!dispatch_unary_op(opname, ret)) {
1813 error("%s", (opname + std::string(" method not found")).c_str());
1814 return octave_value();
1815 }
1816 return ret;
1817 }
1818#endif
1819
1820#if SWIG_OCTAVE_PREREQ(3,3,52)
1821 virtual octave_map map_value() const {
1822 return octave_map();
1823 }
1824#else
1825 virtual Octave_map map_value() const {
1826 return Octave_map();
1827 }
1828#endif
1829
1830 virtual string_vector map_keys() const {
1831 member_map tmp;
1832 load_members(tmp);
1833
1834 string_vector keys(tmp.size());
1835 int k = 0;
1836 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1837 keys(k++) = it->first;
1838
1839 return keys;
1840 }
1841
1842 virtual bool save_ascii (std::ostream& os) {
1843 return true;
1844 }
1845
1846 virtual bool load_ascii (std::istream& is) {
1847 return true;
1848 }
1849
1850 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1851 return true;
1852 }
1853
1854 virtual bool load_binary (std::istream& is, bool swap,
1855#if SWIG_OCTAVE_PREREQ(6,0,0)
1856 octave::mach_info::float_format fmt) {
1857#else
1858 oct_mach_info::float_format fmt) {
1859#endif
1860 return true;
1861 }
1862
1863#if defined (HAVE_HDF5)
1864# if SWIG_OCTAVE_PREREQ(4,0,0)
1865 virtual bool
1866 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1867 return true;
1868 }
1869
1870 virtual bool
1871 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1872 return true;
1873 }
1874# else
1875 virtual bool
1876 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1877 return true;
1878 }
1879
1880 virtual bool
1881 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1882 return true;
1883 }
1884# endif
1885#endif
1886
1887 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1888 return string_value();
1889 }
1890
1891 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1892 return string_value();
1893 }
1894
1895 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1896 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1897 // (rather than any module namespace).
1898
1899 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1900 if (!fcn)
1901 return false;
1902#if SWIG_OCTAVE_PREREQ(4,4,0)
1903 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1904 octave_value_list retval = fcn->call(tw, 1, args);
1905 if (retval.length() == 1)
1906 ret = retval(0);
1907#else
1908 ret = fcn->do_multi_index_op(1, args)(0);
1909#endif
1910 return true;
1911 }
1912
1913 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1915 assert(ost);
1916
1917 octave_value ret;
1918 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1919 return ret;
1920 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1921 octave_value_list args;
1922 args.append(make_value_hack(x));
1923 if (dispatch_global_op(symbol, args, ret))
1924 return ret;
1925
1926 error("could not dispatch unary operator");
1927 return octave_value();
1928 }
1929
1930 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1933
1934 octave_value ret;
1935 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1936 return ret;
1937 if (rhs_ost) {
1938 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1939 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1940 return ret;
1941 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1942 return ret;
1943 }
1944 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1945 return ret;
1946 }
1947
1948 std::string symbol;
1949 octave_value_list args;
1950 args.append(make_value_hack(lhs));
1951 args.append(make_value_hack(rhs));
1952
1953 symbol = SWIG_op_prefix;
1954 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1955 symbol += "_";
1956 symbol += op_name;
1957 symbol += "_";
1958 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1959 if (dispatch_global_op(symbol, args, ret))
1960 return ret;
1961
1962 symbol = SWIG_op_prefix;
1963 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1964 symbol += "_";
1965 symbol += op_name;
1966 symbol += "_";
1967 symbol += "any";
1968 if (dispatch_global_op(symbol, args, ret))
1969 return ret;
1970
1971 symbol = SWIG_op_prefix;
1972 symbol += "any";
1973 symbol += "_";
1974 symbol += op_name;
1975 symbol += "_";
1976 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1977 if (dispatch_global_op(symbol, args, ret))
1978 return ret;
1979
1980 error("could not dispatch binary operator");
1981 return octave_value();
1982 }
1983
1984#if SWIG_OCTAVE_PREREQ(4,0,0)
1985 void print(std::ostream &os, bool pr_as_read_syntax = false)
1986#else
1987 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1988#endif
1989 {
1990 if (is_string()) {
1991 os << string_value();
1992 return;
1993 }
1994
1995 member_map tmp;
1996 load_members(tmp);
1997
1998 indent(os);
1999 os << "{"; newline(os);
2000 increment_indent_level();
2001 for (unsigned int j = 0; j < types.size(); ++j) {
2002 indent(os);
2003 if (types[j].first->clientdata) {
2004 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
2005 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
2006 } else {
2007 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
2008 }
2009 }
2010 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2011 indent(os);
2012 if (it->second.first) {
2013 const char *objtype = it->second.first->method ? "method" : "variable";
2014 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
2015 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
2016 assert(it->second.first->name == it->first);
2017 } else {
2018 os << it->first; newline(os);
2019 }
2020 }
2021 decrement_indent_level();
2022 indent(os);
2023 os << "}"; newline(os);
2024 }
2025 };
2026
2027 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
2028 // will call clone() via make_unique() if there is more than one outstanding
2029 // reference to the lhs, and forces the clone's reference count to 1
2030 // (so you can't just increment your own count and return this).
2031 //
2032 // One way to fix this (without modifying Octave) is to add a level of
2033 // indirection such that clone copies ref-counted pointer and we keep
2034 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
2035 //
2036 // Supporting both pass-by-{ref,value} and toggling via %feature/option
2037 // might be nice.
2038
2039 class octave_swig_ref:public octave_base_value {
2041 public:
2043 :ptr(_ptr)
2044 {
2045 // Ensure type_id() is set correctly
2046#if SWIG_OCTAVE_PREREQ(9,0,0)
2047 if (s_t_id == -1) {
2048 s_t_id = octave_swig_ref::static_type_id();
2049#else
2050 if (t_id == -1) {
2051 t_id = octave_swig_ref::static_type_id();
2052#endif
2053 }
2054 }
2055
2057 { if (ptr) ptr->decref(); }
2058
2060 { return ptr; }
2061
2062 octave_base_value *clone() const
2063 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2064
2065 octave_base_value *empty_clone() const
2066 { return new octave_swig_ref(0); }
2067
2068 dim_vector dims(void) const
2069 { return ptr->dims(); }
2070
2071 bool is_defined() const
2072 { return ptr->is_defined(); }
2073
2074#if SWIG_OCTAVE_PREREQ(6,0,0)
2075 virtual bool isstruct() const
2076 { return ptr->isstruct(); }
2077#else
2078 virtual bool is_map() const
2079 { return ptr->is_map(); }
2080#endif
2081
2082 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2083 { return ptr->subsref(ops, idx); }
2084
2085 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2086 { return ptr->subsref(ops, idx, nargout); }
2087
2088 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2089 { return ptr->subsasgn(ops, idx, rhs); }
2090
2091#if SWIG_OCTAVE_PREREQ(4,4,0)
2092 virtual bool isobject() const
2093 { return ptr->isobject(); }
2094#else
2095 virtual bool is_object() const
2096 { return ptr->is_object(); }
2097#endif
2098
2099 virtual bool is_string() const
2100 { return ptr->is_string(); }
2101
2102 virtual std::string string_value(bool force = false) const
2103 { return ptr->string_value(force); }
2104
2105 virtual double scalar_value(bool frc_str_conv = false) const
2106 { return ptr->scalar_value(frc_str_conv); }
2107
2108#if SWIG_OCTAVE_PREREQ(4,2,0)
2109 virtual octave_value as_double(void) const
2110 { return ptr->as_double(); }
2111
2112 virtual octave_value as_single(void) const
2113 { return ptr->as_single(); }
2114#endif
2115
2116#if SWIG_OCTAVE_PREREQ(3,8,0)
2117 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2118 { return ptr->map(umap); }
2119#endif
2120
2121#if SWIG_OCTAVE_PREREQ(3,3,52)
2122 virtual octave_map map_value() const
2123 { return ptr->map_value(); }
2124#else
2125 virtual Octave_map map_value() const
2126 { return ptr->map_value(); }
2127#endif
2128
2129 virtual string_vector map_keys() const
2130 { return ptr->map_keys(); }
2131
2132 virtual bool save_ascii (std::ostream& os)
2133 { return ptr->save_ascii(os); }
2134
2135 virtual bool load_ascii (std::istream& is)
2136 { return ptr->load_ascii(is); }
2137
2138 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2139 { return ptr->save_binary(os, save_as_floats); }
2140
2141 virtual bool load_binary (std::istream& is, bool swap,
2142#if SWIG_OCTAVE_PREREQ(6,0,0)
2143 octave::mach_info::float_format fmt)
2144#else
2145 oct_mach_info::float_format fmt)
2146#endif
2147 { return ptr->load_binary(is, swap, fmt); }
2148
2149#if defined (HAVE_HDF5)
2150# if SWIG_OCTAVE_PREREQ(4,0,0)
2151 virtual bool
2152 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2153 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2154
2155 virtual bool
2156 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2157 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2158# else
2159 virtual bool
2160 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2161 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2162
2163 virtual bool
2164 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2165 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2166# endif
2167#endif
2168
2169 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2170 { return ptr->convert_to_str(pad, force, type); }
2171
2172 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2173 { return ptr->convert_to_str_internal(pad, force, type); }
2174
2175#if SWIG_OCTAVE_PREREQ(4,0,0)
2176 void print(std::ostream &os, bool pr_as_read_syntax = false)
2177#else
2178 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2179#endif
2180 { return ptr->print(os, pr_as_read_syntax); }
2181
2182#if SWIG_OCTAVE_PREREQ(9,0,0)
2183 static void set_type_id(int type_id) { s_t_id=type_id; }
2184#else
2185# if SWIG_OCTAVE_PREREQ(4,4,0)
2186 static void set_type_id(int type_id) { t_id=type_id; }
2187# endif
2188#endif
2189
2190 virtual type_conv_info numeric_conversion_function(void) const {
2191 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2192 octave_scalar::static_type_id ());
2193 }
2194
2195 private:
2196 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2197 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2198 return new octave_scalar(v.scalar_value());
2199 }
2200
2201#if !SWIG_OCTAVE_PREREQ(4,0,0)
2203#endif
2205 };
2206#if !SWIG_OCTAVE_PREREQ(4,0,0)
2208#endif
2210
2211 class octave_swig_packed:public octave_base_value {
2213 std::vector < char > buf;
2214 public:
2215
2216 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2217 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2218 {
2219 // Ensure type_id() is set correctly
2220#if SWIG_OCTAVE_PREREQ(9,0,0)
2221 if (s_t_id == -1) {
2222 s_t_id = octave_swig_packed::static_type_id();
2223#else
2224 if (t_id == -1) {
2225 t_id = octave_swig_packed::static_type_id();
2226#endif
2227 }
2228 }
2229
2230 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2231 if (outtype && outtype != type)
2232 return false;
2233 assert(sz <= buf.size());
2234 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2235 return true;
2236 }
2237
2238 octave_base_value *clone() const {
2239 return new octave_swig_packed(*this);
2240 }
2241
2242 octave_base_value *empty_clone() const {
2243 return new octave_swig_packed();
2244 }
2245
2246 bool is_defined() const {
2247 return true;
2248 }
2249
2250#if SWIG_OCTAVE_PREREQ(4,0,0)
2251 void print(std::ostream &os, bool pr_as_read_syntax = false)
2252#else
2253 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2254#endif
2255 {
2256 indent(os);
2257 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2258 }
2259
2260
2261 virtual bool save_ascii (std::ostream& os) {
2262 return true;
2263 }
2264
2265 virtual bool load_ascii (std::istream& is) {
2266 return true;
2267 }
2268
2269 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2270 return true;
2271 }
2272
2273 virtual bool load_binary (std::istream& is, bool swap,
2274#if SWIG_OCTAVE_PREREQ(6,0,0)
2275 octave::mach_info::float_format fmt) {
2276#else
2277 oct_mach_info::float_format fmt) {
2278#endif
2279 return true;
2280 }
2281
2282#if defined (HAVE_HDF5)
2283# if SWIG_OCTAVE_PREREQ(4,0,0)
2284 virtual bool
2285 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2286 return true;
2287 }
2288
2289 virtual bool
2290 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2291 return true;
2292 }
2293# else
2294 virtual bool
2295 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2296 return true;
2297 }
2298
2299 virtual bool
2300 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2301 return true;
2302 }
2303# endif
2304#endif
2305
2306#if SWIG_OCTAVE_PREREQ(9,0,0)
2307 static void set_type_id(int type_id) { s_t_id=type_id; }
2308#else
2309# if SWIG_OCTAVE_PREREQ(4,4,0)
2310 static void set_type_id(int type_id) { t_id=type_id; }
2311# endif
2312#endif
2313
2314 private:
2315#if !SWIG_OCTAVE_PREREQ(4,0,0)
2317#endif
2319 };
2320#if !SWIG_OCTAVE_PREREQ(4,0,0)
2322#endif
2324
2325 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2326 error("attempt to set immutable member variable");
2327 return octave_value_list();
2328 }
2329
2331 const octave_value_list &ovl;
2332 int j;
2333
2334 octave_value_ref(const octave_value_list &_ovl, int _j)
2335 :ovl(_ovl), j(_j) { }
2336
2337 operator octave_value() const {
2338 return ovl(j);
2339 }
2340
2341 octave_value operator*() const {
2342 return ovl(j);
2343 }
2344 };
2345
2346
2347namespace Swig {
2348
2350 return new octave_swig_ref(ost);
2351 }
2352
2354 if (
2355#if SWIG_OCTAVE_PREREQ(4,4,0)
2356 ov.iscell()
2357#else
2358 ov.is_cell()
2359#endif
2360 && ov.rows() == 1 && ov.columns() == 1)
2361 ov = ov.cell_value()(0);
2362 return swig_value_deref(*ov.internal_rep());
2363 }
2364
2365 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2366 if (ov.type_id() != octave_swig_ref::static_type_id())
2367 return 0;
2368 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2369 return osr->get_ptr();
2370 }
2371
2372}
2373
2374
2375#define swig_unary_op(name) \
2376SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2377 return octave_swig_type::dispatch_unary_op(x,#name); \
2378}
2379#define swig_binary_op(name) \
2380SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2381 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2382}
2383#if SWIG_OCTAVE_PREREQ(4,4,0)
2384#define swigreg_unary_op(name) \
2385if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2386typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2387#else
2388#define swigreg_unary_op(name) \
2389if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2390octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2391#endif
2392#if SWIG_OCTAVE_PREREQ(4,4,0)
2393#define swigreg_binary_op(name) \
2394if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2395typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2396#else
2397#define swigreg_binary_op(name) \
2398if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2399octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2400#endif
2401
2405 swig_unary_op(transpose);
2406 swig_unary_op(hermitian);
2409
2416#if !SWIG_OCTAVE_PREREQ(4,2,0)
2419#endif
2432
2434#if SWIG_OCTAVE_PREREQ(4,4,0)
2435 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2436#endif
2437 swigreg_unary_op(not);
2438 swigreg_unary_op(uplus);
2439 swigreg_unary_op(uminus);
2440 swigreg_unary_op(transpose);
2441 swigreg_unary_op(hermitian);
2442 swigreg_unary_op(incr);
2443 swigreg_unary_op(decr);
2444 }
2445 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2446#if SWIG_OCTAVE_PREREQ(4,4,0)
2447 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2448#endif
2449 swigreg_binary_op(add);
2450 swigreg_binary_op(sub);
2451 swigreg_binary_op(mul);
2452 swigreg_binary_op(div);
2453 swigreg_binary_op(pow);
2454 swigreg_binary_op(ldiv);
2455#if !SWIG_OCTAVE_PREREQ(4,2,0)
2456 swigreg_binary_op(lshift);
2457 swigreg_binary_op(rshift);
2458#endif
2465 swigreg_binary_op(el_mul);
2466 swigreg_binary_op(el_div);
2467 swigreg_binary_op(el_pow);
2468 swigreg_binary_op(el_ldiv);
2469 swigreg_binary_op(el_and);
2470 swigreg_binary_op(el_or);
2471 }
2473 // here we assume that tid are conseq integers increasing from zero, and
2474 // that our tid is the last one. might be better to have explicit string
2475 // list of types we should bind to, and use lookup_type to resolve their tid.
2476
2478 SWIG_InstallBinaryOps(tid, tid);
2479 for (int j = 0; j < tid; ++j) {
2480 SWIG_InstallBinaryOps(j, tid);
2481 SWIG_InstallBinaryOps(tid, j);
2482 }
2483 }
2484
2485SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2486 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2487
2488 if (ptr) {
2489#ifdef SWIG_DIRECTORS
2490 Swig::Director *d = Swig::get_rtdir(ptr);
2491 if (d && Swig::swig_director_get_self(d))
2492 return Swig::swig_director_get_self(d)->as_value();
2493#endif
2494 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2495 }
2496 return octave_value(Matrix()); // null matrix
2497}
2498
2499SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2500 if (
2501#if SWIG_OCTAVE_PREREQ(4,4,0)
2502 ov.iscell()
2503#else
2504 ov.is_cell()
2505#endif
2506 && ov.rows() == 1 && ov.columns() == 1)
2507 ov = ov.cell_value()(0);
2508 if (!ov.is_defined() ||
2509 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2510 if (ptr)
2511 *ptr = 0;
2513 }
2514 if (ov.type_id() != octave_swig_ref::static_type_id())
2515 return SWIG_ERROR;
2516 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2517 octave_swig_type *ost = osr->get_ptr();
2518 return ost->cast(ptr, type, own, flags);
2519}
2520
2521SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2522 return new octave_swig_packed(type, (char *) ptr, sz);
2523}
2524
2525SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2526 if (!ov.is_defined())
2527 return SWIG_ERROR;
2528 if (ov.type_id() != octave_swig_packed::static_type_id())
2529 return SWIG_ERROR;
2530 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2531 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2532}
2533
2534SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2535 module_ns->assign(name, ov);
2536}
2537
2539#if SWIG_OCTAVE_PREREQ(6,0,0)
2540 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2541 return interp->global_varval(name);
2542#else
2543#if SWIG_OCTAVE_PREREQ(4,4,0)
2544 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2545 return symtab.global_varval(name);
2546#else
2547 return get_global_value(name, true);
2548#endif
2549#endif
2550}
2551
2552SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2553#if SWIG_OCTAVE_PREREQ(6,0,0)
2554 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2555 interp->global_assign(name, value);
2556#elif SWIG_OCTAVE_PREREQ(4,4,0)
2557 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2558 symtab.global_assign(name, value);
2559#else
2560 set_global_value(name, value);
2561#endif
2562}
2563
2565#if SWIG_OCTAVE_PREREQ(4,4,0)
2566 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2567#if SWIG_OCTAVE_PREREQ(6,0,0)
2568 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2569 interp->assign(name, interp->global_varval(name));
2570 octave::tree_evaluator& tree_eval = interp->get_evaluator();
2571#if SWIG_OCTAVE_PREREQ(8,0,0)
2572 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2573#else
2574 octave::call_stack& callStack = tree_eval.get_call_stack();
2575 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2576#endif
2577 octave::symbol_record sym=symscope.lookup_symbol(name);
2578 stackFrame->mark_global(sym);
2579#else
2580 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2581 symscope.assign(name, symtab.global_varval(name));
2582 symscope.mark_global(name);
2583#endif
2584#else
2585#if !SWIG_OCTAVE_PREREQ(3,2,0)
2586 link_to_global_variable(curr_sym_tab->lookup(name, true));
2587#else
2588#if !SWIG_OCTAVE_PREREQ(3,8,0)
2589 symbol_table::varref(name);
2590#endif
2591 symbol_table::mark_global(name);
2592#endif
2593#endif
2594}
2595
2597 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2598 if (!ov.is_defined() ||
2599 ov.type_id() != octave_swig_packed::static_type_id())
2600 return 0;
2601 const octave_swig_packed* osp =
2602 static_cast < const octave_swig_packed *> (ov.internal_rep());
2603 swig_module_info *pointer = 0;
2604 osp->copy(0, &pointer, sizeof(swig_module_info *));
2605 return pointer;
2606}
2607
2608SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2609 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2611}
2612
2613
2614SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
2615 if (obj.is_string())
2616 error("%s", obj.string_value().c_str());
2617 else
2618 error("C++ side threw an exception of type %s", type);
2619}
2620
2621
2622
2623#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2624
2625#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2626
2627
2628
2629/* -------- TYPES TABLE (BEGIN) -------- */
2630
2631#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2632#define SWIGTYPE_p_char swig_types[1]
2633#define SWIGTYPE_p_double swig_types[2]
2634#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2635#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2636#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2637#define SWIGTYPE_p_int swig_types[6]
2638#define SWIGTYPE_p_p_char swig_types[7]
2639#define SWIGTYPE_p_unsigned_int swig_types[8]
2641static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2642#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645/* -------- TYPES TABLE (END) -------- */
2646
2647
2648#ifdef __cplusplus
2649#include <utility>
2650/* SwigValueWrapper is described in swig.swg */
2651template<typename T> class SwigValueWrapper {
2652 struct SwigSmartPointer {
2653 T *ptr;
2654 SwigSmartPointer(T *p) : ptr(p) { }
2655 ~SwigSmartPointer() { delete ptr; }
2656 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
2657 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
2658 } pointer;
2659 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
2660 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
2661public:
2662 SwigValueWrapper() : pointer(0) { }
2663 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
2664#if __cplusplus >=201103L
2665 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
2666 operator T&&() const { return std::move(*pointer.ptr); }
2667#else
2668 operator T&() const { return *pointer.ptr; }
2669#endif
2670 T *operator&() const { return pointer.ptr; }
2671 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2672};
2673
2674/*
2675 * SwigValueInit() is a generic initialisation solution as the following approach:
2676 *
2677 * T c_result = T();
2678 *
2679 * doesn't compile for all types for example:
2680 *
2681 * unsigned int c_result = unsigned int();
2682 */
2683template <typename T> T SwigValueInit() {
2684 return T();
2685}
2686
2687#if __cplusplus >=201103L
2688# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2689#else
2690# define SWIG_STD_MOVE(OBJ) OBJ
2691#endif
2692
2693#endif
2694
2695
2696#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2697#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2698
2699
2700#include <stdexcept>
2701
2702
2703// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2704#undef PACKAGE
2705#undef VERSION
2706
2707#include "plplotP.h"
2708
2709// Temporary fix for problems with -fvisibility=hidden and octave headers.
2710#ifdef OCTAVE_EXPORT
2711 #if defined ( __GNUC__ ) && __GNUC__ > 3
2712 #undef OCTAVE_EXPORT
2713 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2714 #endif
2715#endif
2716
2717
2718
2719// I hate global variables but this is the best way I can think of
2720// to manage consistency checking among function arguments.
2721 static PLINT Alen = 0;
2722 static PLINT Xlen = 0, Ylen = 0;
2723
2724
2725// Convenience functions copied from matwrap-based approach (currently
2726// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2727// tricky scalar case and also adopted so that the resulting
2728// swig-generated source code will look similar to the matwrap-generated
2729// source code.
2730
2731 inline int max( int a, int b )
2732 {
2733 return a >= b ? a : b;
2734 }
2735 inline int min( int a, int b )
2736 {
2737 return a >= b ? a : b;
2738 }
2739
2740//
2741// Function to get the total length (rows*columns) of an octave object of
2742// arbitrary type.
2743// Arguments:
2744// 1) The octave object.
2745//
2746// If the object is a scalar, the array length is 1.
2747//
2748 static int
2749 _arraylen( const octave_value &o_obj )
2750 {
2751 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2752 // max is necessary because sometimes
2753 // rows() or columns() return -1 or 0 for
2754 // scalars.
2755 }
2756
2757//
2758// Function to get the number of dimensions of an object.
2759//
2760 static int
2761 _n_dims( const octave_value &o_obj )
2762 {
2763 if ( max( o_obj.columns(), 1 ) > 1 )
2764 return 2;
2765 // max is necessary because sometimes
2766 // rows() or columns() return -1 or 0 for
2767 // scalars.
2768 else if ( max( o_obj.rows(), 1 ) > 1 )
2769 return 1;
2770 else
2771 return 0;
2772 }
2773
2774//
2775// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2776//
2777 static inline int
2778 _dim( const octave_value &o_obj, int dim_idx )
2779 {
2780 if ( dim_idx == 0 )
2781 return max( o_obj.rows(), 0 );
2782 // max is necessary because sometimes
2783 // rows() or columns() return -1 or 0 for
2784 // scalars.
2785 else if ( dim_idx == 1 )
2786 return max( o_obj.columns(), 0 );
2787 else
2788 return 1;
2789 }
2790
2791//
2792// The following function converts an array of doubles into some other
2793// numeric type. Arguments:
2794// 1) Where to store the result. The type is determined from the type of
2795// this pointer.
2796// 2) A vector of doubles to convert.
2797// 3) The number of doubles.
2798//
2799 template <class FLOAT>
2800 static inline void
2801 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2802 {
2803 while ( n_el-- > 0 )
2804 *out_arr++ = (FLOAT) ( *in_arr++ );
2805 }
2806
2807 template void _cvt_double_to( int *, double *, unsigned );
2808 template void _cvt_double_to( unsigned *, double *, unsigned );
2809 template void _cvt_double_to( long *, double *, unsigned );
2810 template void _cvt_double_to( unsigned long *, double *, unsigned );
2811 template void _cvt_double_to( short *, double *, unsigned );
2812 template void _cvt_double_to( unsigned short *, double *, unsigned );
2813 template void _cvt_double_to( float *, double *, unsigned );
2814 // Instantiate our templates. Octave uses
2815 // manual template instantiation.
2816
2817//
2818// Convert an array of some other type into an array of doubles. Arguments:
2819// 1) The array of objects of other type.
2820// 2) The output array of doubles.
2821// 3) The number of elements to convert.
2822//
2823 template <class FLOAT>
2824 static inline void
2825 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2826 {
2827 while ( n_el-- > 0 )
2828 *d_arr++ = double(*arr++);
2829 }
2830
2831 template void _cvt_to_double( int *, double *, unsigned );
2832 template void _cvt_to_double( unsigned *, double *, unsigned );
2833 template void _cvt_to_double( long *, double *, unsigned );
2834 template void _cvt_to_double( unsigned long *, double *, unsigned );
2835 template void _cvt_to_double( short *, double *, unsigned );
2836 template void _cvt_to_double( unsigned short *, double *, unsigned );
2837 template void _cvt_to_double( float *, double *, unsigned );
2838 // Instantiate our templates. Octave uses
2839 // manual template instantiation.
2840
2841
2842 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2843 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2844 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2845 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2846 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2848 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2849
2850
2851#include <iostream>
2852
2853 octave_function *fcnMapForm;
2854 std::string nameMapForm;
2855
2857 {
2858 octave_idx_type i;
2859 octave_value_list functionArguments;
2860 octave_value_list retval;
2861
2862 Matrix xin( n, 1 );
2863 Matrix yin( n, 1 );
2864 Matrix xout;
2865 Matrix yout;
2866
2867 for ( i = 0; i < n; i++ )
2868 {
2869 xin( i, 0 ) = x[i];
2870 yin( i, 0 ) = y[i];
2871 }
2872
2873 functionArguments( 0 ) = xin;
2874 functionArguments( 1 ) = yin;
2875
2876 if ( fcnMapForm != NULL )
2877#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2878 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2879#else
2880 retval = feval( fcnMapForm, functionArguments, 1 );
2881#endif
2882 else
2883#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2884 retval = octave::feval( nameMapForm, functionArguments, 1 );
2885#else
2886 retval = feval( nameMapForm, functionArguments, 1 );
2887#endif
2888
2889 if ( retval.length() >= 2 )
2890 {
2891 xout = retval( 0 ).matrix_value();
2892 yout = retval( 1 ).matrix_value();
2893
2894 for ( i = 0; i < n; i++ )
2895 {
2896 x[i] = xout( i, 0 );
2897 y[i] = yout( i, 0 );
2898 }
2899 }
2900 }
2901
2902
2903 octave_function *fcnLabelFunc;
2904 std::string nameLabelFunc;
2905
2906 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2907 {
2908 int i;
2909 octave_value_list functionArguments;
2910 octave_value_list retval;
2911
2912 Matrix inAxis( 1, 1 );
2913 Matrix inValue( 1, 1 );
2914 inAxis( 0, 0 ) = axis;
2915 inValue( 0, 0 ) = value;
2916
2917 functionArguments( 0 ) = inAxis;
2918 functionArguments( 1 ) = inValue;
2919
2920 if ( fcnLabelFunc != NULL )
2921#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2922 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2923#else
2924 retval = feval( fcnLabelFunc, functionArguments, 1 );
2925#endif
2926 else
2927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2928 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2929#else
2930 retval = feval( nameLabelFunc, functionArguments, 1 );
2931#endif
2932
2933 strncpy( label, retval( 0 ).string_value().c_str(), length );
2934 }
2935
2936
2937 octave_function *fcnCoordTrans;
2938 std::string nameCoordTrans;
2939
2940 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2941 {
2942 octave_idx_type i;
2943 octave_value_list functionArguments;
2944 octave_value_list retval;
2945
2946 Matrix xin( 1, 1 );
2947 Matrix yin( 1, 1 );
2948 Matrix xout;
2949 Matrix yout;
2950
2951 xin( 0, 0 ) = x;
2952 yin( 0, 0 ) = y;
2953
2954 functionArguments( 0 ) = xin;
2955 functionArguments( 1 ) = yin;
2956
2957 if ( fcnCoordTrans != NULL )
2958#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2959 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2960#else
2961 retval = feval( fcnCoordTrans, functionArguments, 1 );
2962#endif
2963 else
2964#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2965 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2966#else
2967 retval = feval( nameCoordTrans, functionArguments, 1 );
2968#endif
2969
2970 if ( retval.length() >= 2 )
2971 {
2972 xout = retval( 0 ).matrix_value();
2973 yout = retval( 1 ).matrix_value();
2974
2975 *xt = xout( 0, 0 );
2976 *yt = yout( 0, 0 );
2977 }
2978 }
2979
2980
2981 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2982 {
2983 PLINT i;
2984 printf( "nlegend =%d\n", nlegend );
2985 for ( i = 0; i < nlegend; i++ )
2986 {
2987 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2988 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2989 printf( "text[%d] =%s\n", i, text[i] );
2990 }
2991 }
2992
2993
2994#include <limits.h>
2995#if !defined(SWIG_NO_LLONG_MAX)
2996# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2997# define LLONG_MAX __LONG_LONG_MAX__
2998# define LLONG_MIN (-LLONG_MAX - 1LL)
2999# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3000# endif
3001#endif
3002
3003
3004 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
3005 {
3006 if (!ov.is_scalar_type())
3007 return SWIG_TypeError;
3008 if (ov.is_complex_scalar())
3009 return SWIG_TypeError;
3010 if (ov.is_double_type()||ov.is_single_type()) {
3011 double v=ov.double_value();
3012 if (v!=floor(v))
3013 return SWIG_TypeError;
3014 }
3015 if (val)
3016 *val = ov.long_value();
3017 return SWIG_OK;
3018 }
3019
3020
3021SWIGINTERN int
3022SWIG_AsVal_int (octave_value obj, int *val)
3023{
3024 long v;
3025 int res = SWIG_AsVal_long (obj, &v);
3026 if (SWIG_IsOK(res)) {
3027 if ((v < INT_MIN || v > INT_MAX)) {
3028 return SWIG_OverflowError;
3029 } else {
3030 if (val) *val = static_cast< int >(v);
3031 }
3032 }
3033 return res;
3034}
3035
3036
3037 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 )
3038 {
3039 PLGraphicsIn gin;
3040 int status; status = plGetCursor( &gin );
3041 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
3042 strncpy( string, gin.string, PL_MAXKEY - 1 );
3043 string[PL_MAXKEY - 1] = '\0';
3044
3045 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
3046 return status;
3047 }
3048
3049
3050SWIGINTERN int
3051SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
3052{
3053 if (
3054#if SWIG_OCTAVE_PREREQ(4,4,0)
3055 ov.iscell()
3056#else
3057 ov.is_cell()
3058#endif
3059 && ov.rows() == 1 && ov.columns() == 1)
3060 ov = ov.cell_value()(0);
3061 if (!ov.is_string())
3062 return SWIG_TypeError;
3063
3064 std::string str=ov.string_value();
3065 size_t len=str.size();
3066 char* cstr=(char*)str.c_str();
3067 if (alloc) {
3068 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3069 *alloc = SWIG_NEWOBJ;
3070 } else if (cptr)
3071 *cptr = cstr;
3072 if (psize)
3073 *psize = len + 1;
3074 return SWIG_OK;
3075}
3076
3077
3078
3079
3080
3082 {
3083 return octave_value(value);
3084 }
3085
3086
3087SWIGINTERNINLINE octave_value
3089{
3090 return SWIG_From_long (value);
3091}
3092
3093
3095 {
3096 return octave_value(value);
3097 }
3098
3099
3100// Translates relative device coordinates to world coordinates.
3101 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
3102 {
3103 PLGraphicsIn gin;
3104 int st;
3105 gin.dX = x_in; gin.dY = y_in;
3106 st = plTranslateCursor( &gin );
3107 *x = gin.wX; *y = gin.wY;
3108 return st;
3109 }
3110
3111
3112 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
3113 {
3114 if (!ov.is_scalar_type())
3115 return SWIG_TypeError;
3116 if (ov.is_complex_scalar())
3117 return SWIG_TypeError;
3118 if (val)
3119 *val = ov.double_value();
3120 return SWIG_OK;
3121 }
3122
3123
3124// Create 1d stripchart
3125
3126 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3127 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3128 PLFLT xlpos, PLFLT ylpos,
3129 PLBOOL y_ascl, PLBOOL acc,
3130 PLINT colbox, PLINT collab,
3131 const PLINT *colline, const PLINT *styline,
3132 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3133 const char *labx, const char *laby, const char *labtop )
3134 {
3135 const char *legline[4];
3136 legline[0] = legline1; legline[1] = legline2;
3137 legline[2] = legline3; legline[3] = legline4;
3138 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3139 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3140 labx, laby, labtop );
3141 }
3142
3143
3144// One more hack. As it is not possible (and would not be desirable) to pass
3145// an Octave function to plcont(), I have defined three plcont():
3146// plcont uses a defined here xform()
3147// plcont0 uses pltr0()
3148// plcont1 uses pltr1()
3149// plcont2 uses pltr2()
3150// plcont2p uses pltr2p()
3151//
3152// Also, as plplot expect vectorized bidimensional arrays, I provided a
3153// f2c, which is a #define that does the necessary conversion.
3154//
3155
3156 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3157 {
3158 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3159 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3160 }
3161
3162// convert from Fortran like arrays (one vector), to C like 2D arrays
3163
3164#define f2c( f, ff, nx, ny ) \
3165 PLFLT * *ff; \
3166 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3167 for ( int i = 0; i < nx; i++ ) { \
3168 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3169 for ( int j = 0; j < ny; j++ ) \
3170 *( ff[i] + j ) = *( f + nx * j + i );}
3171
3172// simpler plcont() for use with xform()
3173
3174 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3175 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3176 {
3177 f2c( f, ff, nx, ny );
3178 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3179 }
3180
3181// plcont() for use with pltr0() NOT TESTED
3182
3183 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3184 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3185 {
3186 f2c( f, ff, nx, ny );
3187 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3188 }
3189
3190// plcont() for use with pltr1()
3191
3192 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3193 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3194 {
3195 PLcGrid grid1;
3196 grid1.nx = nx; grid1.ny = ny;
3197 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3198 f2c( f, ff, nx, ny );
3199 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3200 }
3201
3202// plcont() for use with pltr2()
3203 void my_plcont2( 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 PLcGrid2 grid2;
3207 f2c( xg, xgg, nx, ny );
3208 f2c( yg, ygg, nx, ny );
3209 grid2.nx = nx; grid2.ny = ny;
3210 grid2.xg = xgg; grid2.yg = ygg;
3211 f2c( f, ff, nx, ny );
3212 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3213 }
3214
3215// plcont() for use with pltr2p()
3216
3217 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3218 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3219 {
3220 PLcGrid2 grid2;
3221 f2c( xg, xgg, nx, ny );
3222 f2c( yg, ygg, nx, ny );
3223 grid2.nx = nx; grid2.ny = ny;
3224 grid2.xg = xgg; grid2.yg = ygg;
3225 f2c( f, ff, nx, ny );
3226 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3227 }
3228
3229
3230 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3231 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3232 PLFLT *zg, int type, PLFLT data )
3233 {
3234 f2c( zg, zgg, nptsx, nptsy );
3235 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3236 for ( int i = 0; i < nptsx; i++ )
3237 for ( int j = 0; j < nptsy; j++ )
3238 *( zg + nptsx * j + i ) = zgg[i][j];
3239 }
3240
3241
3242// Plots a mesh representation of the function z[x][y].
3243
3244 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3245 {
3246 f2c( z, zz, nx, ny );
3247 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3248 }
3249
3250// Plots a mesh representation of the function z[x][y] with contour
3251
3252 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3253 {
3254 f2c( z, zz, nx, ny );
3255 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3256 }
3257
3258
3259// Plots a 3-d representation of the function z[x][y].
3260 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3261 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3262 {
3263 f2c( z, zz, nx, ny );
3264 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3265 }
3266
3267// Plots a 3-d representation of the function z[x][y] with contour
3268 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3269 PLINT nx, PLINT ny, PLINT opt,
3270 const PLFLT *clevel, PLINT nlevel )
3271 {
3272 f2c( z, zz, nx, ny );
3273 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3274 }
3275// Plots a 3-d representation of the function z[x][y] with contour with y
3276// index limits
3277 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3278 PLINT nx, PLINT ny, PLINT opt,
3279 const PLFLT * clevel, PLINT nlevel,
3280 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3281 {
3282 f2c( z, zz, nx, ny );
3283 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3284 indexxmin, indexxmax, indexymin, indexymax );
3285 }
3286
3287
3288 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3289 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3290 {
3291 f2c( z, zz, nx, ny );
3292 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3293 }
3294
3295 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3296 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3297 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3298 {
3299 f2c( z, zz, nx, ny );
3300 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3301 indexxmin, indexxmax, indexymin, indexymax );
3302 }
3303
3304
3305// The same as in plcont. I have hardcoded the first function pointer
3306// to plfill(). The second function pointer will use the same convention
3307// as in plcont().
3308//
3309
3310// the simpler plshade()
3311 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3312 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3313 PLFLT shade_min, PLFLT shade_max,
3314 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3315 PLINT min_color, PLINT min_width,
3316 PLINT max_color, PLINT max_width,
3317 PLINT rectangular, PLFLT *tr )
3318 {
3319 f2c( a, aa, nx, ny );
3320 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3321 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3322 min_color, min_width, max_color, max_width,
3323 plfill, rectangular, xform, tr );
3324 }
3325
3326// plshade() for use with pltr1
3327 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3328 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3329 PLFLT shade_min, PLFLT shade_max,
3330 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3331 PLINT min_color, PLINT min_width,
3332 PLINT max_color, PLINT max_width,
3333 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3334 {
3335 PLcGrid grid1;
3336 grid1.nx = nx; grid1.ny = ny;
3337 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3338 f2c( a, aa, nx, ny );
3339 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3340 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3341 min_color, min_width, max_color, max_width,
3342 plfill, rectangular, pltr1, &grid1 );
3343 }
3344
3345// plshade() for use with pltr2
3346 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3347 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3348 PLFLT shade_min, PLFLT shade_max,
3349 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3350 PLINT min_color, PLINT min_width,
3351 PLINT max_color, PLINT max_width,
3352 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3353 {
3354 PLcGrid2 grid2;
3355 f2c( xg, xgg, nx, ny );
3356 f2c( yg, ygg, nx, ny );
3357 grid2.nx = nx; grid2.ny = ny;
3358 grid2.xg = xgg; grid2.yg = ygg;
3359 f2c( a, aa, nx, ny );
3360 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3361 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3362 min_color, min_width, max_color, max_width,
3363 plfill, rectangular, pltr2, &grid2 );
3364 }
3365
3366
3367
3368 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3369 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3370 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3371 PLINT cont_color, PLINT cont_width,
3372 PLINT rectangular )
3373 {
3374 f2c( a, aa, nx, ny );
3375 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3376 clevel, nlevel, fill_width, cont_color, cont_width,
3377 plfill, rectangular, NULL, NULL );
3378 }
3379
3380 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3381 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3382 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3383 PLINT cont_color, PLINT cont_width,
3384 PLINT rectangular, PLFLT *tr )
3385 {
3386 f2c( a, aa, nx, ny );
3387 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3388 clevel, nlevel, fill_width, cont_color, cont_width,
3389 plfill, rectangular, xform, tr );
3390 }
3391
3392 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3393 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3394 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3395 PLINT cont_color, PLINT cont_width,
3396 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3397 {
3398 PLcGrid grid1;
3399 grid1.nx = nx; grid1.ny = ny;
3400 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3401
3402 f2c( a, aa, nx, ny );
3403 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3404 clevel, nlevel, fill_width, cont_color, cont_width,
3405 plfill, rectangular, pltr1, &grid1 );
3406 }
3407
3408 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3409 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3410 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3411 PLINT cont_color, PLINT cont_width,
3412 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3413 {
3414 PLcGrid2 grid2;
3415 f2c( xg, xgg, nx, ny );
3416 f2c( yg, ygg, nx, ny );
3417 grid2.nx = nx; grid2.ny = ny;
3418 grid2.xg = xgg; grid2.yg = ygg;
3419 f2c( a, aa, nx, ny );
3420 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3421 clevel, nlevel, fill_width, cont_color, cont_width,
3422 plfill, rectangular, pltr2, &grid2 );
3423 }
3424
3425
3426// Plot an array of vector arrows - uses the same function pointer
3427// convention as plcont
3428
3429 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3430 {
3431 f2c( u, uu, nx, ny );
3432 f2c( v, vv, nx, ny );
3433 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3434 }
3435
3436// plvect() for use with pltr1
3437 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3438 {
3439 PLcGrid grid1;
3440 grid1.nx = nx; grid1.ny = ny;
3441 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3442 f2c( u, uu, nx, ny );
3443 f2c( v, vv, nx, ny );
3444 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3445 }
3446
3447// plvect() for use with pltr2
3448 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3449 {
3450 PLcGrid2 grid2;
3451 f2c( xg, xgg, nx, ny );
3452 f2c( yg, ygg, nx, ny );
3453 grid2.nx = nx; grid2.ny = ny;
3454 grid2.xg = xgg; grid2.yg = ygg;
3455 f2c( u, uu, nx, ny );
3456 f2c( v, vv, nx, ny );
3457 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3458 }
3459
3460
3461// Plot an image with distortion - uses the same function pointer
3462 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3463 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3464 PLFLT zmin, PLFLT zmax,
3465 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3466 {
3467 f2c( a, aa, nx, ny );
3468 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3469 }
3470
3471// Plot an image with distortion - uses the same function pointer
3472// convention as plcont
3473 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3474 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3475 PLFLT zmin, PLFLT zmax,
3476 PLFLT valuemin, PLFLT valuemax )
3477 {
3478 f2c( a, aa, nx, ny );
3479 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3480 }
3481
3482 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3483 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3484 PLFLT zmin, PLFLT zmax,
3485 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3486 {
3487 f2c( a, aa, nx, ny );
3488 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3489 }
3490
3491// plimagefr() for use with pltr1
3492 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3493 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3494 PLFLT zmin, PLFLT zmax,
3495 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3496 {
3497 PLcGrid grid1;
3498 grid1.nx = nx + 1; grid1.ny = ny + 1;
3499 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3500 f2c( a, aa, nx, ny );
3501 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3502 }
3503
3504// plimagefr() for use with pltr2
3505 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3506 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3507 PLFLT zmin, PLFLT zmax,
3508 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3509 {
3510 PLcGrid2 grid2;
3511 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3512 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3513 grid2.nx = nx + 1; grid2.ny = ny + 1;
3514 grid2.xg = xgg; grid2.yg = ygg;
3515 f2c( a, aa, nx, ny );
3516 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3517 }
3518
3519
3520
3521 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3522 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3523 PLFLT x_length, PLFLT y_length,
3524 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3525 PLFLT low_cap_color, PLFLT high_cap_color,
3526 PLINT cont_color, PLFLT cont_width,
3527 PLINT n_labels, const PLINT *label_opts, const char **label,
3528 PLINT n_axes, const char ** axis_opts,
3529 const PLFLT *ticks, const PLINT *sub_ticks,
3530 const PLINT *n_values, const PLFLT *a )
3531 {
3532 PLINT nx, ny, i;
3533 nx = n_axes;
3534 ny = -1;
3535 for ( i = 0; i < nx; i++ )
3536 if ( n_values[i] > ny )
3537 ny = n_values[i];
3538 f2c( a, aa, nx, ny );
3539 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3540 opt, position, x, y,
3541 x_length, y_length,
3542 bg_color, bb_color, bb_style,
3543 low_cap_color, high_cap_color,
3544 cont_color, cont_width,
3545 n_labels, label_opts, label,
3546 n_axes, axis_opts,
3547 ticks, sub_ticks,
3548 n_values, aa );
3549 }
3550
3551
3552
3553 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3554 {
3555 if (!ov.is_scalar_type())
3556 return SWIG_TypeError;
3557 if (ov.is_complex_scalar())
3558 return SWIG_TypeError;
3559 if (ov.is_double_type()||ov.is_single_type()) {
3560 double v=ov.double_value();
3561 if (v<0)
3562 return SWIG_OverflowError;
3563 if (v!=floor(v))
3564 return SWIG_TypeError;
3565 }
3566 if (ov.is_int8_type()||ov.is_int16_type()||
3567 ov.is_int32_type()) {
3568 long v=ov.long_value();
3569 if (v<0)
3570 return SWIG_OverflowError;
3571 }
3572 if (ov.is_int64_type()) {
3573 long long v=ov.int64_scalar_value().value();
3574 if (v<0)
3575 return SWIG_OverflowError;
3576 }
3577 if (val)
3578 *val = ov.ulong_value();
3579 return SWIG_OK;
3580 }
3581
3582
3583SWIGINTERN int
3584SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3585{
3586 unsigned long v;
3587 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3588 if (SWIG_IsOK(res)) {
3589 if ((v > UINT_MAX)) {
3590 return SWIG_OverflowError;
3591 } else {
3592 if (val) *val = static_cast< unsigned int >(v);
3593 }
3594 }
3595 return res;
3596}
3597
3598
3600 {
3601 return octave_value(value);
3602 }
3603
3604
3605SWIGINTERNINLINE octave_value
3607{
3609}
3610
3611
3612SWIGINTERN int
3613SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3614{
3615 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3616 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3617 if (SWIG_IsOK(res)) {
3618 /* special case of single char conversion when we don't need space for NUL */
3619 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3620 if (csize <= size) {
3621 if (val) {
3622 if (csize) memcpy(val, cptr, csize*sizeof(char));
3623 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3624 }
3625 if (alloc == SWIG_NEWOBJ) {
3626 delete[] cptr;
3627 res = SWIG_DelNewMask(res);
3628 }
3629 return res;
3630 }
3631 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3632 }
3633 return SWIG_TypeError;
3634}
3635
3636
3639{
3640 static int init = 0;
3641 static swig_type_info* info = 0;
3642 if (!init) {
3643 info = SWIG_TypeQuery("_p_char");
3644 init = 1;
3645 }
3646 return info;
3647}
3648
3649
3650SWIGINTERNINLINE octave_value
3651SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3652{
3653 return std::string(carray,carray+size);
3654}
3655
3656
3657SWIGINTERN size_t
3658SWIG_strnlen(const char* s, size_t maxlen)
3659{
3660 const char *p;
3661 for (p = s; maxlen-- && *p; p++)
3662 ;
3663 return p - s;
3664}
3665
3666
3667SWIGINTERN int
3668SWIG_AsVal_char (octave_value obj, char *val)
3669{
3670 int res = SWIG_AsCharArray(obj, val, 1);
3671 if (!SWIG_IsOK(res)) {
3672 long v;
3673 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3674 if (SWIG_IsOK(res)) {
3675 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3676 if (val) *val = static_cast< char >(v);
3677 } else {
3678 res = SWIG_OverflowError;
3679 }
3680 }
3681 }
3682 return res;
3683}
3684
3685static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3686Set up transformation from metafile coordinates\n\
3687\n\
3688DESCRIPTION:\n\
3689\n\
3690 Set up transformation from metafile coordinates. The size of the plot\n\
3691 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3692 general-purpose facility just yet (not sure why the user would need\n\
3693 it, for one).\n\
3694\n\
3695 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3696 dimypmm)\n\
3697\n\
3698 This function is not used in any examples.\n\
3699\n\
3700\n\
3701\n\
3702SYNOPSIS:\n\
3703\n\
3704plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3705\n\
3706ARGUMENTS:\n\
3707\n\
3708 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3709\n\
3710 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3711\n\
3712 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3713\n\
3714 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3715\n\
3716 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3717\n\
3718 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3719";
3720static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3721Set the cmap0 palette using the specified cmap0*.pal format file\n\
3722\n\
3723DESCRIPTION:\n\
3724\n\
3725 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3726\n\
3727 Redacted form: plspal0(filename)\n\
3728\n\
3729 This function is in example 16.\n\
3730\n\
3731\n\
3732\n\
3733SYNOPSIS:\n\
3734\n\
3735plspal0(filename)\n\
3736\n\
3737ARGUMENTS:\n\
3738\n\
3739 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3740 containing the name of the cmap0*.pal file. If this string is\n\
3741 empty, use the default cmap0*.pal file.\n\
3742";
3743static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3744Set the cmap1 palette using the specified cmap1*.pal format file\n\
3745\n\
3746DESCRIPTION:\n\
3747\n\
3748 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3749\n\
3750 Redacted form: plspal1(filename, interpolate)\n\
3751\n\
3752 This function is used in example 16.\n\
3753\n\
3754\n\
3755\n\
3756SYNOPSIS:\n\
3757\n\
3758plspal1(filename, interpolate)\n\
3759\n\
3760ARGUMENTS:\n\
3761\n\
3762 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3763 containing the name of the cmap1*.pal file. If this string is\n\
3764 empty, use the default cmap1*.pal file.\n\
3765\n\
3766 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3767 columns containing the intensity index, r, g, b, alpha and\n\
3768 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3769 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3770 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3771 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3772 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3773 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3774 are used instead to set the cmap1 palette directly with a call to\n\
3775 plscmap1a.\n\
3776";
3777static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3778Draw a line in 3 space\n\
3779\n\
3780DESCRIPTION:\n\
3781\n\
3782 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3783 first set up the viewport, the 2d viewing window (in world\n\
3784 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3785 more info.\n\
3786\n\
3787 Redacted form: plline3(x, y, z)\n\
3788\n\
3789 This function is used in example 18.\n\
3790\n\
3791\n\
3792\n\
3793SYNOPSIS:\n\
3794\n\
3795plline3(n, x, y, z)\n\
3796\n\
3797ARGUMENTS:\n\
3798\n\
3799 n (PLINT, input) : Number of points defining line.\n\
3800\n\
3801 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3802 points.\n\
3803\n\
3804 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3805 points.\n\
3806\n\
3807 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3808 points.\n\
3809";
3810static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3811Magnitude colored plot surface mesh with contour\n\
3812\n\
3813DESCRIPTION:\n\
3814\n\
3815 A more powerful form of plmesh: the surface mesh can be colored\n\
3816 accordingly to the current z value being plotted, a contour plot can\n\
3817 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3818 plotted function border and the base XY plane.\n\
3819\n\
3820 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3821\n\
3822 This function is used in example 11.\n\
3823\n\
3824\n\
3825\n\
3826SYNOPSIS:\n\
3827\n\
3828plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3829\n\
3830ARGUMENTS:\n\
3831\n\
3832 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3833 which the function is evaluated.\n\
3834\n\
3835 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3836 which the function is evaluated.\n\
3837\n\
3838 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3839 plot. Should have dimensions of\n\
3840 nx by\n\
3841 ny.\n\
3842\n\
3843 nx (PLINT, input) : Number of x values at which function is\n\
3844 evaluated.\n\
3845\n\
3846 ny (PLINT, input) : Number of y values at which function is\n\
3847 evaluated.\n\
3848\n\
3849 opt (PLINT, input) : Determines the way in which the surface is\n\
3850 represented. To specify more than one option just add the options,\n\
3851 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3852 showing z as a function of x for each value of y[j] .\n\
3853 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3854 for each value of x[i] .\n\
3855 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3856 at which function is defined.\n\
3857 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3858 the z value being plotted. The color is used from the current\n\
3859 cmap1.\n\
3860 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3861 using parameters\n\
3862 nlevel and\n\
3863 clevel.\n\
3864 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3865 the borders of the plotted function.\n\
3866\n\
3867\n\
3868 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3869 levels.\n\
3870\n\
3871 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3872";
3873static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3874Draw a line between two points, accounting for coordinate transforms\n\
3875\n\
3876DESCRIPTION:\n\
3877\n\
3878 Joins the point (\n\
3879 x1,\n\
3880 y1) to (\n\
3881 x2,\n\
3882 y2) . If a global coordinate transform is defined then the line is\n\
3883 broken in to n segments to approximate the path. If no transform is\n\
3884 defined then this simply acts like a call to pljoin.\n\
3885\n\
3886 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3887\n\
3888 This function is used in example 22.\n\
3889\n\
3890\n\
3891\n\
3892SYNOPSIS:\n\
3893\n\
3894plpath(n, x1, y1, x2, y2)\n\
3895\n\
3896ARGUMENTS:\n\
3897\n\
3898 n (PLINT, input) : number of points to use to approximate the path.\n\
3899\n\
3900 x1 (PLFLT, input) : x coordinate of first point.\n\
3901\n\
3902 y1 (PLFLT, input) : y coordinate of first point.\n\
3903\n\
3904 x2 (PLFLT, input) : x coordinate of second point.\n\
3905\n\
3906 y2 (PLFLT, input) : y coordinate of second point.\n\
3907";
3908static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3909Write text inside the viewport\n\
3910\n\
3911DESCRIPTION:\n\
3912\n\
3913 Writes text at a specified position and inclination within the\n\
3914 viewport. Text is clipped at the viewport boundaries. The reference\n\
3915 point of a string lies along a line passing through the string at half\n\
3916 the height of a capital letter. The position of the reference point\n\
3917 along this line is determined by just, the reference point is placed\n\
3918 at world coordinates (\n\
3919 x,\n\
3920 y) within the viewport. The inclination of the string is specified\n\
3921 in terms of differences of world coordinates making it easy to write\n\
3922 text parallel to a line in a graph.\n\
3923\n\
3924 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3925\n\
3926 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3927\n\
3928\n\
3929\n\
3930SYNOPSIS:\n\
3931\n\
3932plptex(x, y, dx, dy, just, text)\n\
3933\n\
3934ARGUMENTS:\n\
3935\n\
3936 x (PLFLT, input) : x coordinate of reference point of string.\n\
3937\n\
3938 y (PLFLT, input) : y coordinate of reference point of string.\n\
3939\n\
3940 dx (PLFLT, input) : Together with dy, this specifies the\n\
3941 inclination of the string. The baseline of the string is parallel\n\
3942 to a line joining (\n\
3943 x,\n\
3944 y) to (\n\
3945 x+\n\
3946 dx,\n\
3947 y+\n\
3948 dy) .\n\
3949\n\
3950 dy (PLFLT, input) : Together with dx, this specifies the\n\
3951 inclination of the string.\n\
3952\n\
3953 just (PLFLT, input) : Specifies the position of the string relative\n\
3954 to its reference point. If just=0. , the reference point is at\n\
3955 the left and if just=1. , it is at the right of the string. Other\n\
3956 values of just give intermediate justifications.\n\
3957\n\
3958 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3959 written out.\n\
3960";
3961static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3962Set family file parameters\n\
3963\n\
3964DESCRIPTION:\n\
3965\n\
3966 Sets variables dealing with output file familying. Does nothing if\n\
3967 familying not supported by the driver. This routine, if used, must be\n\
3968 called before initializing PLplot. See the PLplot documentation for\n\
3969 more information.\n\
3970\n\
3971 Redacted form: plsfam(fam, num, bmax)\n\
3972\n\
3973 This function is used in examples 14 and 31.\n\
3974\n\
3975\n\
3976\n\
3977SYNOPSIS:\n\
3978\n\
3979plsfam(fam, num, bmax)\n\
3980\n\
3981ARGUMENTS:\n\
3982\n\
3983 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3984 is enabled.\n\
3985\n\
3986 num (PLINT, input) : Current family file number.\n\
3987\n\
3988 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3989 file.\n\
3990";
3991static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3992Set y axis parameters\n\
3993\n\
3994DESCRIPTION:\n\
3995\n\
3996 Identical to plsxax, except that arguments are flags for y axis. See\n\
3997 the description of plsxax for more detail.\n\
3998\n\
3999 Redacted form: plsyax(digmax, digits)\n\
4000\n\
4001 This function is used in examples 1, 14, and 31.\n\
4002\n\
4003\n\
4004\n\
4005SYNOPSIS:\n\
4006\n\
4007plsyax(digmax, digits)\n\
4008\n\
4009ARGUMENTS:\n\
4010\n\
4011 digmax (PLINT, input) : Variable to set the maximum number of\n\
4012 digits for the y axis. If nonzero, the printed label will be\n\
4013 switched to a floating-point representation when the number of\n\
4014 digits exceeds digmax.\n\
4015\n\
4016 digits (PLINT, input) : Field digits value. Currently, changing\n\
4017 its value here has no effect since it is set only by plbox or\n\
4018 plbox3. However, the user may obtain its value after a call to\n\
4019 either of these functions by calling plgyax.\n\
4020";
4021static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
4022Get z axis parameters\n\
4023\n\
4024DESCRIPTION:\n\
4025\n\
4026 Identical to plgxax, except that arguments are flags for z axis. See\n\
4027 the description of plgxax for more detail.\n\
4028\n\
4029 Redacted form: plgzax(p_digmax, p_digits)\n\
4030\n\
4031 This function is used in example 31.\n\
4032\n\
4033\n\
4034\n\
4035SYNOPSIS:\n\
4036\n\
4037plgzax(p_digmax, p_digits)\n\
4038\n\
4039ARGUMENTS:\n\
4040\n\
4041 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4042 number of digits for the z axis. If nonzero, the printed label\n\
4043 has been switched to a floating-point representation when the\n\
4044 number of digits exceeds this value.\n\
4045\n\
4046 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4047 number of digits for the numeric labels (z axis) from the last\n\
4048 plot.\n\
4049";
4050static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
4051Set format of numerical label for contours\n\
4052\n\
4053DESCRIPTION:\n\
4054\n\
4055 Set format of numerical label for contours.\n\
4056\n\
4057 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4058\n\
4059 This function is used example 9.\n\
4060\n\
4061\n\
4062\n\
4063SYNOPSIS:\n\
4064\n\
4065pl_setcontlabelformat(lexp, sigdig)\n\
4066\n\
4067ARGUMENTS:\n\
4068\n\
4069 lexp (PLINT, input) : If the contour numerical label is greater\n\
4070 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4071 format is used. Default value of lexp is 4.\n\
4072\n\
4073 sigdig (PLINT, input) : Number of significant digits. Default\n\
4074 value is 2.\n\
4075";
4076static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4077Set pen width\n\
4078\n\
4079DESCRIPTION:\n\
4080\n\
4081 Sets the pen width.\n\
4082\n\
4083 Redacted form: plwidth(width)\n\
4084\n\
4085 This function is used in examples 1 and 2.\n\
4086\n\
4087\n\
4088\n\
4089SYNOPSIS:\n\
4090\n\
4091plwidth(width)\n\
4092\n\
4093ARGUMENTS:\n\
4094\n\
4095 width (PLFLT, input) : The desired pen width. If width is negative\n\
4096 or the same as the previous value no action is taken. width = 0.\n\
4097 should be interpreted as as the minimum valid pen width for the\n\
4098 device. The interpretation of positive width values is also\n\
4099 device dependent.\n\
4100";
4101static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4102Get parameters that define current plot-space window\n\
4103\n\
4104DESCRIPTION:\n\
4105\n\
4106 Get relative minima and maxima that define current plot-space window.\n\
4107 If plsdiplt has not been called the default values pointed to by\n\
4108 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4109\n\
4110 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4111\n\
4112 This function is used in example 31.\n\
4113\n\
4114\n\
4115\n\
4116SYNOPSIS:\n\
4117\n\
4118plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4119\n\
4120ARGUMENTS:\n\
4121\n\
4122 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4123 minimum in x.\n\
4124\n\
4125 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4126 minimum in y.\n\
4127\n\
4128 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4129 maximum in x.\n\
4130\n\
4131 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4132 maximum in y.\n\
4133";
4134static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4135Set the cmap1 argument range for continuous color plots\n\
4136\n\
4137DESCRIPTION:\n\
4138\n\
4139 Set the cmap1 argument range for continuous color plots that\n\
4140 corresponds to the range of data values. The maximum range\n\
4141 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4142 the cmap1 argument range that is specified with this routine, the\n\
4143 smaller the subset of the cmap1 color palette that is used to\n\
4144 represent the continuous data being plotted. If\n\
4145 min_color is greater than\n\
4146 max_color or\n\
4147 max_color is greater than 1.0 or\n\
4148 min_color is less than 0.0 then no change is made to the cmap1\n\
4149 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4150\n\
4151 Redacted form: plscmap1_range(min_color, max_color)\n\
4152\n\
4153 This function is currently used in example 33.\n\
4154\n\
4155\n\
4156\n\
4157SYNOPSIS:\n\
4158\n\
4159plscmap1_range(min_color, max_color)\n\
4160\n\
4161ARGUMENTS:\n\
4162\n\
4163 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4164 than 0.0, then 0.0 is used instead.\n\
4165\n\
4166 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4167 than 1.0, then 1.0 is used instead.\n\
4168";
4169static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4170Select standard viewport\n\
4171\n\
4172DESCRIPTION:\n\
4173\n\
4174 Selects the largest viewport within the subpage that leaves a standard\n\
4175 margin (left-hand margin of eight character heights, and a margin\n\
4176 around the other three sides of five character heights).\n\
4177\n\
4178 Redacted form: plvsta()\n\
4179\n\
4180 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4181\n\
4182\n\
4183\n\
4184SYNOPSIS:\n\
4185\n\
4186plvsta()\n\
4187";
4188static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4189Load Hershey fonts\n\
4190\n\
4191DESCRIPTION:\n\
4192\n\
4193 Loads the Hershey fonts used for text and symbols. This routine may\n\
4194 be called before or after initializing PLplot. If not explicitly\n\
4195 called before PLplot initialization, then by default that\n\
4196 initialization loads Hershey fonts with the extended character set.\n\
4197 This routine only has a practical effect for devices that still use\n\
4198 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4199 system fonts instead of Hershey fonts).\n\
4200\n\
4201 Redacted form: plfontld(fnt)\n\
4202\n\
4203 This function is used in examples 1 and 7.\n\
4204\n\
4205\n\
4206\n\
4207SYNOPSIS:\n\
4208\n\
4209plfontld(fnt)\n\
4210\n\
4211ARGUMENTS:\n\
4212\n\
4213 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4214 A zero value specifies Hershey fonts with the standard character\n\
4215 set and a non-zero value (the default assumed if plfontld is never\n\
4216 called) specifies Hershey fonts with the extended character set.\n\
4217";
4218static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4219Draw error bars in x direction\n\
4220\n\
4221DESCRIPTION:\n\
4222\n\
4223 Draws a set of n error bars in x direction, the i\'th error bar\n\
4224 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4225 of the error bars are of length equal to the minor tick length\n\
4226 (settable using plsmin).\n\
4227\n\
4228 Redacted form: General: plerrx(xmin, ymax, y)\n\
4229\n\
4230\n\
4231 This function is used in example 29.\n\
4232\n\
4233\n\
4234\n\
4235SYNOPSIS:\n\
4236\n\
4237plerrx(n, xmin, xmax, y)\n\
4238\n\
4239ARGUMENTS:\n\
4240\n\
4241 n (PLINT, input) : Number of error bars to draw.\n\
4242\n\
4243 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4244 of the left-hand endpoints of the error bars.\n\
4245\n\
4246 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4247 of the right-hand endpoints of the error bars.\n\
4248\n\
4249 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4250 the error bars.\n\
4251";
4252static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4253Plot shaded 3-d surface plot\n\
4254\n\
4255DESCRIPTION:\n\
4256\n\
4257 Plots a three-dimensional shaded surface plot within the environment\n\
4258 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4259 z[\n\
4260 nx][\n\
4261 ny], the point z[i][j] being the value of the function at (\n\
4262 x[i],\n\
4263 y[j]). Note that the points in vectors x and y do not need to be\n\
4264 equally spaced, but must be stored in ascending order. For further\n\
4265 details see the PLplot documentation.\n\
4266\n\
4267 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4268\n\
4269 This function is not used in any examples.\n\
4270\n\
4271\n\
4272\n\
4273SYNOPSIS:\n\
4274\n\
4275plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4276\n\
4277ARGUMENTS:\n\
4278\n\
4279 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4280 which the function is evaluated.\n\
4281\n\
4282 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4283 which the function is evaluated.\n\
4284\n\
4285 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4286 plot. Should have dimensions of\n\
4287 nx by\n\
4288 ny.\n\
4289\n\
4290 nx (PLINT, input) : Number of x values at which function is\n\
4291 evaluated.\n\
4292\n\
4293 ny (PLINT, input) : Number of y values at which function is\n\
4294 evaluated.\n\
4295\n\
4296 opt (PLINT, input) : Determines the way in which the surface is\n\
4297 represented. To specify more than one option just add the options,\n\
4298 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4299 connecting points at which function is defined.\n\
4300 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4301 using parameters\n\
4302 nlevel and\n\
4303 clevel.\n\
4304 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4305 using parameters\n\
4306 nlevel and\n\
4307 clevel.\n\
4308 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4309 the borders of the plotted function.\n\
4310 opt=MAG_COLOR : the surface is colored according to the value\n\
4311 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4312 according to the intensity of the reflected light in the\n\
4313 surface from a light source whose position is set using\n\
4314 pllightsource.\n\
4315\n\
4316\n\
4317 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4318 levels.\n\
4319\n\
4320 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4321";
4322static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4323Get the current library version number\n\
4324\n\
4325DESCRIPTION:\n\
4326\n\
4327 Get the current library version number. Note: you must have allocated\n\
4328 space for this (80 characters is safe).\n\
4329\n\
4330 Redacted form: plgver(p_ver)\n\
4331\n\
4332 This function is used in example 1.\n\
4333\n\
4334\n\
4335\n\
4336SYNOPSIS:\n\
4337\n\
4338plgver(p_ver)\n\
4339\n\
4340ARGUMENTS:\n\
4341\n\
4342 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4343 (with preallocated length of 80 characters or more) containing the\n\
4344 PLplot version number.\n\
4345";
4346static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4347End plotting session for current stream\n\
4348\n\
4349DESCRIPTION:\n\
4350\n\
4351 Ends a plotting session for the current output stream only. See\n\
4352 plsstrm for more info.\n\
4353\n\
4354 Redacted form: plend1()\n\
4355\n\
4356 This function is used in examples 1 and 20.\n\
4357\n\
4358\n\
4359\n\
4360SYNOPSIS:\n\
4361\n\
4362plend1()\n\
4363";
4364static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4365Draw error bars in the y direction\n\
4366\n\
4367DESCRIPTION:\n\
4368\n\
4369 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4370 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4371 of the error bars are of length equal to the minor tick length\n\
4372 (settable using plsmin).\n\
4373\n\
4374 Redacted form: General: plerry(x, ymin, ymax)\n\
4375\n\
4376\n\
4377 This function is used in example 29.\n\
4378\n\
4379\n\
4380\n\
4381SYNOPSIS:\n\
4382\n\
4383plerry(n, x, ymin, ymax)\n\
4384\n\
4385ARGUMENTS:\n\
4386\n\
4387 n (PLINT, input) : Number of error bars to draw.\n\
4388\n\
4389 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4390 the error bars.\n\
4391\n\
4392 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4393 of the lower endpoints of the error bars.\n\
4394\n\
4395 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4396 of the upper endpoints of the error bars.\n\
4397";
4398static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4399Set seed for internal random number generator.\n\
4400\n\
4401DESCRIPTION:\n\
4402\n\
4403 Set the seed for the internal random number generator. See plrandd for\n\
4404 further details.\n\
4405\n\
4406 Redacted form: plseed(seed)\n\
4407\n\
4408 This function is used in example 21.\n\
4409\n\
4410\n\
4411\n\
4412SYNOPSIS:\n\
4413\n\
4414plseed(seed)\n\
4415\n\
4416ARGUMENTS:\n\
4417\n\
4418 seed (unsigned int, input) : Seed for random number generator.\n\
4419";
4420static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4421Specify viewport using normalized subpage coordinates\n\
4422\n\
4423DESCRIPTION:\n\
4424\n\
4425 Device-independent routine for setting up the viewport. This defines\n\
4426 the viewport in terms of normalized subpage coordinates which run from\n\
4427 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4428 current subpage. Use the alternate routine plsvpa in order to create\n\
4429 a viewport of a definite size.\n\
4430\n\
4431 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4432\n\
4433 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4434 24, 26, 27, and 31.\n\
4435\n\
4436\n\
4437\n\
4438SYNOPSIS:\n\
4439\n\
4440plvpor(xmin, xmax, ymin, ymax)\n\
4441\n\
4442ARGUMENTS:\n\
4443\n\
4444 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4445 left-hand edge of the viewport.\n\
4446\n\
4447 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4448 right-hand edge of the viewport.\n\
4449\n\
4450 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4451 bottom edge of the viewport.\n\
4452\n\
4453 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4454 edge of the viewport.\n\
4455";
4456static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4457Plot surface mesh\n\
4458\n\
4459DESCRIPTION:\n\
4460\n\
4461 Plots a surface mesh within the environment set up by plw3d. The\n\
4462 surface is defined by the matrix z[\n\
4463 nx][\n\
4464 ny] , the point z[i][j] being the value of the function at (\n\
4465 x[i],\n\
4466 y[j]). Note that the points in vectors x and y do not need to be\n\
4467 equally spaced, but must be stored in ascending order. The parameter\n\
4468 opt controls the way in which the surface is displayed. For further\n\
4469 details see the PLplot documentation.\n\
4470\n\
4471 Redacted form: plmesh(x, y, z, opt)\n\
4472\n\
4473 This function is used in example 11.\n\
4474\n\
4475\n\
4476\n\
4477SYNOPSIS:\n\
4478\n\
4479plmesh(x, y, z, nx, ny, opt)\n\
4480\n\
4481ARGUMENTS:\n\
4482\n\
4483 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4484 which the function is evaluated.\n\
4485\n\
4486 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4487 which the function is evaluated.\n\
4488\n\
4489 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4490 plot. Should have dimensions of\n\
4491 nx by\n\
4492 ny.\n\
4493\n\
4494 nx (PLINT, input) : Number of x values at which function has been\n\
4495 evaluated.\n\
4496\n\
4497 ny (PLINT, input) : Number of y values at which function has been\n\
4498 evaluated.\n\
4499\n\
4500 opt (PLINT, input) : Determines the way in which the surface is\n\
4501 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4502 function of x for each value of y[j] .\n\
4503 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4504 for each value of x[i] .\n\
4505 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4506 at which function is defined.\n\
4507";
4508static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4509Get the cmap1 argument range for continuous color plots\n\
4510\n\
4511DESCRIPTION:\n\
4512\n\
4513 Get the cmap1 argument range for continuous color plots. (Use\n\
4514 plscmap1_range to set the cmap1 argument range.)\n\
4515\n\
4516 Redacted form: plgcmap1_range(min_color, max_color)\n\
4517\n\
4518 This function is currently not used in any example.\n\
4519\n\
4520\n\
4521\n\
4522SYNOPSIS:\n\
4523\n\
4524plgcmap1_range(min_color, max_color)\n\
4525\n\
4526ARGUMENTS:\n\
4527\n\
4528 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4529 minimum cmap1 argument.\n\
4530\n\
4531 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4532 maximum cmap1 argument.\n\
4533";
4534static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4535Set arrow style for vector plots\n\
4536\n\
4537DESCRIPTION:\n\
4538\n\
4539 Set the style for the arrow used by plvect to plot vectors.\n\
4540\n\
4541 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4542\n\
4543 This function is used in example 22.\n\
4544\n\
4545\n\
4546\n\
4547SYNOPSIS:\n\
4548\n\
4549plsvect(arrowx, arrowy, npts, fill)\n\
4550\n\
4551ARGUMENTS:\n\
4552\n\
4553 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4554 the x and y points which make up the arrow. The arrow is plotted\n\
4555 by joining these points to form a polygon. The scaling assumes\n\
4556 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4557 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4558 will be reset to its default.\n\
4559\n\
4560 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4561 arrowy.\n\
4562\n\
4563 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4564 fill is false then the arrow is open.\n\
4565";
4566static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4567Draw filled polygon\n\
4568\n\
4569DESCRIPTION:\n\
4570\n\
4571 Fills the polygon defined by the n points (\n\
4572 x[i],\n\
4573 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4574 style is a solid fill. The routine will automatically close the\n\
4575 polygon between the last and first vertices. If multiple closed\n\
4576 polygons are passed in x and y then plfill will fill in between them.\n\
4577\n\
4578 Redacted form: plfill(x,y)\n\
4579\n\
4580 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4581\n\
4582\n\
4583\n\
4584SYNOPSIS:\n\
4585\n\
4586plfill(n, x, y)\n\
4587\n\
4588ARGUMENTS:\n\
4589\n\
4590 n (PLINT, input) : Number of vertices in polygon.\n\
4591\n\
4592 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4593 vertices.\n\
4594\n\
4595 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4596 vertices.\n\
4597";
4598static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4599Convert HLS color to RGB\n\
4600\n\
4601DESCRIPTION:\n\
4602\n\
4603 Convert HLS color coordinates to RGB.\n\
4604\n\
4605 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4606\n\
4607\n\
4608 This function is used in example 2.\n\
4609\n\
4610\n\
4611\n\
4612SYNOPSIS:\n\
4613\n\
4614plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4615\n\
4616ARGUMENTS:\n\
4617\n\
4618 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4619 cylinder.\n\
4620\n\
4621 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4622 the axis of the color cylinder.\n\
4623\n\
4624 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4625 the radius of the color cylinder.\n\
4626\n\
4627 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4628 (0.0-1.0) of the color.\n\
4629\n\
4630 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4631 intensity (0.0-1.0) of the color.\n\
4632\n\
4633 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4634 intensity (0.0-1.0) of the color.\n\
4635";
4636static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4637Set format for date / time labels\n\
4638\n\
4639DESCRIPTION:\n\
4640\n\
4641 Sets the format for date / time labels. To enable date / time format\n\
4642 labels see the options to plbox, plbox3, and plenv.\n\
4643\n\
4644 Redacted form: pltimefmt(fmt)\n\
4645\n\
4646 This function is used in example 29.\n\
4647\n\
4648\n\
4649\n\
4650SYNOPSIS:\n\
4651\n\
4652pltimefmt(fmt)\n\
4653\n\
4654ARGUMENTS:\n\
4655\n\
4656 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4657 interpreted similarly to the format specifier of typical system\n\
4658 strftime routines except that PLplot ignores locale and also\n\
4659 supplies some useful extensions in the context of plotting. All\n\
4660 text in the string is printed as-is other than conversion\n\
4661 specifications which take the form of a \'%\' character followed by\n\
4662 further conversion specification character. The conversion\n\
4663 specifications which are similar to those provided by system\n\
4664 strftime routines are the following: %a: The abbreviated (English)\n\
4665 weekday name.\n\
4666 %A: The full (English) weekday name.\n\
4667 %b: The abbreviated (English) month name.\n\
4668 %B: The full (English) month name.\n\
4669 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4670 %C: The century number (year/100) as a 2-digit integer.\n\
4671 %d: The day of the month as a decimal number (range 01 to 31).\n\
4672 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4673 %e: Like %d, but a leading zero is replaced by a space.\n\
4674 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4675 %h: Equivalent to %b.\n\
4676 %H: The hour as a decimal number using a 24-hour clock (range\n\
4677 00 to 23).\n\
4678 %I: The hour as a decimal number using a 12-hour clock (range\n\
4679 01 to 12).\n\
4680 %j: The day of the year as a decimal number (range 001 to\n\
4681 366).\n\
4682 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4683 23); single digits are preceded by a blank. (See also %H.)\n\
4684 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4685 12); single digits are preceded by a blank. (See also %I.)\n\
4686 %m: The month as a decimal number (range 01 to 12).\n\
4687 %M: The minute as a decimal number (range 00 to 59).\n\
4688 %n: A newline character.\n\
4689 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4690 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4691 %r: Equivalent to %I:%M:%S %p.\n\
4692 %R: The time in 24-hour notation (%H:%M). For a version\n\
4693 including the seconds, see %T below.\n\
4694 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4695 +0000 (UTC).\n\
4696 %S: The second as a decimal number (range 00 to 60). (The\n\
4697 range is up to 60 to allow for occasional leap seconds.)\n\
4698 %t: A tab character.\n\
4699 %T: The time in 24-hour notation (%H:%M:%S).\n\
4700 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4701 being 1. See also %w.\n\
4702 %U: The week number of the current year as a decimal number,\n\
4703 range 00 to 53, starting with the first Sunday as the first\n\
4704 day of week 01. See also %V and %W.\n\
4705 %v: Equivalent to %e-%b-%Y.\n\
4706 %V: The ISO 8601 week number of the current year as a decimal\n\
4707 number, range 01 to 53, where week 1 is the first week that\n\
4708 has at least 4 days in the new year. See also %U and %W.\n\
4709 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4710 being 0. See also %u.\n\
4711 %W: The week number of the current year as a decimal number,\n\
4712 range 00 to 53, starting with the first Monday as the first\n\
4713 day of week 01.\n\
4714 %x: Equivalent to %a %b %d %Y.\n\
4715 %X: Equivalent to %T.\n\
4716 %y: The year as a decimal number without a century (range 00\n\
4717 to 99).\n\
4718 %Y: The year as a decimal number including a century.\n\
4719 %z: The UTC time-zone string = \"+0000\".\n\
4720 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4721 %+: The UTC date and time in default format of the Unix date\n\
4722 command which is equivalent to %a %b %d %T %Z %Y.\n\
4723 %%: A literal \"%\" character.\n\
4724 The conversion specifications which are extensions to those normally\n\
4725 provided by system strftime routines are the following: %(0-9):\n\
4726 The fractional part of the seconds field (including leading\n\
4727 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4728 seconds to millisecond accuracy (00.000).\n\
4729 %.: The fractional part of the seconds field (including\n\
4730 leading decimal point) to the maximum available accuracy. Thus\n\
4731 %S%. would give seconds with fractional part up to 9 decimal\n\
4732 places if available.\n\
4733";
4734static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4735Get current subpage parameters\n\
4736\n\
4737DESCRIPTION:\n\
4738\n\
4739 Gets the size of the current subpage in millimeters measured from the\n\
4740 bottom left hand corner of the output device page or screen. Can be\n\
4741 used in conjunction with plsvpa for setting the size of a viewport in\n\
4742 absolute coordinates (millimeters).\n\
4743\n\
4744 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4745\n\
4746 This function is used in example 23.\n\
4747\n\
4748\n\
4749\n\
4750SYNOPSIS:\n\
4751\n\
4752plgspa(xmin, xmax, ymin, ymax)\n\
4753\n\
4754ARGUMENTS:\n\
4755\n\
4756 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4757 the left hand edge of the subpage in millimeters.\n\
4758\n\
4759 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4760 the right hand edge of the subpage in millimeters.\n\
4761\n\
4762 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4763 the bottom edge of the subpage in millimeters.\n\
4764\n\
4765 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4766 the top edge of the subpage in millimeters.\n\
4767";
4768static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4769Calculate world coordinates and corresponding window index from relative device coordinates\n\
4770\n\
4771DESCRIPTION:\n\
4772\n\
4773 Calculate world coordinates, wx and wy, and corresponding window index\n\
4774 from relative device coordinates, rx and ry.\n\
4775\n\
4776 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4777\n\
4778\n\
4779 This function is used in example 31.\n\
4780\n\
4781\n\
4782\n\
4783SYNOPSIS:\n\
4784\n\
4785plcalc_world(rx, ry, wx, wy, window)\n\
4786\n\
4787ARGUMENTS:\n\
4788\n\
4789 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4790 the x coordinate.\n\
4791\n\
4792 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4793 the y coordinate.\n\
4794\n\
4795 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4796 coordinate corresponding to the relative device coordinates rx and\n\
4797 ry.\n\
4798\n\
4799 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4800 coordinate corresponding to the relative device coordinates rx and\n\
4801 ry.\n\
4802\n\
4803 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4804 defined window index that corresponds to the input relative device\n\
4805 coordinates (and the returned world coordinates). To give some\n\
4806 background on the window index, for each page the initial window\n\
4807 index is set to zero, and each time plwind is called within the\n\
4808 page, world and device coordinates are stored for the window and\n\
4809 the window index is incremented. Thus, for a simple page layout\n\
4810 with non-overlapping viewports and one window per viewport, window\n\
4811 corresponds to the viewport index (in the order which the\n\
4812 viewport/windows were created) of the only viewport/window\n\
4813 corresponding to rx and ry. However, for more complicated layouts\n\
4814 with potentially overlapping viewports and possibly more than one\n\
4815 window (set of world coordinates) per viewport, window and the\n\
4816 corresponding output world coordinates corresponds to the last\n\
4817 window created that fulfills the criterion that the relative\n\
4818 device coordinates are inside it. Finally, in all cases where the\n\
4819 input relative device coordinates are not inside any\n\
4820 viewport/window, then the returned value of the last defined\n\
4821 window index is set to -1.\n\
4822";
4823static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4824Get output file name\n\
4825\n\
4826DESCRIPTION:\n\
4827\n\
4828 Gets the current output file name, if applicable.\n\
4829\n\
4830 Redacted form: plgfnam(fnam)\n\
4831\n\
4832 This function is used in example 31.\n\
4833\n\
4834\n\
4835\n\
4836SYNOPSIS:\n\
4837\n\
4838plgfnam(fnam)\n\
4839\n\
4840ARGUMENTS:\n\
4841\n\
4842 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4843 (with preallocated length of 80 characters or more) containing the\n\
4844 file name.\n\
4845";
4846static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4847Vector plot\n\
4848\n\
4849DESCRIPTION:\n\
4850\n\
4851 Draws a plot of vector data contained in the matrices (\n\
4852 u[\n\
4853 nx][\n\
4854 ny],\n\
4855 v[\n\
4856 nx][\n\
4857 ny]) . The scaling factor for the vectors is given by scale. A\n\
4858 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4859 additional data required by the transformation routine to map indices\n\
4860 within the matrices to the world coordinates. The style of the vector\n\
4861 arrow may be set using plsvect.\n\
4862\n\
4863 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4864 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4865 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4866 with either one or two dimensions.\n\
4867\n\
4868 This function is used in example 22.\n\
4869\n\
4870\n\
4871\n\
4872SYNOPSIS:\n\
4873\n\
4874plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4875\n\
4876ARGUMENTS:\n\
4877\n\
4878 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4879 and y components of the vector data to be plotted.\n\
4880\n\
4881 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4882\n\
4883 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4884 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4885 automatically calculated for the data. If scale < 0 then the\n\
4886 scaling factor is automatically calculated for the data and then\n\
4887 multiplied by -\n\
4888 scale. If scale > 0 then the scaling factor is set to scale.\n\
4889\n\
4890 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4891 defines the transformation between the zero-based indices of the\n\
4892 matrices u and v and world coordinates.For the C case,\n\
4893 transformation functions are provided in the PLplot library: pltr0\n\
4894 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4895 mappings respectively defined by vectors and matrices. In\n\
4896 addition, C callback routines for the transformation can be\n\
4897 supplied by the user such as the mypltr function in\n\
4898 examples/c/x09c.c which provides a general linear transformation\n\
4899 between index coordinates and world coordinates.For languages\n\
4900 other than C you should consult the PLplot documentation for the\n\
4901 details concerning how PLTRANSFORM_callback arguments are\n\
4902 interfaced. However, in general, a particular pattern of\n\
4903 callback-associated arguments such as a tr vector with 6 elements;\n\
4904 xg and yg vectors; or xg and yg matrices are respectively\n\
4905 interfaced to a linear-transformation routine similar to the above\n\
4906 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4907 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4908 support native language callbacks for handling index to\n\
4909 world-coordinate transformations. Examples of these various\n\
4910 approaches are given in examples/<language>x09*,\n\
4911 examples/<language>x16*, examples/<language>x20*,\n\
4912 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4913 supported languages.\n\
4914\n\
4915 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4916 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4917 that is externally supplied.\n\
4918";
4919static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4920Plot a glyph at the specified points\n\
4921\n\
4922DESCRIPTION:\n\
4923\n\
4924 Plot a glyph at the specified points. (This function is largely\n\
4925 superseded by plstring which gives access to many[!] more glyphs.)\n\
4926\n\
4927 Redacted form: plsym(x, y, code)\n\
4928\n\
4929 This function is used in example 7.\n\
4930\n\
4931\n\
4932\n\
4933SYNOPSIS:\n\
4934\n\
4935plsym(n, x, y, code)\n\
4936\n\
4937ARGUMENTS:\n\
4938\n\
4939 n (PLINT, input) : Number of points in the x and y vectors.\n\
4940\n\
4941 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4942 the points.\n\
4943\n\
4944 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4945 the points.\n\
4946\n\
4947 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4948 to be plotted at each of the n points.\n\
4949";
4950static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4951Get viewport limits in normalized device coordinates\n\
4952\n\
4953DESCRIPTION:\n\
4954\n\
4955 Get viewport limits in normalized device coordinates.\n\
4956\n\
4957 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4958\n\
4959\n\
4960 This function is used in example 31.\n\
4961\n\
4962\n\
4963\n\
4964SYNOPSIS:\n\
4965\n\
4966plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4967\n\
4968ARGUMENTS:\n\
4969\n\
4970 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4971 viewport limit of the normalized device coordinate in x.\n\
4972\n\
4973 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4974 viewport limit of the normalized device coordinate in x.\n\
4975\n\
4976 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4977 viewport limit of the normalized device coordinate in y.\n\
4978\n\
4979 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4980 viewport limit of the normalized device coordinate in y.\n\
4981";
4982static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4983Get page parameters\n\
4984\n\
4985DESCRIPTION:\n\
4986\n\
4987 Gets the current page configuration. The length and offset values are\n\
4988 expressed in units that are specific to the current driver. For\n\
4989 instance: screen drivers will usually interpret them as number of\n\
4990 pixels, whereas printer drivers will usually use mm.\n\
4991\n\
4992 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4993\n\
4994 This function is used in examples 14 and 31.\n\
4995\n\
4996\n\
4997\n\
4998SYNOPSIS:\n\
4999\n\
5000plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5001\n\
5002ARGUMENTS:\n\
5003\n\
5004 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5005 pixels/inch (DPI) in x.\n\
5006\n\
5007 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5008 pixels/inch (DPI) in y.\n\
5009\n\
5010 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5011 length.\n\
5012\n\
5013 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5014 length.\n\
5015\n\
5016 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5017 offset.\n\
5018\n\
5019 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5020 offset.\n\
5021";
5022static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
5023Plot a glyph at the specified 3D points\n\
5024\n\
5025DESCRIPTION:\n\
5026\n\
5027 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5028 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5029 this function similar to what is done for plline3. The glyph is\n\
5030 specified with a PLplot user string. Note that the user string is not\n\
5031 actually limited to one glyph so it is possible (but not normally\n\
5032 useful) to plot more than one glyph at the specified points with this\n\
5033 function. As with plmtex and plptex, the user string can contain FCI\n\
5034 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5035 else PLplot escapes for Hershey or unicode text to determine the\n\
5036 glyph.\n\
5037\n\
5038 Redacted form: plstring3(x, y, z, string)\n\
5039\n\
5040 This function is used in example 18.\n\
5041\n\
5042\n\
5043\n\
5044SYNOPSIS:\n\
5045\n\
5046plstring3(n, x, y, z, string)\n\
5047\n\
5048ARGUMENTS:\n\
5049\n\
5050 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5051\n\
5052 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5053 the points.\n\
5054\n\
5055 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5056 the points.\n\
5057\n\
5058 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5059 the points.\n\
5060\n\
5061 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5062 the glyph(s) to be plotted at each of the n points. points.\n\
5063";
5064static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
5065Shade regions on the basis of value\n\
5066\n\
5067DESCRIPTION:\n\
5068\n\
5069 Shade regions on the basis of value. This is the high-level routine\n\
5070 for making continuous color shaded plots with cmap1 while plshade\n\
5071 should be used to plot individual shaded regions using either cmap0 or\n\
5072 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5073 our supported languages.\n\
5074\n\
5075 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5076 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5077 pltr_data)\n\
5078\n\
5079\n\
5080 This function is used in examples 16, 21, and 22.\n\
5081\n\
5082\n\
5083\n\
5084SYNOPSIS:\n\
5085\n\
5086plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5087\n\
5088ARGUMENTS:\n\
5089\n\
5090 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5091 plot. Should have dimensions of\n\
5092 nx by\n\
5093 ny.\n\
5094\n\
5095 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5096\n\
5097 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5098\n\
5099 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5100 the region that should be plotted in the shade plot. This\n\
5101 function accepts x and y coordinates as input arguments and must\n\
5102 return 1 if the point is to be included in the shade plot and 0\n\
5103 otherwise. If you want to plot the entire shade plot (the usual\n\
5104 case), this argument should be set to NULL.\n\
5105\n\
5106 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5107 pltr below for how these arguments are used (only for the special case\n\
5108 when the callback function\n\
5109 pltr is not supplied).\n\
5110\n\
5111 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5112 corresponding to the edges of each shaded region that will be\n\
5113 plotted by this function. To work properly the levels should be\n\
5114 monotonic.\n\
5115\n\
5116 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5117 of shade edge values in clevel).\n\
5118\n\
5119 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5120 pattern.\n\
5121\n\
5122 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5123 contours defining edges of shaded regions. The pen color is only\n\
5124 temporary set for the contour drawing. Set this value to zero or\n\
5125 less if no shade edge contours are wanted.\n\
5126\n\
5127 cont_width (PLFLT, input) : Defines line width used for contours\n\
5128 defining edges of shaded regions. This value may not be honored\n\
5129 by all drivers. The pen width is only temporary set for the\n\
5130 contour drawing. Set this value to zero or less if no shade edge\n\
5131 contours are wanted.\n\
5132\n\
5133 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5134 region. Use plfill for this purpose.\n\
5135\n\
5136 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5137 map to rectangles after coordinate transformation with pltrl.\n\
5138 Otherwise, set rectangular to false. If rectangular is set to\n\
5139 true, plshade tries to save time by filling large rectangles.\n\
5140 This optimization fails if the coordinate transformation distorts\n\
5141 the shape of rectangles. For example a plot in polar coordinates\n\
5142 has to have rectangular set to false.\n\
5143\n\
5144 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5145 defines the transformation between the zero-based indices of the\n\
5146 matrix a and world coordinates. If\n\
5147 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5148 indices of a are mapped to the range\n\
5149 xmin through\n\
5150 xmax and the y indices of a are mapped to the range\n\
5151 ymin through\n\
5152 ymax.For the C case, transformation functions are provided in the\n\
5153 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5154 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5155 matrices. In addition, C callback routines for the transformation\n\
5156 can be supplied by the user such as the mypltr function in\n\
5157 examples/c/x09c.c which provides a general linear transformation\n\
5158 between index coordinates and world coordinates.For languages\n\
5159 other than C you should consult the PLplot documentation for the\n\
5160 details concerning how PLTRANSFORM_callback arguments are\n\
5161 interfaced. However, in general, a particular pattern of\n\
5162 callback-associated arguments such as a tr vector with 6 elements;\n\
5163 xg and yg vectors; or xg and yg matrices are respectively\n\
5164 interfaced to a linear-transformation routine similar to the above\n\
5165 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5166 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5167 support native language callbacks for handling index to\n\
5168 world-coordinate transformations. Examples of these various\n\
5169 approaches are given in examples/<language>x09*,\n\
5170 examples/<language>x16*, examples/<language>x20*,\n\
5171 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5172 supported languages.\n\
5173\n\
5174 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5175 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5176 externally supplied.\n\
5177";
5178static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5179Set output file name\n\
5180\n\
5181DESCRIPTION:\n\
5182\n\
5183 Sets the current output file name, if applicable. If the file name\n\
5184 has not been specified and is required by the driver, the user will be\n\
5185 prompted for it. If using the X-windows output driver, this sets the\n\
5186 display name. This routine, if used, must be called before\n\
5187 initializing PLplot.\n\
5188\n\
5189 Redacted form: plsfnam(fnam)\n\
5190\n\
5191 This function is used in examples 1 and 20.\n\
5192\n\
5193\n\
5194\n\
5195SYNOPSIS:\n\
5196\n\
5197plsfnam(fnam)\n\
5198\n\
5199ARGUMENTS:\n\
5200\n\
5201 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5202 the file name.\n\
5203";
5204static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5205Contour plot\n\
5206\n\
5207DESCRIPTION:\n\
5208\n\
5209 Draws a contour plot of the data in f[\n\
5210 nx][\n\
5211 ny], using the nlevel contour levels specified by clevel. Only the\n\
5212 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5213 where all these index ranges are interpreted as one-based for\n\
5214 historical reasons. A transformation routine pointed to by pltr with\n\
5215 a generic pointer pltr_data for additional data required by the\n\
5216 transformation routine is used to map indices within the matrix to the\n\
5217 world coordinates.\n\
5218\n\
5219 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5220 where (see above discussion) the pltr, pltr_data callback arguments\n\
5221 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5222 vectors; or xg and yg matrices.\n\
5223\n\
5224 This function is used in examples 9, 14, 16, and 22.\n\
5225\n\
5226\n\
5227\n\
5228SYNOPSIS:\n\
5229\n\
5230plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5231\n\
5232ARGUMENTS:\n\
5233\n\
5234 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5235\n\
5236 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5237\n\
5238 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5239 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5240 zero-based for historical backwards-compatibility reasons.\n\
5241\n\
5242 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5243 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5244 zero-based for historical backwards-compatibility reasons.\n\
5245\n\
5246 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5247 which to draw contours.\n\
5248\n\
5249 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5250\n\
5251 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5252 defines the transformation between the zero-based indices of the\n\
5253 matrix f and the world coordinates.For the C case, transformation\n\
5254 functions are provided in the PLplot library: pltr0 for the\n\
5255 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5256 respectively defined by vectors and matrices. In addition, C\n\
5257 callback routines for the transformation can be supplied by the\n\
5258 user such as the mypltr function in examples/c/x09c.c which\n\
5259 provides a general linear transformation between index coordinates\n\
5260 and world coordinates.For languages other than C you should\n\
5261 consult the PLplot documentation for the details concerning how\n\
5262 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5263 general, a particular pattern of callback-associated arguments\n\
5264 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5265 yg matrices are respectively interfaced to a linear-transformation\n\
5266 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5267 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5268 the PLplot documentation) support native language callbacks for\n\
5269 handling index to world-coordinate transformations. Examples of\n\
5270 these various approaches are given in examples/<language>x09*,\n\
5271 examples/<language>x16*, examples/<language>x20*,\n\
5272 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5273 supported languages.\n\
5274\n\
5275 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5276 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5277 that is externally supplied.\n\
5278";
5279static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5280Set parameters that define current plot-space window\n\
5281\n\
5282DESCRIPTION:\n\
5283\n\
5284 Set relative minima and maxima that define the current plot-space\n\
5285 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5286 xmax, and ymax are 0., 0., 1., and 1.\n\
5287\n\
5288 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5289\n\
5290 This function is used in example 31.\n\
5291\n\
5292\n\
5293\n\
5294SYNOPSIS:\n\
5295\n\
5296plsdiplt(xmin, ymin, xmax, ymax)\n\
5297\n\
5298ARGUMENTS:\n\
5299\n\
5300 xmin (PLFLT, input) : Relative minimum in x.\n\
5301\n\
5302 ymin (PLFLT, input) : Relative minimum in y.\n\
5303\n\
5304 xmax (PLFLT, input) : Relative maximum in x.\n\
5305\n\
5306 ymax (PLFLT, input) : Relative maximum in y.\n\
5307";
5308static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5309Write text inside the viewport of a 3D plot\n\
5310\n\
5311DESCRIPTION:\n\
5312\n\
5313 Writes text at a specified position and inclination and with a\n\
5314 specified shear within the viewport. Text is clipped at the viewport\n\
5315 boundaries. The reference point of a string lies along a line passing\n\
5316 through the string at half the height of a capital letter. The\n\
5317 position of the reference point along this line is determined by just,\n\
5318 and the reference point is placed at world coordinates (\n\
5319 wx,\n\
5320 wy,\n\
5321 wz) within the viewport. The inclination and shear of the string is\n\
5322 specified in terms of differences of world coordinates making it easy\n\
5323 to write text parallel to a line in a graph.\n\
5324\n\
5325 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5326\n\
5327 This function is used in example 28.\n\
5328\n\
5329\n\
5330\n\
5331SYNOPSIS:\n\
5332\n\
5333plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5334\n\
5335ARGUMENTS:\n\
5336\n\
5337 wx (PLFLT, input) : x world coordinate of reference point of\n\
5338 string.\n\
5339\n\
5340 wy (PLFLT, input) : y world coordinate of reference point of\n\
5341 string.\n\
5342\n\
5343 wz (PLFLT, input) : z world coordinate of reference point of\n\
5344 string.\n\
5345\n\
5346 dx (PLFLT, input) : Together with dy and\n\
5347 dz , this specifies the inclination of the string. The baseline of\n\
5348 the string is parallel to a line joining (\n\
5349 x,\n\
5350 y,\n\
5351 z) to (\n\
5352 x+\n\
5353 dx,\n\
5354 y+\n\
5355 dy,\n\
5356 z+\n\
5357 dz) .\n\
5358\n\
5359 dy (PLFLT, input) : Together with dx and\n\
5360 dz, this specifies the inclination of the string.\n\
5361\n\
5362 dz (PLFLT, input) : Together with dx and\n\
5363 dy, this specifies the inclination of the string.\n\
5364\n\
5365 sx (PLFLT, input) : Together with sy and\n\
5366 sz , this specifies the shear of the string. The string is sheared so\n\
5367 that the characters are vertically parallel to a line joining (\n\
5368 x,\n\
5369 y,\n\
5370 z) to (\n\
5371 x+\n\
5372 sx,\n\
5373 y+\n\
5374 sy,\n\
5375 z+\n\
5376 sz) . If sx =\n\
5377 sy =\n\
5378 sz = 0.) then the text is not sheared.\n\
5379\n\
5380 sy (PLFLT, input) : Together with sx and\n\
5381 sz, this specifies shear of the string.\n\
5382\n\
5383 sz (PLFLT, input) : Together with sx and\n\
5384 sy, this specifies shear of the string.\n\
5385\n\
5386 just (PLFLT, input) : Specifies the position of the string relative\n\
5387 to its reference point. If just=0. , the reference point is at\n\
5388 the left and if just=1. , it is at the right of the string. Other\n\
5389 values of just give intermediate justifications.\n\
5390\n\
5391 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5392 written out.\n\
5393";
5394static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5395Plot continental outline or shapefile data in world coordinates\n\
5396\n\
5397DESCRIPTION:\n\
5398\n\
5399 Plots continental outlines or shapefile data in world coordinates. A\n\
5400 demonstration of how to use this function to create different\n\
5401 projections can be found in examples/c/x19c. PLplot is provided with\n\
5402 basic coastal outlines and USA state borders. To use the map\n\
5403 functionality PLplot must be compiled with the shapelib library.\n\
5404 Shapefiles have become a popular standard for geographical data and\n\
5405 data in this format can be easily found from a number of online\n\
5406 sources. Shapefile data is actually provided as three or more files\n\
5407 with the same filename, but different extensions. The .shp and .shx\n\
5408 files are required for plotting Shapefile data with PLplot.\n\
5409\n\
5410 PLplot currently supports the point, multipoint, polyline and polygon\n\
5411 objects within shapefiles. However holes in polygons are not\n\
5412 supported. When plmap is used the type of object is derived from the\n\
5413 shapefile, if you wish to override the type then use one of the other\n\
5414 plmap variants. The built in maps have line data only.\n\
5415\n\
5416 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5417\n\
5418 This function is used in example 19.\n\
5419\n\
5420\n\
5421\n\
5422SYNOPSIS:\n\
5423\n\
5424plmap(mapform, name, minx, maxx, miny, maxy)\n\
5425\n\
5426ARGUMENTS:\n\
5427\n\
5428 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5429 transform the original map data coordinates to a new coordinate\n\
5430 system. The PLplot-supplied map data is provided as latitudes and\n\
5431 longitudes; other Shapefile data may be provided in other\n\
5432 coordinate systems as can be found in their .prj plain text files.\n\
5433 For example, by using this transform we can change from a\n\
5434 longitude, latitude coordinate to a polar stereographic\n\
5435 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5436 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5437 corresponding y coordinates (latitudes for the PLplot supplied\n\
5438 data). After the call to mapform(), x[] and y[] should be\n\
5439 replaced by the corresponding plot coordinates. If no transform is\n\
5440 desired, mapform can be replaced by NULL.\n\
5441\n\
5442 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5443 the type of map plotted. This is either one of the PLplot built-in\n\
5444 maps or the file name of a set of Shapefile files without the file\n\
5445 extensions. For the PLplot built-in maps the possible values are:\n\
5446 \"globe\" -- continental outlines\n\
5447 \"usa\" -- USA and state boundaries\n\
5448 \"cglobe\" -- continental outlines and countries\n\
5449 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5450\n\
5451\n\
5452 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5453 drawn. The units must match the shapefile (built in maps are\n\
5454 degrees lat/lon). Objects in the file which do not encroach on the\n\
5455 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5456 note this is simply an optimisation, not a clipping so for objects\n\
5457 with some points inside the box and some points outside the box\n\
5458 all the points will be rendered. These parameters also define\n\
5459 latitude and longitude wrapping for shapefiles using these units.\n\
5460 Longitude points will be wrapped by integer multiples of 360\n\
5461 degrees to place them in the box. This allows the same data to be\n\
5462 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5463 you plot from -180-540 you will get two cycles of data drawn. The\n\
5464 value of minx must be less than the value of maxx. Passing in a\n\
5465 nan, max/-max floating point number or +/-infinity will case the\n\
5466 bounding box from the shapefile to be used.\n\
5467\n\
5468 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5469 drawn - see minx.\n\
5470\n\
5471 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5472 drawn - see minx.\n\
5473\n\
5474 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5475 drawn - see minx.\n\
5476";
5477static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5478Specify viewport using coordinates and aspect ratio\n\
5479\n\
5480DESCRIPTION:\n\
5481\n\
5482 Device-independent routine for setting up the viewport. The viewport\n\
5483 is chosen to be the largest with the given aspect ratio that fits\n\
5484 within the specified region (in terms of normalized subpage\n\
5485 coordinates). This routine is functionally equivalent to plvpor when\n\
5486 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5487 routine reserves no extra space at the edges for labels.\n\
5488\n\
5489 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5490\n\
5491 This function is used in example 9.\n\
5492\n\
5493\n\
5494\n\
5495SYNOPSIS:\n\
5496\n\
5497plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5498\n\
5499ARGUMENTS:\n\
5500\n\
5501 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5502 left-hand edge of the viewport.\n\
5503\n\
5504 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5505 right-hand edge of the viewport.\n\
5506\n\
5507 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5508 bottom edge of the viewport.\n\
5509\n\
5510 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5511 edge of the viewport.\n\
5512\n\
5513 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5514 axis.\n\
5515";
5516static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5517Set the pause (on end-of-page) status\n\
5518\n\
5519DESCRIPTION:\n\
5520\n\
5521 Set the pause (on end-of-page) status.\n\
5522\n\
5523 Redacted form: plspause(pause)\n\
5524\n\
5525 This function is in examples 14,20.\n\
5526\n\
5527\n\
5528\n\
5529SYNOPSIS:\n\
5530\n\
5531plspause(pause)\n\
5532\n\
5533ARGUMENTS:\n\
5534\n\
5535 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5536 end-of-page for those drivers which support this. Otherwise there\n\
5537 is no pause.\n\
5538";
5539static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5540Plot 3-d surface plot\n\
5541\n\
5542DESCRIPTION:\n\
5543\n\
5544 Plots a three-dimensional surface plot within the environment set up\n\
5545 by plw3d. The surface is defined by the matrix z[\n\
5546 nx][\n\
5547 ny] , the point z[i][j] being the value of the function at (\n\
5548 x[i],\n\
5549 y[j]). Note that the points in vectors x and y do not need to be\n\
5550 equally spaced, but must be stored in ascending order. The parameter\n\
5551 opt controls the way in which the surface is displayed. For further\n\
5552 details see the PLplot documentation. The only difference between\n\
5553 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5554 while plot3d only draws the surface as viewed from the top.\n\
5555\n\
5556 Redacted form: plot3d(x, y, z, opt, side)\n\
5557\n\
5558 This function is used in examples 11 and 21.\n\
5559\n\
5560\n\
5561\n\
5562SYNOPSIS:\n\
5563\n\
5564plot3d(x, y, z, nx, ny, opt, side)\n\
5565\n\
5566ARGUMENTS:\n\
5567\n\
5568 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5569 which the function is evaluated.\n\
5570\n\
5571 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5572 which the function is evaluated.\n\
5573\n\
5574 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5575 plot. Should have dimensions of\n\
5576 nx by\n\
5577 ny.\n\
5578\n\
5579 nx (PLINT, input) : Number of x values at which function is\n\
5580 evaluated.\n\
5581\n\
5582 ny (PLINT, input) : Number of y values at which function is\n\
5583 evaluated.\n\
5584\n\
5585 opt (PLINT, input) : Determines the way in which the surface is\n\
5586 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5587 function of x for each value of y[j] .\n\
5588 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5589 for each value of x[i] .\n\
5590 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5591 at which function is defined.\n\
5592\n\
5593\n\
5594 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5595 should be draw on the figure. If side is true sides are drawn,\n\
5596 otherwise no sides are drawn.\n\
5597";
5598static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5599Copy state parameters from the reference stream to the current stream\n\
5600\n\
5601DESCRIPTION:\n\
5602\n\
5603 Copies state parameters from the reference stream to the current\n\
5604 stream. Tell driver interface to map device coordinates unless flags\n\
5605 == 1.\n\
5606\n\
5607 This function is used for making save files of selected plots (e.g.\n\
5608 from the TK driver). After initializing, you can get a copy of the\n\
5609 current plot to the specified device by switching to this stream and\n\
5610 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5611 appropriate. The plot buffer must have previously been enabled (done\n\
5612 automatically by some display drivers, such as X).\n\
5613\n\
5614 Redacted form: plcpstrm(iplsr, flags)\n\
5615\n\
5616 This function is used in example 1,20.\n\
5617\n\
5618\n\
5619\n\
5620SYNOPSIS:\n\
5621\n\
5622plcpstrm(iplsr, flags)\n\
5623\n\
5624ARGUMENTS:\n\
5625\n\
5626 iplsr (PLINT, input) : Number of reference stream.\n\
5627\n\
5628 flags (PLBOOL, input) : If flags is set to true the device\n\
5629 coordinates are not copied from the reference to current stream.\n\
5630";
5631static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5632Set page parameters\n\
5633\n\
5634DESCRIPTION:\n\
5635\n\
5636 Sets the page configuration (optional). If an individual parameter is\n\
5637 zero then that parameter value is not updated. Not all parameters are\n\
5638 recognized by all drivers and the interpretation is device-dependent.\n\
5639 The X-window driver uses the length and offset parameters to determine\n\
5640 the window size and location. The length and offset values are\n\
5641 expressed in units that are specific to the current driver. For\n\
5642 instance: screen drivers will usually interpret them as number of\n\
5643 pixels, whereas printer drivers will usually use mm.\n\
5644\n\
5645 This routine, if used, must be called before initializing PLplot. It\n\
5646 may be called at later times for interactive drivers to change only\n\
5647 the dpi for subsequent redraws which you can force via a call to\n\
5648 plreplot. If this function is not called then the page size defaults\n\
5649 to landscape A4 for drivers which use real world page sizes and 744\n\
5650 pixels wide by 538 pixels high for raster drivers. The default value\n\
5651 for dx and dy is 90 pixels per inch for raster drivers.\n\
5652\n\
5653\n\
5654\n\
5655 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5656\n\
5657 This function is used in examples 14 and 31.\n\
5658\n\
5659\n\
5660\n\
5661SYNOPSIS:\n\
5662\n\
5663plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5664\n\
5665ARGUMENTS:\n\
5666\n\
5667 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5668 by raster drivers, ignored by drivers which use \"real world\" units\n\
5669 (e.g. mm).\n\
5670\n\
5671 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5672 by raster drivers, ignored by drivers which use \"real world\" units\n\
5673 (e.g. mm).\n\
5674\n\
5675 xleng (PLINT, input) : Page length, x.\n\
5676\n\
5677 yleng (PLINT, input) : Page length, y.\n\
5678\n\
5679 xoff (PLINT, input) : Page offset, x.\n\
5680\n\
5681 yoff (PLINT, input) : Page offset, y.\n\
5682";
5683static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5684Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5685\n\
5686DESCRIPTION:\n\
5687\n\
5688 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5689 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5690 Values are negative if an invalid color id is given.\n\
5691\n\
5692 Redacted form: plgcola(r, g, b)\n\
5693\n\
5694 This function is used in example 30.\n\
5695\n\
5696\n\
5697\n\
5698SYNOPSIS:\n\
5699\n\
5700plgcol0a(icol0, r, g, b, alpha)\n\
5701\n\
5702ARGUMENTS:\n\
5703\n\
5704 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5705\n\
5706 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5707 in the range from 0 to 255.\n\
5708\n\
5709 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5710 in the range from 0 to 255.\n\
5711\n\
5712 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5713 in the range from 0 to 255.\n\
5714\n\
5715 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5716 transparency in the range from (0.0-1.0).\n\
5717";
5718static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5719Returns 8-bit RGB values for given color index from cmap0\n\
5720\n\
5721DESCRIPTION:\n\
5722\n\
5723 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5724 PLplot documentation). Values are negative if an invalid color id is\n\
5725 given.\n\
5726\n\
5727 Redacted form: plgcol0(icol0, r, g, b)\n\
5728\n\
5729 This function is used in example 2.\n\
5730\n\
5731\n\
5732\n\
5733SYNOPSIS:\n\
5734\n\
5735plgcol0(icol0, r, g, b)\n\
5736\n\
5737ARGUMENTS:\n\
5738\n\
5739 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5740\n\
5741 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5742 value.\n\
5743\n\
5744 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5745 value.\n\
5746\n\
5747 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5748 value.\n\
5749";
5750static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5751Set parameters incrementally (zoom mode) that define current plot-space window\n\
5752\n\
5753DESCRIPTION:\n\
5754\n\
5755 Set relative minima and maxima incrementally (zoom mode) that define\n\
5756 the current plot-space window. This function has the same effect as\n\
5757 plsdiplt if that function has not been previously called. Otherwise,\n\
5758 this function implements zoom mode using the transformation min_used =\n\
5759 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5760 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5761 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5762\n\
5763 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5764\n\
5765 This function is used in example 31.\n\
5766\n\
5767\n\
5768\n\
5769SYNOPSIS:\n\
5770\n\
5771plsdiplz(xmin, ymin, xmax, ymax)\n\
5772\n\
5773ARGUMENTS:\n\
5774\n\
5775 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5776\n\
5777 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5778\n\
5779 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5780\n\
5781 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5782";
5783static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5784Plot all or a subset of Shapefile data, filling the polygons\n\
5785\n\
5786DESCRIPTION:\n\
5787\n\
5788 As per plmapline, however the items are filled in the same way as\n\
5789 plfill.\n\
5790\n\
5791 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5792 plotentries)\n\
5793\n\
5794 This function is used in example 19.\n\
5795\n\
5796\n\
5797\n\
5798SYNOPSIS:\n\
5799\n\
5800plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5801\n\
5802ARGUMENTS:\n\
5803\n\
5804 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5805 transform the coordinates given in the shapefile into a plot\n\
5806 coordinate system. By using this transform, we can change from a\n\
5807 longitude, latitude coordinate to a polar stereographic project,\n\
5808 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5809 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5810 mapform(), x[] and y[] should be replaced by the corresponding\n\
5811 plot coordinates. If no transform is desired, mapform can be\n\
5812 replaced by NULL.\n\
5813\n\
5814 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5815 the file name of a set of Shapefile files without the file\n\
5816 extension.\n\
5817\n\
5818 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5819 be in the same units as used by the Shapefile. You could use a\n\
5820 very large negative number to plot everything, but you can improve\n\
5821 performance by limiting the area drawn. The units must match those\n\
5822 of the Shapefile projection, which may be for example longitude or\n\
5823 distance. The value of minx must be less than the value of maxx.\n\
5824\n\
5825 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5826 use a very large number to plot everything, but you can improve\n\
5827 performance by limiting the area drawn.\n\
5828\n\
5829 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5830 be in the same units as used by the Shapefile. You could use a\n\
5831 very large negative number to plot everything, but you can improve\n\
5832 performance by limiting the area drawn. The units must match those\n\
5833 of the Shapefile projection, which may be for example latitude or\n\
5834 distance. The value of miny must be less than the value of maxy.\n\
5835\n\
5836 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5837 use a very large number to plot everything, but you can improve\n\
5838 performance by limiting the area drawn.\n\
5839\n\
5840 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5841 zero-based indices of the Shapefile elements which will be drawn.\n\
5842 Setting\n\
5843 plotentries to NULL will plot all elements of the Shapefile.\n\
5844\n\
5845 nplotentries (PLINT, input) : The number of items in\n\
5846 plotentries. Ignored if\n\
5847 plotentries is NULL.\n\
5848";
5849static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5850Draw a line\n\
5851\n\
5852DESCRIPTION:\n\
5853\n\
5854 Draws line defined by n points in x and y.\n\
5855\n\
5856 Redacted form: plline(x, y)\n\
5857\n\
5858 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5859 25-27, and 29.\n\
5860\n\
5861\n\
5862\n\
5863SYNOPSIS:\n\
5864\n\
5865plline(n, x, y)\n\
5866\n\
5867ARGUMENTS:\n\
5868\n\
5869 n (PLINT, input) : Number of points defining line.\n\
5870\n\
5871 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5872 points.\n\
5873\n\
5874 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5875 points.\n\
5876";
5877static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5878Get viewport limits in world coordinates\n\
5879\n\
5880DESCRIPTION:\n\
5881\n\
5882 Get viewport limits in world coordinates.\n\
5883\n\
5884 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5885\n\
5886\n\
5887 This function is used in example 31.\n\
5888\n\
5889\n\
5890\n\
5891SYNOPSIS:\n\
5892\n\
5893plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5894\n\
5895ARGUMENTS:\n\
5896\n\
5897 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5898 viewport limit of the world coordinate in x.\n\
5899\n\
5900 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5901 viewport limit of the world coordinate in x.\n\
5902\n\
5903 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5904 viewport limit of the world coordinate in y.\n\
5905\n\
5906 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5907 viewport limit of the world coordinate in y.\n\
5908";
5909static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5910Set area line fill pattern\n\
5911\n\
5912DESCRIPTION:\n\
5913\n\
5914 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5915 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5916 inclinations and spacings. The arguments to this routine are the\n\
5917 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5918 elements) specifying the inclinations in tenths of a degree and the\n\
5919 spacing in micrometers. (See also plpsty)\n\
5920\n\
5921 Redacted form: General: plpat(inc, del)\n\
5922\n\
5923\n\
5924 This function is used in example 15.\n\
5925\n\
5926\n\
5927\n\
5928SYNOPSIS:\n\
5929\n\
5930plpat(nlin, inc, del)\n\
5931\n\
5932ARGUMENTS:\n\
5933\n\
5934 nlin (PLINT, input) : Number of sets of lines making up the\n\
5935 pattern, either 1 or 2.\n\
5936\n\
5937 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5938 inclination in tenths of a degree. (Should be between -900 and\n\
5939 900).\n\
5940\n\
5941 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5942 spacing in micrometers between the lines making up the pattern.\n\
5943";
5944static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5945Set x axis parameters\n\
5946\n\
5947DESCRIPTION:\n\
5948\n\
5949 Sets values of the digmax and digits flags for the x axis. See the\n\
5950 PLplot documentation for more information.\n\
5951\n\
5952 Redacted form: plsxax(digmax, digits)\n\
5953\n\
5954 This function is used in example 31.\n\
5955\n\
5956\n\
5957\n\
5958SYNOPSIS:\n\
5959\n\
5960plsxax(digmax, digits)\n\
5961\n\
5962ARGUMENTS:\n\
5963\n\
5964 digmax (PLINT, input) : Variable to set the maximum number of\n\
5965 digits for the x axis. If nonzero, the printed label will be\n\
5966 switched to a floating-point representation when the number of\n\
5967 digits exceeds digmax.\n\
5968\n\
5969 digits (PLINT, input) : Field digits value. Currently, changing\n\
5970 its value here has no effect since it is set only by plbox or\n\
5971 plbox3. However, the user may obtain its value after a call to\n\
5972 either of these functions by calling plgxax.\n\
5973";
5974static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5975Get family file parameters\n\
5976\n\
5977DESCRIPTION:\n\
5978\n\
5979 Gets information about current family file, if familying is enabled.\n\
5980 See the PLplot documentation for more information.\n\
5981\n\
5982 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5983\n\
5984 This function is used in examples 14 and 31.\n\
5985\n\
5986\n\
5987\n\
5988SYNOPSIS:\n\
5989\n\
5990plgfam(p_fam, p_num, p_bmax)\n\
5991\n\
5992ARGUMENTS:\n\
5993\n\
5994 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5995 family flag value. If nonzero, familying is enabled for the\n\
5996 current device.\n\
5997\n\
5998 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5999 family file number.\n\
6000\n\
6001 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6002 file size (in bytes) for a family file.\n\
6003";
6004static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
6005Get y axis parameters\n\
6006\n\
6007DESCRIPTION:\n\
6008\n\
6009 Identical to plgxax, except that arguments are flags for y axis. See\n\
6010 the description of plgxax for more detail.\n\
6011\n\
6012 Redacted form: plgyax(p_digmax, p_digits)\n\
6013\n\
6014 This function is used in example 31.\n\
6015\n\
6016\n\
6017\n\
6018SYNOPSIS:\n\
6019\n\
6020plgyax(p_digmax, p_digits)\n\
6021\n\
6022ARGUMENTS:\n\
6023\n\
6024 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6025 number of digits for the y axis. If nonzero, the printed label\n\
6026 has been switched to a floating-point representation when the\n\
6027 number of digits exceeds this value.\n\
6028\n\
6029 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6030 number of digits for the numeric labels (y axis) from the last\n\
6031 plot.\n\
6032";
6033static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6034Plot a glyph at the specified points\n\
6035\n\
6036DESCRIPTION:\n\
6037\n\
6038 Plot a glyph at the specified points. (This function is largely\n\
6039 superseded by plstring which gives access to many[!] more glyphs.)\n\
6040 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6041 and a draw at the same place. Not ideal, since a sufficiently\n\
6042 intelligent output device may optimize it away, or there may be faster\n\
6043 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6044 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6045 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6046 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6047 code <= 127 the corresponding printable ASCII character is plotted.\n\
6048\n\
6049 Redacted form: plpoin(x, y, code)\n\
6050\n\
6051 This function is used in examples 1, 6, 14, and 29.\n\
6052\n\
6053\n\
6054\n\
6055SYNOPSIS:\n\
6056\n\
6057plpoin(n, x, y, code)\n\
6058\n\
6059ARGUMENTS:\n\
6060\n\
6061 n (PLINT, input) : Number of points in the x and y vectors.\n\
6062\n\
6063 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6064 points.\n\
6065\n\
6066 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6067 points.\n\
6068\n\
6069 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6070 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6071 each of the n points.\n\
6072";
6073static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6074Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6075\n\
6076DESCRIPTION:\n\
6077\n\
6078 As per plmapline, however the items are plotted as strings or points\n\
6079 in the same way as plstring.\n\
6080\n\
6081 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6082 maxy, plotentries)\n\
6083\n\
6084 This function is not used in any examples.\n\
6085\n\
6086\n\
6087\n\
6088SYNOPSIS:\n\
6089\n\
6090plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6091\n\
6092ARGUMENTS:\n\
6093\n\
6094 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6095 transform the coordinates given in the shapefile into a plot\n\
6096 coordinate system. By using this transform, we can change from a\n\
6097 longitude, latitude coordinate to a polar stereographic project,\n\
6098 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6099 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6100 mapform(), x[] and y[] should be replaced by the corresponding\n\
6101 plot coordinates. If no transform is desired, mapform can be\n\
6102 replaced by NULL.\n\
6103\n\
6104 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6105 the file name of a set of Shapefile files without the file\n\
6106 extension.\n\
6107\n\
6108 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6109 drawn.\n\
6110\n\
6111 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6112 be in the same units as used by the Shapefile. You could use a\n\
6113 very large negative number to plot everything, but you can improve\n\
6114 performance by limiting the area drawn. The units must match those\n\
6115 of the Shapefile projection, which may be for example longitude or\n\
6116 distance. The value of minx must be less than the value of maxx.\n\
6117\n\
6118 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6119 use a very large number to plot everything, but you can improve\n\
6120 performance by limiting the area drawn.\n\
6121\n\
6122 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6123 be in the same units as used by the Shapefile. You could use a\n\
6124 very large negative number to plot everything, but you can improve\n\
6125 performance by limiting the area drawn. The units must match those\n\
6126 of the Shapefile projection, which may be for example latitude or\n\
6127 distance. The value of miny must be less than the value of maxy.\n\
6128\n\
6129 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6130 use a very large number to plot everything, but you can improve\n\
6131 performance by limiting the area drawn.\n\
6132\n\
6133 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6134 zero-based indices of the Shapefile elements which will be drawn.\n\
6135 Setting\n\
6136 plotentries to NULL will plot all elements of the Shapefile.\n\
6137\n\
6138 nplotentries (PLINT, input) : The number of items in\n\
6139 plotentries. Ignored if\n\
6140 plotentries is NULL.\n\
6141";
6142static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6143Select area fill pattern\n\
6144\n\
6145DESCRIPTION:\n\
6146\n\
6147 If\n\
6148 patt is zero or less use either a hardware solid fill if the drivers\n\
6149 have that capability (virtually all do) or fall back to a software\n\
6150 emulation of a solid fill using the eighth area line fill pattern. If\n\
6151 0 <\n\
6152 patt <= 8, then select one of eight predefined area line fill patterns\n\
6153 to use (see plpat if you desire other patterns).\n\
6154\n\
6155 Redacted form: plpsty(patt)\n\
6156\n\
6157 This function is used in examples 12, 13, 15, 16, and 25.\n\
6158\n\
6159\n\
6160\n\
6161SYNOPSIS:\n\
6162\n\
6163plpsty(patt)\n\
6164\n\
6165ARGUMENTS:\n\
6166\n\
6167 patt (PLINT, input) : The desired pattern index. If\n\
6168 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6169 above) used. For\n\
6170 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6171 line fill capability itself (most deliberately do not so that line\n\
6172 fill patterns look identical for those drivers), the patterns\n\
6173 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6174 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6175 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6176 (8) lines at both 45 degrees and -45 degrees.\n\
6177";
6178static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6179Set 8-bit RGB values for given cmap0 color index\n\
6180\n\
6181DESCRIPTION:\n\
6182\n\
6183 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6184 index. Overwrites the previous color value for the given index and,\n\
6185 thus, does not result in any additional allocation of space for\n\
6186 colors.\n\
6187\n\
6188 Redacted form: plscol0(icol0, r, g, b)\n\
6189\n\
6190 This function is used in any example 31.\n\
6191\n\
6192\n\
6193\n\
6194SYNOPSIS:\n\
6195\n\
6196plscol0(icol0, r, g, b)\n\
6197\n\
6198ARGUMENTS:\n\
6199\n\
6200 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6201 number of colors (which is set by default, by plscmap0n, or even\n\
6202 by plscmap0).\n\
6203\n\
6204 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6205 degree of red in the color.\n\
6206\n\
6207 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6208 degree of green in the color.\n\
6209\n\
6210 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6211 degree of blue in the color.\n\
6212";
6213static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6214Used to globally turn color output on/off\n\
6215\n\
6216DESCRIPTION:\n\
6217\n\
6218 Used to globally turn color output on/off for those drivers/devices\n\
6219 that support it.\n\
6220\n\
6221 Redacted form: plscolor(color)\n\
6222\n\
6223 This function is used in example 31.\n\
6224\n\
6225\n\
6226\n\
6227SYNOPSIS:\n\
6228\n\
6229plscolor(color)\n\
6230\n\
6231ARGUMENTS:\n\
6232\n\
6233 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6234 turned off. If non-zero, color is turned on.\n\
6235";
6236static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6237End plotting session\n\
6238\n\
6239DESCRIPTION:\n\
6240\n\
6241 Ends a plotting session, tidies up all the output files, switches\n\
6242 interactive devices back into text mode and frees up any memory that\n\
6243 was allocated. Must be called before end of program.\n\
6244\n\
6245 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6246 wait state after a call to plend or other functions which trigger the\n\
6247 end of a plot page. To avoid this, use the plspause function.\n\
6248\n\
6249 Redacted form: plend()\n\
6250\n\
6251 This function is used in all of the examples.\n\
6252\n\
6253\n\
6254\n\
6255SYNOPSIS:\n\
6256\n\
6257plend()\n\
6258";
6259static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6260Plot a histogram from binned data\n\
6261\n\
6262DESCRIPTION:\n\
6263\n\
6264 Plots a histogram consisting of nbin bins. The value associated with\n\
6265 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6266 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6267 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6268 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6269 placed midway between the values in the x vector. Also see plhist for\n\
6270 drawing histograms from unbinned data.\n\
6271\n\
6272 Redacted form: General: plbin(x, y, opt)\n\
6273 Python: plbin(nbin, x, y, opt)\n\
6274\n\
6275\n\
6276 This function is not used in any examples.\n\
6277\n\
6278\n\
6279\n\
6280SYNOPSIS:\n\
6281\n\
6282plbin(nbin, x, y, opt)\n\
6283\n\
6284ARGUMENTS:\n\
6285\n\
6286 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6287 and y vectors.)\n\
6288\n\
6289 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6290 with bins. These must form a strictly increasing sequence.\n\
6291\n\
6292 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6293 proportional to the number of points in each bin. This is a PLFLT\n\
6294 (instead of PLINT) vector so as to allow histograms of\n\
6295 probabilities, etc.\n\
6296\n\
6297 opt (PLINT, input) : Is a combination of several flags:\n\
6298 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6299 outer bins are expanded to fill up the entire x-axis and bins of\n\
6300 zero height are simply drawn.\n\
6301 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6302 between the x values. If the values in x are equally spaced,\n\
6303 the values are the center values of the bins.\n\
6304 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6305 size as the ones inside.\n\
6306 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6307 (there is a gap for such bins).\n\
6308";
6309static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6310Plot a 2D matrix using cmap1\n\
6311\n\
6312DESCRIPTION:\n\
6313\n\
6314 Plot a 2D matrix using cmap1.\n\
6315\n\
6316 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6317 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6318\n\
6319\n\
6320 This function is used in example 20.\n\
6321\n\
6322\n\
6323\n\
6324SYNOPSIS:\n\
6325\n\
6326plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6327\n\
6328ARGUMENTS:\n\
6329\n\
6330 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6331 plot. Should have dimensions of\n\
6332 nx by\n\
6333 ny.\n\
6334\n\
6335 nx, ny (PLINT, input) : Dimensions of idata\n\
6336\n\
6337 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6338 pltr below for how these arguments are used (only for the special case\n\
6339 when the callback function\n\
6340 pltr is not supplied).\n\
6341\n\
6342 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6343 (inclusive) will be plotted.\n\
6344\n\
6345 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6346 values to use for value to color mappings. A datum equal to or\n\
6347 less than valuemin will be plotted with color 0.0, while a datum\n\
6348 equal to or greater than valuemax will be plotted with color 1.0.\n\
6349 Data between valuemin and valuemax map linearly to colors in the\n\
6350 range (0.0-1.0).\n\
6351\n\
6352 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6353 defines the transformation between the zero-based indices of the\n\
6354 matrix idata and world coordinates. If\n\
6355 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6356 indices of idata are mapped to the range\n\
6357 xmin through\n\
6358 xmax and the y indices of idata are mapped to the range\n\
6359 ymin through\n\
6360 ymax.For the C case, transformation functions are provided in the\n\
6361 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6362 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6363 matrices. In addition, C callback routines for the transformation\n\
6364 can be supplied by the user such as the mypltr function in\n\
6365 examples/c/x09c.c which provides a general linear transformation\n\
6366 between index coordinates and world coordinates.For languages\n\
6367 other than C you should consult the PLplot documentation for the\n\
6368 details concerning how PLTRANSFORM_callback arguments are\n\
6369 interfaced. However, in general, a particular pattern of\n\
6370 callback-associated arguments such as a tr vector with 6 elements;\n\
6371 xg and yg vectors; or xg and yg matrices are respectively\n\
6372 interfaced to a linear-transformation routine similar to the above\n\
6373 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6374 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6375 support native language callbacks for handling index to\n\
6376 world-coordinate transformations. Examples of these various\n\
6377 approaches are given in examples/<language>x09*,\n\
6378 examples/<language>x16*, examples/<language>x20*,\n\
6379 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6380 supported languages.\n\
6381\n\
6382 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6383 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6384 externally supplied.\n\
6385";
6386static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6387Sets the 3D position of the light source\n\
6388\n\
6389DESCRIPTION:\n\
6390\n\
6391 Sets the 3D position of the light source for use with plsurf3d and\n\
6392 plsurf3dl\n\
6393\n\
6394 Redacted form: pllightsource(x, y, z)\n\
6395\n\
6396 This function is used in example 8.\n\
6397\n\
6398\n\
6399\n\
6400SYNOPSIS:\n\
6401\n\
6402pllightsource(x, y, z)\n\
6403\n\
6404ARGUMENTS:\n\
6405\n\
6406 x (PLFLT, input) : X-coordinate of the light source.\n\
6407\n\
6408 y (PLFLT, input) : Y-coordinate of the light source.\n\
6409\n\
6410 z (PLFLT, input) : Z-coordinate of the light source.\n\
6411";
6412static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6413Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6414\n\
6415DESCRIPTION:\n\
6416\n\
6417 When the implementation is completed this variant of plot3dc (see that\n\
6418 function\'s documentation for more details) should be suitable for the\n\
6419 case where the area of the x, y coordinate grid where z is defined can\n\
6420 be non-rectangular. The implementation is incomplete so the last 4\n\
6421 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6422 indexymax; are currently ignored and the functionality is otherwise\n\
6423 identical to that of plot3dc.\n\
6424\n\
6425 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6426 indexymin, indexymax)\n\
6427\n\
6428\n\
6429 This function is not used in any example.\n\
6430\n\
6431\n\
6432\n\
6433SYNOPSIS:\n\
6434\n\
6435plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6436\n\
6437ARGUMENTS:\n\
6438\n\
6439 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6440 which the function is evaluated.\n\
6441\n\
6442 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6443 which the function is evaluated.\n\
6444\n\
6445 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6446 plot. Should have dimensions of\n\
6447 nx by\n\
6448 ny.\n\
6449\n\
6450 nx (PLINT, input) : Number of x values at which the function is\n\
6451 evaluated.\n\
6452\n\
6453 ny (PLINT, input) : Number of y values at which the function is\n\
6454 evaluated.\n\
6455\n\
6456 opt (PLINT, input) : Determines the way in which the surface is\n\
6457 represented. To specify more than one option just add the options,\n\
6458 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6459 showing z as a function of x for each value of y[j] .\n\
6460 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6461 for each value of x[i] .\n\
6462 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6463 at which function is defined.\n\
6464 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6465 the z value being plotted. The color is used from the current\n\
6466 cmap1.\n\
6467 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6468 using parameters\n\
6469 nlevel and\n\
6470 clevel.\n\
6471 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6472 the borders of the plotted function.\n\
6473\n\
6474\n\
6475 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6476 levels.\n\
6477\n\
6478 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6479\n\
6480 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6481 corresponds to the first x index where z is defined.\n\
6482\n\
6483 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6484 which corresponds (by convention) to one more than the last x\n\
6485 index value where z is defined.\n\
6486\n\
6487 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6488 values which all must be ≥ 0. These values are the first y index\n\
6489 where z is defined for a particular x index in the range from\n\
6490 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6491 indexxmax.\n\
6492\n\
6493 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6494 values which all must be ≤ ny. These values correspond (by\n\
6495 convention) to one more than the last y index where z is defined\n\
6496 for a particular x index in the range from indexxmin to indexxmax\n\
6497 - 1. The dimension of indexymax is indexxmax.\n\
6498";
6499static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6500Creates a new stream and makes it the default\n\
6501\n\
6502DESCRIPTION:\n\
6503\n\
6504 Creates a new stream and makes it the default. Differs from using\n\
6505 plsstrm, in that a free stream number is found, and returned.\n\
6506 Unfortunately, I have to start at stream 1 and work upward, since\n\
6507 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6508 that no initial, library-opening call is required. So stream 0 must\n\
6509 be preallocated, and there is no simple way of determining whether it\n\
6510 is already in use or not.\n\
6511\n\
6512 Redacted form: plmkstrm(p_strm)\n\
6513\n\
6514 This function is used in examples 1 and 20.\n\
6515\n\
6516\n\
6517\n\
6518SYNOPSIS:\n\
6519\n\
6520plmkstrm(p_strm)\n\
6521\n\
6522ARGUMENTS:\n\
6523\n\
6524 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6525 number of the created stream.\n\
6526";
6527static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6528Set FCI (font characterization integer)\n\
6529\n\
6530DESCRIPTION:\n\
6531\n\
6532 Sets font characteristics to be used at the start of the next string\n\
6533 using the FCI approach. See the PLplot documentation for more\n\
6534 information. Note, plsfont (which calls plsfci internally) provides a\n\
6535 more user-friendly API for setting the font characterisitics.\n\
6536\n\
6537 Redacted form: General: plsfci(fci)\n\
6538\n\
6539\n\
6540 This function is used in example 23.\n\
6541\n\
6542\n\
6543\n\
6544SYNOPSIS:\n\
6545\n\
6546plsfci(fci)\n\
6547\n\
6548ARGUMENTS:\n\
6549\n\
6550 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6551 of FCI.\n\
6552";
6553static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6554Initialize PLplot\n\
6555\n\
6556DESCRIPTION:\n\
6557\n\
6558 Initializing the plotting package. The program prompts for the device\n\
6559 keyword or number of the desired output device. Hitting a RETURN in\n\
6560 response to the prompt is the same as selecting the first device.\n\
6561 plinit will issue no prompt if either the device was specified\n\
6562 previously (via command line flag, the plsetopt function, or the\n\
6563 plsdev function), or if only one device is enabled when PLplot is\n\
6564 installed. If subpages have been specified, the output device is\n\
6565 divided into nx by ny subpages, each of which may be used\n\
6566 independently. If plinit is called again during a program, the\n\
6567 previously opened file will be closed. The subroutine pladv is used\n\
6568 to advance from one subpage to the next.\n\
6569\n\
6570 Redacted form: plinit()\n\
6571\n\
6572 This function is used in all of the examples.\n\
6573\n\
6574\n\
6575\n\
6576SYNOPSIS:\n\
6577\n\
6578plinit()\n\
6579";
6580static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6581Set line style\n\
6582\n\
6583DESCRIPTION:\n\
6584\n\
6585 This sets up the line style for all lines subsequently drawn. A line\n\
6586 consists of segments in which the pen is alternately down and up. The\n\
6587 lengths of these segments are passed in the vectors mark and space\n\
6588 respectively. The number of mark-space pairs is specified by nms. In\n\
6589 order to return the line style to the default continuous line, plstyl\n\
6590 should be called with nms =0 .(see also pllsty)\n\
6591\n\
6592 Redacted form: plstyl(mark, space)\n\
6593\n\
6594 This function is used in examples 1, 9, and 14.\n\
6595\n\
6596\n\
6597\n\
6598SYNOPSIS:\n\
6599\n\
6600plstyl(nms, mark, space)\n\
6601\n\
6602ARGUMENTS:\n\
6603\n\
6604 nms (PLINT, input) : The number of mark and space elements in a\n\
6605 line. Thus a simple broken line can be obtained by setting nms=1\n\
6606 . A continuous line is specified by setting nms=0 .\n\
6607\n\
6608 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6609 segments during which the pen is down, measured in micrometers.\n\
6610\n\
6611 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6612 the segments during which the pen is up, measured in micrometers.\n\
6613";
6614static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6615Set length of minor ticks\n\
6616\n\
6617DESCRIPTION:\n\
6618\n\
6619 This sets up the length of the minor ticks and the length of the\n\
6620 terminals on error bars. The actual length is the product of the\n\
6621 default length and a scaling factor as for character height.\n\
6622\n\
6623 Redacted form: plsmin(def, scale)\n\
6624\n\
6625 This function is used in example 29.\n\
6626\n\
6627\n\
6628\n\
6629SYNOPSIS:\n\
6630\n\
6631plsmin(def, scale)\n\
6632\n\
6633ARGUMENTS:\n\
6634\n\
6635 def (PLFLT, input) : The default length of a minor tick in\n\
6636 millimeters, should be set to zero if the default length is to\n\
6637 remain unchanged.\n\
6638\n\
6639 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6640 actual tick length.\n\
6641";
6642static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6643Draw a box with axes, etc, in 3-d\n\
6644\n\
6645DESCRIPTION:\n\
6646\n\
6647 Draws axes, numeric and text labels for a three-dimensional surface\n\
6648 plot. For a more complete description of three-dimensional plotting\n\
6649 see the PLplot documentation.\n\
6650\n\
6651 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6652 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6653\n\
6654\n\
6655 This function is used in examples 8, 11, 18, and 21.\n\
6656\n\
6657\n\
6658\n\
6659SYNOPSIS:\n\
6660\n\
6661plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6662\n\
6663ARGUMENTS:\n\
6664\n\
6665 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6666 options for the x axis. The string can include any combination of\n\
6667 the following letters (upper or lower case) in any order: b: Draws\n\
6668 axis at base, at height z=\n\
6669 zmin where zmin is defined by call to plw3d. This character must be\n\
6670 specified in order to use any of the other options.\n\
6671 d: Plot labels as date / time. Values are assumed to be\n\
6672 seconds since the epoch (as used by gmtime).\n\
6673 f: Always use fixed point numeric labels.\n\
6674 i: Inverts tick marks, so they are drawn downwards, rather\n\
6675 than upwards.\n\
6676 l: Labels axis logarithmically. This only affects the labels,\n\
6677 not the data, and so it is necessary to compute the logarithms\n\
6678 of data points before passing them to any of the drawing\n\
6679 routines.\n\
6680 n: Writes numeric labels at major tick intervals.\n\
6681 o: Use custom labelling function to generate axis label text.\n\
6682 The custom labelling function can be defined with the\n\
6683 plslabelfunc command.\n\
6684 s: Enables subticks between major ticks, only valid if t is\n\
6685 also specified.\n\
6686 t: Draws major ticks.\n\
6687 u: If this is specified, the text label for the axis is\n\
6688 written under the axis.\n\
6689\n\
6690\n\
6691 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6692 the text label for the x axis. It is only drawn if u is in the\n\
6693 xopt string.\n\
6694\n\
6695 xtick (PLFLT, input) : World coordinate interval between major\n\
6696 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6697 generates a suitable tick interval.\n\
6698\n\
6699 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6700 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6701 generates a suitable minor tick interval.\n\
6702\n\
6703 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6704 options for the y axis. The string is interpreted in the same way\n\
6705 as xopt.\n\
6706\n\
6707 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6708 the text label for the y axis. It is only drawn if u is in the\n\
6709 yopt string.\n\
6710\n\
6711 ytick (PLFLT, input) : World coordinate interval between major\n\
6712 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6713 generates a suitable tick interval.\n\
6714\n\
6715 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6716 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6717 generates a suitable minor tick interval.\n\
6718\n\
6719 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6720 options for the z axis. The string can include any combination of\n\
6721 the following letters (upper or lower case) in any order: b: Draws\n\
6722 z axis to the left of the surface plot.\n\
6723 c: Draws z axis to the right of the surface plot.\n\
6724 d: Draws grid lines parallel to the x-y plane behind the\n\
6725 figure. These lines are not drawn until after plot3d or\n\
6726 plmesh are called because of the need for hidden line removal.\n\
6727 e: Plot labels as date / time. Values are assumed to be\n\
6728 seconds since the epoch (as used by gmtime). Note this\n\
6729 suboption is interpreted the same as the d suboption for xopt\n\
6730 and yopt, but it has to be identified as e for zopt since d\n\
6731 has already been used for the different purpose above.\n\
6732 f: Always use fixed point numeric labels.\n\
6733 i: Inverts tick marks, so they are drawn away from the center.\n\
6734 l: Labels axis logarithmically. This only affects the labels,\n\
6735 not the data, and so it is necessary to compute the logarithms\n\
6736 of data points before passing them to any of the drawing\n\
6737 routines.\n\
6738 m: Writes numeric labels at major tick intervals on the\n\
6739 right-hand z axis.\n\
6740 n: Writes numeric labels at major tick intervals on the\n\
6741 left-hand z axis.\n\
6742 o: Use custom labelling function to generate axis label text.\n\
6743 The custom labelling function can be defined with the\n\
6744 plslabelfunc command.\n\
6745 s: Enables subticks between major ticks, only valid if t is\n\
6746 also specified.\n\
6747 t: Draws major ticks.\n\
6748 u: If this is specified, the text label is written beside the\n\
6749 left-hand axis.\n\
6750 v: If this is specified, the text label is written beside the\n\
6751 right-hand axis.\n\
6752\n\
6753\n\
6754 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6755 the text label for the z axis. It is only drawn if u or v are in\n\
6756 the zopt string.\n\
6757\n\
6758 ztick (PLFLT, input) : World coordinate interval between major\n\
6759 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6760 generates a suitable tick interval.\n\
6761\n\
6762 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6763 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6764 generates a suitable minor tick interval.\n\
6765";
6766static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6767Set character size\n\
6768\n\
6769DESCRIPTION:\n\
6770\n\
6771 This sets up the size of all subsequent characters drawn. The actual\n\
6772 height of a character is the product of the default character size and\n\
6773 a scaling factor.\n\
6774\n\
6775 Redacted form: plschr(def, scale)\n\
6776\n\
6777 This function is used in examples 2, 13, 23, and 24.\n\
6778\n\
6779\n\
6780\n\
6781SYNOPSIS:\n\
6782\n\
6783plschr(def, scale)\n\
6784\n\
6785ARGUMENTS:\n\
6786\n\
6787 def (PLFLT, input) : The default height of a character in\n\
6788 millimeters, should be set to zero if the default height is to\n\
6789 remain unchanged. For rasterized drivers the dx and dy values\n\
6790 specified in plspage are used to convert from mm to pixels (note\n\
6791 the different unit systems used). This dpi aware scaling is not\n\
6792 implemented for all drivers yet.\n\
6793\n\
6794 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6795 actual character height.\n\
6796";
6797static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6798Calculate continuous time from broken-down time for the current stream\n\
6799\n\
6800DESCRIPTION:\n\
6801\n\
6802 Calculate continuous time, ctime, from broken-down time for the\n\
6803 current stream. The broken-down\n\
6804 time is specified by the following parameters: year, month, day, hour,\n\
6805 min, and sec. This function is the inverse of plbtime.\n\
6806\n\
6807 The PLplot definition of broken-down time is a calendar time that\n\
6808 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6809 responsibility to apply those offsets (if so desired) before using the\n\
6810 PLplot time API. By default broken-down time is defined using the\n\
6811 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6812 continuous time is defined as the number of seconds since the Unix\n\
6813 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6814 broken-down and continuous time are possible, see plconfigtime which\n\
6815 specifies that transformation for the current stream.\n\
6816\n\
6817 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6818 ctime)\n\
6819\n\
6820\n\
6821 This function is used in example 29.\n\
6822\n\
6823\n\
6824\n\
6825SYNOPSIS:\n\
6826\n\
6827plctime(year, month, day, hour, min, sec, ctime)\n\
6828\n\
6829ARGUMENTS:\n\
6830\n\
6831 year (PLINT, input) : Input year.\n\
6832\n\
6833 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6834 (December).\n\
6835\n\
6836 day (PLINT, input) : Input day in range from 1 to 31.\n\
6837\n\
6838 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6839\n\
6840 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6841\n\
6842 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6843\n\
6844 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6845 time calculated from the broken-down time specified by the\n\
6846 previous parameters.\n\
6847";
6848static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6849Set color, cmap0\n\
6850\n\
6851DESCRIPTION:\n\
6852\n\
6853 Sets the color index for cmap0 (see the PLplot documentation).\n\
6854\n\
6855 Redacted form: plcol0(icol0)\n\
6856\n\
6857 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6858\n\
6859\n\
6860\n\
6861SYNOPSIS:\n\
6862\n\
6863plcol0(icol0)\n\
6864\n\
6865ARGUMENTS:\n\
6866\n\
6867 icol0 (PLINT, input) : Integer representing the color. The\n\
6868 defaults at present are (these may change):\n\
6869 0 black (default background)\n\
6870 1 red (default foreground)\n\
6871 2 yellow\n\
6872 3 green\n\
6873 4 aquamarine\n\
6874 5 pink\n\
6875 6 wheat\n\
6876 7 grey\n\
6877 8 brown\n\
6878 9 blue\n\
6879 10 BlueViolet\n\
6880 11 cyan\n\
6881 12 turquoise\n\
6882 13 magenta\n\
6883 14 salmon\n\
6884 15 white\n\
6885\n\
6886 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6887 change an individual color in the cmap0 color palette.\n\
6888";
6889static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6890Set color, cmap1\n\
6891\n\
6892DESCRIPTION:\n\
6893\n\
6894 Sets the color for cmap1 (see the PLplot documentation).\n\
6895\n\
6896 Redacted form: plcol1(col1)\n\
6897\n\
6898 This function is used in examples 12 and 21.\n\
6899\n\
6900\n\
6901\n\
6902SYNOPSIS:\n\
6903\n\
6904plcol1(col1)\n\
6905\n\
6906ARGUMENTS:\n\
6907\n\
6908 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6909 is mapped to color using the continuous cmap1 palette which by\n\
6910 default ranges from blue to the background color to red. The\n\
6911 cmap1 palette can also be straightforwardly changed by the user\n\
6912 with plscmap1 or plscmap1l.\n\
6913";
6914static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6915Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6916\n\
6917DESCRIPTION:\n\
6918\n\
6919 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6920\n\
6921 Redacted form: plgcolbg(r, g, b)\n\
6922\n\
6923 This function is used in example 31.\n\
6924\n\
6925\n\
6926\n\
6927SYNOPSIS:\n\
6928\n\
6929plgcolbg(r, g, b)\n\
6930\n\
6931ARGUMENTS:\n\
6932\n\
6933 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6934 in the range from 0 to 255.\n\
6935\n\
6936 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6937 in the range from 0 to 255.\n\
6938\n\
6939 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6940 in the range from 0 to 255.\n\
6941";
6942static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6943Draw a circular or elliptical arc\n\
6944\n\
6945DESCRIPTION:\n\
6946\n\
6947 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6948 semiminor axis b, starting at angle1 and ending at angle2.\n\
6949\n\
6950 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6951 fill)\n\
6952\n\
6953\n\
6954 This function is used in examples 3 and 27.\n\
6955\n\
6956\n\
6957\n\
6958SYNOPSIS:\n\
6959\n\
6960plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6961\n\
6962ARGUMENTS:\n\
6963\n\
6964 x (PLFLT, input) : X coordinate of arc center.\n\
6965\n\
6966 y (PLFLT, input) : Y coordinate of arc center.\n\
6967\n\
6968 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6969\n\
6970 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6971\n\
6972 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6973 semimajor axis.\n\
6974\n\
6975 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6976 semimajor axis.\n\
6977\n\
6978 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6979 X-axis.\n\
6980\n\
6981 fill (PLBOOL, input) : Draw a filled arc.\n\
6982";
6983static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6984Parse command-line arguments\n\
6985\n\
6986DESCRIPTION:\n\
6987\n\
6988 Parse command-line arguments.\n\
6989\n\
6990 plparseopts removes all recognized flags (decreasing argc\n\
6991 accordingly), so that invalid input may be readily detected. It can\n\
6992 also be used to process user command line flags. The user can merge\n\
6993 an option table of type PLOptionTable into the internal option table\n\
6994 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6995 the external table(s) be parsed by calling plClearOpts before\n\
6996 plMergeOpts.\n\
6997\n\
6998 The default action taken by plparseopts is as follows:\n\
6999 Returns with an error if an unrecognized option or badly formed\n\
7000 option-value pair are encountered.\n\
7001 Returns immediately (return code 0) when the first non-option command\n\
7002 line argument is found.\n\
7003 Returns with the return code of the option handler, if one was called.\n\
7004\n\
7005 Deletes command line arguments from argv list as they are found, and\n\
7006 decrements argc accordingly.\n\
7007 Does not show \"invisible\" options in usage or help messages.\n\
7008 Assumes the program name is contained in argv[0].\n\
7009\n\
7010 These behaviors may be controlled through the\n\
7011 mode argument.\n\
7012\n\
7013 Redacted form: General: plparseopts(argv, mode)\n\
7014\n\
7015\n\
7016 This function is used in all of the examples.\n\
7017\n\
7018\n\
7019\n\
7020SYNOPSIS:\n\
7021\n\
7022PLINT plparseopts(p_argc, argv, mode)\n\
7023\n\
7024ARGUMENTS:\n\
7025\n\
7026 p_argc (int *, input/output) : Number of arguments.\n\
7027\n\
7028 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7029 strings containing *p_argc command-line arguments.\n\
7030\n\
7031 mode (PLINT, input) : Parsing mode with the following\n\
7032 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7033 and all error messages enabled, including program exit when an\n\
7034 error occurs. Anything on the command line that isn\'t recognized\n\
7035 as a valid option or option argument is flagged as an error.\n\
7036 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7037 of errors.\n\
7038 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7039 arguments.\n\
7040 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7041 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7042 pointer to the program name.\n\
7043 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7044 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7045 unrecognized arguments.\n\
7046";
7047static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
7048Get parameters that define current device-space window\n\
7049\n\
7050DESCRIPTION:\n\
7051\n\
7052 Get relative margin width, aspect ratio, and relative justification\n\
7053 that define current device-space window. If plsdidev has not been\n\
7054 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7055 p_jy will all be 0.\n\
7056\n\
7057 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7058\n\
7059 This function is used in example 31.\n\
7060\n\
7061\n\
7062\n\
7063SYNOPSIS:\n\
7064\n\
7065plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7066\n\
7067ARGUMENTS:\n\
7068\n\
7069 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7070 margin width.\n\
7071\n\
7072 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7073 ratio.\n\
7074\n\
7075 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7076 justification in x.\n\
7077\n\
7078 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7079 justification in y.\n\
7080";
7081static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7082Assign a function to use for generating custom axis labels\n\
7083\n\
7084DESCRIPTION:\n\
7085\n\
7086 This function allows a user to provide their own function to provide\n\
7087 axis label text. The user function is given the numeric value for a\n\
7088 point on an axis and returns a string label to correspond with that\n\
7089 value. Custom axis labels can be enabled by passing appropriate\n\
7090 arguments to plenv, plbox, plbox3 and similar functions.\n\
7091\n\
7092 This function is used in example 19.\n\
7093\n\
7094\n\
7095\n\
7096SYNOPSIS:\n\
7097\n\
7098plslabelfunc(label_func, label_data)\n\
7099\n\
7100ARGUMENTS:\n\
7101\n\
7102 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7103 label function. In order to reset to the default labelling, set\n\
7104 this to NULL. The labelling function parameters are, in order:\n\
7105 axis: This indicates which axis a label is being requested for.\n\
7106 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7107\n\
7108 value: This is the value along the axis which is being labelled.\n\
7109\n\
7110 label_text: The string representation of the label value.\n\
7111\n\
7112 length: The maximum length in characters allowed for label_text.\n\
7113\n\
7114\n\
7115 label_data (PLPointer, input) : This parameter may be used to pass\n\
7116 data to the label_func function.\n\
7117";
7118static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7119Get the (current) run level\n\
7120\n\
7121DESCRIPTION:\n\
7122\n\
7123 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7124 1, initialized\n\
7125 2, viewport defined\n\
7126 3, world coordinates defined\n\
7127\n\
7128\n\
7129 Redacted form: plglevel(p_level)\n\
7130\n\
7131 This function is used in example 31.\n\
7132\n\
7133\n\
7134\n\
7135SYNOPSIS:\n\
7136\n\
7137plglevel(p_level)\n\
7138\n\
7139ARGUMENTS:\n\
7140\n\
7141 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7142 level.\n\
7143";
7144static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7145Select line style\n\
7146\n\
7147DESCRIPTION:\n\
7148\n\
7149 This sets the line style according to one of eight predefined patterns\n\
7150 (also see plstyl).\n\
7151\n\
7152 Redacted form: pllsty(lin)\n\
7153\n\
7154 This function is used in examples 9, 12, 22, and 25.\n\
7155\n\
7156\n\
7157\n\
7158SYNOPSIS:\n\
7159\n\
7160pllsty(lin)\n\
7161\n\
7162ARGUMENTS:\n\
7163\n\
7164 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7165 a continuous line, line style 2 is a line with short dashes and\n\
7166 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7167 4 has long dashes and short gaps and so on.\n\
7168";
7169static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7170Set up standard window and draw box\n\
7171\n\
7172DESCRIPTION:\n\
7173\n\
7174 Sets up plotter environment for simple graphs by calling pladv and\n\
7175 setting up viewport and window to sensible default values. plenv\n\
7176 leaves a standard margin (left-hand margin of eight character heights,\n\
7177 and a margin around the other three sides of five character heights)\n\
7178 around most graphs for axis labels and a title. When these defaults\n\
7179 are not suitable, use the individual routines plvpas, plvpor, or\n\
7180 plvasp for setting up the viewport, plwind for defining the window,\n\
7181 and plbox for drawing the box.\n\
7182\n\
7183 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7184\n\
7185 This function is used in example 1,3,9,13,14,19-22,29.\n\
7186\n\
7187\n\
7188\n\
7189SYNOPSIS:\n\
7190\n\
7191plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7192\n\
7193ARGUMENTS:\n\
7194\n\
7195 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7196 world coordinates).\n\
7197\n\
7198 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7199 world coordinates).\n\
7200\n\
7201 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7202 coordinates).\n\
7203\n\
7204 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7205 coordinates).\n\
7206\n\
7207 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7208 scales will not be set, the user must set up the scale before\n\
7209 calling plenv using plsvpa, plvasp or other.\n\
7210 0: the x and y axes are scaled independently to use as much of\n\
7211 the screen as possible.\n\
7212 1: the scales of the x and y axes are made equal.\n\
7213 2: the axis of the x and y axes are made equal, and the plot\n\
7214 box will be square.\n\
7215\n\
7216\n\
7217 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7218 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7219 -1: draw box only.\n\
7220 0: draw box, ticks, and numeric tick labels.\n\
7221 1: also draw coordinate axes at x=0 and y=0.\n\
7222 2: also draw a grid at major tick positions in both\n\
7223 coordinates.\n\
7224 3: also draw a grid at minor tick positions in both\n\
7225 coordinates.\n\
7226 10: same as 0 except logarithmic x tick marks. (The x data\n\
7227 have to be converted to logarithms separately.)\n\
7228 11: same as 1 except logarithmic x tick marks. (The x data\n\
7229 have to be converted to logarithms separately.)\n\
7230 12: same as 2 except logarithmic x tick marks. (The x data\n\
7231 have to be converted to logarithms separately.)\n\
7232 13: same as 3 except logarithmic x tick marks. (The x data\n\
7233 have to be converted to logarithms separately.)\n\
7234 20: same as 0 except logarithmic y tick marks. (The y data\n\
7235 have to be converted to logarithms separately.)\n\
7236 21: same as 1 except logarithmic y tick marks. (The y data\n\
7237 have to be converted to logarithms separately.)\n\
7238 22: same as 2 except logarithmic y tick marks. (The y data\n\
7239 have to be converted to logarithms separately.)\n\
7240 23: same as 3 except logarithmic y tick marks. (The y data\n\
7241 have to be converted to logarithms separately.)\n\
7242 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7243 and y data have to be converted to logarithms separately.)\n\
7244 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7245 and y data have to be converted to logarithms separately.)\n\
7246 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7247 and y data have to be converted to logarithms separately.)\n\
7248 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7249 and y data have to be converted to logarithms separately.)\n\
7250 40: same as 0 except date / time x labels.\n\
7251 41: same as 1 except date / time x labels.\n\
7252 42: same as 2 except date / time x labels.\n\
7253 43: same as 3 except date / time x labels.\n\
7254 50: same as 0 except date / time y labels.\n\
7255 51: same as 1 except date / time y labels.\n\
7256 52: same as 2 except date / time y labels.\n\
7257 53: same as 3 except date / time y labels.\n\
7258 60: same as 0 except date / time x and y labels.\n\
7259 61: same as 1 except date / time x and y labels.\n\
7260 62: same as 2 except date / time x and y labels.\n\
7261 63: same as 3 except date / time x and y labels.\n\
7262 70: same as 0 except custom x and y labels.\n\
7263 71: same as 1 except custom x and y labels.\n\
7264 72: same as 2 except custom x and y labels.\n\
7265 73: same as 3 except custom x and y labels.\n\
7266";
7267static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7268Initialization\n\
7269\n\
7270DESCRIPTION:\n\
7271\n\
7272 Alternative to plstar for initializing the plotting package. The\n\
7273 device name keyword for the desired output device must be supplied as\n\
7274 an argument. These keywords are the same as those printed out by\n\
7275 plstar. If the requested device is not available, or if the input\n\
7276 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7277 is used. This routine also divides the output device page into nx by\n\
7278 ny subpages, each of which may be used independently. The subroutine\n\
7279 pladv is used to advance from one subpage to the next.\n\
7280\n\
7281 Redacted form: General: plstart(devname, nx, ny)\n\
7282\n\
7283\n\
7284 This function is not used in any examples.\n\
7285\n\
7286\n\
7287\n\
7288SYNOPSIS:\n\
7289\n\
7290plstart(devname, nx, ny)\n\
7291\n\
7292ARGUMENTS:\n\
7293\n\
7294 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7295 containing the device name keyword of the required output device.\n\
7296 If\n\
7297 devname is NULL or if the first character of the string is a ``?\'\',\n\
7298 the normal (prompted) start up is used.\n\
7299\n\
7300 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7301 x direction.\n\
7302\n\
7303 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7304 y direction.\n\
7305";
7306static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7307Plot a glyph at the specified points\n\
7308\n\
7309DESCRIPTION:\n\
7310\n\
7311 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7312 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7313 is specified with a PLplot user string. Note that the user string is\n\
7314 not actually limited to one glyph so it is possible (but not normally\n\
7315 useful) to plot more than one glyph at the specified points with this\n\
7316 function. As with plmtex and plptex, the user string can contain FCI\n\
7317 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7318 else PLplot escapes for Hershey or unicode text to determine the\n\
7319 glyph.\n\
7320\n\
7321 Redacted form: plstring(x, y, string)\n\
7322\n\
7323 This function is used in examples 4, 21 and 26.\n\
7324\n\
7325\n\
7326\n\
7327SYNOPSIS:\n\
7328\n\
7329plstring(n, x, y, string)\n\
7330\n\
7331ARGUMENTS:\n\
7332\n\
7333 n (PLINT, input) : Number of points in the x and y vectors.\n\
7334\n\
7335 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7336 the points.\n\
7337\n\
7338 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7339 the points.\n\
7340\n\
7341 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7342 the glyph(s) to be plotted at each of the n points.\n\
7343";
7344static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7345Write text relative to viewport boundaries in 3D plots\n\
7346\n\
7347DESCRIPTION:\n\
7348\n\
7349 Writes text at a specified position relative to the viewport\n\
7350 boundaries. Text may be written inside or outside the viewport, but\n\
7351 is clipped at the subpage boundaries. The reference point of a string\n\
7352 lies along a line passing through the string at half the height of a\n\
7353 capital letter. The position of the reference point along this line\n\
7354 is determined by just, and the position of the reference point\n\
7355 relative to the viewport is set by disp and pos.\n\
7356\n\
7357 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7358\n\
7359 This function is used in example 28.\n\
7360\n\
7361\n\
7362\n\
7363SYNOPSIS:\n\
7364\n\
7365plmtex3(side, disp, pos, just, text)\n\
7366\n\
7367ARGUMENTS:\n\
7368\n\
7369 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7370 the side of the viewport along which the text is to be written.\n\
7371 The string should contain one or more of the following characters:\n\
7372 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7373 only label the X axis, not both the X and Y axes. x: Label the X\n\
7374 axis.\n\
7375 y: Label the Y axis.\n\
7376 z: Label the Z axis.\n\
7377 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7378 For X it is the axis that starts at y-min. For Y it is the\n\
7379 axis that starts at x-min.\n\
7380 s: Label the secondary axis.\n\
7381 v: Draw the text perpendicular to the axis.\n\
7382\n\
7383\n\
7384 disp (PLFLT, input) : Position of the reference point of string,\n\
7385 measured outwards from the specified viewport edge in units of the\n\
7386 current character height. Use negative disp to write within the\n\
7387 viewport.\n\
7388\n\
7389 pos (PLFLT, input) : Position of the reference point of string\n\
7390 along the specified edge, expressed as a fraction of the length of\n\
7391 the edge.\n\
7392\n\
7393 just (PLFLT, input) : Specifies the position of the string relative\n\
7394 to its reference point. If just=0. , the reference point is at\n\
7395 the left and if just=1. , it is at the right of the string. Other\n\
7396 values of just give intermediate justifications.\n\
7397\n\
7398 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7399 written out.\n\
7400";
7401static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7402Get plot orientation\n\
7403\n\
7404DESCRIPTION:\n\
7405\n\
7406 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7407 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7408 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7409 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7410 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7411 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7412 not been called the default value pointed to by p_rot will be 0.\n\
7413\n\
7414 Redacted form: plgdiori(p_rot)\n\
7415\n\
7416 This function is not used in any examples.\n\
7417\n\
7418\n\
7419\n\
7420SYNOPSIS:\n\
7421\n\
7422plgdiori(p_rot)\n\
7423\n\
7424ARGUMENTS:\n\
7425\n\
7426 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7427 parameter.\n\
7428";
7429static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7430Simple routine to write labels\n\
7431\n\
7432DESCRIPTION:\n\
7433\n\
7434 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7435\n\
7436 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7437\n\
7438 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7439\n\
7440\n\
7441\n\
7442SYNOPSIS:\n\
7443\n\
7444pllab(xlabel, ylabel, tlabel)\n\
7445\n\
7446ARGUMENTS:\n\
7447\n\
7448 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7449 the label for the x axis.\n\
7450\n\
7451 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7452 the label for the y axis.\n\
7453\n\
7454 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7455 the title of the plot.\n\
7456";
7457static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7458Switch to text screen\n\
7459\n\
7460DESCRIPTION:\n\
7461\n\
7462 Sets an interactive device to text mode, used in conjunction with\n\
7463 plgra to allow graphics and text to be interspersed. On a device\n\
7464 which supports separate text and graphics windows, this command causes\n\
7465 control to be switched to the text window. This can be useful for\n\
7466 printing diagnostic messages or getting user input, which would\n\
7467 otherwise interfere with the plots. The program must switch back to\n\
7468 the graphics window before issuing plot commands, as the text (or\n\
7469 console) device will probably become quite confused otherwise. If\n\
7470 already in text mode, this command is ignored. It is also ignored on\n\
7471 devices which only support a single window or use a different method\n\
7472 for shifting focus (see also plgra).\n\
7473\n\
7474 Redacted form: pltext()\n\
7475\n\
7476 This function is used in example 1.\n\
7477\n\
7478\n\
7479\n\
7480SYNOPSIS:\n\
7481\n\
7482pltext()\n\
7483";
7484static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7485Plot all or a subset of Shapefile data using lines in world coordinates\n\
7486\n\
7487DESCRIPTION:\n\
7488\n\
7489 Plot all or a subset of Shapefile data using lines in world\n\
7490 coordinates. Our 19th standard example demonstrates how to use this\n\
7491 function. This function plots data from a Shapefile using lines as in\n\
7492 plmap, however it also has the option of also only drawing specified\n\
7493 elements from the Shapefile. The vector of indices of the required\n\
7494 elements are passed as a function argument. The Shapefile data should\n\
7495 include a metadata file (extension.dbf) listing all items within the\n\
7496 Shapefile. This file can be opened by most popular spreadsheet\n\
7497 programs and can be used to decide which indices to pass to this\n\
7498 function.\n\
7499\n\
7500 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7501 plotentries)\n\
7502\n\
7503 This function is used in example 19.\n\
7504\n\
7505\n\
7506\n\
7507SYNOPSIS:\n\
7508\n\
7509plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7510\n\
7511ARGUMENTS:\n\
7512\n\
7513 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7514 transform the coordinates given in the shapefile into a plot\n\
7515 coordinate system. By using this transform, we can change from a\n\
7516 longitude, latitude coordinate to a polar stereographic project,\n\
7517 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7518 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7519 mapform(), x[] and y[] should be replaced by the corresponding\n\
7520 plot coordinates. If no transform is desired, mapform can be\n\
7521 replaced by NULL.\n\
7522\n\
7523 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7524 the file name of a set of Shapefile files without the file\n\
7525 extension.\n\
7526\n\
7527 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7528 be in the same units as used by the Shapefile. You could use a\n\
7529 very large negative number to plot everything, but you can improve\n\
7530 performance by limiting the area drawn. The units must match those\n\
7531 of the Shapefile projection, which may be for example longitude or\n\
7532 distance. The value of minx must be less than the value of maxx.\n\
7533\n\
7534 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7535 use a very large number to plot everything, but you can improve\n\
7536 performance by limiting the area drawn.\n\
7537\n\
7538 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7539 be in the same units as used by the Shapefile. You could use a\n\
7540 very large negative number to plot everything, but you can improve\n\
7541 performance by limiting the area drawn. The units must match those\n\
7542 of the Shapefile projection, which may be for example latitude or\n\
7543 distance. The value of miny must be less than the value of maxy.\n\
7544\n\
7545 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7546 use a very large number to plot everything, but you can improve\n\
7547 performance by limiting the area drawn.\n\
7548\n\
7549 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7550 zero-based indices of the Shapefile elements which will be drawn.\n\
7551 Setting\n\
7552 plotentries to NULL will plot all elements of the Shapefile.\n\
7553\n\
7554 nplotentries (PLINT, input) : The number of items in\n\
7555 plotentries. Ignored if\n\
7556 plotentries is NULL.\n\
7557";
7558static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7559Set precision in numeric labels\n\
7560\n\
7561DESCRIPTION:\n\
7562\n\
7563 Sets the number of places after the decimal point in numeric labels.\n\
7564\n\
7565 Redacted form: plprec(setp, prec)\n\
7566\n\
7567 This function is used in example 29.\n\
7568\n\
7569\n\
7570\n\
7571SYNOPSIS:\n\
7572\n\
7573plprec(setp, prec)\n\
7574\n\
7575ARGUMENTS:\n\
7576\n\
7577 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7578 automatically determines the number of places to use after the\n\
7579 decimal point in numeric labels (like those used to label axes).\n\
7580 If setp is 1 then prec sets the number of places.\n\
7581\n\
7582 prec (PLINT, input) : The number of characters to draw after the\n\
7583 decimal point in numeric labels.\n\
7584";
7585static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7586Draw a line between two points\n\
7587\n\
7588DESCRIPTION:\n\
7589\n\
7590 Joins the point (\n\
7591 x1,\n\
7592 y1) to (\n\
7593 x2,\n\
7594 y2).\n\
7595\n\
7596 Redacted form: pljoin(x1,y1,x2,y2)\n\
7597\n\
7598 This function is used in examples 3 and 14.\n\
7599\n\
7600\n\
7601\n\
7602SYNOPSIS:\n\
7603\n\
7604pljoin(x1, y1, x2, y2)\n\
7605\n\
7606ARGUMENTS:\n\
7607\n\
7608 x1 (PLFLT, input) : x coordinate of first point.\n\
7609\n\
7610 y1 (PLFLT, input) : y coordinate of first point.\n\
7611\n\
7612 x2 (PLFLT, input) : x coordinate of second point.\n\
7613\n\
7614 y2 (PLFLT, input) : y coordinate of second point.\n\
7615";
7616static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7617Set the device (keyword) name\n\
7618\n\
7619DESCRIPTION:\n\
7620\n\
7621 Set the device (keyword) name.\n\
7622\n\
7623 Redacted form: plsdev(devname)\n\
7624\n\
7625 This function is used in examples 1, 14, and 20.\n\
7626\n\
7627\n\
7628\n\
7629SYNOPSIS:\n\
7630\n\
7631plsdev(devname)\n\
7632\n\
7633ARGUMENTS:\n\
7634\n\
7635 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7636 containing the device name keyword of the required output device.\n\
7637 If\n\
7638 devname is NULL or if the first character of the string is a ``?\'\',\n\
7639 the normal (prompted) start up is used.\n\
7640";
7641static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7642Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7643\n\
7644DESCRIPTION:\n\
7645\n\
7646 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7647 (see the PLplot documentation) index. Overwrites the previous color\n\
7648 value for the given index and, thus, does not result in any additional\n\
7649 allocation of space for colors.\n\
7650\n\
7651 This function is used in example 30.\n\
7652\n\
7653\n\
7654\n\
7655SYNOPSIS:\n\
7656\n\
7657plscol0a(icol0, r, g, b, alpha)\n\
7658\n\
7659ARGUMENTS:\n\
7660\n\
7661 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7662 number of colors (which is set by default, by plscmap0n, or even\n\
7663 by plscmap0).\n\
7664\n\
7665 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7666 degree of red in the color.\n\
7667\n\
7668 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7669 degree of green in the color.\n\
7670\n\
7671 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7672 degree of blue in the color.\n\
7673\n\
7674 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7675 (0.0-1.0).\n\
7676";
7677static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7678Draw filled polygon in 3D\n\
7679\n\
7680DESCRIPTION:\n\
7681\n\
7682 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7683 vectors using the pattern defined by plpsty or plpat. The routine\n\
7684 will automatically close the polygon between the last and first\n\
7685 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7686 plfill3 will fill in between them.\n\
7687\n\
7688 Redacted form: General: plfill3(x, y, z)\n\
7689\n\
7690\n\
7691 This function is used in example 15.\n\
7692\n\
7693\n\
7694\n\
7695SYNOPSIS:\n\
7696\n\
7697plfill3(n, x, y, z)\n\
7698\n\
7699ARGUMENTS:\n\
7700\n\
7701 n (PLINT, input) : Number of vertices in polygon.\n\
7702\n\
7703 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7704 vertices.\n\
7705\n\
7706 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7707 vertices.\n\
7708\n\
7709 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7710 vertices.\n\
7711";
7712static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7713Specify window\n\
7714\n\
7715DESCRIPTION:\n\
7716\n\
7717 Specify the window, i.e., the world coordinates of the edges of the\n\
7718 viewport.\n\
7719\n\
7720 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7721\n\
7722 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7723 29, and 31.\n\
7724\n\
7725\n\
7726\n\
7727SYNOPSIS:\n\
7728\n\
7729plwind(xmin, xmax, ymin, ymax)\n\
7730\n\
7731ARGUMENTS:\n\
7732\n\
7733 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7734 of the viewport.\n\
7735\n\
7736 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7737 of the viewport.\n\
7738\n\
7739 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7740 the viewport.\n\
7741\n\
7742 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7743 viewport.\n\
7744";
7745static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7746Draw text at points defined by Shapefile data in world coordinates\n\
7747\n\
7748DESCRIPTION:\n\
7749\n\
7750 As per plmapline, however the items are plotted as text in the same\n\
7751 way as plptex.\n\
7752\n\
7753 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7754 miny, maxy, plotentry)\n\
7755\n\
7756 This function is used in example 19.\n\
7757\n\
7758\n\
7759\n\
7760SYNOPSIS:\n\
7761\n\
7762plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7763\n\
7764ARGUMENTS:\n\
7765\n\
7766 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7767 transform the coordinates given in the shapefile into a plot\n\
7768 coordinate system. By using this transform, we can change from a\n\
7769 longitude, latitude coordinate to a polar stereographic project,\n\
7770 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7771 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7772 mapform(), x[] and y[] should be replaced by the corresponding\n\
7773 plot coordinates. If no transform is desired, mapform can be\n\
7774 replaced by NULL.\n\
7775\n\
7776 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7777 the file name of a set of Shapefile files without the file\n\
7778 extension.\n\
7779\n\
7780 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7781 dy/dx.\n\
7782\n\
7783 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7784 dy/dx.\n\
7785\n\
7786 just (PLFLT, input) : Set the justification of the text. The value\n\
7787 given will be the fraction of the distance along the string that\n\
7788 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7789 centralized text and 1.0 gives right aligned text.\n\
7790\n\
7791 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7792\n\
7793 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7794 be in the same units as used by the Shapefile. You could use a\n\
7795 very large negative number to plot everything, but you can improve\n\
7796 performance by limiting the area drawn. The units must match those\n\
7797 of the Shapefile projection, which may be for example longitude or\n\
7798 distance. The value of minx must be less than the value of maxx.\n\
7799\n\
7800 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7801 use a very large number to plot everything, but you can improve\n\
7802 performance by limiting the area drawn.\n\
7803\n\
7804 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7805 be in the same units as used by the Shapefile. You could use a\n\
7806 very large negative number to plot everything, but you can improve\n\
7807 performance by limiting the area drawn. The units must match those\n\
7808 of the Shapefile projection, which may be for example latitude or\n\
7809 distance. The value of miny must be less than the value of maxy.\n\
7810\n\
7811 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7812 use a very large number to plot everything, but you can improve\n\
7813 performance by limiting the area drawn.\n\
7814\n\
7815 plotentry (PLINT, input) : An integer indicating which text string\n\
7816 of the Shapefile (zero indexed) will be drawn.\n\
7817";
7818static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7819Switch to graphics screen\n\
7820\n\
7821DESCRIPTION:\n\
7822\n\
7823 Sets an interactive device to graphics mode, used in conjunction with\n\
7824 pltext to allow graphics and text to be interspersed. On a device\n\
7825 which supports separate text and graphics windows, this command causes\n\
7826 control to be switched to the graphics window. If already in graphics\n\
7827 mode, this command is ignored. It is also ignored on devices which\n\
7828 only support a single window or use a different method for shifting\n\
7829 focus. See also pltext.\n\
7830\n\
7831 Redacted form: plgra()\n\
7832\n\
7833 This function is used in example 1.\n\
7834\n\
7835\n\
7836\n\
7837SYNOPSIS:\n\
7838\n\
7839plgra()\n\
7840";
7841static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7842Set parameters of contour labelling other than format of numerical label\n\
7843\n\
7844DESCRIPTION:\n\
7845\n\
7846 Set parameters of contour labelling other than those handled by\n\
7847 pl_setcontlabelformat.\n\
7848\n\
7849 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7850\n\
7851 This function is used in example 9.\n\
7852\n\
7853\n\
7854\n\
7855SYNOPSIS:\n\
7856\n\
7857pl_setcontlabelparam(offset, size, spacing, active)\n\
7858\n\
7859ARGUMENTS:\n\
7860\n\
7861 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7862 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7863\n\
7864 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7865 Default value is 0.3.\n\
7866\n\
7867 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7868 Default value is 0.1.\n\
7869\n\
7870 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7871 contour labels on. Default is off (0).\n\
7872";
7873static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7874Get family, style and weight of the current font\n\
7875\n\
7876DESCRIPTION:\n\
7877\n\
7878 Gets information about current font. See the PLplot documentation for\n\
7879 more information on font selection.\n\
7880\n\
7881 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7882\n\
7883 This function is used in example 23.\n\
7884\n\
7885\n\
7886\n\
7887SYNOPSIS:\n\
7888\n\
7889plgfont(p_family, p_style, p_weight)\n\
7890\n\
7891ARGUMENTS:\n\
7892\n\
7893 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7894 font family. The available values are given by the PL_FCI_*\n\
7895 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7896 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7897 p_family is NULL then the font family is not returned.\n\
7898\n\
7899 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7900 font style. The available values are given by the PL_FCI_*\n\
7901 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7902 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7903 style is not returned.\n\
7904\n\
7905 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7906 font weight. The available values are given by the PL_FCI_*\n\
7907 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7908 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7909 returned.\n\
7910";
7911static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7912Plot a histogram from unbinned data\n\
7913\n\
7914DESCRIPTION:\n\
7915\n\
7916 Plots a histogram from n data points stored in the data vector. This\n\
7917 routine bins the data into nbin bins equally spaced between datmin and\n\
7918 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7919 opt allows, among other things, the histogram either to be plotted in\n\
7920 an existing window or causes plhist to call plenv with suitable limits\n\
7921 before plotting the histogram.\n\
7922\n\
7923 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7924\n\
7925 This function is used in example 5.\n\
7926\n\
7927\n\
7928\n\
7929SYNOPSIS:\n\
7930\n\
7931plhist(n, data, datmin, datmax, nbin, opt)\n\
7932\n\
7933ARGUMENTS:\n\
7934\n\
7935 n (PLINT, input) : Number of data points.\n\
7936\n\
7937 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7938 n data points.\n\
7939\n\
7940 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7941\n\
7942 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7943\n\
7944 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7945 divide the interval xmin to xmax.\n\
7946\n\
7947 opt (PLINT, input) : Is a combination of several flags:\n\
7948 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7949 the histogram data, the outer bins are expanded to fill up the\n\
7950 entire x-axis, data outside the given extremes are assigned to the\n\
7951 outer bins and bins of zero height are simply drawn.\n\
7952 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7953 to fit the histogram data, without this flag, plenv is called\n\
7954 to set the world coordinates.\n\
7955 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7956 extremes are not taken into account. This option should\n\
7957 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7958 properly present the data.\n\
7959 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7960 size as the ones inside.\n\
7961 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7962 (there is a gap for such bins).\n\
7963";
7964static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7965Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7966\n\
7967DESCRIPTION:\n\
7968\n\
7969 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7970 alpha transparency value.\n\
7971\n\
7972 This function is used in example 31.\n\
7973\n\
7974\n\
7975\n\
7976SYNOPSIS:\n\
7977\n\
7978plgcolbga(r, g, b, alpha)\n\
7979\n\
7980ARGUMENTS:\n\
7981\n\
7982 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7983 in the range from 0 to 255.\n\
7984\n\
7985 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7986 in the range from 0 to 255.\n\
7987\n\
7988 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7989 in the range from 0 to 255.\n\
7990\n\
7991 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7992 transparency in the range (0.0-1.0).\n\
7993";
7994static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
7995Set orientation\n\
7996\n\
7997DESCRIPTION:\n\
7998\n\
7999 Set integer plot orientation parameter. This function is identical to\n\
8000 plsdiori except for the type of the argument, and should be used in\n\
8001 the same way. See the documentation of plsdiori for details.\n\
8002\n\
8003 Redacted form: plsori(ori)\n\
8004\n\
8005 This function is used in example 3.\n\
8006\n\
8007\n\
8008\n\
8009SYNOPSIS:\n\
8010\n\
8011plsori(ori)\n\
8012\n\
8013ARGUMENTS:\n\
8014\n\
8015 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8016 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8017 angle.\n\
8018";
8019static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
8020Plot latitude and longitude lines\n\
8021\n\
8022DESCRIPTION:\n\
8023\n\
8024 Displays latitude and longitude on the current plot. The lines are\n\
8025 plotted in the current color and line style.\n\
8026\n\
8027 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8028 minlat, maxlat)\n\
8029\n\
8030 This function is used in example 19.\n\
8031\n\
8032\n\
8033\n\
8034SYNOPSIS:\n\
8035\n\
8036plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8037\n\
8038ARGUMENTS:\n\
8039\n\
8040 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8041 transform the coordinate longitudes and latitudes to a plot\n\
8042 coordinate system. By using this transform, we can change from a\n\
8043 longitude, latitude coordinate to a polar stereographic project,\n\
8044 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8045 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8046 mapform(), x[] and y[] should be replaced by the corresponding\n\
8047 plot coordinates. If no transform is desired, mapform can be\n\
8048 replaced by NULL.\n\
8049\n\
8050 dlong (PLFLT, input) : The interval in degrees at which the\n\
8051 longitude lines are to be plotted.\n\
8052\n\
8053 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8054 lines are to be plotted.\n\
8055\n\
8056 minlong (PLFLT, input) : The value of the longitude on the left\n\
8057 side of the plot. The value of minlong must be less than the value\n\
8058 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8059 equal to 360.\n\
8060\n\
8061 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8062 side of the plot.\n\
8063\n\
8064 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8065 background. One can always use -90.0 as the boundary outside the\n\
8066 plot window will be automatically eliminated. However, the\n\
8067 program will be faster if one can reduce the size of the\n\
8068 background plotted.\n\
8069\n\
8070 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8071 background. One can always use 90.0 as the boundary outside the\n\
8072 plot window will be automatically eliminated.\n\
8073";
8074static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8075Clear current (sub)page\n\
8076\n\
8077DESCRIPTION:\n\
8078\n\
8079 Clears the current page, effectively erasing everything that have been\n\
8080 drawn. This command only works with interactive drivers; if the\n\
8081 driver does not support this, the page is filled with the background\n\
8082 color in use. If the current page is divided into subpages, only the\n\
8083 current subpage is erased. The nth subpage can be selected with\n\
8084 pladv(n).\n\
8085\n\
8086 Redacted form: General: plclear()\n\
8087\n\
8088\n\
8089 This function is not used in any examples.\n\
8090\n\
8091\n\
8092\n\
8093SYNOPSIS:\n\
8094\n\
8095plclear()\n\
8096";
8097static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8098Initialization\n\
8099\n\
8100DESCRIPTION:\n\
8101\n\
8102 Initializing the plotting package. The program prompts for the device\n\
8103 keyword or number of the desired output device. Hitting a RETURN in\n\
8104 response to the prompt is the same as selecting the first device. If\n\
8105 only one device is enabled when PLplot is installed, plstar will issue\n\
8106 no prompt. The output device is divided into nx by ny subpages, each\n\
8107 of which may be used independently. The subroutine pladv is used to\n\
8108 advance from one subpage to the next.\n\
8109\n\
8110 Redacted form: plstar(nx, ny)\n\
8111\n\
8112 This function is used in example 1.\n\
8113\n\
8114\n\
8115\n\
8116SYNOPSIS:\n\
8117\n\
8118plstar(nx, ny)\n\
8119\n\
8120ARGUMENTS:\n\
8121\n\
8122 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8123 x direction.\n\
8124\n\
8125 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8126 y direction.\n\
8127";
8128static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8129Write text relative to viewport boundaries\n\
8130\n\
8131DESCRIPTION:\n\
8132\n\
8133 Writes text at a specified position relative to the viewport\n\
8134 boundaries. Text may be written inside or outside the viewport, but\n\
8135 is clipped at the subpage boundaries. The reference point of a string\n\
8136 lies along a line passing through the string at half the height of a\n\
8137 capital letter. The position of the reference point along this line\n\
8138 is determined by just, and the position of the reference point\n\
8139 relative to the viewport is set by disp and pos.\n\
8140\n\
8141 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8142\n\
8143\n\
8144 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8145 26.\n\
8146\n\
8147\n\
8148\n\
8149SYNOPSIS:\n\
8150\n\
8151plmtex(side, disp, pos, just, text)\n\
8152\n\
8153ARGUMENTS:\n\
8154\n\
8155 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8156 the side of the viewport along which the text is to be written.\n\
8157 The string must be one of: b: Bottom of viewport, text written\n\
8158 parallel to edge.\n\
8159 bv: Bottom of viewport, text written at right angles to edge.\n\
8160 l: Left of viewport, text written parallel to edge.\n\
8161 lv: Left of viewport, text written at right angles to edge.\n\
8162 r: Right of viewport, text written parallel to edge.\n\
8163 rv: Right of viewport, text written at right angles to edge.\n\
8164 t: Top of viewport, text written parallel to edge.\n\
8165 tv: Top of viewport, text written at right angles to edge.\n\
8166\n\
8167\n\
8168 disp (PLFLT, input) : Position of the reference point of string,\n\
8169 measured outwards from the specified viewport edge in units of the\n\
8170 current character height. Use negative disp to write within the\n\
8171 viewport.\n\
8172\n\
8173 pos (PLFLT, input) : Position of the reference point of string\n\
8174 along the specified edge, expressed as a fraction of the length of\n\
8175 the edge.\n\
8176\n\
8177 just (PLFLT, input) : Specifies the position of the string relative\n\
8178 to its reference point. If just=0. , the reference point is at\n\
8179 the left and if just=1. , it is at the right of the string. Other\n\
8180 values of just give intermediate justifications.\n\
8181\n\
8182 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8183 written out.\n\
8184";
8185static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8186Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8187\n\
8188DESCRIPTION:\n\
8189\n\
8190 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8191 PLFLT alpha transparency value (see the PLplot documentation).\n\
8192\n\
8193 This function is used in example 31.\n\
8194\n\
8195\n\
8196\n\
8197SYNOPSIS:\n\
8198\n\
8199plscolbga(r, g, b, alpha)\n\
8200\n\
8201ARGUMENTS:\n\
8202\n\
8203 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8204 degree of red in the color.\n\
8205\n\
8206 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8207 degree of green in the color.\n\
8208\n\
8209 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8210 degree of blue in the color.\n\
8211\n\
8212 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8213 (0.0-1.0).\n\
8214";
8215static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8216Replays contents of plot buffer to current device/file\n\
8217\n\
8218DESCRIPTION:\n\
8219\n\
8220 Replays contents of plot buffer to current device/file.\n\
8221\n\
8222 Redacted form: plreplot()\n\
8223\n\
8224 This function is used in example 1,20.\n\
8225\n\
8226\n\
8227\n\
8228SYNOPSIS:\n\
8229\n\
8230plreplot()\n\
8231";
8232static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8233Plot a glyph at the specified 3D points\n\
8234\n\
8235DESCRIPTION:\n\
8236\n\
8237 Plot a glyph at the specified 3D points. (This function is largely\n\
8238 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8239 Set up the call to this function similar to what is done for plline3.\n\
8240 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8241 and a draw at the same place. Not ideal, since a sufficiently\n\
8242 intelligent output device may optimize it away, or there may be faster\n\
8243 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8244 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8245 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8246 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8247 code <= 127 the corresponding printable ASCII character is plotted.\n\
8248\n\
8249 Redacted form: plpoin3(x, y, z, code)\n\
8250\n\
8251 This function is not used in any example.\n\
8252\n\
8253\n\
8254\n\
8255SYNOPSIS:\n\
8256\n\
8257plpoin3(n, x, y, z, code)\n\
8258\n\
8259ARGUMENTS:\n\
8260\n\
8261 n (PLINT, input) : Number of points in the x and y vectors.\n\
8262\n\
8263 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8264 points.\n\
8265\n\
8266 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8267 points.\n\
8268\n\
8269 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8270 points.\n\
8271\n\
8272 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8273 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8274 each of the n points.\n\
8275";
8276static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8277Set family, style and weight of the current font\n\
8278\n\
8279DESCRIPTION:\n\
8280\n\
8281 Sets the current font. See the PLplot documentation for more\n\
8282 information on font selection.\n\
8283\n\
8284 Redacted form: plsfont(family, style, weight)\n\
8285\n\
8286 This function is used in example 23.\n\
8287\n\
8288\n\
8289\n\
8290SYNOPSIS:\n\
8291\n\
8292plsfont(family, style, weight)\n\
8293\n\
8294ARGUMENTS:\n\
8295\n\
8296 family (PLINT, input) : Font family to select for the current font.\n\
8297 The available values are given by the PL_FCI_* constants in\n\
8298 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8299 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8300 signifies that the font family should not be altered.\n\
8301\n\
8302 style (PLINT, input) : Font style to select for the current font.\n\
8303 The available values are given by the PL_FCI_* constants in\n\
8304 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8305 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8306 should not be altered.\n\
8307\n\
8308 weight (PLINT, input) : Font weight to select for the current font.\n\
8309 The available values are given by the PL_FCI_* constants in\n\
8310 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8311 negative value signifies that the font weight should not be\n\
8312 altered.\n\
8313";
8314static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8315Draw a box with axes, etc. with arbitrary origin\n\
8316\n\
8317DESCRIPTION:\n\
8318\n\
8319 Draws a box around the currently defined viewport with arbitrary\n\
8320 world-coordinate origin specified by x0 and y0 and labels it with\n\
8321 world coordinate values appropriate to the window. Thus plaxes should\n\
8322 only be called after defining both viewport and window. The ascii\n\
8323 character strings xopt and yopt specify how the box should be drawn as\n\
8324 described below. If ticks and/or subticks are to be drawn for a\n\
8325 particular axis, the tick intervals and number of subintervals may be\n\
8326 specified explicitly, or they may be defaulted by setting the\n\
8327 appropriate arguments to zero.\n\
8328\n\
8329 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8330 ytick, nysub)\n\
8331\n\
8332\n\
8333 This function is not used in any examples.\n\
8334\n\
8335\n\
8336\n\
8337SYNOPSIS:\n\
8338\n\
8339plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8340\n\
8341ARGUMENTS:\n\
8342\n\
8343 x0 (PLFLT, input) : World X coordinate of origin.\n\
8344\n\
8345 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8346\n\
8347 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8348 options for the x axis. The string can include any combination of\n\
8349 the following letters (upper or lower case) in any order: a: Draws\n\
8350 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8351 (x=0).\n\
8352 b: Draws bottom (X) or left (Y) edge of frame.\n\
8353 c: Draws top (X) or right (Y) edge of frame.\n\
8354 d: Plot labels as date / time. Values are assumed to be\n\
8355 seconds since the epoch (as used by gmtime).\n\
8356 f: Always use fixed point numeric labels.\n\
8357 g: Draws a grid at the major tick interval.\n\
8358 h: Draws a grid at the minor tick interval.\n\
8359 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8360 inwards.\n\
8361 l: Labels axis logarithmically. This only affects the labels,\n\
8362 not the data, and so it is necessary to compute the logarithms\n\
8363 of data points before passing them to any of the drawing\n\
8364 routines.\n\
8365 m: Writes numeric labels at major tick intervals in the\n\
8366 unconventional location (above box for X, right of box for Y).\n\
8367 n: Writes numeric labels at major tick intervals in the\n\
8368 conventional location (below box for X, left of box for Y).\n\
8369 o: Use custom labelling function to generate axis label text.\n\
8370 The custom labelling function can be defined with the\n\
8371 plslabelfunc command.\n\
8372 s: Enables subticks between major ticks, only valid if t is\n\
8373 also specified.\n\
8374 t: Draws major ticks.\n\
8375 u: Exactly like \"b\" except don\'t draw edge line.\n\
8376 w: Exactly like \"c\" except don\'t draw edge line.\n\
8377 x: Exactly like \"t\" (including the side effect of the\n\
8378 numerical labels for the major ticks) except exclude drawing\n\
8379 the major and minor tick marks.\n\
8380\n\
8381\n\
8382 xtick (PLFLT, input) : World coordinate interval between major\n\
8383 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8384 generates a suitable tick interval.\n\
8385\n\
8386 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8387 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8388 generates a suitable minor tick interval.\n\
8389\n\
8390 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8391 options for the y axis. The string can include any combination of\n\
8392 the letters defined above for xopt, and in addition may contain:\n\
8393 v: Write numeric labels for the y axis parallel to the base of the\n\
8394 graph, rather than parallel to the axis.\n\
8395\n\
8396\n\
8397 ytick (PLFLT, input) : World coordinate interval between major\n\
8398 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8399 generates a suitable tick interval.\n\
8400\n\
8401 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8402 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8403 generates a suitable minor tick interval.\n\
8404";
8405static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8406Begin a new page\n\
8407\n\
8408DESCRIPTION:\n\
8409\n\
8410 Begins a new page. For a file driver, the output file is opened if\n\
8411 necessary. Advancing the page via pleop and plbop is useful when a\n\
8412 page break is desired at a particular point when plotting to subpages.\n\
8413 Another use for pleop and plbop is when plotting pages to different\n\
8414 files, since you can manually set the file name by calling plsfnam\n\
8415 after the call to pleop. (In fact some drivers may only support a\n\
8416 single page per file, making this a necessity.) One way to handle\n\
8417 this case automatically is to page advance via pladv, but enable\n\
8418 familying (see plsfam) with a small limit on the file size so that a\n\
8419 new family member file will be created on each page break.\n\
8420\n\
8421 Redacted form: plbop()\n\
8422\n\
8423 This function is used in examples 2 and 20.\n\
8424\n\
8425\n\
8426\n\
8427SYNOPSIS:\n\
8428\n\
8429plbop()\n\
8430";
8431static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8432Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8433\n\
8434DESCRIPTION:\n\
8435\n\
8436 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8437 and PLFLT alpha transparency value. This sets the entire color map --\n\
8438 only as many colors as specified will be allocated.\n\
8439\n\
8440 Redacted form: plscmap0a(r, g, b, alpha)\n\
8441\n\
8442 This function is used in examples 30.\n\
8443\n\
8444\n\
8445\n\
8446SYNOPSIS:\n\
8447\n\
8448plscmap0a(r, g, b, alpha, ncol0)\n\
8449\n\
8450ARGUMENTS:\n\
8451\n\
8452 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8453 integers (0-255) representing the degree of red in the color.\n\
8454\n\
8455 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8456 integers (0-255) representing the degree of green in the color.\n\
8457\n\
8458 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8459 integers (0-255) representing the degree of blue in the color.\n\
8460\n\
8461 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8462 representing the alpha transparency of the color.\n\
8463\n\
8464 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8465 vectors.\n\
8466";
8467static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8468Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8469\n\
8470DESCRIPTION:\n\
8471\n\
8472 This is a variant of plscmap1l that supports alpha channel\n\
8473 transparency. It sets cmap1 colors using a piece-wise linear\n\
8474 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8475 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8476 transparency value (0.0-1.0). It may be called at any time.\n\
8477\n\
8478 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8479 alpha, alt_hue_path)\n\
8480\n\
8481 This function is used in example 30.\n\
8482\n\
8483\n\
8484\n\
8485SYNOPSIS:\n\
8486\n\
8487plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8488\n\
8489ARGUMENTS:\n\
8490\n\
8491 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8492\n\
8493 npts (PLINT, input) : number of control points.\n\
8494\n\
8495 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8496 intensity index (0.0-1.0) in ascending order for each control\n\
8497 point.\n\
8498\n\
8499 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8500 coordinate (H or R) for each control point.\n\
8501\n\
8502 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8503 coordinate (L or G) for each control point.\n\
8504\n\
8505 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8506 coordinate (S or B) for each control point.\n\
8507\n\
8508 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8509 transparency value (0.0-1.0) for each control point.\n\
8510\n\
8511 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8512 npts - 1 elements) containing the alternative interpolation method\n\
8513 Boolean value for each control point interval. (alt_hue_path[i]\n\
8514 refers to the interpolation interval between the i and i + 1\n\
8515 control points).\n\
8516";
8517static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8518Enter or leave xor mode\n\
8519\n\
8520DESCRIPTION:\n\
8521\n\
8522 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8523 those drivers (e.g., the xwin driver) that support it. Enables\n\
8524 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8525 is not capable of xor operation it returns a status of false.\n\
8526\n\
8527 Redacted form: plxormod(mode, status)\n\
8528\n\
8529 This function is used in examples 1 and 20.\n\
8530\n\
8531\n\
8532\n\
8533SYNOPSIS:\n\
8534\n\
8535plxormod(mode, status)\n\
8536\n\
8537ARGUMENTS:\n\
8538\n\
8539 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8540 is false means leave xor mode.\n\
8541\n\
8542 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8543 modestatus of true (false) means driver is capable (incapable) of\n\
8544 xor mode.\n\
8545";
8546static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8547Eject current page\n\
8548\n\
8549DESCRIPTION:\n\
8550\n\
8551 Clears the graphics screen of an interactive device, or ejects a page\n\
8552 on a plotter. See plbop for more information.\n\
8553\n\
8554 Redacted form: pleop()\n\
8555\n\
8556 This function is used in example 2,14.\n\
8557\n\
8558\n\
8559\n\
8560SYNOPSIS:\n\
8561\n\
8562pleop()\n\
8563";
8564static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8565Draw a box with axes, etc\n\
8566\n\
8567DESCRIPTION:\n\
8568\n\
8569 Draws a box around the currently defined viewport, and labels it with\n\
8570 world coordinate values appropriate to the window. Thus plbox should\n\
8571 only be called after defining both viewport and window. The ascii\n\
8572 character strings xopt and yopt specify how the box should be drawn as\n\
8573 described below. If ticks and/or subticks are to be drawn for a\n\
8574 particular axis, the tick intervals and number of subintervals may be\n\
8575 specified explicitly, or they may be defaulted by setting the\n\
8576 appropriate arguments to zero.\n\
8577\n\
8578 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8579\n\
8580\n\
8581 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8582 and 29.\n\
8583\n\
8584\n\
8585\n\
8586SYNOPSIS:\n\
8587\n\
8588plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8589\n\
8590ARGUMENTS:\n\
8591\n\
8592 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8593 options for the x axis. The string can include any combination of\n\
8594 the following letters (upper or lower case) in any order: a: Draws\n\
8595 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8596 (x=0).\n\
8597 b: Draws bottom (X) or left (Y) edge of frame.\n\
8598 c: Draws top (X) or right (Y) edge of frame.\n\
8599 d: Plot labels as date / time. Values are assumed to be\n\
8600 seconds since the epoch (as used by gmtime).\n\
8601 f: Always use fixed point numeric labels.\n\
8602 g: Draws a grid at the major tick interval.\n\
8603 h: Draws a grid at the minor tick interval.\n\
8604 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8605 inwards.\n\
8606 l: Labels axis logarithmically. This only affects the labels,\n\
8607 not the data, and so it is necessary to compute the logarithms\n\
8608 of data points before passing them to any of the drawing\n\
8609 routines.\n\
8610 m: Writes numeric labels at major tick intervals in the\n\
8611 unconventional location (above box for X, right of box for Y).\n\
8612 n: Writes numeric labels at major tick intervals in the\n\
8613 conventional location (below box for X, left of box for Y).\n\
8614 o: Use custom labelling function to generate axis label text.\n\
8615 The custom labelling function can be defined with the\n\
8616 plslabelfunc command.\n\
8617 s: Enables subticks between major ticks, only valid if t is\n\
8618 also specified.\n\
8619 t: Draws major ticks.\n\
8620 u: Exactly like \"b\" except don\'t draw edge line.\n\
8621 w: Exactly like \"c\" except don\'t draw edge line.\n\
8622 x: Exactly like \"t\" (including the side effect of the\n\
8623 numerical labels for the major ticks) except exclude drawing\n\
8624 the major and minor tick marks.\n\
8625\n\
8626\n\
8627 xtick (PLFLT, input) : World coordinate interval between major\n\
8628 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8629 generates a suitable tick interval.\n\
8630\n\
8631 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8632 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8633 generates a suitable minor tick interval.\n\
8634\n\
8635 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8636 options for the y axis. The string can include any combination of\n\
8637 the letters defined above for xopt, and in addition may contain:\n\
8638 v: Write numeric labels for the y axis parallel to the base of the\n\
8639 graph, rather than parallel to the axis.\n\
8640\n\
8641\n\
8642 ytick (PLFLT, input) : World coordinate interval between major\n\
8643 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8644 generates a suitable tick interval.\n\
8645\n\
8646 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8647 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8648 generates a suitable minor tick interval.\n\
8649";
8650static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8651Get x axis parameters\n\
8652\n\
8653DESCRIPTION:\n\
8654\n\
8655 Returns current values of the p_digmax and p_digits flags for the x\n\
8656 axis. p_digits is updated after the plot is drawn, so this routine\n\
8657 should only be called after the call to plbox (or plbox3) is complete.\n\
8658 See the PLplot documentation for more information.\n\
8659\n\
8660 Redacted form: plgxax(p_digmax, p_digits)\n\
8661\n\
8662 This function is used in example 31.\n\
8663\n\
8664\n\
8665\n\
8666SYNOPSIS:\n\
8667\n\
8668plgxax(p_digmax, p_digits)\n\
8669\n\
8670ARGUMENTS:\n\
8671\n\
8672 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8673 number of digits for the x axis. If nonzero, the printed label\n\
8674 has been switched to a floating-point representation when the\n\
8675 number of digits exceeds this value.\n\
8676\n\
8677 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8678 number of digits for the numeric labels (x axis) from the last\n\
8679 plot.\n\
8680";
8681static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8682Set font\n\
8683\n\
8684DESCRIPTION:\n\
8685\n\
8686 Sets the font used for subsequent text and symbols. For devices that\n\
8687 still use Hershey fonts this routine has no effect unless the Hershey\n\
8688 fonts with extended character set are loaded (see plfontld). For\n\
8689 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8690 this routine calls the plsfci routine with argument set up\n\
8691 appropriately for the various cases below. However, this method of\n\
8692 specifying the font for unicode-aware devices is deprecated, and the\n\
8693 much more flexible method of calling plsfont directly is recommended\n\
8694 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8695\n\
8696 Redacted form: plfont(ifont)\n\
8697\n\
8698 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8699\n\
8700\n\
8701\n\
8702SYNOPSIS:\n\
8703\n\
8704plfont(ifont)\n\
8705\n\
8706ARGUMENTS:\n\
8707\n\
8708 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8709 (simplest and fastest)\n\
8710 2: Serif font\n\
8711 3: Italic font\n\
8712 4: Script font\n\
8713";
8714static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8715Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8716\n\
8717DESCRIPTION:\n\
8718\n\
8719 Routine for creating a discrete plot legend with a plotted filled box,\n\
8720 line, and/or line of symbols for each annotated legend entry. (See\n\
8721 plcolorbar for similar functionality for creating continuous color\n\
8722 bars.) The arguments of pllegend provide control over the location\n\
8723 and size of the legend as well as the location and characteristics of\n\
8724 the elements (most of which are optional) within that legend. The\n\
8725 resulting legend is clipped at the boundaries of the current subpage.\n\
8726 (N.B. the adopted coordinate system used for some of the parameters is\n\
8727 defined in the documentation of the position parameter.)\n\
8728\n\
8729 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8730 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8731 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8732 test_justification, text_colors, text, box_colors, box_patterns,\n\
8733 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8734 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8735\n\
8736 This function is used in examples 4, 26, and 33.\n\
8737\n\
8738\n\
8739\n\
8740SYNOPSIS:\n\
8741\n\
8742pllegend(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\
8743\n\
8744ARGUMENTS:\n\
8745\n\
8746 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8747 legend width in adopted coordinates. This quantity is calculated\n\
8748 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8749 the routine depending on nlegend and nrow), and the length\n\
8750 (calculated internally) of the longest text string.\n\
8751\n\
8752 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8753 legend height in adopted coordinates. This quantity is calculated\n\
8754 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8755 the routine depending on nlegend and nrow).\n\
8756\n\
8757 opt (PLINT, input) : opt contains bits controlling the overall\n\
8758 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8759 on the left of the legend and the plotted area on the right.\n\
8760 Otherwise, put the text area on the right of the legend and the\n\
8761 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8762 plot a (semitransparent) background for the legend. If the\n\
8763 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8764 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8765 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8766 plot the resulting array of legend entries in row-major order.\n\
8767 Otherwise, plot the legend entries in column-major order.\n\
8768\n\
8769 position (PLINT, input) : position contains bits which control the\n\
8770 overall position of the legend and the definition of the adopted\n\
8771 coordinates used for positions just like what is done for the\n\
8772 position argument for plcolorbar. However, note that the defaults\n\
8773 for the position bits (see below) are different than the\n\
8774 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8775 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8776 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8777 the 16 possible standard positions (the 4 corners and centers of\n\
8778 the 4 sides for both the inside and outside cases) of the legend\n\
8779 relative to the adopted coordinate system. The corner positions\n\
8780 are specified by the appropriate combination of two of the\n\
8781 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8782 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8783 value of one of those bits. The adopted coordinates are\n\
8784 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8785 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8786 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8787 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8788 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8789 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8790 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8791 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8792\n\
8793 x (PLFLT, input) : X offset of the legend position in adopted\n\
8794 coordinates from the specified standard position of the legend.\n\
8795 For positive x, the direction of motion away from the standard\n\
8796 position is inward/outward from the standard corner positions or\n\
8797 standard left or right positions if the\n\
8798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8799 For the standard top or bottom positions, the direction of motion\n\
8800 is toward positive X.\n\
8801\n\
8802 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8803 coordinates from the specified standard position of the legend.\n\
8804 For positive y, the direction of motion away from the standard\n\
8805 position is inward/outward from the standard corner positions or\n\
8806 standard top or bottom positions if the\n\
8807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8808 the standard left or right positions, the direction of motion is\n\
8809 toward positive Y.\n\
8810\n\
8811 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8812 of the plot area (where the colored boxes, lines, and/or lines of\n\
8813 symbols are drawn) of the legend.\n\
8814\n\
8815 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8816 legend (PL_LEGEND_BACKGROUND).\n\
8817\n\
8818 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8819 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8820\n\
8821 bb_style (PLINT, input) : The pllsty style number for the\n\
8822 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8823\n\
8824 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8825 render the\n\
8826 nlegend legend entries. For internal transformations of\n\
8827 nrow, see further remarks under\n\
8828 nlegend.\n\
8829\n\
8830 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8831 to render the\n\
8832 nlegend legend entries. For internal transformations of\n\
8833 ncolumn, see further remarks under\n\
8834 nlegend.\n\
8835\n\
8836 nlegend (PLINT, input) : Number of legend entries. The above\n\
8837 nrow and\n\
8838 ncolumn values are transformed internally to be consistent with\n\
8839 nlegend. If either\n\
8840 nrow or\n\
8841 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8842 of\n\
8843 nrow and\n\
8844 ncolumn is less than\n\
8845 nlegend, the smaller of the two (or\n\
8846 nrow, if\n\
8847 nrow ==\n\
8848 ncolumn) is increased so the product is >=\n\
8849 nlegend. Thus, for example, the common\n\
8850 nrow = 0,\n\
8851 ncolumn = 0 case is transformed internally to\n\
8852 nrow =\n\
8853 nlegend,\n\
8854 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8855 column.\n\
8856\n\
8857 opt_array (PLINT_VECTOR, input) : A vector of\n\
8858 nlegend values of options to control each individual plotted area\n\
8859 corresponding to a legend entry. If the\n\
8860 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8861 area. If the\n\
8862 PL_LEGEND_COLOR_BOX,\n\
8863 PL_LEGEND_LINE, and/or\n\
8864 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8865 entry is plotted with a colored box; a line; and/or a line of\n\
8866 symbols.\n\
8867\n\
8868 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8869 area in units of character width.\n\
8870\n\
8871 text_scale (PLFLT, input) : Character height scale for text\n\
8872 annotations.\n\
8873\n\
8874 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8875 character height from one legend entry to the next.\n\
8876\n\
8877 text_justification (PLFLT, input) : Justification parameter used\n\
8878 for text justification. The most common values of\n\
8879 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8880 is left justified, centred, or right justified within the text\n\
8881 area, but other values are allowed as well.\n\
8882\n\
8883 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8884 nlegend cmap0 text colors.\n\
8885\n\
8886 text (PLCHAR_MATRIX, input) : A vector of\n\
8887 nlegend UTF-8 character strings containing the legend annotations.\n\
8888\n\
8889 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8890 nlegend cmap0 colors for the discrete colored boxes (\n\
8891 PL_LEGEND_COLOR_BOX).\n\
8892\n\
8893 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8894 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8895 PL_LEGEND_COLOR_BOX).\n\
8896\n\
8897 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8898 nlegend scales (units of fraction of character height) for the height\n\
8899 of the discrete colored boxes (\n\
8900 PL_LEGEND_COLOR_BOX).\n\
8901\n\
8902 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8903 nlegend line widths for the patterns specified by box_patterns (\n\
8904 PL_LEGEND_COLOR_BOX).\n\
8905\n\
8906 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8907 nlegend cmap0 line colors (\n\
8908 PL_LEGEND_LINE).\n\
8909\n\
8910 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8911 nlegend line styles (plsty indices) (\n\
8912 PL_LEGEND_LINE).\n\
8913\n\
8914 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8915 nlegend line widths (\n\
8916 PL_LEGEND_LINE).\n\
8917\n\
8918 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8919 nlegend cmap0 symbol colors (\n\
8920 PL_LEGEND_SYMBOL).\n\
8921\n\
8922 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8923 nlegend scale values for the symbol height (\n\
8924 PL_LEGEND_SYMBOL).\n\
8925\n\
8926 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8927 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8928 area (\n\
8929 PL_LEGEND_SYMBOL).\n\
8930\n\
8931 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8932 nlegend UTF-8 character strings containing the legend symbols. (\n\
8933 PL_LEGEND_SYMBOL).\n\
8934";
8935static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8936Set the background color by 8-bit RGB value\n\
8937\n\
8938DESCRIPTION:\n\
8939\n\
8940 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8941 the PLplot documentation).\n\
8942\n\
8943 Redacted form: plscolbg(r, g, b)\n\
8944\n\
8945 This function is used in examples 15 and 31.\n\
8946\n\
8947\n\
8948\n\
8949SYNOPSIS:\n\
8950\n\
8951plscolbg(r, g, b)\n\
8952\n\
8953ARGUMENTS:\n\
8954\n\
8955 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8956 degree of red in the color.\n\
8957\n\
8958 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8959 degree of green in the color.\n\
8960\n\
8961 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8962 degree of blue in the color.\n\
8963";
8964static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8965Set parameters that define current device-space window\n\
8966\n\
8967DESCRIPTION:\n\
8968\n\
8969 Set relative margin width, aspect ratio, and relative justification\n\
8970 that define current device-space window. If you want to just use the\n\
8971 previous value for any of these, just pass in the magic value\n\
8972 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8973 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8974 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8975 to a device-specific value.\n\
8976\n\
8977 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8978\n\
8979 This function is used in example 31.\n\
8980\n\
8981\n\
8982\n\
8983SYNOPSIS:\n\
8984\n\
8985plsdidev(mar, aspect, jx, jy)\n\
8986\n\
8987ARGUMENTS:\n\
8988\n\
8989 mar (PLFLT, input) : Relative margin width.\n\
8990\n\
8991 aspect (PLFLT, input) : Aspect ratio.\n\
8992\n\
8993 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8994 the range -0.5 to 0.5.\n\
8995\n\
8996 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8997 the range -0.5 to 0.5.\n\
8998";
8999static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9000Specify viewport using aspect ratio only\n\
9001\n\
9002DESCRIPTION:\n\
9003\n\
9004 Selects the largest viewport with the given aspect ratio within the\n\
9005 subpage that leaves a standard margin (left-hand margin of eight\n\
9006 character heights, and a margin around the other three sides of five\n\
9007 character heights).\n\
9008\n\
9009 Redacted form: plvasp(aspect)\n\
9010\n\
9011 This function is used in example 13.\n\
9012\n\
9013\n\
9014\n\
9015SYNOPSIS:\n\
9016\n\
9017plvasp(aspect)\n\
9018\n\
9019ARGUMENTS:\n\
9020\n\
9021 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9022 axis of resulting viewport.\n\
9023";
9024static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
9025Configure the transformations required for projecting a 3D surface on a 2D window\n\
9026\n\
9027DESCRIPTION:\n\
9028\n\
9029 Configure the transformations required for projecting a 3D surface on\n\
9030 an existing 2D window. Those transformations (see the PLplot\n\
9031 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9032 surface which has its limits expressed in 3D world coordinates and\n\
9033 also normalized 3D coordinates (used for interpreting the altitude and\n\
9034 azimuth of the viewing angle). The transformations consist of the\n\
9035 linear transform from 3D world coordinates to normalized 3D\n\
9036 coordinates, and the 3D rotation of normalized coordinates required to\n\
9037 align the pole of the new 3D coordinate system with the viewing\n\
9038 direction specified by altitude and azimuth so that x and y of the\n\
9039 surface elements in that transformed coordinate system are the\n\
9040 projection of the 3D surface with given viewing direction on the 2D\n\
9041 window.\n\
9042\n\
9043 The enclosing rectangular cuboid for the surface plot is defined by\n\
9044 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9045 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9046 sizes of basex by basey by height so that xmin maps to -\n\
9047 basex/2, xmax maps to basex/2, ymin maps to -\n\
9048 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9049 The resulting rectangular cuboid in normalized coordinates is then\n\
9050 viewed by an observer at altitude alt and azimuth az. This routine\n\
9051 must be called before plbox3 or any of the 3D surface plotting\n\
9052 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9053 plsurf3dl or plfill3.\n\
9054\n\
9055 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9056 zmin, zmax, alt, az)\n\
9057\n\
9058 This function is examples 8, 11, 18, and 21.\n\
9059\n\
9060\n\
9061\n\
9062SYNOPSIS:\n\
9063\n\
9064plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9065\n\
9066ARGUMENTS:\n\
9067\n\
9068 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9069 rectangular cuboid.\n\
9070\n\
9071 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9072 rectangular cuboid.\n\
9073\n\
9074 height (PLFLT, input) : The normalized z coordinate size of the\n\
9075 rectangular cuboid.\n\
9076\n\
9077 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9078 rectangular cuboid.\n\
9079\n\
9080 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9081 rectangular cuboid.\n\
9082\n\
9083 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9084 rectangular cuboid.\n\
9085\n\
9086 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9087 rectangular cuboid.\n\
9088\n\
9089 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9090 rectangular cuboid.\n\
9091\n\
9092 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9093 rectangular cuboid.\n\
9094\n\
9095 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9096 plane of the rectangular cuboid in normalized coordinates.\n\
9097\n\
9098 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9099 rectangular cuboid in normalized coordinates. When az=0, the\n\
9100 observer is looking face onto the zx plane of the rectangular\n\
9101 cuboid in normalized coordinates, and as az is increased, the\n\
9102 observer moves clockwise around that cuboid when viewed from above\n\
9103 the xy plane.\n\
9104";
9105static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9106Wait for graphics input event and translate to world coordinates.\n\
9107\n\
9108DESCRIPTION:\n\
9109\n\
9110 Wait for graphics input event and translate to world coordinates.\n\
9111 Returns 0 if no translation to world coordinates is possible.\n\
9112\n\
9113 This function returns 1 on success and 0 if no translation to world\n\
9114 coordinates is possible.\n\
9115\n\
9116 Redacted form: plGetCursor(gin)\n\
9117\n\
9118 This function is used in examples 1 and 20.\n\
9119\n\
9120\n\
9121\n\
9122SYNOPSIS:\n\
9123\n\
9124PLINT plGetCursor(gin)\n\
9125\n\
9126ARGUMENTS:\n\
9127\n\
9128 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9129 which will contain the output. The structure is not allocated by\n\
9130 the routine and must exist before the function is called.\n\
9131";
9132static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9133Set number of colors in cmap0\n\
9134\n\
9135DESCRIPTION:\n\
9136\n\
9137 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9138 (or reallocate) cmap0, and fill with default values for those colors\n\
9139 not previously allocated. The first 16 default colors are given in\n\
9140 the plcol0 documentation. For larger indices the default color is\n\
9141 red.\n\
9142\n\
9143 The drivers are not guaranteed to support more than 16 colors.\n\
9144\n\
9145 Redacted form: plscmap0n(ncol0)\n\
9146\n\
9147 This function is used in examples 15, 16, and 24.\n\
9148\n\
9149\n\
9150\n\
9151SYNOPSIS:\n\
9152\n\
9153plscmap0n(ncol0)\n\
9154\n\
9155ARGUMENTS:\n\
9156\n\
9157 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9158 the cmap0 palette. If this number is zero or less, then the value\n\
9159 from the previous call to plscmap0n is used and if there is no\n\
9160 previous call, then a default value is used.\n\
9161";
9162static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9163Set z axis parameters\n\
9164\n\
9165DESCRIPTION:\n\
9166\n\
9167 Identical to plsxax, except that arguments are flags for z axis. See\n\
9168 the description of plsxax for more detail.\n\
9169\n\
9170 Redacted form: plszax(digmax, digits)\n\
9171\n\
9172 This function is used in example 31.\n\
9173\n\
9174\n\
9175\n\
9176SYNOPSIS:\n\
9177\n\
9178plszax(digmax, digits)\n\
9179\n\
9180ARGUMENTS:\n\
9181\n\
9182 digmax (PLINT, input) : Variable to set the maximum number of\n\
9183 digits for the z axis. If nonzero, the printed label will be\n\
9184 switched to a floating-point representation when the number of\n\
9185 digits exceeds digmax.\n\
9186\n\
9187 digits (PLINT, input) : Field digits value. Currently, changing\n\
9188 its value here has no effect since it is set only by plbox or\n\
9189 plbox3. However, the user may obtain its value after a call to\n\
9190 either of these functions by calling plgzax.\n\
9191";
9192static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9193Get FCI (font characterization integer)\n\
9194\n\
9195DESCRIPTION:\n\
9196\n\
9197 Gets information about the current font using the FCI approach. See\n\
9198 the PLplot documentation for more information.\n\
9199\n\
9200 Redacted form: plgfci(p_fci)\n\
9201\n\
9202 This function is used in example 23.\n\
9203\n\
9204\n\
9205\n\
9206SYNOPSIS:\n\
9207\n\
9208plgfci(p_fci)\n\
9209\n\
9210ARGUMENTS:\n\
9211\n\
9212 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9213 FCI value.\n\
9214";
9215static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9216Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9217\n\
9218DESCRIPTION:\n\
9219\n\
9220 Sets up plotter environment for simple graphs by calling pladv and\n\
9221 setting up viewport and window to sensible default values. plenv0\n\
9222 leaves a standard margin (left-hand margin of eight character heights,\n\
9223 and a margin around the other three sides of five character heights)\n\
9224 around most graphs for axis labels and a title. When these defaults\n\
9225 are not suitable, use the individual routines plvpas, plvpor, or\n\
9226 plvasp for setting up the viewport, plwind for defining the window,\n\
9227 and plbox for drawing the box.\n\
9228\n\
9229 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9230\n\
9231 This function is used in example 21.\n\
9232\n\
9233\n\
9234\n\
9235SYNOPSIS:\n\
9236\n\
9237plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9238\n\
9239ARGUMENTS:\n\
9240\n\
9241 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9242 world coordinates).\n\
9243\n\
9244 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9245 world coordinates).\n\
9246\n\
9247 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9248 coordinates).\n\
9249\n\
9250 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9251 coordinates).\n\
9252\n\
9253 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9254 scales will not be set, the user must set up the scale before\n\
9255 calling plenv0 using plsvpa, plvasp or other.\n\
9256 0: the x and y axes are scaled independently to use as much of\n\
9257 the screen as possible.\n\
9258 1: the scales of the x and y axes are made equal.\n\
9259 2: the axis of the x and y axes are made equal, and the plot\n\
9260 box will be square.\n\
9261\n\
9262\n\
9263 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9264 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9265 -1: draw box only.\n\
9266 0: draw box, ticks, and numeric tick labels.\n\
9267 1: also draw coordinate axes at x=0 and y=0.\n\
9268 2: also draw a grid at major tick positions in both\n\
9269 coordinates.\n\
9270 3: also draw a grid at minor tick positions in both\n\
9271 coordinates.\n\
9272 10: same as 0 except logarithmic x tick marks. (The x data\n\
9273 have to be converted to logarithms separately.)\n\
9274 11: same as 1 except logarithmic x tick marks. (The x data\n\
9275 have to be converted to logarithms separately.)\n\
9276 12: same as 2 except logarithmic x tick marks. (The x data\n\
9277 have to be converted to logarithms separately.)\n\
9278 13: same as 3 except logarithmic x tick marks. (The x data\n\
9279 have to be converted to logarithms separately.)\n\
9280 20: same as 0 except logarithmic y tick marks. (The y data\n\
9281 have to be converted to logarithms separately.)\n\
9282 21: same as 1 except logarithmic y tick marks. (The y data\n\
9283 have to be converted to logarithms separately.)\n\
9284 22: same as 2 except logarithmic y tick marks. (The y data\n\
9285 have to be converted to logarithms separately.)\n\
9286 23: same as 3 except logarithmic y tick marks. (The y data\n\
9287 have to be converted to logarithms separately.)\n\
9288 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9289 and y data have to be converted to logarithms separately.)\n\
9290 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9291 and y data have to be converted to logarithms separately.)\n\
9292 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9293 and y data have to be converted to logarithms separately.)\n\
9294 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9295 and y data have to be converted to logarithms separately.)\n\
9296 40: same as 0 except date / time x labels.\n\
9297 41: same as 1 except date / time x labels.\n\
9298 42: same as 2 except date / time x labels.\n\
9299 43: same as 3 except date / time x labels.\n\
9300 50: same as 0 except date / time y labels.\n\
9301 51: same as 1 except date / time y labels.\n\
9302 52: same as 2 except date / time y labels.\n\
9303 53: same as 3 except date / time y labels.\n\
9304 60: same as 0 except date / time x and y labels.\n\
9305 61: same as 1 except date / time x and y labels.\n\
9306 62: same as 2 except date / time x and y labels.\n\
9307 63: same as 3 except date / time x and y labels.\n\
9308 70: same as 0 except custom x and y labels.\n\
9309 71: same as 1 except custom x and y labels.\n\
9310 72: same as 2 except custom x and y labels.\n\
9311 73: same as 3 except custom x and y labels.\n\
9312";
9313static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9314Set symbol size\n\
9315\n\
9316DESCRIPTION:\n\
9317\n\
9318 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9319 plsym. The actual height of a symbol is the product of the default\n\
9320 symbol size and a scaling factor as for the character height.\n\
9321\n\
9322 Redacted form: plssym(def, scale)\n\
9323\n\
9324 This function is used in example 29.\n\
9325\n\
9326\n\
9327\n\
9328SYNOPSIS:\n\
9329\n\
9330plssym(def, scale)\n\
9331\n\
9332ARGUMENTS:\n\
9333\n\
9334 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9335 should be set to zero if the default height is to remain\n\
9336 unchanged.\n\
9337\n\
9338 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9339 actual symbol height.\n\
9340";
9341static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9342Set plot orientation\n\
9343\n\
9344DESCRIPTION:\n\
9345\n\
9346 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9347 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9348 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9349 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9350 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9351 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9352 not called the default value of rot is 0.\n\
9353\n\
9354 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9355 probably want to change the aspect ratio to a value suitable for the\n\
9356 plot orientation using a call to plsdidev or the command-line options\n\
9357 -a or -freeaspect. For more documentation of those options see the\n\
9358 PLplot documentation. Such command-line options can be set internally\n\
9359 using plsetopt or set directly using the command line and parsed using\n\
9360 a call to plparseopts.\n\
9361\n\
9362 Redacted form: plsdiori(rot)\n\
9363\n\
9364 This function is not used in any examples.\n\
9365\n\
9366\n\
9367\n\
9368SYNOPSIS:\n\
9369\n\
9370plsdiori(rot)\n\
9371\n\
9372ARGUMENTS:\n\
9373\n\
9374 rot (PLFLT, input) : Plot orientation parameter.\n\
9375";
9376static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9377Advance the (sub-)page\n\
9378\n\
9379DESCRIPTION:\n\
9380\n\
9381 Advances to the next subpage if sub=0, performing a page advance if\n\
9382 there are no remaining subpages on the current page. If subpages\n\
9383 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9384 PLplot switches to the specified subpage. Note that this allows you\n\
9385 to overwrite a plot on the specified subpage; if this is not what you\n\
9386 intended, use pleop followed by plbop to first advance the page. This\n\
9387 routine is called automatically (with page=0) by plenv, but if plenv\n\
9388 is not used, pladv must be called after initializing PLplot but before\n\
9389 defining the viewport.\n\
9390\n\
9391 Redacted form: pladv(page)\n\
9392\n\
9393 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9394 29, and 31.\n\
9395\n\
9396\n\
9397\n\
9398SYNOPSIS:\n\
9399\n\
9400pladv(page)\n\
9401\n\
9402ARGUMENTS:\n\
9403\n\
9404 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9405 in the top left corner and increasing along the rows) to which to\n\
9406 advance. Set to zero to advance to the next subpage (or to the\n\
9407 next page if subpages are not being used).\n\
9408";
9409static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9410Set cmap0 colors by 8-bit RGB values\n\
9411\n\
9412DESCRIPTION:\n\
9413\n\
9414 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9415 documentation). This sets the entire color map -- only as many colors\n\
9416 as specified will be allocated.\n\
9417\n\
9418 Redacted form: plscmap0(r, g, b)\n\
9419\n\
9420 This function is used in examples 2 and 24.\n\
9421\n\
9422\n\
9423\n\
9424SYNOPSIS:\n\
9425\n\
9426plscmap0(r, g, b, ncol0)\n\
9427\n\
9428ARGUMENTS:\n\
9429\n\
9430 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9431 integers (0-255) representing the degree of red in the color.\n\
9432\n\
9433 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9434 integers (0-255) representing the degree of green in the color.\n\
9435\n\
9436 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9437 integers (0-255) representing the degree of blue in the color.\n\
9438\n\
9439 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9440";
9441static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9442Get character default height and current (scaled) height\n\
9443\n\
9444DESCRIPTION:\n\
9445\n\
9446 Get character default height and current (scaled) height.\n\
9447\n\
9448 Redacted form: plgchr(p_def, p_ht)\n\
9449\n\
9450 This function is used in example 23.\n\
9451\n\
9452\n\
9453\n\
9454SYNOPSIS:\n\
9455\n\
9456plgchr(p_def, p_ht)\n\
9457\n\
9458ARGUMENTS:\n\
9459\n\
9460 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9461 character height (mm).\n\
9462\n\
9463 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9464 character height (mm).\n\
9465";
9466static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9467Set opaque RGB cmap1 colors values\n\
9468\n\
9469DESCRIPTION:\n\
9470\n\
9471 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9472 vector values. This function also sets the number of cmap1 colors.\n\
9473 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9474 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9475 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9476 to\n\
9477 ncol1-1. So in order for this continuous color model to work\n\
9478 properly, it is the responsibility of the user of plscmap1 to insure\n\
9479 that these RGB vectors are continuous functions of their integer\n\
9480 indices.\n\
9481\n\
9482 Redacted form: plscmap1(r, g, b)\n\
9483\n\
9484 This function is used in example 31.\n\
9485\n\
9486\n\
9487\n\
9488SYNOPSIS:\n\
9489\n\
9490plscmap1(r, g, b, ncol1)\n\
9491\n\
9492ARGUMENTS:\n\
9493\n\
9494 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9495 8-bit integers in the range from 0-255) the degree of red in the\n\
9496 color as a continuous function of the integer index of the vector.\n\
9497\n\
9498 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9499 8-bit integers in the range from 0-255) the degree of green in the\n\
9500 color as a continuous function of the integer index of the vector.\n\
9501\n\
9502 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9503 8-bit integers in the range from 0-255) the degree of blue in the\n\
9504 color as a continuous function of the integer index of the vector.\n\
9505\n\
9506 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9507";
9508static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9509Set any command-line option\n\
9510\n\
9511DESCRIPTION:\n\
9512\n\
9513 Set any command-line option internally from a program before it\n\
9514 invokes plinit. opt is the name of the command-line option and optarg\n\
9515 is the corresponding command-line option argument.\n\
9516\n\
9517 This function returns 0 on success.\n\
9518\n\
9519 Redacted form: plsetopt(opt, optarg)\n\
9520\n\
9521 This function is used in example 14.\n\
9522\n\
9523\n\
9524\n\
9525SYNOPSIS:\n\
9526\n\
9527PLINT plsetopt(opt, optarg)\n\
9528\n\
9529ARGUMENTS:\n\
9530\n\
9531 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9532 the command-line option.\n\
9533\n\
9534 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9535 containing the argument of the command-line option.\n\
9536";
9537static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9538Draw linear gradient inside polygon\n\
9539\n\
9540DESCRIPTION:\n\
9541\n\
9542 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9543 points (\n\
9544 x[i],\n\
9545 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9546 polygon coordinates and the gradient angle are all expressed in world\n\
9547 coordinates. The angle from the x axis for both the rotated\n\
9548 coordinate system and the gradient vector is specified by angle. The\n\
9549 magnitude of the gradient vector is the difference between the maximum\n\
9550 and minimum values of x for the vertices in the rotated coordinate\n\
9551 system. The origin of the gradient vector can be interpreted as being\n\
9552 anywhere on the line corresponding to the minimum x value for the\n\
9553 vertices in the rotated coordinate system. The distance along the\n\
9554 gradient vector is linearly transformed to the independent variable of\n\
9555 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9556 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9557 color corresponding to the independent variable of cmap1. For more\n\
9558 information about cmap1 (see the PLplot documentation).\n\
9559\n\
9560 Redacted form: plgradient(x,y,angle)\n\
9561\n\
9562 This function is used in examples 25 and 30.\n\
9563\n\
9564\n\
9565\n\
9566SYNOPSIS:\n\
9567\n\
9568plgradient(n, x, y, angle)\n\
9569\n\
9570ARGUMENTS:\n\
9571\n\
9572 n (PLINT, input) : Number of vertices in polygon.\n\
9573\n\
9574 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9575 vertices.\n\
9576\n\
9577 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9578 vertices.\n\
9579\n\
9580 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9581 axis.\n\
9582";
9583static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9584Set length of major ticks\n\
9585\n\
9586DESCRIPTION:\n\
9587\n\
9588 This sets up the length of the major ticks. The actual length is the\n\
9589 product of the default length and a scaling factor as for character\n\
9590 height.\n\
9591\n\
9592 Redacted form: plsmaj(def, scale)\n\
9593\n\
9594 This function is used in example 29.\n\
9595\n\
9596\n\
9597\n\
9598SYNOPSIS:\n\
9599\n\
9600plsmaj(def, scale)\n\
9601\n\
9602ARGUMENTS:\n\
9603\n\
9604 def (PLFLT, input) : The default length of a major tick in\n\
9605 millimeters, should be set to zero if the default length is to\n\
9606 remain unchanged.\n\
9607\n\
9608 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9609 actual tick length.\n\
9610";
9611static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9612Set a global coordinate transform function\n\
9613\n\
9614DESCRIPTION:\n\
9615\n\
9616 This function can be used to define a coordinate transformation which\n\
9617 affects all elements drawn within the current plot window. The\n\
9618 coordinate_transform callback function is similar to that provided for\n\
9619 the plmap and plmeridians functions. The coordinate_transform_data\n\
9620 parameter may be used to pass extra data to coordinate_transform.\n\
9621\n\
9622 Redacted form: General: plstransform(coordinate_transform,\n\
9623 coordinate_transform_data)\n\
9624\n\
9625\n\
9626 This function is used in examples 19 and 22.\n\
9627\n\
9628\n\
9629\n\
9630SYNOPSIS:\n\
9631\n\
9632plstransform(coordinate_transform, coordinate_transform_data)\n\
9633\n\
9634ARGUMENTS:\n\
9635\n\
9636 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9637 function that defines the transformation from the input (x, y)\n\
9638 world coordinates to new PLplot world coordinates. If\n\
9639 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9640 case), then no transform is applied.\n\
9641\n\
9642 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9643 for\n\
9644 coordinate_transform.\n\
9645";
9646static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9647Configure the transformation between continuous and broken-down time for the current stream\n\
9648\n\
9649DESCRIPTION:\n\
9650\n\
9651 Configure the transformation between continuous and broken-down time\n\
9652 for the current stream. This transformation is used by both plbtime\n\
9653 and plctime.\n\
9654\n\
9655 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9656 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9657\n\
9658\n\
9659 This function is used in example 29.\n\
9660\n\
9661\n\
9662\n\
9663SYNOPSIS:\n\
9664\n\
9665plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9666\n\
9667ARGUMENTS:\n\
9668\n\
9669 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9670 As a special case, if\n\
9671 scale is 0., then all other arguments are ignored, and the result (the\n\
9672 default used by PLplot) is the equivalent of a call to\n\
9673 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9674 That is, for this special case broken-down time is calculated with\n\
9675 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9676 and the continuous time is defined as the number of seconds since\n\
9677 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9678\n\
9679 offset1 (PLFLT, input) : If\n\
9680 ifbtime_offset is true, the parameters\n\
9681 offset1 and\n\
9682 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9683 (with units in days) specify the epoch of the continuous time\n\
9684 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9685 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9686 are used to specify the origin to allow users (by specifying\n\
9687 offset1 as an integer that can be exactly represented by a\n\
9688 floating-point variable and specifying\n\
9689 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9690 the numerical errors of the continuous time representation.\n\
9691\n\
9692 offset2 (PLFLT, input) : See documentation of\n\
9693 offset1.\n\
9694\n\
9695 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9696 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9697 calendar is used for broken-down time rather than the proleptic\n\
9698 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9699 have been historically used to define UTC are inserted into the\n\
9700 broken-down time. Other possibilities for additional control bits\n\
9701 for ccontrol exist such as making the historical time corrections\n\
9702 in the broken-down time corresponding to ET (ephemeris time) or\n\
9703 making the (slightly non-constant) corrections from international\n\
9704 atomic time (TAI) to what astronomers define as terrestrial time\n\
9705 (TT). But those additional possibilities have not been\n\
9706 implemented yet in the qsastime library (one of the PLplot utility\n\
9707 libraries).\n\
9708\n\
9709 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9710 epoch of the continuous time scale is specified by the user. If\n\
9711 ifbtime_offset is false, then\n\
9712 offset1 and\n\
9713 offset2 are used to specify the epoch, and the following broken-down\n\
9714 time parameters are completely ignored. If\n\
9715 ifbtime_offset is true, then\n\
9716 offset1 and\n\
9717 offset2 are completely ignored, and the following broken-down time\n\
9718 parameters are used to specify the epoch.\n\
9719\n\
9720 year (PLINT, input) : Year of epoch.\n\
9721\n\
9722 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9723 11 (December).\n\
9724\n\
9725 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9726\n\
9727 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9728\n\
9729 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9730\n\
9731 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9732";
9733static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9734Flushes the output stream\n\
9735\n\
9736DESCRIPTION:\n\
9737\n\
9738 Flushes the output stream. Use sparingly, if at all.\n\
9739\n\
9740 Redacted form: plflush()\n\
9741\n\
9742 This function is used in examples 1 and 14.\n\
9743\n\
9744\n\
9745\n\
9746SYNOPSIS:\n\
9747\n\
9748plflush()\n\
9749";
9750static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9751Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9752\n\
9753DESCRIPTION:\n\
9754\n\
9755 This variant of plsurf3d (see that function\'s documentation for more\n\
9756 details) should be suitable for the case where the area of the x, y\n\
9757 coordinate grid where z is defined can be non-rectangular. The limits\n\
9758 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9759 indexymin, and indexymax.\n\
9760\n\
9761 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9762 indexymax)\n\
9763\n\
9764 This function is used in example 8.\n\
9765\n\
9766\n\
9767\n\
9768SYNOPSIS:\n\
9769\n\
9770plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9771\n\
9772ARGUMENTS:\n\
9773\n\
9774 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9775 which the function is evaluated.\n\
9776\n\
9777 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9778 which the function is evaluated.\n\
9779\n\
9780 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9781 plot. Should have dimensions of\n\
9782 nx by\n\
9783 ny.\n\
9784\n\
9785 nx (PLINT, input) : Number of x values at which function is\n\
9786 evaluated.\n\
9787\n\
9788 ny (PLINT, input) : Number of y values at which function is\n\
9789 evaluated.\n\
9790\n\
9791 opt (PLINT, input) : Determines the way in which the surface is\n\
9792 represented. To specify more than one option just add the options,\n\
9793 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9794 connecting points at which function is defined.\n\
9795 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9796 using parameters\n\
9797 nlevel and\n\
9798 clevel.\n\
9799 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9800 using parameters\n\
9801 nlevel and\n\
9802 clevel.\n\
9803 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9804 the borders of the plotted function.\n\
9805 opt=MAG_COLOR : the surface is colored according to the value\n\
9806 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9807 according to the intensity of the reflected light in the\n\
9808 surface from a light source whose position is set using\n\
9809 pllightsource.\n\
9810\n\
9811\n\
9812 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9813 levels.\n\
9814\n\
9815 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9816\n\
9817 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9818 corresponds to the first x index where z is defined.\n\
9819\n\
9820 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9821 which corresponds (by convention) to one more than the last x\n\
9822 index value where z is defined.\n\
9823\n\
9824 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9825 values which all must be ≥ 0. These values are the first y index\n\
9826 where z is defined for a particular x index in the range from\n\
9827 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9828 indexxmax.\n\
9829\n\
9830 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9831 values which all must be ≤ ny. These values correspond (by\n\
9832 convention) to one more than the last y index where z is defined\n\
9833 for a particular x index in the range from indexxmin to indexxmax\n\
9834 - 1. The dimension of indexymax is indexxmax.\n\
9835";
9836static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9837Set semitransparent cmap1 RGBA colors.\n\
9838\n\
9839DESCRIPTION:\n\
9840\n\
9841 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9842 RGBA vector values. This function also sets the number of cmap1\n\
9843 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9844 floating-point index in the range from 0.0-1.0 which is linearly\n\
9845 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9846 vectors in the range from 0 to\n\
9847 ncol1-1. So in order for this continuous color model to work\n\
9848 properly, it is the responsibility of the user of plscmap1 to insure\n\
9849 that these RGBA vectors are continuous functions of their integer\n\
9850 indices.\n\
9851\n\
9852 Redacted form: plscmap1a(r, g, b, alpha)\n\
9853\n\
9854 This function is used in example 31.\n\
9855\n\
9856\n\
9857\n\
9858SYNOPSIS:\n\
9859\n\
9860plscmap1a(r, g, b, alpha, ncol1)\n\
9861\n\
9862ARGUMENTS:\n\
9863\n\
9864 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9865 8-bit integers in the range from 0-255) the degree of red in the\n\
9866 color as a continuous function of the integer index of the vector.\n\
9867\n\
9868 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9869 8-bit integers in the range from 0-255) the degree of green in the\n\
9870 color as a continuous function of the integer index of the vector.\n\
9871\n\
9872 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9873 8-bit integers in the range from 0-255) the degree of blue in the\n\
9874 color as a continuous function of the integer index of the vector.\n\
9875\n\
9876 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9877 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9878 completely transparent and 1.0 corresponds to completely opaque)\n\
9879 the alpha transparency of the color as a continuous function of\n\
9880 the integer index of the vector.\n\
9881\n\
9882 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9883 vectors.\n\
9884";
9885static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9886Calculate broken-down time from continuous time for the current stream\n\
9887\n\
9888DESCRIPTION:\n\
9889\n\
9890 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9891 continuous time, ctime for the current stream. This function is the\n\
9892 inverse of plctime.\n\
9893\n\
9894 The PLplot definition of broken-down time is a calendar time that\n\
9895 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9896 responsibility to apply those offsets (if so desired) before using the\n\
9897 PLplot time API. By default broken-down time is defined using the\n\
9898 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9899 continuous time is defined as the number of seconds since the Unix\n\
9900 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9901 broken-down and continuous time are possible, see plconfigtime.\n\
9902\n\
9903 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9904 ctime)\n\
9905\n\
9906\n\
9907 This function is used in example 29.\n\
9908\n\
9909\n\
9910\n\
9911SYNOPSIS:\n\
9912\n\
9913plbtime(year, month, day, hour, min, sec, ctime)\n\
9914\n\
9915ARGUMENTS:\n\
9916\n\
9917 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9918 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9919 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9920 BCE, etc.)\n\
9921\n\
9922 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9923 the year in the range from 0 (January) to 11 (December).\n\
9924\n\
9925 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9926 month in the range from 1 to 31.\n\
9927\n\
9928 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9929 day in the range from 0 to 23.\n\
9930\n\
9931 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9932 hour in the range from 0 to 59\n\
9933\n\
9934 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9935 minute in range from 0. to 60.\n\
9936\n\
9937 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9938 time is calculated.\n\
9939";
9940static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9941Convert RGB color to HLS\n\
9942\n\
9943DESCRIPTION:\n\
9944\n\
9945 Convert RGB color coordinates to HLS\n\
9946\n\
9947 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9948\n\
9949\n\
9950 This function is used in example 2.\n\
9951\n\
9952\n\
9953\n\
9954SYNOPSIS:\n\
9955\n\
9956plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9957\n\
9958ARGUMENTS:\n\
9959\n\
9960 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9961\n\
9962 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9963\n\
9964 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9965\n\
9966 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9967 degrees (0.0-360.0) on the color cylinder.\n\
9968\n\
9969 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9970 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9971 cylinder.\n\
9972\n\
9973 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9974 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9975 cylinder.\n\
9976";
9977static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9978Get the current device (keyword) name\n\
9979\n\
9980DESCRIPTION:\n\
9981\n\
9982 Get the current device (keyword) name. Note: you must have allocated\n\
9983 space for this (80 characters is safe).\n\
9984\n\
9985 Redacted form: plgdev(p_dev)\n\
9986\n\
9987 This function is used in example 14.\n\
9988\n\
9989\n\
9990\n\
9991SYNOPSIS:\n\
9992\n\
9993plgdev(p_dev)\n\
9994\n\
9995ARGUMENTS:\n\
9996\n\
9997 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9998 (with preallocated length of 80 characters or more) containing the\n\
9999 device (keyword) name.\n\
10000";
10001static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
10002Set the number of subpages in x and y\n\
10003\n\
10004DESCRIPTION:\n\
10005\n\
10006 Set the number of subpages in x and y.\n\
10007\n\
10008 Redacted form: plssub(nx, ny)\n\
10009\n\
10010 This function is examples 1,2,14,21,25,27.\n\
10011\n\
10012\n\
10013\n\
10014SYNOPSIS:\n\
10015\n\
10016plssub(nx, ny)\n\
10017\n\
10018ARGUMENTS:\n\
10019\n\
10020 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10021 of window columns).\n\
10022\n\
10023 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10024 of window rows).\n\
10025";
10026static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
10027Get current stream number\n\
10028\n\
10029DESCRIPTION:\n\
10030\n\
10031 Gets the number of the current output stream. See also plsstrm.\n\
10032\n\
10033 Redacted form: plgstrm(p_strm)\n\
10034\n\
10035 This function is used in example 1,20.\n\
10036\n\
10037\n\
10038\n\
10039SYNOPSIS:\n\
10040\n\
10041plgstrm(p_strm)\n\
10042\n\
10043ARGUMENTS:\n\
10044\n\
10045 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10046 stream value.\n\
10047";
10048static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
10049Random number generator returning a real random number in the range [0,1]\n\
10050\n\
10051DESCRIPTION:\n\
10052\n\
10053 Random number generator returning a real random number in the range\n\
10054 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10055 / compilers provide their own random number generator, and so this is\n\
10056 provided purely for convenience and to give a consistent random number\n\
10057 generator across all languages supported by PLplot. This is\n\
10058 particularly useful for comparing results from the test suite of\n\
10059 examples.\n\
10060\n\
10061 Redacted form: plrandd()\n\
10062\n\
10063 This function is used in examples 17 and 21.\n\
10064\n\
10065\n\
10066\n\
10067SYNOPSIS:\n\
10068\n\
10069plrandd()\n\
10070";
10071static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10072Add a point to a strip chart\n\
10073\n\
10074DESCRIPTION:\n\
10075\n\
10076 Add a point to a given pen of a given strip chart. There is no need\n\
10077 for all pens to have the same number of points or to be equally\n\
10078 sampled in the x coordinate. Allocates memory and rescales as\n\
10079 necessary.\n\
10080\n\
10081 Redacted form: plstripa(id, pen, x, y)\n\
10082\n\
10083 This function is used in example 17.\n\
10084\n\
10085\n\
10086\n\
10087SYNOPSIS:\n\
10088\n\
10089plstripa(id, pen, x, y)\n\
10090\n\
10091ARGUMENTS:\n\
10092\n\
10093 id (PLINT, input) : Identification number of the strip chart (set\n\
10094 up in plstripc).\n\
10095\n\
10096 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10097\n\
10098 x (PLFLT, input) : X coordinate of point to plot.\n\
10099\n\
10100 y (PLFLT, input) : Y coordinate of point to plot.\n\
10101";
10102static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10103Set device-compression level\n\
10104\n\
10105DESCRIPTION:\n\
10106\n\
10107 Set device-compression level. Only used for drivers that provide\n\
10108 compression. This function, if used, should be invoked before a call\n\
10109 to plinit.\n\
10110\n\
10111 Redacted form: plscompression(compression)\n\
10112\n\
10113 This function is used in example 31.\n\
10114\n\
10115\n\
10116\n\
10117SYNOPSIS:\n\
10118\n\
10119plscompression(compression)\n\
10120\n\
10121ARGUMENTS:\n\
10122\n\
10123 compression (PLINT, input) : The desired compression level. This is\n\
10124 a device-dependent value. Currently only the jpeg and png devices\n\
10125 use these values. For jpeg value is the jpeg quality which should\n\
10126 normally be in the range 0-95. Higher values denote higher quality\n\
10127 and hence larger image sizes. For png values are in the range -1\n\
10128 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10129 A value of -1 denotes the default zlib compression level. Values\n\
10130 in the range 10-99 are divided by 10 and then used as the zlib\n\
10131 compression level. Higher compression levels correspond to greater\n\
10132 compression and small file sizes at the expense of more\n\
10133 computation.\n\
10134";
10135static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10136Specify viewport in absolute coordinates\n\
10137\n\
10138DESCRIPTION:\n\
10139\n\
10140 Alternate routine to plvpor for setting up the viewport. This routine\n\
10141 should be used only if the viewport is required to have a definite\n\
10142 size in millimeters. The routine plgspa is useful for finding out the\n\
10143 size of the current subpage.\n\
10144\n\
10145 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10146\n\
10147 This function is used in example 10.\n\
10148\n\
10149\n\
10150\n\
10151SYNOPSIS:\n\
10152\n\
10153plsvpa(xmin, xmax, ymin, ymax)\n\
10154\n\
10155ARGUMENTS:\n\
10156\n\
10157 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10158 viewport from the left-hand edge of the subpage in millimeters.\n\
10159\n\
10160 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10161 viewport from the left-hand edge of the subpage in millimeters.\n\
10162\n\
10163 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10164 viewport from the bottom edge of the subpage in millimeters.\n\
10165\n\
10166 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10167 from the bottom edge of the subpage in millimeters.\n\
10168";
10169static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10170Draw a polygon in 3 space\n\
10171\n\
10172DESCRIPTION:\n\
10173\n\
10174 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10175 like plline3, but differs from that function in that plpoly3 attempts\n\
10176 to determine if the polygon is viewable depending on the order of the\n\
10177 points within the vector and the value of ifcc. If the back of\n\
10178 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10179 you want, then use plline3 instead.\n\
10180\n\
10181 The points are assumed to be in a plane, and the directionality of the\n\
10182 plane is determined from the first three points. Additional points do\n\
10183 not have to lie on the plane defined by the first three, but if they\n\
10184 do not, then the determination of visibility obviously can\'t be 100%\n\
10185 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10186 consider breaking them into smaller polygons. 3 points define a plane\n\
10187 :-).\n\
10188\n\
10189 Bugs: If one of the first two segments is of zero length, or if they\n\
10190 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10191 being correct. Avoid such situations :-). See x18c.c for an example\n\
10192 of this problem. (Search for 20.1).\n\
10193\n\
10194 Redacted form: plpoly3(x, y, z, code)\n\
10195\n\
10196 This function is used in example 18.\n\
10197\n\
10198\n\
10199\n\
10200SYNOPSIS:\n\
10201\n\
10202plpoly3(n, x, y, z, draw, ifcc)\n\
10203\n\
10204ARGUMENTS:\n\
10205\n\
10206 n (PLINT, input) : Number of points defining line.\n\
10207\n\
10208 x (PLFLT_VECTOR, input) : A vector containing\n\
10209 n x coordinates of points.\n\
10210\n\
10211 y (PLFLT_VECTOR, input) : A vector containing\n\
10212 n y coordinates of points.\n\
10213\n\
10214 z (PLFLT_VECTOR, input) : A vector containing\n\
10215 n z coordinates of points.\n\
10216\n\
10217 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10218 n-1 Boolean values which control drawing the segments of the polygon.\n\
10219 If draw[i] is true, then the polygon segment from index [i] to\n\
10220 [i+1] is drawn, otherwise, not.\n\
10221\n\
10222 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10223 polygon is determined by assuming the points are laid out in a\n\
10224 counter-clockwise order. Otherwise, the directionality of the\n\
10225 polygon is determined by assuming the points are laid out in a\n\
10226 clockwise order.\n\
10227";
10228static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10229Magnitude colored plot surface with contour\n\
10230\n\
10231DESCRIPTION:\n\
10232\n\
10233 Aside from dropping the\n\
10234 side functionality this is a more powerful form of plot3d: the surface\n\
10235 mesh can be colored accordingly to the current z value being plotted,\n\
10236 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10237 drawn between the plotted function border and the base XY plane. The\n\
10238 arguments are identical to those of plmeshc. The only difference\n\
10239 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10240 the surface, while plot3dc only draws the surface as viewed from the\n\
10241 top.\n\
10242\n\
10243 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10244\n\
10245\n\
10246 This function is used in example 21.\n\
10247\n\
10248\n\
10249\n\
10250SYNOPSIS:\n\
10251\n\
10252plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10253\n\
10254ARGUMENTS:\n\
10255\n\
10256 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10257 which the function is evaluated.\n\
10258\n\
10259 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10260 which the function is evaluated.\n\
10261\n\
10262 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10263 plot. Should have dimensions of\n\
10264 nx by\n\
10265 ny.\n\
10266\n\
10267 nx (PLINT, input) : Number of x values at which function is\n\
10268 evaluated.\n\
10269\n\
10270 ny (PLINT, input) : Number of y values at which function is\n\
10271 evaluated.\n\
10272\n\
10273 opt (PLINT, input) : Determines the way in which the surface is\n\
10274 represented. To specify more than one option just add the options,\n\
10275 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10276 showing z as a function of x for each value of y[j] .\n\
10277 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10278 for each value of x[i] .\n\
10279 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10280 at which function is defined.\n\
10281 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10282 the z value being plotted. The color is used from the current\n\
10283 cmap1.\n\
10284 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10285 using parameters\n\
10286 nlevel and\n\
10287 clevel.\n\
10288 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10289 the borders of the plotted function.\n\
10290\n\
10291\n\
10292 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10293 levels.\n\
10294\n\
10295 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10296";
10297static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10298Create a 4-pen strip chart\n\
10299\n\
10300DESCRIPTION:\n\
10301\n\
10302 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10303\n\
10304 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10305 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10306 styline, legline, labx, laby, labz)\n\
10307\n\
10308\n\
10309 This function is used in example 17.\n\
10310\n\
10311\n\
10312\n\
10313SYNOPSIS:\n\
10314\n\
10315plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10316\n\
10317ARGUMENTS:\n\
10318\n\
10319 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10320 number of the strip chart to use on plstripa and plstripd.\n\
10321\n\
10322 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10323 the x-axis specification as in plbox.\n\
10324\n\
10325 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10326 the y-axis specification as in plbox.\n\
10327\n\
10328 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10329 change as data are added.\n\
10330\n\
10331 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10332 change as data are added.\n\
10333\n\
10334 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10335 is multiplied by the factor (1 +\n\
10336 xjump) .\n\
10337\n\
10338 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10339 change as data are added.\n\
10340\n\
10341 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10342 change as data are added.\n\
10343\n\
10344 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10345\n\
10346 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10347\n\
10348 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10349 true, otherwise not.\n\
10350\n\
10351 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10352 otherwise slide display.\n\
10353\n\
10354 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10355\n\
10356 collab (PLINT, input) : Legend color index (cmap0).\n\
10357\n\
10358 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10359 indices for the 4 pens.\n\
10360\n\
10361 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10362 indices for the 4 pens.\n\
10363\n\
10364 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10365 strings containing legends for the 4 pens.\n\
10366\n\
10367 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10368 the label for the x axis.\n\
10369\n\
10370 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10371 the label for the y axis.\n\
10372\n\
10373 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10374 the plot title.\n\
10375";
10376static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10377Deletes and releases memory used by a strip chart\n\
10378\n\
10379DESCRIPTION:\n\
10380\n\
10381 Deletes and releases memory used by a strip chart.\n\
10382\n\
10383 Redacted form: plstripd(id)\n\
10384\n\
10385 This function is used in example 17.\n\
10386\n\
10387\n\
10388\n\
10389SYNOPSIS:\n\
10390\n\
10391plstripd(id)\n\
10392\n\
10393ARGUMENTS:\n\
10394\n\
10395 id (PLINT, input) : Identification number of strip chart to delete.\n\
10396";
10397static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10398Set cmap1 colors using a piece-wise linear relationship\n\
10399\n\
10400DESCRIPTION:\n\
10401\n\
10402 Set cmap1 colors using a piece-wise linear relationship between the\n\
10403 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10404 (see the PLplot documentation). May be called at any time.\n\
10405\n\
10406 The idea here is to specify a number of control points that define the\n\
10407 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10408 these points, linear interpolation is used which gives a smooth\n\
10409 variation of color with intensity index. Any number of control points\n\
10410 may be specified, located at arbitrary positions, although typically 2\n\
10411 - 4 are enough. Another way of stating this is that we are traversing\n\
10412 a given number of lines through HLS or RGB space as we move through\n\
10413 cmap1 intensity indices. The control points at the minimum and\n\
10414 maximum position (0 and 1) must always be specified. By adding more\n\
10415 control points you can get more variation. One good technique for\n\
10416 plotting functions that vary about some expected average is to use an\n\
10417 additional 2 control points in the center (position ~= 0.5) that are\n\
10418 the same lightness as the background (typically white for paper\n\
10419 output, black for crt), and same hue as the boundary control points.\n\
10420 This allows the highs and lows to be very easily distinguished.\n\
10421\n\
10422 Each control point must specify the cmap1 intensity index and the\n\
10423 associated three coordinates in HLS or RGB space. The first point\n\
10424 must correspond to position = 0, and the last to position = 1.\n\
10425\n\
10426 If RGB colors are provided then the interpolation takes place in RGB\n\
10427 space and is trivial. However if HLS colors are provided then, because\n\
10428 of the circular nature of the color wheel for the hue coordinate, the\n\
10429 interpolation could be performed in either direction around the color\n\
10430 wheel. The default behaviour is for the hue to be linearly\n\
10431 interpolated ignoring this circular property of hue. So for example,\n\
10432 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10433 green and cyan. If instead you wish to interpolate the other way\n\
10434 around the color wheel you have two options. You may provide hues\n\
10435 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10436 for red the interpolation will proceed via magenta. Alternatively you\n\
10437 can utilise the alt_hue_path variable to reverse the direction of\n\
10438 interpolation if you need to provide hues within the [0-360) range.\n\
10439\n\
10440 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10441 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10442 -120]falsegreen-yellow-red-magenta-blue[240\n\
10443 480]falseblue-magenta-red-yellow-green[120\n\
10444 240]truegreen-yellow-red-magenta-blue[240\n\
10445 120]trueblue-magenta-red-yellow-green\n\
10446\n\
10447 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10448 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10449 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10450\n\
10451 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10452 alt_hue_path)\n\
10453\n\
10454 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10455\n\
10456\n\
10457\n\
10458SYNOPSIS:\n\
10459\n\
10460plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10461\n\
10462ARGUMENTS:\n\
10463\n\
10464 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10465\n\
10466 npts (PLINT, input) : number of control points\n\
10467\n\
10468 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10469 intensity index (0.0-1.0) in ascending order for each control\n\
10470 point.\n\
10471\n\
10472 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10473 coordinate (H or R) for each control point.\n\
10474\n\
10475 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10476 coordinate (L or G) for each control point.\n\
10477\n\
10478 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10479 coordinate (S or B) for each control point.\n\
10480\n\
10481 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10482 npts - 1 elements), each containing either true to use the reversed\n\
10483 HLS interpolation or false to use the regular HLS interpolation.\n\
10484 (alt_hue_path[i] refers to the interpolation interval between the\n\
10485 i and i + 1 control points). This parameter is not used for RGB\n\
10486 colors (\n\
10487 itype = true).\n\
10488";
10489static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10490Shade individual region on the basis of value\n\
10491\n\
10492DESCRIPTION:\n\
10493\n\
10494 Shade individual region on the basis of value. Use plshades if you\n\
10495 want to shade a number of contiguous regions using continuous colors.\n\
10496 In particular the edge contours are treated properly in plshades. If\n\
10497 you attempt to do contiguous regions with plshade the contours at the\n\
10498 edge of the shade are partially obliterated by subsequent plots of\n\
10499 contiguous shaded regions.\n\
10500\n\
10501 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10502 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10503 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10504\n\
10505\n\
10506 This function is used in example 15.\n\
10507\n\
10508\n\
10509\n\
10510SYNOPSIS:\n\
10511\n\
10512plshade(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\
10513\n\
10514ARGUMENTS:\n\
10515\n\
10516 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10517 plot. Should have dimensions of\n\
10518 nx by\n\
10519 ny.\n\
10520\n\
10521 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10522\n\
10523 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10524\n\
10525 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10526 the region that should be plotted in the shade plot. This\n\
10527 function accepts x and y coordinates as input arguments and must\n\
10528 return 1 if the point is to be included in the shade plot and 0\n\
10529 otherwise. If you want to plot the entire shade plot (the usual\n\
10530 case), this argument should be set to NULL.\n\
10531\n\
10532 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10533 pltr below for how these arguments are used (only for the special case\n\
10534 when the callback function\n\
10535 pltr is not supplied).\n\
10536\n\
10537 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10538 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10539\n\
10540 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10541 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10542\n\
10543 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10544 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10545 then sh_color is interpreted as a cmap1 argument in the range\n\
10546 (0.0-1.0).\n\
10547\n\
10548 sh_color (PLFLT, input) : Defines color map index with integer\n\
10549 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10550\n\
10551 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10552\n\
10553 min_color (PLINT, input) : Defines pen color, width used by the\n\
10554 boundary of shaded region. The min values are used for the\n\
10555 shade_min boundary, and the max values are used on the shade_max\n\
10556 boundary. Set color and width to zero for no plotted boundaries.\n\
10557\n\
10558 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10559 boundary of shaded region. The min values are used for the\n\
10560 shade_min boundary, and the max values are used on the shade_max\n\
10561 boundary. Set color and width to zero for no plotted boundaries.\n\
10562\n\
10563 max_color (PLINT, input) : Defines pen color, width used by the\n\
10564 boundary of shaded region. The min values are used for the\n\
10565 shade_min boundary, and the max values are used on the shade_max\n\
10566 boundary. Set color and width to zero for no plotted boundaries.\n\
10567\n\
10568 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10569 boundary of shaded region. The min values are used for the\n\
10570 shade_min boundary, and the max values are used on the shade_max\n\
10571 boundary. Set color and width to zero for no plotted boundaries.\n\
10572\n\
10573 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10574 Use plfill. Future version of PLplot may have other fill\n\
10575 routines.\n\
10576\n\
10577 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10578 map to rectangles after coordinate transformation with pltrl.\n\
10579 Otherwise, set rectangular to false. If rectangular is set to\n\
10580 true, plshade tries to save time by filling large rectangles.\n\
10581 This optimization fails if the coordinate transformation distorts\n\
10582 the shape of rectangles. For example a plot in polar coordinates\n\
10583 has to have rectangular set to false.\n\
10584\n\
10585 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10586 defines the transformation between the zero-based indices of the\n\
10587 matrix a and world coordinates. If\n\
10588 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10589 indices of a are mapped to the range\n\
10590 xmin through\n\
10591 xmax and the y indices of a are mapped to the range\n\
10592 ymin through\n\
10593 ymax.For the C case, transformation functions are provided in the\n\
10594 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10595 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10596 matrices. In addition, C callback routines for the transformation\n\
10597 can be supplied by the user such as the mypltr function in\n\
10598 examples/c/x09c.c which provides a general linear transformation\n\
10599 between index coordinates and world coordinates.For languages\n\
10600 other than C you should consult the PLplot documentation for the\n\
10601 details concerning how PLTRANSFORM_callback arguments are\n\
10602 interfaced. However, in general, a particular pattern of\n\
10603 callback-associated arguments such as a tr vector with 6 elements;\n\
10604 xg and yg vectors; or xg and yg matrices are respectively\n\
10605 interfaced to a linear-transformation routine similar to the above\n\
10606 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10607 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10608 support native language callbacks for handling index to\n\
10609 world-coordinate transformations. Examples of these various\n\
10610 approaches are given in examples/<language>x09*,\n\
10611 examples/<language>x16*, examples/<language>x20*,\n\
10612 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10613 supported languages.\n\
10614\n\
10615 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10616 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10617 externally supplied.\n\
10618";
10619static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10620Set number of colors in cmap1\n\
10621\n\
10622DESCRIPTION:\n\
10623\n\
10624 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10625 values if this is the first allocation (see the PLplot documentation).\n\
10626\n\
10627 Redacted form: plscmap1n(ncol1)\n\
10628\n\
10629 This function is used in examples 8, 11, 20, and 21.\n\
10630\n\
10631\n\
10632\n\
10633SYNOPSIS:\n\
10634\n\
10635plscmap1n(ncol1)\n\
10636\n\
10637ARGUMENTS:\n\
10638\n\
10639 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10640 the cmap1 palette. If this number is zero or less, then the value\n\
10641 from the previous call to plscmap1n is used and if there is no\n\
10642 previous call, then a default value is used.\n\
10643";
10644static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10645Advance to the next family file on the next new page\n\
10646\n\
10647DESCRIPTION:\n\
10648\n\
10649 Advance to the next family file on the next new page.\n\
10650\n\
10651 Redacted form: plfamadv()\n\
10652\n\
10653 This function is not used in any examples.\n\
10654\n\
10655\n\
10656\n\
10657SYNOPSIS:\n\
10658\n\
10659plfamadv()\n\
10660";
10661static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10662Set the escape character for text strings\n\
10663\n\
10664DESCRIPTION:\n\
10665\n\
10666 Set the escape character for text strings. From C (in contrast to\n\
10667 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10668 characters are allowed to prevent the user from shooting himself in\n\
10669 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10670 use of backslash as a character escape). Here are the allowed escape\n\
10671 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10672 #, ASCII 35\n\
10673 $, ASCII 36\n\
10674 %, ASCII 37\n\
10675 &, ASCII 38\n\
10676 *, ASCII 42\n\
10677 @, ASCII 64\n\
10678 ^, ASCII 94\n\
10679 ~, ASCII 126\n\
10680\n\
10681\n\
10682 Redacted form: General: plsesc(esc)\n\
10683\n\
10684\n\
10685 This function is used in example 29.\n\
10686\n\
10687\n\
10688\n\
10689SYNOPSIS:\n\
10690\n\
10691plsesc(esc)\n\
10692\n\
10693ARGUMENTS:\n\
10694\n\
10695 esc (char, input) : Escape character.\n\
10696";
10697static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10698Plot color bar for image, shade or gradient plots\n\
10699\n\
10700DESCRIPTION:\n\
10701\n\
10702 Routine for creating a continuous color bar for image, shade, or\n\
10703 gradient plots. (See pllegend for similar functionality for creating\n\
10704 legends with discrete elements). The arguments of plcolorbar provide\n\
10705 control over the location and size of the color bar as well as the\n\
10706 location and characteristics of the elements (most of which are\n\
10707 optional) within that color bar. The resulting color bar is clipped\n\
10708 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10709 system used for some of the parameters is defined in the documentation\n\
10710 of the position parameter.)\n\
10711\n\
10712 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10713 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10714 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10715 labels, axis_opts, ticks, sub_ticks, values)\n\
10716\n\
10717 This function is used in examples 16 and 33.\n\
10718\n\
10719\n\
10720\n\
10721SYNOPSIS:\n\
10722\n\
10723plcolorbar(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\
10724\n\
10725ARGUMENTS:\n\
10726\n\
10727 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10728 labelled and decorated color bar width in adopted coordinates.\n\
10729\n\
10730 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10731 labelled and decorated color bar height in adopted coordinates.\n\
10732\n\
10733 opt (PLINT, input) : opt contains bits controlling the overall\n\
10734 color bar. The orientation (direction of the maximum value) of\n\
10735 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10736 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10737 specified, the default orientation is toward the top if the\n\
10738 colorbar is placed on the left or right of the viewport or toward\n\
10739 the right if the colorbar is placed on the top or bottom of the\n\
10740 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10741 (semitransparent) background for the color bar. If the\n\
10742 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10743 color bar. The type of color bar must be specified with one of\n\
10744 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10745 more than one of those bits is set only the first one in the above\n\
10746 list is honored. The position of the (optional) label/title can be\n\
10747 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10748 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10749 will be drawn. If more than one of this list of bits is specified,\n\
10750 only the first one on the list is honored. End-caps for the color\n\
10751 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10752 If a particular color bar cap option is not specified then no cap\n\
10753 will be drawn for that end. As a special case for\n\
10754 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10755 specified. If this option is provided then any tick marks and tick\n\
10756 labels will be placed at the breaks between shaded segments. TODO:\n\
10757 This should be expanded to support custom placement of tick marks\n\
10758 and tick labels at custom value locations for any color bar type.\n\
10759\n\
10760 position (PLINT, input) : position contains bits which control the\n\
10761 overall position of the color bar and the definition of the\n\
10762 adopted coordinates used for positions just like what is done for\n\
10763 the position argument for pllegend. However, note that the\n\
10764 defaults for the position bits (see below) are different than the\n\
10765 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10766 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10767 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10768 the 16 possible standard positions (the 4 corners and centers of\n\
10769 the 4 sides for both the inside and outside cases) of the color\n\
10770 bar relative to the adopted coordinate system. The corner\n\
10771 positions are specified by the appropriate combination of two of\n\
10772 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10773 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10774 value of one of those bits. The adopted coordinates are\n\
10775 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10776 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10777 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10778 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10779 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10780 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10781 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10782 PL_POSITION_VIEWPORT.\n\
10783\n\
10784 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10785 coordinates from the specified standard position of the color bar.\n\
10786 For positive x, the direction of motion away from the standard\n\
10787 position is inward/outward from the standard corner positions or\n\
10788 standard left or right positions if the\n\
10789 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10790 For the standard top or bottom positions, the direction of motion\n\
10791 is toward positive X.\n\
10792\n\
10793 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10794 coordinates from the specified standard position of the color bar.\n\
10795 For positive y, the direction of motion away from the standard\n\
10796 position is inward/outward from the standard corner positions or\n\
10797 standard top or bottom positions if the\n\
10798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10799 For the standard left or right positions, the direction of motion\n\
10800 is toward positive Y.\n\
10801\n\
10802 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10803 the X direction in adopted coordinates.\n\
10804\n\
10805 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10806 the Y direction in adopted coordinates.\n\
10807\n\
10808 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10809 color bar (PL_COLORBAR_BACKGROUND).\n\
10810\n\
10811 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10812 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10813\n\
10814 bb_style (PLINT, input) : The pllsty style number for the\n\
10815 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10816\n\
10817 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10818 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10819\n\
10820 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10821 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10822\n\
10823 cont_color (PLINT, input) : The cmap0 contour color for\n\
10824 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10825 it will be interpreted according to the design of plshades.\n\
10826\n\
10827 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10828 plots. This is passed directly to plshades, so it will be\n\
10829 interpreted according to the design of plshades.\n\
10830\n\
10831 n_labels (PLINT, input) : Number of labels to place around the\n\
10832 color bar.\n\
10833\n\
10834 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10835 n_labels labels.\n\
10836\n\
10837 labels (PLCHAR_MATRIX, input) : A vector of\n\
10838 n_labels UTF-8 character strings containing the labels for the color\n\
10839 bar. Ignored if no label position is specified with one of the\n\
10840 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10841 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10842 corresponding label_opts field.\n\
10843\n\
10844 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10845 value must be greater than 0. It is typically 1 (numerical axis\n\
10846 labels are provided for one of the long edges of the color bar),\n\
10847 but it can be larger if multiple numerical axis labels for the\n\
10848 long edges of the color bar are desired.\n\
10849\n\
10850 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10851 n_axes ascii character strings containing options (interpreted as for\n\
10852 plbox) for the color bar\'s axis definitions.\n\
10853\n\
10854 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10855 spacing of the major tick marks (interpreted as for plbox) for the\n\
10856 color bar\'s axis definitions.\n\
10857\n\
10858 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10859 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10860 axis definitions.\n\
10861\n\
10862 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10863 elements in each of the n_axes rows of the values matrix.\n\
10864\n\
10865 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10866 values for the data range represented by the color bar. For a row\n\
10867 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10868 elements in the row is specified by n_values[i_axis]. For\n\
10869 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10870 is 2, and the corresponding row elements of the values matrix are\n\
10871 the minimum and maximum value represented by the colorbar. For\n\
10872 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10873 of the values matrix is interpreted the same as the nlevel and\n\
10874 clevel arguments of plshades.\n\
10875";
10876static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10877Set current output stream\n\
10878\n\
10879DESCRIPTION:\n\
10880\n\
10881 Sets the number of the current output stream. The stream number\n\
10882 defaults to 0 unless changed by this routine. The first use of this\n\
10883 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10884\n\
10885 Redacted form: plsstrm(strm)\n\
10886\n\
10887 This function is examples 1,14,20.\n\
10888\n\
10889\n\
10890\n\
10891SYNOPSIS:\n\
10892\n\
10893plsstrm(strm)\n\
10894\n\
10895ARGUMENTS:\n\
10896\n\
10897 strm (PLINT, input) : The current stream number.\n\
10898";
10899static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10900Get the current device-compression setting\n\
10901\n\
10902DESCRIPTION:\n\
10903\n\
10904 Get the current device-compression setting. This parameter is only\n\
10905 used for drivers that provide compression.\n\
10906\n\
10907 Redacted form: plgcompression(compression)\n\
10908\n\
10909 This function is used in example 31.\n\
10910\n\
10911\n\
10912\n\
10913SYNOPSIS:\n\
10914\n\
10915plgcompression(compression)\n\
10916\n\
10917ARGUMENTS:\n\
10918\n\
10919 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10920 compression setting for the current device.\n\
10921";
10922static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10923Grid data from irregularly sampled data\n\
10924\n\
10925DESCRIPTION:\n\
10926\n\
10927 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10928 require data organized as a grid, i.e., with x sample point values\n\
10929 independent of y coordinate and vice versa. This function takes\n\
10930 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10931 vectors; reads the desired grid location from the input vectors\n\
10932 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10933 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10934 interpolate the data to the grid is specified with the argument type\n\
10935 which can have one parameter specified in argument data.\n\
10936\n\
10937 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10938 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10939\n\
10940\n\
10941 This function is used in example 21.\n\
10942\n\
10943\n\
10944\n\
10945SYNOPSIS:\n\
10946\n\
10947plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10948\n\
10949ARGUMENTS:\n\
10950\n\
10951 x (PLFLT_VECTOR, input) : The input x vector.\n\
10952\n\
10953 y (PLFLT_VECTOR, input) : The input y vector.\n\
10954\n\
10955 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10956 y[i], z[i] represents one data sample coordinate.\n\
10957\n\
10958 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10959 vectors.\n\
10960\n\
10961 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10962 in the x direction. Usually xg has nptsx equally spaced values\n\
10963 from the minimum to the maximum values of the x input vector.\n\
10964\n\
10965 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10966\n\
10967 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10968 in the y direction. Similar to the xg parameter.\n\
10969\n\
10970 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10971\n\
10972 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10973 where data lies in the grid specified by xg and yg. Therefore the\n\
10974 zg matrix must be dimensioned\n\
10975 nptsx by\n\
10976 nptsy.\n\
10977\n\
10978 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10979 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10980 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10981 GRID_NNI: Natural Neighbors Interpolation\n\
10982 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10983 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10984 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10985 Weighted\n\
10986 For details of the algorithms read the source file plgridd.c.\n\
10987\n\
10988 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10989 which can be specified through this argument. Currently, for\n\
10990 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10991 use, the lower the value, the noisier (more local) the\n\
10992 approximation is.\n\
10993 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10994 range [1. .. 2.]. High values enable the usage of very thin\n\
10995 triangles for interpolation, possibly resulting in error in\n\
10996 the approximation.\n\
10997 GRID_NNI, only weights greater than data will be accepted. If\n\
10998 0, all weights will be accepted.\n\
10999";
11000
11001SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
11002 PLINT arg1 ;
11003 PLINT *arg2 = (PLINT *) 0 ;
11004 char **arg3 = (char **) 0 ;
11005 Matrix temp1 ;
11006 octave_value_list _out;
11007 octave_value_list *_outp=&_out;
11008 octave_value _outv;
11009
11010 try {
11011 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
11012 SWIG_fail;
11013 }
11014 {
11015 if ( _n_dims( args(0) ) > 1 )
11016 {
11017 error( "argument must be a scalar or vector" ); SWIG_fail;
11018 }
11019 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
11020 arg2 = new PLINT[Alen];
11021 temp1 = args(0).matrix_value();
11022 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
11023 }
11024 {
11025 charMatrix temp_matrix;
11026 Cell temp_cell;
11027 char *tmp_cstring;
11028 std::string str;
11029 size_t max_length = 0, non_blank_length;
11030 int i, ifcell;
11031 if ( _n_dims( args(1) ) > 2 )
11032 {
11033 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11034 }
11035#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11036 if ( !args(1).isempty() )
11037#else
11038 if ( !args(1).is_empty() )
11039#endif
11040 {
11041 if ( _dim( args(1), 0 ) != Alen )
11042 {
11043 error( "first dimension must be same length as previous vector" ); SWIG_fail;
11044 }
11045 arg3 = new char*[Alen];
11046#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11047 ifcell = args(1).iscell();
11048#else
11049 ifcell = args(1).is_cell();
11050#endif
11051 if ( ifcell )
11052 {
11053 temp_cell = args(1).cell_value();
11054 }
11055 else
11056 {
11057 temp_matrix = args(1).char_matrix_value();
11058 // Allow one extra space for null termination.
11059 max_length = _dim( args(1), 1 ) + 1;
11060 }
11061
11062 for ( i = 0; i < Alen; i++ )
11063 {
11064 // Must copy string to "permanent" location because the string
11065 // location corresponding to tmp_cstring gets
11066 // overwritten for each iteration of loop.
11067 if ( ifcell )
11068 {
11069 if ( temp_cell.elem( i ).is_string() )
11070 {
11071 str = temp_cell.elem( i ).string_value();
11072 // leave room for null termination.
11073 max_length = str.size() + 1;
11074 tmp_cstring = (char *) str.c_str();
11075 }
11076 else
11077 {
11078 // Use null string if user attempts to pass a cell array
11079 // with a non-string element (likely an empty element
11080 // since that should be allowed by the PLplot interface
11081 // if that element is going to be unused).
11082 // leave room for null termination.
11083 max_length = 1;
11084 tmp_cstring = (char *) "";
11085 }
11086 }
11087 else
11088 {
11089 str = temp_matrix.row_as_string( i );
11090 tmp_cstring = (char *) str.c_str();
11091 }
11092 arg3[i] = new char[max_length];
11093 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11094 arg3[i][max_length - 1] = '\0';
11095 // All the trailing blank crapola should not be needed for
11096 // string cell arrays.
11097 if ( !ifcell )
11098 {
11099 // remove trailing-blank padding that is used by the
11100 // charMatrix class to insure all strings in a given
11101 // charMatrix instance have the same length.
11102 // This transformation also removes legitimate trailing
11103 // blanks but there is nothing we can do about that
11104 // for the charMatrix class.
11105
11106 // Look for trailing nulls first (just in case, although that
11107 // shouldn't happen if charMatrix implemented as documented)
11108 // before looking for trailing blanks.
11109 non_blank_length = max_length - 2;
11110 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11111 {
11112 non_blank_length--;
11113 }
11114 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11115 {
11116 non_blank_length--;
11117 }
11118 arg3[i][non_blank_length + 1] = '\0';
11119 }
11120 }
11121 }
11122 else
11123 {
11124 arg3 = NULL;
11125 }
11126 }
11127 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11128 _outv = octave_value();
11129 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11130 {
11131 delete [] arg2;
11132 }
11133 {
11134 int i;
11135 if ( arg3 != NULL )
11136 {
11137 for ( i = 0; i < Alen; i++ )
11138 {
11139 delete[] arg3[i];
11140 }
11141 delete[] arg3;
11142 }
11143 }
11144 return _out;
11145 fail:
11146 {
11147 delete [] arg2;
11148 }
11149 {
11150 int i;
11151 if ( arg3 != NULL )
11152 {
11153 for ( i = 0; i < Alen; i++ )
11154 {
11155 delete[] arg3[i];
11156 }
11157 delete[] arg3;
11158 }
11159 }
11160 return octave_value_list();
11161 }
11162 catch(...) {
11163 {
11164 delete [] arg2;
11165 }
11166 {
11167 int i;
11168 if ( arg3 != NULL )
11169 {
11170 for ( i = 0; i < Alen; i++ )
11171 {
11172 delete[] arg3[i];
11173 }
11174 delete[] arg3;
11175 }
11176 }
11177 throw;
11178 }
11179}
11180
11181
11183 int *arg1 = (int *) 0 ;
11184 int *arg2 = (int *) 0 ;
11185 int *arg3 = (int *) 0 ;
11186 char *arg4 = (char *) 0 ;
11187 int *arg5 = (int *) 0 ;
11188 int *arg6 = (int *) 0 ;
11189 PLFLT *arg7 = (PLFLT *) 0 ;
11190 PLFLT *arg8 = (PLFLT *) 0 ;
11191 PLFLT *arg9 = (PLFLT *) 0 ;
11192 PLFLT *arg10 = (PLFLT *) 0 ;
11193 int *arg11 = (int *) 0 ;
11194 int temp1 ;
11195 int res1 = SWIG_TMPOBJ ;
11196 int temp2 ;
11197 int res2 = SWIG_TMPOBJ ;
11198 int temp3 ;
11199 int res3 = SWIG_TMPOBJ ;
11200 char local_string4[80] ;
11201 int temp5 ;
11202 int res5 = SWIG_TMPOBJ ;
11203 int temp6 ;
11204 int res6 = SWIG_TMPOBJ ;
11205 PLFLT temp7 ;
11206 int res7 = SWIG_TMPOBJ ;
11207 PLFLT temp8 ;
11208 int res8 = SWIG_TMPOBJ ;
11209 PLFLT temp9 ;
11210 int res9 = SWIG_TMPOBJ ;
11211 PLFLT temp10 ;
11212 int res10 = SWIG_TMPOBJ ;
11213 int temp11 ;
11214 int res11 = SWIG_TMPOBJ ;
11215 size_t local_string_length4 ;
11216 charMatrix local_charMatrix4 ;
11217 octave_value_list retval4 ;
11218 octave_value_list _out;
11219 octave_value_list *_outp=&_out;
11220 octave_value _outv;
11221 int result;
11222
11223 try {
11224 arg1 = &temp1;
11225 arg2 = &temp2;
11226 arg3 = &temp3;
11227 {
11228 arg4 = local_string4;
11229 }
11230 arg5 = &temp5;
11231 arg6 = &temp6;
11232 arg7 = &temp7;
11233 arg8 = &temp8;
11234 arg9 = &temp9;
11235 arg10 = &temp10;
11236 arg11 = &temp11;
11237 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11238 SWIG_fail;
11239 }
11240 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11241 _outv = SWIG_From_int(static_cast< int >(result));
11242 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11243 if (SWIG_IsTmpObj(res1)) {
11244 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11245 } else {
11246 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11247 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11248 }
11249 if (SWIG_IsTmpObj(res2)) {
11250 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11251 } else {
11252 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11253 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11254 }
11255 if (SWIG_IsTmpObj(res3)) {
11256 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11257 } else {
11258 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11260 }
11261 {
11262 local_string_length4 = strlen( local_string4 );
11263 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11264 local_charMatrix4.insert( local_string4, 0, 0 );
11265 retval4( 0 ) = octave_value( local_charMatrix4 );
11266 _outp = SWIG_Octave_AppendOutput(_outp, retval4( 0 ));
11267 }
11268 if (SWIG_IsTmpObj(res5)) {
11269 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11270 } else {
11271 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11272 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11273 }
11274 if (SWIG_IsTmpObj(res6)) {
11275 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11276 } else {
11277 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11279 }
11280 if (SWIG_IsTmpObj(res7)) {
11281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11282 } else {
11283 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11285 }
11286 if (SWIG_IsTmpObj(res8)) {
11287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11288 } else {
11289 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11291 }
11292 if (SWIG_IsTmpObj(res9)) {
11293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11294 } else {
11295 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11296 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11297 }
11298 if (SWIG_IsTmpObj(res10)) {
11299 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11300 } else {
11301 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11302 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11303 }
11304 if (SWIG_IsTmpObj(res11)) {
11305 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11306 } else {
11307 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11308 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11309 }
11310 return _out;
11311 fail:
11312 return octave_value_list();
11313 }
11314 catch(...) {
11315 throw;
11316 }
11317}
11318
11319
11320SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11321 PLFLT *arg1 = (PLFLT *) 0 ;
11322 PLFLT *arg2 = (PLFLT *) 0 ;
11323 PLFLT arg3 ;
11324 PLFLT arg4 ;
11325 PLFLT temp1 ;
11326 int res1 = SWIG_TMPOBJ ;
11327 PLFLT temp2 ;
11328 int res2 = SWIG_TMPOBJ ;
11329 double val3 ;
11330 int ecode3 = 0 ;
11331 double val4 ;
11332 int ecode4 = 0 ;
11333 octave_value_list _out;
11334 octave_value_list *_outp=&_out;
11335 octave_value _outv;
11336 int result;
11337
11338 try {
11339 arg1 = &temp1;
11340 arg2 = &temp2;
11341 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11342 SWIG_fail;
11343 }
11344 ecode3 = SWIG_AsVal_double(args(0), &val3);
11345 if (!SWIG_IsOK(ecode3)) {
11346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11347 }
11348 arg3 = static_cast< PLFLT >(val3);
11349 ecode4 = SWIG_AsVal_double(args(1), &val4);
11350 if (!SWIG_IsOK(ecode4)) {
11351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11352 }
11353 arg4 = static_cast< PLFLT >(val4);
11354 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11355 _outv = SWIG_From_int(static_cast< int >(result));
11356 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11357 if (SWIG_IsTmpObj(res1)) {
11358 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11359 } else {
11360 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11361 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11362 }
11363 if (SWIG_IsTmpObj(res2)) {
11364 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11365 } else {
11366 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11367 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11368 }
11369 return _out;
11370 fail:
11371 return octave_value_list();
11372 }
11373 catch(...) {
11374 throw;
11375 }
11376}
11377
11378
11380 PLINT *arg1 = (PLINT *) 0 ;
11381 char *arg2 = (char *) 0 ;
11382 char *arg3 = (char *) 0 ;
11383 PLFLT arg4 ;
11384 PLFLT arg5 ;
11385 PLFLT arg6 ;
11386 PLFLT arg7 ;
11387 PLFLT arg8 ;
11388 PLFLT arg9 ;
11389 PLFLT arg10 ;
11390 PLBOOL arg11 ;
11391 PLBOOL arg12 ;
11392 PLINT arg13 ;
11393 PLINT arg14 ;
11394 PLINT *arg15 = (PLINT *) 0 ;
11395 PLINT *arg16 = (PLINT *) 0 ;
11396 char *arg17 = (char *) 0 ;
11397 char *arg18 = (char *) 0 ;
11398 char *arg19 = (char *) 0 ;
11399 char *arg20 = (char *) 0 ;
11400 char *arg21 = (char *) 0 ;
11401 char *arg22 = (char *) 0 ;
11402 char *arg23 = (char *) 0 ;
11403 PLINT temp1 ;
11404 int res1 = SWIG_TMPOBJ ;
11405 int res2 ;
11406 char *buf2 = 0 ;
11407 int alloc2 = 0 ;
11408 int res3 ;
11409 char *buf3 = 0 ;
11410 int alloc3 = 0 ;
11411 double val4 ;
11412 int ecode4 = 0 ;
11413 double val5 ;
11414 int ecode5 = 0 ;
11415 double val6 ;
11416 int ecode6 = 0 ;
11417 double val7 ;
11418 int ecode7 = 0 ;
11419 double val8 ;
11420 int ecode8 = 0 ;
11421 double val9 ;
11422 int ecode9 = 0 ;
11423 double val10 ;
11424 int ecode10 = 0 ;
11425 int val11 ;
11426 int ecode11 = 0 ;
11427 int val12 ;
11428 int ecode12 = 0 ;
11429 int val13 ;
11430 int ecode13 = 0 ;
11431 int val14 ;
11432 int ecode14 = 0 ;
11433 Matrix temp15 ;
11434 Matrix temp16 ;
11435 int res17 ;
11436 char *buf17 = 0 ;
11437 int alloc17 = 0 ;
11438 int res18 ;
11439 char *buf18 = 0 ;
11440 int alloc18 = 0 ;
11441 int res19 ;
11442 char *buf19 = 0 ;
11443 int alloc19 = 0 ;
11444 int res20 ;
11445 char *buf20 = 0 ;
11446 int alloc20 = 0 ;
11447 int res21 ;
11448 char *buf21 = 0 ;
11449 int alloc21 = 0 ;
11450 int res22 ;
11451 char *buf22 = 0 ;
11452 int alloc22 = 0 ;
11453 int res23 ;
11454 char *buf23 = 0 ;
11455 int alloc23 = 0 ;
11456 octave_value_list _out;
11457 octave_value_list *_outp=&_out;
11458 octave_value _outv;
11459
11460 try {
11461 arg1 = &temp1;
11462 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11463 SWIG_fail;
11464 }
11465 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11466 if (!SWIG_IsOK(res2)) {
11467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11468 }
11469 arg2 = reinterpret_cast< char * >(buf2);
11470 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11471 if (!SWIG_IsOK(res3)) {
11472 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11473 }
11474 arg3 = reinterpret_cast< char * >(buf3);
11475 ecode4 = SWIG_AsVal_double(args(2), &val4);
11476 if (!SWIG_IsOK(ecode4)) {
11477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11478 }
11479 arg4 = static_cast< PLFLT >(val4);
11480 ecode5 = SWIG_AsVal_double(args(3), &val5);
11481 if (!SWIG_IsOK(ecode5)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11483 }
11484 arg5 = static_cast< PLFLT >(val5);
11485 ecode6 = SWIG_AsVal_double(args(4), &val6);
11486 if (!SWIG_IsOK(ecode6)) {
11487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11488 }
11489 arg6 = static_cast< PLFLT >(val6);
11490 ecode7 = SWIG_AsVal_double(args(5), &val7);
11491 if (!SWIG_IsOK(ecode7)) {
11492 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11493 }
11494 arg7 = static_cast< PLFLT >(val7);
11495 ecode8 = SWIG_AsVal_double(args(6), &val8);
11496 if (!SWIG_IsOK(ecode8)) {
11497 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11498 }
11499 arg8 = static_cast< PLFLT >(val8);
11500 ecode9 = SWIG_AsVal_double(args(7), &val9);
11501 if (!SWIG_IsOK(ecode9)) {
11502 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11503 }
11504 arg9 = static_cast< PLFLT >(val9);
11505 ecode10 = SWIG_AsVal_double(args(8), &val10);
11506 if (!SWIG_IsOK(ecode10)) {
11507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11508 }
11509 arg10 = static_cast< PLFLT >(val10);
11510 ecode11 = SWIG_AsVal_int(args(9), &val11);
11511 if (!SWIG_IsOK(ecode11)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11513 }
11514 arg11 = static_cast< PLBOOL >(val11);
11515 ecode12 = SWIG_AsVal_int(args(10), &val12);
11516 if (!SWIG_IsOK(ecode12)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11518 }
11519 arg12 = static_cast< PLBOOL >(val12);
11520 ecode13 = SWIG_AsVal_int(args(11), &val13);
11521 if (!SWIG_IsOK(ecode13)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11523 }
11524 arg13 = static_cast< PLINT >(val13);
11525 ecode14 = SWIG_AsVal_int(args(12), &val14);
11526 if (!SWIG_IsOK(ecode14)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11528 }
11529 arg14 = static_cast< PLINT >(val14);
11530 {
11531 if ( _n_dims( args(13) ) > 1 )
11532 {
11533 error( "argument must be a scalar or vector" ); SWIG_fail;
11534 }
11535 Alen = (PLINT) ( _dim( args(13), 0 ) );
11536 temp15 = args(13).matrix_value();
11537 arg15 = new PLINT[Alen];
11538 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11539 }
11540 {
11541 if ( _n_dims( args(14) ) > 1 )
11542 {
11543 error( "argument must be a scalar or vector" ); SWIG_fail;
11544 }
11545 if ( _dim( args(14), 0 ) != Alen )
11546 {
11547 error( "argument vectors must be same length" ); SWIG_fail;
11548 }
11549 temp16 = args(14).matrix_value();
11550 arg16 = new PLINT[Alen];
11551 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11552 }
11553 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11554 if (!SWIG_IsOK(res17)) {
11555 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11556 }
11557 arg17 = reinterpret_cast< char * >(buf17);
11558 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11559 if (!SWIG_IsOK(res18)) {
11560 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11561 }
11562 arg18 = reinterpret_cast< char * >(buf18);
11563 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11564 if (!SWIG_IsOK(res19)) {
11565 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11566 }
11567 arg19 = reinterpret_cast< char * >(buf19);
11568 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11569 if (!SWIG_IsOK(res20)) {
11570 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11571 }
11572 arg20 = reinterpret_cast< char * >(buf20);
11573 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11574 if (!SWIG_IsOK(res21)) {
11575 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11576 }
11577 arg21 = reinterpret_cast< char * >(buf21);
11578 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11579 if (!SWIG_IsOK(res22)) {
11580 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11581 }
11582 arg22 = reinterpret_cast< char * >(buf22);
11583 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11584 if (!SWIG_IsOK(res23)) {
11585 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11586 }
11587 arg23 = reinterpret_cast< char * >(buf23);
11588 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);
11589 _outv = octave_value();
11590 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11591 if (SWIG_IsTmpObj(res1)) {
11592 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11593 } else {
11594 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11595 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11596 }
11597 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11598 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11599 {
11600 delete [] arg15;
11601 }
11602 {
11603 delete [] arg16;
11604 }
11605 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11606 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11607 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11608 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11609 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11610 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11611 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11612 return _out;
11613 fail:
11614 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11615 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11616 {
11617 delete [] arg15;
11618 }
11619 {
11620 delete [] arg16;
11621 }
11622 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11623 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11624 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11625 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11626 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11627 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11628 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11629 return octave_value_list();
11630 }
11631 catch(...) {
11632 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11633 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11634 {
11635 delete [] arg15;
11636 }
11637 {
11638 delete [] arg16;
11639 }
11640 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11641 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11642 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11643 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11644 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11645 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11646 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11647 throw;
11648 }
11649}
11650
11651
11653 PLFLT *arg1 = (PLFLT *) 0 ;
11654 PLINT arg2 ;
11655 PLINT arg3 ;
11656 PLINT arg4 ;
11657 PLINT arg5 ;
11658 PLINT arg6 ;
11659 PLINT arg7 ;
11660 PLFLT *arg8 = (PLFLT *) 0 ;
11661 PLINT arg9 ;
11662 PLFLT *arg10 = (PLFLT *) 0 ;
11663 Matrix temp1 ;
11664 int val4 ;
11665 int ecode4 = 0 ;
11666 int val5 ;
11667 int ecode5 = 0 ;
11668 int val6 ;
11669 int ecode6 = 0 ;
11670 int val7 ;
11671 int ecode7 = 0 ;
11672 Matrix temp8 ;
11673 Matrix temp10 ;
11674 octave_value_list _out;
11675 octave_value_list *_outp=&_out;
11676 octave_value _outv;
11677
11678 try {
11679 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11680 SWIG_fail;
11681 }
11682 {
11683 if ( _n_dims( args(0) ) > 2 )
11684 {
11685 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11686 }
11687 temp1 = args(0).matrix_value();
11688 arg1 = &temp1( 0, 0 );
11689 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11690 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11691 }
11692 ecode4 = SWIG_AsVal_int(args(1), &val4);
11693 if (!SWIG_IsOK(ecode4)) {
11694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11695 }
11696 arg4 = static_cast< PLINT >(val4);
11697 ecode5 = SWIG_AsVal_int(args(2), &val5);
11698 if (!SWIG_IsOK(ecode5)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11700 }
11701 arg5 = static_cast< PLINT >(val5);
11702 ecode6 = SWIG_AsVal_int(args(3), &val6);
11703 if (!SWIG_IsOK(ecode6)) {
11704 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11705 }
11706 arg6 = static_cast< PLINT >(val6);
11707 ecode7 = SWIG_AsVal_int(args(4), &val7);
11708 if (!SWIG_IsOK(ecode7)) {
11709 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11710 }
11711 arg7 = static_cast< PLINT >(val7);
11712 {
11713 if ( _n_dims( args(5) ) > 1 )
11714 {
11715 error( "argument must be a scalar or vector" ); SWIG_fail;
11716 }
11717 temp8 = args(5).matrix_value();
11718 arg8 = &temp8( 0, 0 );
11719 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11720 }
11721 {
11722 if ( _n_dims( args(6) ) > 1 )
11723 {
11724 error( "argument must be a scalar or vector" ); SWIG_fail;
11725 }
11726 if ( _dim( args(6), 0 ) != 6 )
11727 {
11728 error( "argument vectors must have length of 6" ); SWIG_fail;
11729 }
11730 temp10 = args(6).matrix_value();
11731 arg10 = &temp10( 0, 0 );
11732 }
11733 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11734 _outv = octave_value();
11735 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11736 {
11737
11738 }
11739 {
11740
11741 }
11742 {
11743
11744 }
11745 return _out;
11746 fail:
11747 {
11748
11749 }
11750 {
11751
11752 }
11753 {
11754
11755 }
11756 return octave_value_list();
11757 }
11758 catch(...) {
11759 {
11760
11761 }
11762 {
11763
11764 }
11765 {
11766
11767 }
11768 throw;
11769 }
11770}
11771
11772
11773SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11774 PLFLT *arg1 = (PLFLT *) 0 ;
11775 PLINT arg2 ;
11776 PLINT arg3 ;
11777 PLINT arg4 ;
11778 PLINT arg5 ;
11779 PLINT arg6 ;
11780 PLINT arg7 ;
11781 PLFLT *arg8 = (PLFLT *) 0 ;
11782 PLINT arg9 ;
11783 Matrix temp1 ;
11784 int val4 ;
11785 int ecode4 = 0 ;
11786 int val5 ;
11787 int ecode5 = 0 ;
11788 int val6 ;
11789 int ecode6 = 0 ;
11790 int val7 ;
11791 int ecode7 = 0 ;
11792 Matrix temp8 ;
11793 octave_value_list _out;
11794 octave_value_list *_outp=&_out;
11795 octave_value _outv;
11796
11797 try {
11798 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11799 SWIG_fail;
11800 }
11801 {
11802 if ( _n_dims( args(0) ) > 2 )
11803 {
11804 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11805 }
11806 temp1 = args(0).matrix_value();
11807 arg1 = &temp1( 0, 0 );
11808 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11809 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11810 }
11811 ecode4 = SWIG_AsVal_int(args(1), &val4);
11812 if (!SWIG_IsOK(ecode4)) {
11813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11814 }
11815 arg4 = static_cast< PLINT >(val4);
11816 ecode5 = SWIG_AsVal_int(args(2), &val5);
11817 if (!SWIG_IsOK(ecode5)) {
11818 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11819 }
11820 arg5 = static_cast< PLINT >(val5);
11821 ecode6 = SWIG_AsVal_int(args(3), &val6);
11822 if (!SWIG_IsOK(ecode6)) {
11823 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11824 }
11825 arg6 = static_cast< PLINT >(val6);
11826 ecode7 = SWIG_AsVal_int(args(4), &val7);
11827 if (!SWIG_IsOK(ecode7)) {
11828 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11829 }
11830 arg7 = static_cast< PLINT >(val7);
11831 {
11832 if ( _n_dims( args(5) ) > 1 )
11833 {
11834 error( "argument must be a scalar or vector" ); SWIG_fail;
11835 }
11836 temp8 = args(5).matrix_value();
11837 arg8 = &temp8( 0, 0 );
11838 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11839 }
11840 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11841 _outv = octave_value();
11842 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11843 {
11844
11845 }
11846 {
11847
11848 }
11849 return _out;
11850 fail:
11851 {
11852
11853 }
11854 {
11855
11856 }
11857 return octave_value_list();
11858 }
11859 catch(...) {
11860 {
11861
11862 }
11863 {
11864
11865 }
11866 throw;
11867 }
11868}
11869
11870
11871SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11872 PLFLT *arg1 = (PLFLT *) 0 ;
11873 PLINT arg2 ;
11874 PLINT arg3 ;
11875 PLINT arg4 ;
11876 PLINT arg5 ;
11877 PLINT arg6 ;
11878 PLINT arg7 ;
11879 PLFLT *arg8 = (PLFLT *) 0 ;
11880 PLINT arg9 ;
11881 PLFLT *arg10 = (PLFLT *) 0 ;
11882 PLFLT *arg11 = (PLFLT *) 0 ;
11883 Matrix temp1 ;
11884 int val4 ;
11885 int ecode4 = 0 ;
11886 int val5 ;
11887 int ecode5 = 0 ;
11888 int val6 ;
11889 int ecode6 = 0 ;
11890 int val7 ;
11891 int ecode7 = 0 ;
11892 Matrix temp8 ;
11893 Matrix temp10 ;
11894 Matrix temp11 ;
11895 octave_value_list _out;
11896 octave_value_list *_outp=&_out;
11897 octave_value _outv;
11898
11899 try {
11900 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11901 SWIG_fail;
11902 }
11903 {
11904 if ( _n_dims( args(0) ) > 2 )
11905 {
11906 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11907 }
11908 temp1 = args(0).matrix_value();
11909 arg1 = &temp1( 0, 0 );
11910 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11911 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11912 }
11913 ecode4 = SWIG_AsVal_int(args(1), &val4);
11914 if (!SWIG_IsOK(ecode4)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11916 }
11917 arg4 = static_cast< PLINT >(val4);
11918 ecode5 = SWIG_AsVal_int(args(2), &val5);
11919 if (!SWIG_IsOK(ecode5)) {
11920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11921 }
11922 arg5 = static_cast< PLINT >(val5);
11923 ecode6 = SWIG_AsVal_int(args(3), &val6);
11924 if (!SWIG_IsOK(ecode6)) {
11925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11926 }
11927 arg6 = static_cast< PLINT >(val6);
11928 ecode7 = SWIG_AsVal_int(args(4), &val7);
11929 if (!SWIG_IsOK(ecode7)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11931 }
11932 arg7 = static_cast< PLINT >(val7);
11933 {
11934 if ( _n_dims( args(5) ) > 1 )
11935 {
11936 error( "argument must be a scalar or vector" ); SWIG_fail;
11937 }
11938 temp8 = args(5).matrix_value();
11939 arg8 = &temp8( 0, 0 );
11940 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11941 }
11942 {
11943 if ( _n_dims( args(6) ) > 1 )
11944 {
11945 error( "argument must be a scalar or vector" ); SWIG_fail;
11946 }
11947 if ( _dim( args(6), 0 ) != Xlen )
11948 {
11949 error( "argument vectors must be same length" ); SWIG_fail;
11950 }
11951 temp10 = args(6).matrix_value();
11952 arg10 = &temp10( 0, 0 );
11953 }
11954 {
11955 if ( _n_dims( args(7) ) > 1 )
11956 {
11957 error( "argument must be a scalar or vector" ); SWIG_fail;
11958 }
11959 if ( _dim( args(7), 0 ) != Ylen )
11960 {
11961 error( "argument vectors must be same length" ); SWIG_fail;
11962 }
11963 temp11 = args(7).matrix_value();
11964 arg11 = &temp11( 0, 0 );
11965 }
11966 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11967 _outv = octave_value();
11968 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11969 {
11970
11971 }
11972 {
11973
11974 }
11975 {
11976
11977 }
11978 {
11979
11980 }
11981 return _out;
11982 fail:
11983 {
11984
11985 }
11986 {
11987
11988 }
11989 {
11990
11991 }
11992 {
11993
11994 }
11995 return octave_value_list();
11996 }
11997 catch(...) {
11998 {
11999
12000 }
12001 {
12002
12003 }
12004 {
12005
12006 }
12007 {
12008
12009 }
12010 throw;
12011 }
12012}
12013
12014
12015SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
12016 PLFLT *arg1 = (PLFLT *) 0 ;
12017 PLINT arg2 ;
12018 PLINT arg3 ;
12019 PLINT arg4 ;
12020 PLINT arg5 ;
12021 PLINT arg6 ;
12022 PLINT arg7 ;
12023 PLFLT *arg8 = (PLFLT *) 0 ;
12024 PLINT arg9 ;
12025 PLFLT *arg10 = (PLFLT *) 0 ;
12026 PLFLT *arg11 = (PLFLT *) 0 ;
12027 Matrix temp1 ;
12028 int val4 ;
12029 int ecode4 = 0 ;
12030 int val5 ;
12031 int ecode5 = 0 ;
12032 int val6 ;
12033 int ecode6 = 0 ;
12034 int val7 ;
12035 int ecode7 = 0 ;
12036 Matrix temp8 ;
12037 Matrix temp10 ;
12038 Matrix temp11 ;
12039 octave_value_list _out;
12040 octave_value_list *_outp=&_out;
12041 octave_value _outv;
12042
12043 try {
12044 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
12045 SWIG_fail;
12046 }
12047 {
12048 if ( _n_dims( args(0) ) > 2 )
12049 {
12050 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12051 }
12052 temp1 = args(0).matrix_value();
12053 arg1 = &temp1( 0, 0 );
12054 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12055 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12056 }
12057 ecode4 = SWIG_AsVal_int(args(1), &val4);
12058 if (!SWIG_IsOK(ecode4)) {
12059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
12060 }
12061 arg4 = static_cast< PLINT >(val4);
12062 ecode5 = SWIG_AsVal_int(args(2), &val5);
12063 if (!SWIG_IsOK(ecode5)) {
12064 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
12065 }
12066 arg5 = static_cast< PLINT >(val5);
12067 ecode6 = SWIG_AsVal_int(args(3), &val6);
12068 if (!SWIG_IsOK(ecode6)) {
12069 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
12070 }
12071 arg6 = static_cast< PLINT >(val6);
12072 ecode7 = SWIG_AsVal_int(args(4), &val7);
12073 if (!SWIG_IsOK(ecode7)) {
12074 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12075 }
12076 arg7 = static_cast< PLINT >(val7);
12077 {
12078 if ( _n_dims( args(5) ) > 1 )
12079 {
12080 error( "argument must be a scalar or vector" ); SWIG_fail;
12081 }
12082 temp8 = args(5).matrix_value();
12083 arg8 = &temp8( 0, 0 );
12084 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12085 }
12086 {
12087 if ( _n_dims( args(6) ) > 2 )
12088 {
12089 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12090 }
12091 if ( _dim( args(6), 0 ) != Xlen )
12092 {
12093 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12094 }
12095 if ( _dim( args(6), 1 ) != Ylen )
12096 {
12097 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12098 }
12099 temp10 = args(6).matrix_value();
12100 arg10 = &temp10( 0, 0 );
12101 }
12102 {
12103 if ( _n_dims( args(7) ) > 2 )
12104 {
12105 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12106 }
12107 if ( _dim( args(7), 0 ) != Xlen )
12108 {
12109 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12110 }
12111 if ( _dim( args(7), 1 ) != Ylen )
12112 {
12113 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12114 }
12115 temp11 = args(7).matrix_value();
12116 arg11 = &temp11( 0, 0 );
12117 }
12118 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12119 _outv = octave_value();
12120 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12121 {
12122
12123 }
12124 {
12125
12126 }
12127 {
12128
12129 }
12130 {
12131
12132 }
12133 return _out;
12134 fail:
12135 {
12136
12137 }
12138 {
12139
12140 }
12141 {
12142
12143 }
12144 {
12145
12146 }
12147 return octave_value_list();
12148 }
12149 catch(...) {
12150 {
12151
12152 }
12153 {
12154
12155 }
12156 {
12157
12158 }
12159 {
12160
12161 }
12162 throw;
12163 }
12164}
12165
12166
12167SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12168 PLFLT *arg1 = (PLFLT *) 0 ;
12169 PLINT arg2 ;
12170 PLINT arg3 ;
12171 PLINT arg4 ;
12172 PLINT arg5 ;
12173 PLINT arg6 ;
12174 PLINT arg7 ;
12175 PLFLT *arg8 = (PLFLT *) 0 ;
12176 PLINT arg9 ;
12177 PLFLT *arg10 = (PLFLT *) 0 ;
12178 PLFLT *arg11 = (PLFLT *) 0 ;
12179 Matrix temp1 ;
12180 int val4 ;
12181 int ecode4 = 0 ;
12182 int val5 ;
12183 int ecode5 = 0 ;
12184 int val6 ;
12185 int ecode6 = 0 ;
12186 int val7 ;
12187 int ecode7 = 0 ;
12188 Matrix temp8 ;
12189 Matrix temp10 ;
12190 Matrix temp11 ;
12191 octave_value_list _out;
12192 octave_value_list *_outp=&_out;
12193 octave_value _outv;
12194
12195 try {
12196 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12197 SWIG_fail;
12198 }
12199 {
12200 if ( _n_dims( args(0) ) > 2 )
12201 {
12202 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12203 }
12204 temp1 = args(0).matrix_value();
12205 arg1 = &temp1( 0, 0 );
12206 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12207 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12208 }
12209 ecode4 = SWIG_AsVal_int(args(1), &val4);
12210 if (!SWIG_IsOK(ecode4)) {
12211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12212 }
12213 arg4 = static_cast< PLINT >(val4);
12214 ecode5 = SWIG_AsVal_int(args(2), &val5);
12215 if (!SWIG_IsOK(ecode5)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12217 }
12218 arg5 = static_cast< PLINT >(val5);
12219 ecode6 = SWIG_AsVal_int(args(3), &val6);
12220 if (!SWIG_IsOK(ecode6)) {
12221 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12222 }
12223 arg6 = static_cast< PLINT >(val6);
12224 ecode7 = SWIG_AsVal_int(args(4), &val7);
12225 if (!SWIG_IsOK(ecode7)) {
12226 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12227 }
12228 arg7 = static_cast< PLINT >(val7);
12229 {
12230 if ( _n_dims( args(5) ) > 1 )
12231 {
12232 error( "argument must be a scalar or vector" ); SWIG_fail;
12233 }
12234 temp8 = args(5).matrix_value();
12235 arg8 = &temp8( 0, 0 );
12236 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12237 }
12238 {
12239 if ( _n_dims( args(6) ) > 2 )
12240 {
12241 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12242 }
12243 if ( _dim( args(6), 0 ) != Xlen )
12244 {
12245 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12246 }
12247 if ( _dim( args(6), 1 ) != Ylen )
12248 {
12249 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12250 }
12251 temp10 = args(6).matrix_value();
12252 arg10 = &temp10( 0, 0 );
12253 }
12254 {
12255 if ( _n_dims( args(7) ) > 2 )
12256 {
12257 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12258 }
12259 if ( _dim( args(7), 0 ) != Xlen )
12260 {
12261 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12262 }
12263 if ( _dim( args(7), 1 ) != Ylen )
12264 {
12265 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12266 }
12267 temp11 = args(7).matrix_value();
12268 arg11 = &temp11( 0, 0 );
12269 }
12270 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12271 _outv = octave_value();
12272 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12273 {
12274
12275 }
12276 {
12277
12278 }
12279 {
12280
12281 }
12282 {
12283
12284 }
12285 return _out;
12286 fail:
12287 {
12288
12289 }
12290 {
12291
12292 }
12293 {
12294
12295 }
12296 {
12297
12298 }
12299 return octave_value_list();
12300 }
12301 catch(...) {
12302 {
12303
12304 }
12305 {
12306
12307 }
12308 {
12309
12310 }
12311 {
12312
12313 }
12314 throw;
12315 }
12316}
12317
12318
12319SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12320 PLFLT *arg1 = (PLFLT *) 0 ;
12321 PLFLT *arg2 = (PLFLT *) 0 ;
12322 PLFLT *arg3 = (PLFLT *) 0 ;
12323 PLINT arg4 ;
12324 PLFLT *arg5 = (PLFLT *) 0 ;
12325 PLINT arg6 ;
12326 PLFLT *arg7 = (PLFLT *) 0 ;
12327 PLINT arg8 ;
12328 PLFLT *arg9 = (PLFLT *) 0 ;
12329 PLINT arg10 ;
12330 PLFLT arg11 ;
12331 Matrix temp1 ;
12332 Matrix temp2 ;
12333 Matrix temp3 ;
12334 Matrix temp5 ;
12335 Matrix temp7 ;
12336 octave_value_list retval7 ;
12337 int val10 ;
12338 int ecode10 = 0 ;
12339 double val11 ;
12340 int ecode11 = 0 ;
12341 octave_value_list _out;
12342 octave_value_list *_outp=&_out;
12343 octave_value _outv;
12344
12345 try {
12346 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12347 SWIG_fail;
12348 }
12349 {
12350 if ( _n_dims( args(0) ) > 1 )
12351 {
12352 error( "argument must be a scalar or vector" ); SWIG_fail;
12353 }
12354 Alen = (PLINT) ( _dim( args(0), 0 ) );
12355 temp1 = args(0).matrix_value();
12356 arg1 = &temp1( 0, 0 );
12357 }
12358 {
12359 if ( _n_dims( args(1) ) > 1 )
12360 {
12361 error( "argument must be a scalar or vector" ); SWIG_fail;
12362 }
12363 if ( _dim( args(1), 0 ) != Alen )
12364 {
12365 error( "argument vectors must be same length" ); SWIG_fail;
12366 }
12367 temp2 = args(1).matrix_value();
12368 arg2 = &temp2( 0, 0 );
12369 }
12370 {
12371 if ( _n_dims( args(2) ) > 1 )
12372 {
12373 error( "argument must be a scalar or vector" ); SWIG_fail;
12374 }
12375 if ( _dim( args(2), 0 ) != Alen )
12376 {
12377 error( "argument vectors must be same length" ); SWIG_fail;
12378 }
12379 temp3 = args(2).matrix_value();
12380 arg3 = &temp3( 0, 0 );
12381 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12382 }
12383 {
12384 if ( _n_dims( args(3) ) > 1 )
12385 {
12386 error( "argument must be a scalar or vector" ); SWIG_fail;
12387 }
12388 temp5 = args(3).matrix_value();
12389 arg5 = &temp5( 0, 0 );
12390 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12391 }
12392 {
12393 if ( _n_dims( args(4) ) > 1 )
12394 {
12395 error( "argument must be a scalar or vector" ); SWIG_fail;
12396 }
12397 temp7 = args(4).matrix_value();
12398 arg7 = &temp7( 0, 0 );
12399 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12400 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12401 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12402 }
12403 ecode10 = SWIG_AsVal_int(args(5), &val10);
12404 if (!SWIG_IsOK(ecode10)) {
12405 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12406 }
12407 arg10 = static_cast< PLINT >(val10);
12408 ecode11 = SWIG_AsVal_double(args(6), &val11);
12409 if (!SWIG_IsOK(ecode11)) {
12410 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12411 }
12412 arg11 = static_cast< PLFLT >(val11);
12413 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12414 _outv = octave_value();
12415 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12416 {
12417 _outp = SWIG_Octave_AppendOutput(_outp, retval7( 0 ));
12418 }
12419 {
12420
12421 }
12422 {
12423
12424 }
12425 {
12426
12427 }
12428 {
12429
12430 }
12431 {
12432
12433 }
12434 return _out;
12435 fail:
12436 {
12437
12438 }
12439 {
12440
12441 }
12442 {
12443
12444 }
12445 {
12446
12447 }
12448 {
12449
12450 }
12451 return octave_value_list();
12452 }
12453 catch(...) {
12454 {
12455
12456 }
12457 {
12458
12459 }
12460 {
12461
12462 }
12463 {
12464
12465 }
12466 {
12467
12468 }
12469 throw;
12470 }
12471}
12472
12473
12475 PLFLT *arg1 = (PLFLT *) 0 ;
12476 PLFLT *arg2 = (PLFLT *) 0 ;
12477 PLFLT *arg3 = (PLFLT *) 0 ;
12478 PLINT arg4 ;
12479 PLINT arg5 ;
12480 PLINT arg6 ;
12481 Matrix temp1 ;
12482 Matrix temp2 ;
12483 Matrix temp3 ;
12484 int val6 ;
12485 int ecode6 = 0 ;
12486 octave_value_list _out;
12487 octave_value_list *_outp=&_out;
12488 octave_value _outv;
12489
12490 try {
12491 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12492 SWIG_fail;
12493 }
12494 {
12495 if ( _n_dims( args(0) ) > 1 )
12496 {
12497 error( "argument must be a scalar or vector" ); SWIG_fail;
12498 }
12499 temp1 = args(0).matrix_value();
12500 arg1 = &temp1( 0, 0 );
12501 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12502 }
12503 {
12504 if ( _n_dims( args(1) ) > 1 )
12505 {
12506 error( "argument must be a scalar or vector" ); SWIG_fail;
12507 }
12508 temp2 = args(1).matrix_value();
12509 arg2 = &temp2( 0, 0 );
12510 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12511 }
12512 {
12513 if ( _n_dims( args(2) ) > 2 )
12514 {
12515 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12516 }
12517 if ( _dim( args(2), 0 ) != Xlen )
12518 {
12519 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12520 }
12521 if ( _dim( args(2), 1 ) != Ylen )
12522 {
12523 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12524 }
12525 temp3 = args(2).matrix_value();
12526 arg3 = &temp3( 0, 0 );
12527 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12528 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12529 }
12530 ecode6 = SWIG_AsVal_int(args(3), &val6);
12531 if (!SWIG_IsOK(ecode6)) {
12532 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12533 }
12534 arg6 = static_cast< PLINT >(val6);
12535 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12536 _outv = octave_value();
12537 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12538 {
12539
12540 }
12541 {
12542
12543 }
12544 {
12545
12546 }
12547 return _out;
12548 fail:
12549 {
12550
12551 }
12552 {
12553
12554 }
12555 {
12556
12557 }
12558 return octave_value_list();
12559 }
12560 catch(...) {
12561 {
12562
12563 }
12564 {
12565
12566 }
12567 {
12568
12569 }
12570 throw;
12571 }
12572}
12573
12574
12576 PLFLT *arg1 = (PLFLT *) 0 ;
12577 PLFLT *arg2 = (PLFLT *) 0 ;
12578 PLFLT *arg3 = (PLFLT *) 0 ;
12579 PLINT arg4 ;
12580 PLINT arg5 ;
12581 PLINT arg6 ;
12582 PLFLT *arg7 = (PLFLT *) 0 ;
12583 PLINT arg8 ;
12584 Matrix temp1 ;
12585 Matrix temp2 ;
12586 Matrix temp3 ;
12587 int val6 ;
12588 int ecode6 = 0 ;
12589 Matrix temp7 ;
12590 octave_value_list _out;
12591 octave_value_list *_outp=&_out;
12592 octave_value _outv;
12593
12594 try {
12595 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12596 SWIG_fail;
12597 }
12598 {
12599 if ( _n_dims( args(0) ) > 1 )
12600 {
12601 error( "argument must be a scalar or vector" ); SWIG_fail;
12602 }
12603 temp1 = args(0).matrix_value();
12604 arg1 = &temp1( 0, 0 );
12605 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12606 }
12607 {
12608 if ( _n_dims( args(1) ) > 1 )
12609 {
12610 error( "argument must be a scalar or vector" ); SWIG_fail;
12611 }
12612 temp2 = args(1).matrix_value();
12613 arg2 = &temp2( 0, 0 );
12614 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12615 }
12616 {
12617 if ( _n_dims( args(2) ) > 2 )
12618 {
12619 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12620 }
12621 if ( _dim( args(2), 0 ) != Xlen )
12622 {
12623 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12624 }
12625 if ( _dim( args(2), 1 ) != Ylen )
12626 {
12627 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12628 }
12629 temp3 = args(2).matrix_value();
12630 arg3 = &temp3( 0, 0 );
12631 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12632 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12633 }
12634 ecode6 = SWIG_AsVal_int(args(3), &val6);
12635 if (!SWIG_IsOK(ecode6)) {
12636 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12637 }
12638 arg6 = static_cast< PLINT >(val6);
12639 {
12640 if ( _n_dims( args(4) ) > 1 )
12641 {
12642 error( "argument must be a scalar or vector" ); SWIG_fail;
12643 }
12644 temp7 = args(4).matrix_value();
12645 arg7 = &temp7( 0, 0 );
12646 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12647 }
12648 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12649 _outv = octave_value();
12650 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12651 {
12652
12653 }
12654 {
12655
12656 }
12657 {
12658
12659 }
12660 {
12661
12662 }
12663 return _out;
12664 fail:
12665 {
12666
12667 }
12668 {
12669
12670 }
12671 {
12672
12673 }
12674 {
12675
12676 }
12677 return octave_value_list();
12678 }
12679 catch(...) {
12680 {
12681
12682 }
12683 {
12684
12685 }
12686 {
12687
12688 }
12689 {
12690
12691 }
12692 throw;
12693 }
12694}
12695
12696
12698 PLFLT *arg1 = (PLFLT *) 0 ;
12699 PLFLT *arg2 = (PLFLT *) 0 ;
12700 PLFLT *arg3 = (PLFLT *) 0 ;
12701 PLINT arg4 ;
12702 PLINT arg5 ;
12703 PLINT arg6 ;
12704 PLBOOL arg7 ;
12705 Matrix temp1 ;
12706 Matrix temp2 ;
12707 Matrix temp3 ;
12708 int val6 ;
12709 int ecode6 = 0 ;
12710 int val7 ;
12711 int ecode7 = 0 ;
12712 octave_value_list _out;
12713 octave_value_list *_outp=&_out;
12714 octave_value _outv;
12715
12716 try {
12717 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12718 SWIG_fail;
12719 }
12720 {
12721 if ( _n_dims( args(0) ) > 1 )
12722 {
12723 error( "argument must be a scalar or vector" ); SWIG_fail;
12724 }
12725 temp1 = args(0).matrix_value();
12726 arg1 = &temp1( 0, 0 );
12727 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12728 }
12729 {
12730 if ( _n_dims( args(1) ) > 1 )
12731 {
12732 error( "argument must be a scalar or vector" ); SWIG_fail;
12733 }
12734 temp2 = args(1).matrix_value();
12735 arg2 = &temp2( 0, 0 );
12736 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12737 }
12738 {
12739 if ( _n_dims( args(2) ) > 2 )
12740 {
12741 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12742 }
12743 if ( _dim( args(2), 0 ) != Xlen )
12744 {
12745 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12746 }
12747 if ( _dim( args(2), 1 ) != Ylen )
12748 {
12749 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12750 }
12751 temp3 = args(2).matrix_value();
12752 arg3 = &temp3( 0, 0 );
12753 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12754 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12755 }
12756 ecode6 = SWIG_AsVal_int(args(3), &val6);
12757 if (!SWIG_IsOK(ecode6)) {
12758 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12759 }
12760 arg6 = static_cast< PLINT >(val6);
12761 ecode7 = SWIG_AsVal_int(args(4), &val7);
12762 if (!SWIG_IsOK(ecode7)) {
12763 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12764 }
12765 arg7 = static_cast< PLBOOL >(val7);
12766 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12767 _outv = octave_value();
12768 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12769 {
12770
12771 }
12772 {
12773
12774 }
12775 {
12776
12777 }
12778 return _out;
12779 fail:
12780 {
12781
12782 }
12783 {
12784
12785 }
12786 {
12787
12788 }
12789 return octave_value_list();
12790 }
12791 catch(...) {
12792 {
12793
12794 }
12795 {
12796
12797 }
12798 {
12799
12800 }
12801 throw;
12802 }
12803}
12804
12805
12807 PLFLT *arg1 = (PLFLT *) 0 ;
12808 PLFLT *arg2 = (PLFLT *) 0 ;
12809 PLFLT *arg3 = (PLFLT *) 0 ;
12810 PLINT arg4 ;
12811 PLINT arg5 ;
12812 PLINT arg6 ;
12813 PLFLT *arg7 = (PLFLT *) 0 ;
12814 PLINT arg8 ;
12815 Matrix temp1 ;
12816 Matrix temp2 ;
12817 Matrix temp3 ;
12818 int val6 ;
12819 int ecode6 = 0 ;
12820 Matrix temp7 ;
12821 octave_value_list _out;
12822 octave_value_list *_outp=&_out;
12823 octave_value _outv;
12824
12825 try {
12826 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12827 SWIG_fail;
12828 }
12829 {
12830 if ( _n_dims( args(0) ) > 1 )
12831 {
12832 error( "argument must be a scalar or vector" ); SWIG_fail;
12833 }
12834 temp1 = args(0).matrix_value();
12835 arg1 = &temp1( 0, 0 );
12836 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12837 }
12838 {
12839 if ( _n_dims( args(1) ) > 1 )
12840 {
12841 error( "argument must be a scalar or vector" ); SWIG_fail;
12842 }
12843 temp2 = args(1).matrix_value();
12844 arg2 = &temp2( 0, 0 );
12845 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12846 }
12847 {
12848 if ( _n_dims( args(2) ) > 2 )
12849 {
12850 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12851 }
12852 if ( _dim( args(2), 0 ) != Xlen )
12853 {
12854 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12855 }
12856 if ( _dim( args(2), 1 ) != Ylen )
12857 {
12858 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12859 }
12860 temp3 = args(2).matrix_value();
12861 arg3 = &temp3( 0, 0 );
12862 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12863 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12864 }
12865 ecode6 = SWIG_AsVal_int(args(3), &val6);
12866 if (!SWIG_IsOK(ecode6)) {
12867 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12868 }
12869 arg6 = static_cast< PLINT >(val6);
12870 {
12871 if ( _n_dims( args(4) ) > 1 )
12872 {
12873 error( "argument must be a scalar or vector" ); SWIG_fail;
12874 }
12875 temp7 = args(4).matrix_value();
12876 arg7 = &temp7( 0, 0 );
12877 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12878 }
12879 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12880 _outv = octave_value();
12881 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12882 {
12883
12884 }
12885 {
12886
12887 }
12888 {
12889
12890 }
12891 {
12892
12893 }
12894 return _out;
12895 fail:
12896 {
12897
12898 }
12899 {
12900
12901 }
12902 {
12903
12904 }
12905 {
12906
12907 }
12908 return octave_value_list();
12909 }
12910 catch(...) {
12911 {
12912
12913 }
12914 {
12915
12916 }
12917 {
12918
12919 }
12920 {
12921
12922 }
12923 throw;
12924 }
12925}
12926
12927
12929 PLFLT *arg1 = (PLFLT *) 0 ;
12930 PLFLT *arg2 = (PLFLT *) 0 ;
12931 PLFLT *arg3 = (PLFLT *) 0 ;
12932 PLINT arg4 ;
12933 PLINT arg5 ;
12934 PLINT arg6 ;
12935 PLFLT *arg7 = (PLFLT *) 0 ;
12936 PLINT arg8 ;
12937 PLINT arg9 ;
12938 PLINT arg10 ;
12939 PLINT *arg11 = (PLINT *) 0 ;
12940 PLINT *arg12 = (PLINT *) 0 ;
12941 Matrix temp1 ;
12942 Matrix temp2 ;
12943 Matrix temp3 ;
12944 int val6 ;
12945 int ecode6 = 0 ;
12946 Matrix temp7 ;
12947 int val9 ;
12948 int ecode9 = 0 ;
12949 Matrix temp10 ;
12950 Matrix temp12 ;
12951 octave_value_list _out;
12952 octave_value_list *_outp=&_out;
12953 octave_value _outv;
12954
12955 try {
12956 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12957 SWIG_fail;
12958 }
12959 {
12960 if ( _n_dims( args(0) ) > 1 )
12961 {
12962 error( "argument must be a scalar or vector" ); SWIG_fail;
12963 }
12964 temp1 = args(0).matrix_value();
12965 arg1 = &temp1( 0, 0 );
12966 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12967 }
12968 {
12969 if ( _n_dims( args(1) ) > 1 )
12970 {
12971 error( "argument must be a scalar or vector" ); SWIG_fail;
12972 }
12973 temp2 = args(1).matrix_value();
12974 arg2 = &temp2( 0, 0 );
12975 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12976 }
12977 {
12978 if ( _n_dims( args(2) ) > 2 )
12979 {
12980 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12981 }
12982 if ( _dim( args(2), 0 ) != Xlen )
12983 {
12984 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12985 }
12986 if ( _dim( args(2), 1 ) != Ylen )
12987 {
12988 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12989 }
12990 temp3 = args(2).matrix_value();
12991 arg3 = &temp3( 0, 0 );
12992 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12993 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12994 }
12995 ecode6 = SWIG_AsVal_int(args(3), &val6);
12996 if (!SWIG_IsOK(ecode6)) {
12997 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12998 }
12999 arg6 = static_cast< PLINT >(val6);
13000 {
13001 if ( _n_dims( args(4) ) > 1 )
13002 {
13003 error( "argument must be a scalar or vector" ); SWIG_fail;
13004 }
13005 temp7 = args(4).matrix_value();
13006 arg7 = &temp7( 0, 0 );
13007 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13008 }
13009 ecode9 = SWIG_AsVal_int(args(5), &val9);
13010 if (!SWIG_IsOK(ecode9)) {
13011 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
13012 }
13013 arg9 = static_cast< PLINT >(val9);
13014 {
13015 if ( _n_dims( args(6) ) > 1 )
13016 {
13017 error( "argument must be a scalar or vector" ); SWIG_fail;
13018 }
13019 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13020 arg11 = new PLINT[Alen];
13021 temp10 = args(6).matrix_value();
13022 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13023 }
13024 {
13025 if ( _n_dims( args(7) ) > 1 )
13026 {
13027 error( "argument must be a scalar or vector" ); SWIG_fail;
13028 }
13029 if ( _dim( args(7), 0 ) != Alen )
13030 {
13031 error( "argument vectors must be same length" ); SWIG_fail;
13032 }
13033 temp12 = args(7).matrix_value();
13034 arg12 = new PLINT[Alen];
13035 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13036 }
13037 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);
13038 _outv = octave_value();
13039 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13040 {
13041
13042 }
13043 {
13044
13045 }
13046 {
13047
13048 }
13049 {
13050
13051 }
13052 {
13053 delete [] arg11;
13054 }
13055 {
13056 delete [] arg12;
13057 }
13058 return _out;
13059 fail:
13060 {
13061
13062 }
13063 {
13064
13065 }
13066 {
13067
13068 }
13069 {
13070
13071 }
13072 {
13073 delete [] arg11;
13074 }
13075 {
13076 delete [] arg12;
13077 }
13078 return octave_value_list();
13079 }
13080 catch(...) {
13081 {
13082
13083 }
13084 {
13085
13086 }
13087 {
13088
13089 }
13090 {
13091
13092 }
13093 {
13094 delete [] arg11;
13095 }
13096 {
13097 delete [] arg12;
13098 }
13099 throw;
13100 }
13101}
13102
13103
13105 PLFLT *arg1 = (PLFLT *) 0 ;
13106 PLFLT *arg2 = (PLFLT *) 0 ;
13107 PLFLT *arg3 = (PLFLT *) 0 ;
13108 PLINT arg4 ;
13109 PLINT arg5 ;
13110 PLINT arg6 ;
13111 PLFLT *arg7 = (PLFLT *) 0 ;
13112 PLINT arg8 ;
13113 Matrix temp1 ;
13114 Matrix temp2 ;
13115 Matrix temp3 ;
13116 int val6 ;
13117 int ecode6 = 0 ;
13118 Matrix temp7 ;
13119 octave_value_list _out;
13120 octave_value_list *_outp=&_out;
13121 octave_value _outv;
13122
13123 try {
13124 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13125 SWIG_fail;
13126 }
13127 {
13128 if ( _n_dims( args(0) ) > 1 )
13129 {
13130 error( "argument must be a scalar or vector" ); SWIG_fail;
13131 }
13132 temp1 = args(0).matrix_value();
13133 arg1 = &temp1( 0, 0 );
13134 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13135 }
13136 {
13137 if ( _n_dims( args(1) ) > 1 )
13138 {
13139 error( "argument must be a scalar or vector" ); SWIG_fail;
13140 }
13141 temp2 = args(1).matrix_value();
13142 arg2 = &temp2( 0, 0 );
13143 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13144 }
13145 {
13146 if ( _n_dims( args(2) ) > 2 )
13147 {
13148 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13149 }
13150 if ( _dim( args(2), 0 ) != Xlen )
13151 {
13152 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13153 }
13154 if ( _dim( args(2), 1 ) != Ylen )
13155 {
13156 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13157 }
13158 temp3 = args(2).matrix_value();
13159 arg3 = &temp3( 0, 0 );
13160 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13161 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13162 }
13163 ecode6 = SWIG_AsVal_int(args(3), &val6);
13164 if (!SWIG_IsOK(ecode6)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13166 }
13167 arg6 = static_cast< PLINT >(val6);
13168 {
13169 if ( _n_dims( args(4) ) > 1 )
13170 {
13171 error( "argument must be a scalar or vector" ); SWIG_fail;
13172 }
13173 temp7 = args(4).matrix_value();
13174 arg7 = &temp7( 0, 0 );
13175 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13176 }
13177 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13178 _outv = octave_value();
13179 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13180 {
13181
13182 }
13183 {
13184
13185 }
13186 {
13187
13188 }
13189 {
13190
13191 }
13192 return _out;
13193 fail:
13194 {
13195
13196 }
13197 {
13198
13199 }
13200 {
13201
13202 }
13203 {
13204
13205 }
13206 return octave_value_list();
13207 }
13208 catch(...) {
13209 {
13210
13211 }
13212 {
13213
13214 }
13215 {
13216
13217 }
13218 {
13219
13220 }
13221 throw;
13222 }
13223}
13224
13225
13227 PLFLT *arg1 = (PLFLT *) 0 ;
13228 PLFLT *arg2 = (PLFLT *) 0 ;
13229 PLFLT *arg3 = (PLFLT *) 0 ;
13230 PLINT arg4 ;
13231 PLINT arg5 ;
13232 PLINT arg6 ;
13233 PLFLT *arg7 = (PLFLT *) 0 ;
13234 PLINT arg8 ;
13235 PLINT arg9 ;
13236 PLINT arg10 ;
13237 PLINT *arg11 = (PLINT *) 0 ;
13238 PLINT *arg12 = (PLINT *) 0 ;
13239 Matrix temp1 ;
13240 Matrix temp2 ;
13241 Matrix temp3 ;
13242 int val6 ;
13243 int ecode6 = 0 ;
13244 Matrix temp7 ;
13245 int val9 ;
13246 int ecode9 = 0 ;
13247 Matrix temp10 ;
13248 Matrix temp12 ;
13249 octave_value_list _out;
13250 octave_value_list *_outp=&_out;
13251 octave_value _outv;
13252
13253 try {
13254 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13255 SWIG_fail;
13256 }
13257 {
13258 if ( _n_dims( args(0) ) > 1 )
13259 {
13260 error( "argument must be a scalar or vector" ); SWIG_fail;
13261 }
13262 temp1 = args(0).matrix_value();
13263 arg1 = &temp1( 0, 0 );
13264 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13265 }
13266 {
13267 if ( _n_dims( args(1) ) > 1 )
13268 {
13269 error( "argument must be a scalar or vector" ); SWIG_fail;
13270 }
13271 temp2 = args(1).matrix_value();
13272 arg2 = &temp2( 0, 0 );
13273 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13274 }
13275 {
13276 if ( _n_dims( args(2) ) > 2 )
13277 {
13278 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13279 }
13280 if ( _dim( args(2), 0 ) != Xlen )
13281 {
13282 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13283 }
13284 if ( _dim( args(2), 1 ) != Ylen )
13285 {
13286 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13287 }
13288 temp3 = args(2).matrix_value();
13289 arg3 = &temp3( 0, 0 );
13290 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13291 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13292 }
13293 ecode6 = SWIG_AsVal_int(args(3), &val6);
13294 if (!SWIG_IsOK(ecode6)) {
13295 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13296 }
13297 arg6 = static_cast< PLINT >(val6);
13298 {
13299 if ( _n_dims( args(4) ) > 1 )
13300 {
13301 error( "argument must be a scalar or vector" ); SWIG_fail;
13302 }
13303 temp7 = args(4).matrix_value();
13304 arg7 = &temp7( 0, 0 );
13305 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13306 }
13307 ecode9 = SWIG_AsVal_int(args(5), &val9);
13308 if (!SWIG_IsOK(ecode9)) {
13309 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13310 }
13311 arg9 = static_cast< PLINT >(val9);
13312 {
13313 if ( _n_dims( args(6) ) > 1 )
13314 {
13315 error( "argument must be a scalar or vector" ); SWIG_fail;
13316 }
13317 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13318 arg11 = new PLINT[Alen];
13319 temp10 = args(6).matrix_value();
13320 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13321 }
13322 {
13323 if ( _n_dims( args(7) ) > 1 )
13324 {
13325 error( "argument must be a scalar or vector" ); SWIG_fail;
13326 }
13327 if ( _dim( args(7), 0 ) != Alen )
13328 {
13329 error( "argument vectors must be same length" ); SWIG_fail;
13330 }
13331 temp12 = args(7).matrix_value();
13332 arg12 = new PLINT[Alen];
13333 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13334 }
13335 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);
13336 _outv = octave_value();
13337 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13338 {
13339
13340 }
13341 {
13342
13343 }
13344 {
13345
13346 }
13347 {
13348
13349 }
13350 {
13351 delete [] arg11;
13352 }
13353 {
13354 delete [] arg12;
13355 }
13356 return _out;
13357 fail:
13358 {
13359
13360 }
13361 {
13362
13363 }
13364 {
13365
13366 }
13367 {
13368
13369 }
13370 {
13371 delete [] arg11;
13372 }
13373 {
13374 delete [] arg12;
13375 }
13376 return octave_value_list();
13377 }
13378 catch(...) {
13379 {
13380
13381 }
13382 {
13383
13384 }
13385 {
13386
13387 }
13388 {
13389
13390 }
13391 {
13392 delete [] arg11;
13393 }
13394 {
13395 delete [] arg12;
13396 }
13397 throw;
13398 }
13399}
13400
13401
13403 PLFLT *arg1 = (PLFLT *) 0 ;
13404 PLINT arg2 ;
13405 PLINT arg3 ;
13406 PLFLT *arg4 = (PLFLT *) 0 ;
13407 PLFLT arg5 ;
13408 PLFLT arg6 ;
13409 PLFLT arg7 ;
13410 PLFLT arg8 ;
13411 PLFLT arg9 ;
13412 PLFLT arg10 ;
13413 PLINT arg11 ;
13414 PLFLT arg12 ;
13415 PLINT arg13 ;
13416 PLINT arg14 ;
13417 PLINT arg15 ;
13418 PLINT arg16 ;
13419 PLINT arg17 ;
13420 PLBOOL arg18 ;
13421 PLFLT *arg19 = (PLFLT *) 0 ;
13422 Matrix temp1 ;
13423 Matrix temp4 ;
13424 double val5 ;
13425 int ecode5 = 0 ;
13426 double val6 ;
13427 int ecode6 = 0 ;
13428 double val7 ;
13429 int ecode7 = 0 ;
13430 double val8 ;
13431 int ecode8 = 0 ;
13432 double val9 ;
13433 int ecode9 = 0 ;
13434 double val10 ;
13435 int ecode10 = 0 ;
13436 int val11 ;
13437 int ecode11 = 0 ;
13438 double val12 ;
13439 int ecode12 = 0 ;
13440 int val13 ;
13441 int ecode13 = 0 ;
13442 int val14 ;
13443 int ecode14 = 0 ;
13444 int val15 ;
13445 int ecode15 = 0 ;
13446 int val16 ;
13447 int ecode16 = 0 ;
13448 int val17 ;
13449 int ecode17 = 0 ;
13450 int val18 ;
13451 int ecode18 = 0 ;
13452 Matrix temp19 ;
13453 octave_value_list _out;
13454 octave_value_list *_outp=&_out;
13455 octave_value _outv;
13456
13457 try {
13458 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13459 SWIG_fail;
13460 }
13461 {
13462 if ( _n_dims( args(0) ) > 2 )
13463 {
13464 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13465 }
13466 temp1 = args(0).matrix_value();
13467 arg1 = &temp1( 0, 0 );
13468 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13469 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13470 }
13471 {
13472 if ( _n_dims( args(1) ) > 1 )
13473 {
13474 error( "argument must be a scalar or vector" ); SWIG_fail;
13475 }
13476 Alen = (PLINT) ( _dim( args(1), 0 ) );
13477 temp4 = args(1).matrix_value();
13478 arg4 = &temp4( 0, 0 );
13479 }
13480 ecode5 = SWIG_AsVal_double(args(2), &val5);
13481 if (!SWIG_IsOK(ecode5)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13483 }
13484 arg5 = static_cast< PLFLT >(val5);
13485 ecode6 = SWIG_AsVal_double(args(3), &val6);
13486 if (!SWIG_IsOK(ecode6)) {
13487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13488 }
13489 arg6 = static_cast< PLFLT >(val6);
13490 ecode7 = SWIG_AsVal_double(args(4), &val7);
13491 if (!SWIG_IsOK(ecode7)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13493 }
13494 arg7 = static_cast< PLFLT >(val7);
13495 ecode8 = SWIG_AsVal_double(args(5), &val8);
13496 if (!SWIG_IsOK(ecode8)) {
13497 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13498 }
13499 arg8 = static_cast< PLFLT >(val8);
13500 ecode9 = SWIG_AsVal_double(args(6), &val9);
13501 if (!SWIG_IsOK(ecode9)) {
13502 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13503 }
13504 arg9 = static_cast< PLFLT >(val9);
13505 ecode10 = SWIG_AsVal_double(args(7), &val10);
13506 if (!SWIG_IsOK(ecode10)) {
13507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13508 }
13509 arg10 = static_cast< PLFLT >(val10);
13510 ecode11 = SWIG_AsVal_int(args(8), &val11);
13511 if (!SWIG_IsOK(ecode11)) {
13512 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13513 }
13514 arg11 = static_cast< PLINT >(val11);
13515 ecode12 = SWIG_AsVal_double(args(9), &val12);
13516 if (!SWIG_IsOK(ecode12)) {
13517 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13518 }
13519 arg12 = static_cast< PLFLT >(val12);
13520 ecode13 = SWIG_AsVal_int(args(10), &val13);
13521 if (!SWIG_IsOK(ecode13)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13523 }
13524 arg13 = static_cast< PLINT >(val13);
13525 ecode14 = SWIG_AsVal_int(args(11), &val14);
13526 if (!SWIG_IsOK(ecode14)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13528 }
13529 arg14 = static_cast< PLINT >(val14);
13530 ecode15 = SWIG_AsVal_int(args(12), &val15);
13531 if (!SWIG_IsOK(ecode15)) {
13532 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13533 }
13534 arg15 = static_cast< PLINT >(val15);
13535 ecode16 = SWIG_AsVal_int(args(13), &val16);
13536 if (!SWIG_IsOK(ecode16)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13538 }
13539 arg16 = static_cast< PLINT >(val16);
13540 ecode17 = SWIG_AsVal_int(args(14), &val17);
13541 if (!SWIG_IsOK(ecode17)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13543 }
13544 arg17 = static_cast< PLINT >(val17);
13545 ecode18 = SWIG_AsVal_int(args(15), &val18);
13546 if (!SWIG_IsOK(ecode18)) {
13547 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13548 }
13549 arg18 = static_cast< PLBOOL >(val18);
13550 {
13551 if ( _n_dims( args(16) ) > 1 )
13552 {
13553 error( "argument must be a scalar or vector" ); SWIG_fail;
13554 }
13555 if ( _dim( args(16), 0 ) != 6 )
13556 {
13557 error( "argument vectors must have length of 6" ); SWIG_fail;
13558 }
13559 temp19 = args(16).matrix_value();
13560 arg19 = &temp19( 0, 0 );
13561 }
13562 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);
13563 _outv = octave_value();
13564 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13565 {
13566
13567 }
13568 {
13569
13570 }
13571 {
13572
13573 }
13574 return _out;
13575 fail:
13576 {
13577
13578 }
13579 {
13580
13581 }
13582 {
13583
13584 }
13585 return octave_value_list();
13586 }
13587 catch(...) {
13588 {
13589
13590 }
13591 {
13592
13593 }
13594 {
13595
13596 }
13597 throw;
13598 }
13599}
13600
13601
13602SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13603 PLFLT *arg1 = (PLFLT *) 0 ;
13604 PLINT arg2 ;
13605 PLINT arg3 ;
13606 char *arg4 = (char *) 0 ;
13607 PLFLT arg5 ;
13608 PLFLT arg6 ;
13609 PLFLT arg7 ;
13610 PLFLT arg8 ;
13611 PLFLT arg9 ;
13612 PLFLT arg10 ;
13613 PLINT arg11 ;
13614 PLFLT arg12 ;
13615 PLINT arg13 ;
13616 PLINT arg14 ;
13617 PLINT arg15 ;
13618 PLINT arg16 ;
13619 PLINT arg17 ;
13620 PLBOOL arg18 ;
13621 PLFLT *arg19 = (PLFLT *) 0 ;
13622 PLFLT *arg20 = (PLFLT *) 0 ;
13623 Matrix temp1 ;
13624 int res4 ;
13625 char *buf4 = 0 ;
13626 int alloc4 = 0 ;
13627 double val5 ;
13628 int ecode5 = 0 ;
13629 double val6 ;
13630 int ecode6 = 0 ;
13631 double val7 ;
13632 int ecode7 = 0 ;
13633 double val8 ;
13634 int ecode8 = 0 ;
13635 double val9 ;
13636 int ecode9 = 0 ;
13637 double val10 ;
13638 int ecode10 = 0 ;
13639 int val11 ;
13640 int ecode11 = 0 ;
13641 double val12 ;
13642 int ecode12 = 0 ;
13643 int val13 ;
13644 int ecode13 = 0 ;
13645 int val14 ;
13646 int ecode14 = 0 ;
13647 int val15 ;
13648 int ecode15 = 0 ;
13649 int val16 ;
13650 int ecode16 = 0 ;
13651 int val17 ;
13652 int ecode17 = 0 ;
13653 int val18 ;
13654 int ecode18 = 0 ;
13655 Matrix temp19 ;
13656 Matrix temp20 ;
13657 octave_value_list _out;
13658 octave_value_list *_outp=&_out;
13659 octave_value _outv;
13660
13661 try {
13662 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13663 SWIG_fail;
13664 }
13665 {
13666 if ( _n_dims( args(0) ) > 2 )
13667 {
13668 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13669 }
13670 temp1 = args(0).matrix_value();
13671 arg1 = &temp1( 0, 0 );
13672 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13673 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13674 }
13675 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13676 if (!SWIG_IsOK(res4)) {
13677 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13678 }
13679 arg4 = reinterpret_cast< char * >(buf4);
13680 ecode5 = SWIG_AsVal_double(args(2), &val5);
13681 if (!SWIG_IsOK(ecode5)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13683 }
13684 arg5 = static_cast< PLFLT >(val5);
13685 ecode6 = SWIG_AsVal_double(args(3), &val6);
13686 if (!SWIG_IsOK(ecode6)) {
13687 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13688 }
13689 arg6 = static_cast< PLFLT >(val6);
13690 ecode7 = SWIG_AsVal_double(args(4), &val7);
13691 if (!SWIG_IsOK(ecode7)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13693 }
13694 arg7 = static_cast< PLFLT >(val7);
13695 ecode8 = SWIG_AsVal_double(args(5), &val8);
13696 if (!SWIG_IsOK(ecode8)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13698 }
13699 arg8 = static_cast< PLFLT >(val8);
13700 ecode9 = SWIG_AsVal_double(args(6), &val9);
13701 if (!SWIG_IsOK(ecode9)) {
13702 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13703 }
13704 arg9 = static_cast< PLFLT >(val9);
13705 ecode10 = SWIG_AsVal_double(args(7), &val10);
13706 if (!SWIG_IsOK(ecode10)) {
13707 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13708 }
13709 arg10 = static_cast< PLFLT >(val10);
13710 ecode11 = SWIG_AsVal_int(args(8), &val11);
13711 if (!SWIG_IsOK(ecode11)) {
13712 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13713 }
13714 arg11 = static_cast< PLINT >(val11);
13715 ecode12 = SWIG_AsVal_double(args(9), &val12);
13716 if (!SWIG_IsOK(ecode12)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13718 }
13719 arg12 = static_cast< PLFLT >(val12);
13720 ecode13 = SWIG_AsVal_int(args(10), &val13);
13721 if (!SWIG_IsOK(ecode13)) {
13722 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13723 }
13724 arg13 = static_cast< PLINT >(val13);
13725 ecode14 = SWIG_AsVal_int(args(11), &val14);
13726 if (!SWIG_IsOK(ecode14)) {
13727 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13728 }
13729 arg14 = static_cast< PLINT >(val14);
13730 ecode15 = SWIG_AsVal_int(args(12), &val15);
13731 if (!SWIG_IsOK(ecode15)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13733 }
13734 arg15 = static_cast< PLINT >(val15);
13735 ecode16 = SWIG_AsVal_int(args(13), &val16);
13736 if (!SWIG_IsOK(ecode16)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13738 }
13739 arg16 = static_cast< PLINT >(val16);
13740 ecode17 = SWIG_AsVal_int(args(14), &val17);
13741 if (!SWIG_IsOK(ecode17)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13743 }
13744 arg17 = static_cast< PLINT >(val17);
13745 ecode18 = SWIG_AsVal_int(args(15), &val18);
13746 if (!SWIG_IsOK(ecode18)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13748 }
13749 arg18 = static_cast< PLBOOL >(val18);
13750 {
13751 if ( _n_dims( args(16) ) > 1 )
13752 {
13753 error( "argument must be a scalar or vector" ); SWIG_fail;
13754 }
13755 if ( _dim( args(16), 0 ) != Xlen )
13756 {
13757 error( "argument vectors must be same length" ); SWIG_fail;
13758 }
13759 temp19 = args(16).matrix_value();
13760 arg19 = &temp19( 0, 0 );
13761 }
13762 {
13763 if ( _n_dims( args(17) ) > 1 )
13764 {
13765 error( "argument must be a scalar or vector" ); SWIG_fail;
13766 }
13767 if ( _dim( args(17), 0 ) != Ylen )
13768 {
13769 error( "argument vectors must be same length" ); SWIG_fail;
13770 }
13771 temp20 = args(17).matrix_value();
13772 arg20 = &temp20( 0, 0 );
13773 }
13774 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);
13775 _outv = octave_value();
13776 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13777 {
13778
13779 }
13780 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13781 {
13782
13783 }
13784 {
13785
13786 }
13787 return _out;
13788 fail:
13789 {
13790
13791 }
13792 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13793 {
13794
13795 }
13796 {
13797
13798 }
13799 return octave_value_list();
13800 }
13801 catch(...) {
13802 {
13803
13804 }
13805 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13806 {
13807
13808 }
13809 {
13810
13811 }
13812 throw;
13813 }
13814}
13815
13816
13817SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13818 PLFLT *arg1 = (PLFLT *) 0 ;
13819 PLINT arg2 ;
13820 PLINT arg3 ;
13821 char *arg4 = (char *) 0 ;
13822 PLFLT arg5 ;
13823 PLFLT arg6 ;
13824 PLFLT arg7 ;
13825 PLFLT arg8 ;
13826 PLFLT arg9 ;
13827 PLFLT arg10 ;
13828 PLINT arg11 ;
13829 PLFLT arg12 ;
13830 PLINT arg13 ;
13831 PLINT arg14 ;
13832 PLINT arg15 ;
13833 PLINT arg16 ;
13834 PLINT arg17 ;
13835 PLBOOL arg18 ;
13836 PLFLT *arg19 = (PLFLT *) 0 ;
13837 PLFLT *arg20 = (PLFLT *) 0 ;
13838 Matrix temp1 ;
13839 int res4 ;
13840 char *buf4 = 0 ;
13841 int alloc4 = 0 ;
13842 double val5 ;
13843 int ecode5 = 0 ;
13844 double val6 ;
13845 int ecode6 = 0 ;
13846 double val7 ;
13847 int ecode7 = 0 ;
13848 double val8 ;
13849 int ecode8 = 0 ;
13850 double val9 ;
13851 int ecode9 = 0 ;
13852 double val10 ;
13853 int ecode10 = 0 ;
13854 int val11 ;
13855 int ecode11 = 0 ;
13856 double val12 ;
13857 int ecode12 = 0 ;
13858 int val13 ;
13859 int ecode13 = 0 ;
13860 int val14 ;
13861 int ecode14 = 0 ;
13862 int val15 ;
13863 int ecode15 = 0 ;
13864 int val16 ;
13865 int ecode16 = 0 ;
13866 int val17 ;
13867 int ecode17 = 0 ;
13868 int val18 ;
13869 int ecode18 = 0 ;
13870 Matrix temp19 ;
13871 Matrix temp20 ;
13872 octave_value_list _out;
13873 octave_value_list *_outp=&_out;
13874 octave_value _outv;
13875
13876 try {
13877 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13878 SWIG_fail;
13879 }
13880 {
13881 if ( _n_dims( args(0) ) > 2 )
13882 {
13883 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13884 }
13885 temp1 = args(0).matrix_value();
13886 arg1 = &temp1( 0, 0 );
13887 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13888 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13889 }
13890 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13891 if (!SWIG_IsOK(res4)) {
13892 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13893 }
13894 arg4 = reinterpret_cast< char * >(buf4);
13895 ecode5 = SWIG_AsVal_double(args(2), &val5);
13896 if (!SWIG_IsOK(ecode5)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13898 }
13899 arg5 = static_cast< PLFLT >(val5);
13900 ecode6 = SWIG_AsVal_double(args(3), &val6);
13901 if (!SWIG_IsOK(ecode6)) {
13902 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13903 }
13904 arg6 = static_cast< PLFLT >(val6);
13905 ecode7 = SWIG_AsVal_double(args(4), &val7);
13906 if (!SWIG_IsOK(ecode7)) {
13907 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13908 }
13909 arg7 = static_cast< PLFLT >(val7);
13910 ecode8 = SWIG_AsVal_double(args(5), &val8);
13911 if (!SWIG_IsOK(ecode8)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13913 }
13914 arg8 = static_cast< PLFLT >(val8);
13915 ecode9 = SWIG_AsVal_double(args(6), &val9);
13916 if (!SWIG_IsOK(ecode9)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13918 }
13919 arg9 = static_cast< PLFLT >(val9);
13920 ecode10 = SWIG_AsVal_double(args(7), &val10);
13921 if (!SWIG_IsOK(ecode10)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13923 }
13924 arg10 = static_cast< PLFLT >(val10);
13925 ecode11 = SWIG_AsVal_int(args(8), &val11);
13926 if (!SWIG_IsOK(ecode11)) {
13927 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13928 }
13929 arg11 = static_cast< PLINT >(val11);
13930 ecode12 = SWIG_AsVal_double(args(9), &val12);
13931 if (!SWIG_IsOK(ecode12)) {
13932 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13933 }
13934 arg12 = static_cast< PLFLT >(val12);
13935 ecode13 = SWIG_AsVal_int(args(10), &val13);
13936 if (!SWIG_IsOK(ecode13)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13938 }
13939 arg13 = static_cast< PLINT >(val13);
13940 ecode14 = SWIG_AsVal_int(args(11), &val14);
13941 if (!SWIG_IsOK(ecode14)) {
13942 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13943 }
13944 arg14 = static_cast< PLINT >(val14);
13945 ecode15 = SWIG_AsVal_int(args(12), &val15);
13946 if (!SWIG_IsOK(ecode15)) {
13947 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13948 }
13949 arg15 = static_cast< PLINT >(val15);
13950 ecode16 = SWIG_AsVal_int(args(13), &val16);
13951 if (!SWIG_IsOK(ecode16)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13953 }
13954 arg16 = static_cast< PLINT >(val16);
13955 ecode17 = SWIG_AsVal_int(args(14), &val17);
13956 if (!SWIG_IsOK(ecode17)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13958 }
13959 arg17 = static_cast< PLINT >(val17);
13960 ecode18 = SWIG_AsVal_int(args(15), &val18);
13961 if (!SWIG_IsOK(ecode18)) {
13962 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13963 }
13964 arg18 = static_cast< PLBOOL >(val18);
13965 {
13966 if ( _n_dims( args(16) ) > 2 )
13967 {
13968 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13969 }
13970 temp19 = args(16).matrix_value();
13971 arg19 = &temp19( 0, 0 );
13972 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13973 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13974 }
13975 {
13976 if ( _n_dims( args(17) ) > 2 )
13977 {
13978 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13979 }
13980 temp20 = args(17).matrix_value();
13981 arg20 = &temp20( 0, 0 );
13982 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13983 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13984 }
13985 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);
13986 _outv = octave_value();
13987 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13988 {
13989
13990 }
13991 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13992 {
13993
13994 }
13995 {
13996
13997 }
13998 return _out;
13999 fail:
14000 {
14001
14002 }
14003 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14004 {
14005
14006 }
14007 {
14008
14009 }
14010 return octave_value_list();
14011 }
14012 catch(...) {
14013 {
14014
14015 }
14016 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
14017 {
14018
14019 }
14020 {
14021
14022 }
14023 throw;
14024 }
14025}
14026
14027
14029 PLFLT *arg1 = (PLFLT *) 0 ;
14030 PLINT arg2 ;
14031 PLINT arg3 ;
14032 PLFLT arg4 ;
14033 PLFLT arg5 ;
14034 PLFLT arg6 ;
14035 PLFLT arg7 ;
14036 PLFLT *arg8 = (PLFLT *) 0 ;
14037 PLINT arg9 ;
14038 PLINT arg10 ;
14039 PLINT arg11 ;
14040 PLINT arg12 ;
14041 PLBOOL arg13 ;
14042 Matrix temp1 ;
14043 double val4 ;
14044 int ecode4 = 0 ;
14045 double val5 ;
14046 int ecode5 = 0 ;
14047 double val6 ;
14048 int ecode6 = 0 ;
14049 double val7 ;
14050 int ecode7 = 0 ;
14051 Matrix temp8 ;
14052 int val10 ;
14053 int ecode10 = 0 ;
14054 int val11 ;
14055 int ecode11 = 0 ;
14056 int val12 ;
14057 int ecode12 = 0 ;
14058 int val13 ;
14059 int ecode13 = 0 ;
14060 octave_value_list _out;
14061 octave_value_list *_outp=&_out;
14062 octave_value _outv;
14063
14064 try {
14065 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
14066 SWIG_fail;
14067 }
14068 {
14069 if ( _n_dims( args(0) ) > 2 )
14070 {
14071 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14072 }
14073 temp1 = args(0).matrix_value();
14074 arg1 = &temp1( 0, 0 );
14075 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14076 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14077 }
14078 ecode4 = SWIG_AsVal_double(args(1), &val4);
14079 if (!SWIG_IsOK(ecode4)) {
14080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14081 }
14082 arg4 = static_cast< PLFLT >(val4);
14083 ecode5 = SWIG_AsVal_double(args(2), &val5);
14084 if (!SWIG_IsOK(ecode5)) {
14085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14086 }
14087 arg5 = static_cast< PLFLT >(val5);
14088 ecode6 = SWIG_AsVal_double(args(3), &val6);
14089 if (!SWIG_IsOK(ecode6)) {
14090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14091 }
14092 arg6 = static_cast< PLFLT >(val6);
14093 ecode7 = SWIG_AsVal_double(args(4), &val7);
14094 if (!SWIG_IsOK(ecode7)) {
14095 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14096 }
14097 arg7 = static_cast< PLFLT >(val7);
14098 {
14099 if ( _n_dims( args(5) ) > 1 )
14100 {
14101 error( "argument must be a scalar or vector" ); SWIG_fail;
14102 }
14103 temp8 = args(5).matrix_value();
14104 arg8 = &temp8( 0, 0 );
14105 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14106 }
14107 ecode10 = SWIG_AsVal_int(args(6), &val10);
14108 if (!SWIG_IsOK(ecode10)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14110 }
14111 arg10 = static_cast< PLINT >(val10);
14112 ecode11 = SWIG_AsVal_int(args(7), &val11);
14113 if (!SWIG_IsOK(ecode11)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14115 }
14116 arg11 = static_cast< PLINT >(val11);
14117 ecode12 = SWIG_AsVal_int(args(8), &val12);
14118 if (!SWIG_IsOK(ecode12)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14120 }
14121 arg12 = static_cast< PLINT >(val12);
14122 ecode13 = SWIG_AsVal_int(args(9), &val13);
14123 if (!SWIG_IsOK(ecode13)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14125 }
14126 arg13 = static_cast< PLBOOL >(val13);
14127 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14128 _outv = octave_value();
14129 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14130 {
14131
14132 }
14133 {
14134
14135 }
14136 return _out;
14137 fail:
14138 {
14139
14140 }
14141 {
14142
14143 }
14144 return octave_value_list();
14145 }
14146 catch(...) {
14147 {
14148
14149 }
14150 {
14151
14152 }
14153 throw;
14154 }
14155}
14156
14157
14158SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14159 PLFLT *arg1 = (PLFLT *) 0 ;
14160 PLINT arg2 ;
14161 PLINT arg3 ;
14162 PLFLT arg4 ;
14163 PLFLT arg5 ;
14164 PLFLT arg6 ;
14165 PLFLT arg7 ;
14166 PLFLT *arg8 = (PLFLT *) 0 ;
14167 PLINT arg9 ;
14168 PLINT arg10 ;
14169 PLINT arg11 ;
14170 PLINT arg12 ;
14171 PLBOOL arg13 ;
14172 PLFLT *arg14 = (PLFLT *) 0 ;
14173 Matrix temp1 ;
14174 double val4 ;
14175 int ecode4 = 0 ;
14176 double val5 ;
14177 int ecode5 = 0 ;
14178 double val6 ;
14179 int ecode6 = 0 ;
14180 double val7 ;
14181 int ecode7 = 0 ;
14182 Matrix temp8 ;
14183 int val10 ;
14184 int ecode10 = 0 ;
14185 int val11 ;
14186 int ecode11 = 0 ;
14187 int val12 ;
14188 int ecode12 = 0 ;
14189 int val13 ;
14190 int ecode13 = 0 ;
14191 Matrix temp14 ;
14192 octave_value_list _out;
14193 octave_value_list *_outp=&_out;
14194 octave_value _outv;
14195
14196 try {
14197 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14198 SWIG_fail;
14199 }
14200 {
14201 if ( _n_dims( args(0) ) > 2 )
14202 {
14203 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14204 }
14205 temp1 = args(0).matrix_value();
14206 arg1 = &temp1( 0, 0 );
14207 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14208 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14209 }
14210 ecode4 = SWIG_AsVal_double(args(1), &val4);
14211 if (!SWIG_IsOK(ecode4)) {
14212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14213 }
14214 arg4 = static_cast< PLFLT >(val4);
14215 ecode5 = SWIG_AsVal_double(args(2), &val5);
14216 if (!SWIG_IsOK(ecode5)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14218 }
14219 arg5 = static_cast< PLFLT >(val5);
14220 ecode6 = SWIG_AsVal_double(args(3), &val6);
14221 if (!SWIG_IsOK(ecode6)) {
14222 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14223 }
14224 arg6 = static_cast< PLFLT >(val6);
14225 ecode7 = SWIG_AsVal_double(args(4), &val7);
14226 if (!SWIG_IsOK(ecode7)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14228 }
14229 arg7 = static_cast< PLFLT >(val7);
14230 {
14231 if ( _n_dims( args(5) ) > 1 )
14232 {
14233 error( "argument must be a scalar or vector" ); SWIG_fail;
14234 }
14235 temp8 = args(5).matrix_value();
14236 arg8 = &temp8( 0, 0 );
14237 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14238 }
14239 ecode10 = SWIG_AsVal_int(args(6), &val10);
14240 if (!SWIG_IsOK(ecode10)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14242 }
14243 arg10 = static_cast< PLINT >(val10);
14244 ecode11 = SWIG_AsVal_int(args(7), &val11);
14245 if (!SWIG_IsOK(ecode11)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14247 }
14248 arg11 = static_cast< PLINT >(val11);
14249 ecode12 = SWIG_AsVal_int(args(8), &val12);
14250 if (!SWIG_IsOK(ecode12)) {
14251 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14252 }
14253 arg12 = static_cast< PLINT >(val12);
14254 ecode13 = SWIG_AsVal_int(args(9), &val13);
14255 if (!SWIG_IsOK(ecode13)) {
14256 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14257 }
14258 arg13 = static_cast< PLBOOL >(val13);
14259 {
14260 if ( _n_dims( args(10) ) > 1 )
14261 {
14262 error( "argument must be a scalar or vector" ); SWIG_fail;
14263 }
14264 if ( _dim( args(10), 0 ) != 6 )
14265 {
14266 error( "argument vectors must have length of 6" ); SWIG_fail;
14267 }
14268 temp14 = args(10).matrix_value();
14269 arg14 = &temp14( 0, 0 );
14270 }
14271 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14272 _outv = octave_value();
14273 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14274 {
14275
14276 }
14277 {
14278
14279 }
14280 {
14281
14282 }
14283 return _out;
14284 fail:
14285 {
14286
14287 }
14288 {
14289
14290 }
14291 {
14292
14293 }
14294 return octave_value_list();
14295 }
14296 catch(...) {
14297 {
14298
14299 }
14300 {
14301
14302 }
14303 {
14304
14305 }
14306 throw;
14307 }
14308}
14309
14310
14311SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14312 PLFLT *arg1 = (PLFLT *) 0 ;
14313 PLINT arg2 ;
14314 PLINT arg3 ;
14315 PLFLT arg4 ;
14316 PLFLT arg5 ;
14317 PLFLT arg6 ;
14318 PLFLT arg7 ;
14319 PLFLT *arg8 = (PLFLT *) 0 ;
14320 PLINT arg9 ;
14321 PLINT arg10 ;
14322 PLINT arg11 ;
14323 PLINT arg12 ;
14324 PLBOOL arg13 ;
14325 PLFLT *arg14 = (PLFLT *) 0 ;
14326 PLFLT *arg15 = (PLFLT *) 0 ;
14327 Matrix temp1 ;
14328 double val4 ;
14329 int ecode4 = 0 ;
14330 double val5 ;
14331 int ecode5 = 0 ;
14332 double val6 ;
14333 int ecode6 = 0 ;
14334 double val7 ;
14335 int ecode7 = 0 ;
14336 Matrix temp8 ;
14337 int val10 ;
14338 int ecode10 = 0 ;
14339 int val11 ;
14340 int ecode11 = 0 ;
14341 int val12 ;
14342 int ecode12 = 0 ;
14343 int val13 ;
14344 int ecode13 = 0 ;
14345 Matrix temp14 ;
14346 Matrix temp15 ;
14347 octave_value_list _out;
14348 octave_value_list *_outp=&_out;
14349 octave_value _outv;
14350
14351 try {
14352 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14353 SWIG_fail;
14354 }
14355 {
14356 if ( _n_dims( args(0) ) > 2 )
14357 {
14358 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14359 }
14360 temp1 = args(0).matrix_value();
14361 arg1 = &temp1( 0, 0 );
14362 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14363 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14364 }
14365 ecode4 = SWIG_AsVal_double(args(1), &val4);
14366 if (!SWIG_IsOK(ecode4)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14368 }
14369 arg4 = static_cast< PLFLT >(val4);
14370 ecode5 = SWIG_AsVal_double(args(2), &val5);
14371 if (!SWIG_IsOK(ecode5)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14373 }
14374 arg5 = static_cast< PLFLT >(val5);
14375 ecode6 = SWIG_AsVal_double(args(3), &val6);
14376 if (!SWIG_IsOK(ecode6)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14378 }
14379 arg6 = static_cast< PLFLT >(val6);
14380 ecode7 = SWIG_AsVal_double(args(4), &val7);
14381 if (!SWIG_IsOK(ecode7)) {
14382 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14383 }
14384 arg7 = static_cast< PLFLT >(val7);
14385 {
14386 if ( _n_dims( args(5) ) > 1 )
14387 {
14388 error( "argument must be a scalar or vector" ); SWIG_fail;
14389 }
14390 temp8 = args(5).matrix_value();
14391 arg8 = &temp8( 0, 0 );
14392 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14393 }
14394 ecode10 = SWIG_AsVal_int(args(6), &val10);
14395 if (!SWIG_IsOK(ecode10)) {
14396 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14397 }
14398 arg10 = static_cast< PLINT >(val10);
14399 ecode11 = SWIG_AsVal_int(args(7), &val11);
14400 if (!SWIG_IsOK(ecode11)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14402 }
14403 arg11 = static_cast< PLINT >(val11);
14404 ecode12 = SWIG_AsVal_int(args(8), &val12);
14405 if (!SWIG_IsOK(ecode12)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14407 }
14408 arg12 = static_cast< PLINT >(val12);
14409 ecode13 = SWIG_AsVal_int(args(9), &val13);
14410 if (!SWIG_IsOK(ecode13)) {
14411 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14412 }
14413 arg13 = static_cast< PLBOOL >(val13);
14414 {
14415 if ( _n_dims( args(10) ) > 1 )
14416 {
14417 error( "argument must be a scalar or vector" ); SWIG_fail;
14418 }
14419 if ( _dim( args(10), 0 ) != Xlen )
14420 {
14421 error( "argument vectors must be same length" ); SWIG_fail;
14422 }
14423 temp14 = args(10).matrix_value();
14424 arg14 = &temp14( 0, 0 );
14425 }
14426 {
14427 if ( _n_dims( args(11) ) > 1 )
14428 {
14429 error( "argument must be a scalar or vector" ); SWIG_fail;
14430 }
14431 if ( _dim( args(11), 0 ) != Ylen )
14432 {
14433 error( "argument vectors must be same length" ); SWIG_fail;
14434 }
14435 temp15 = args(11).matrix_value();
14436 arg15 = &temp15( 0, 0 );
14437 }
14438 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);
14439 _outv = octave_value();
14440 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14441 {
14442
14443 }
14444 {
14445
14446 }
14447 {
14448
14449 }
14450 {
14451
14452 }
14453 return _out;
14454 fail:
14455 {
14456
14457 }
14458 {
14459
14460 }
14461 {
14462
14463 }
14464 {
14465
14466 }
14467 return octave_value_list();
14468 }
14469 catch(...) {
14470 {
14471
14472 }
14473 {
14474
14475 }
14476 {
14477
14478 }
14479 {
14480
14481 }
14482 throw;
14483 }
14484}
14485
14486
14487SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14488 PLFLT *arg1 = (PLFLT *) 0 ;
14489 PLINT arg2 ;
14490 PLINT arg3 ;
14491 PLFLT arg4 ;
14492 PLFLT arg5 ;
14493 PLFLT arg6 ;
14494 PLFLT arg7 ;
14495 PLFLT *arg8 = (PLFLT *) 0 ;
14496 PLINT arg9 ;
14497 PLINT arg10 ;
14498 PLINT arg11 ;
14499 PLINT arg12 ;
14500 PLBOOL arg13 ;
14501 PLFLT *arg14 = (PLFLT *) 0 ;
14502 PLFLT *arg15 = (PLFLT *) 0 ;
14503 Matrix temp1 ;
14504 double val4 ;
14505 int ecode4 = 0 ;
14506 double val5 ;
14507 int ecode5 = 0 ;
14508 double val6 ;
14509 int ecode6 = 0 ;
14510 double val7 ;
14511 int ecode7 = 0 ;
14512 Matrix temp8 ;
14513 int val10 ;
14514 int ecode10 = 0 ;
14515 int val11 ;
14516 int ecode11 = 0 ;
14517 int val12 ;
14518 int ecode12 = 0 ;
14519 int val13 ;
14520 int ecode13 = 0 ;
14521 Matrix temp14 ;
14522 Matrix temp15 ;
14523 octave_value_list _out;
14524 octave_value_list *_outp=&_out;
14525 octave_value _outv;
14526
14527 try {
14528 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14529 SWIG_fail;
14530 }
14531 {
14532 if ( _n_dims( args(0) ) > 2 )
14533 {
14534 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14535 }
14536 temp1 = args(0).matrix_value();
14537 arg1 = &temp1( 0, 0 );
14538 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14539 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14540 }
14541 ecode4 = SWIG_AsVal_double(args(1), &val4);
14542 if (!SWIG_IsOK(ecode4)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14544 }
14545 arg4 = static_cast< PLFLT >(val4);
14546 ecode5 = SWIG_AsVal_double(args(2), &val5);
14547 if (!SWIG_IsOK(ecode5)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14549 }
14550 arg5 = static_cast< PLFLT >(val5);
14551 ecode6 = SWIG_AsVal_double(args(3), &val6);
14552 if (!SWIG_IsOK(ecode6)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14554 }
14555 arg6 = static_cast< PLFLT >(val6);
14556 ecode7 = SWIG_AsVal_double(args(4), &val7);
14557 if (!SWIG_IsOK(ecode7)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14559 }
14560 arg7 = static_cast< PLFLT >(val7);
14561 {
14562 if ( _n_dims( args(5) ) > 1 )
14563 {
14564 error( "argument must be a scalar or vector" ); SWIG_fail;
14565 }
14566 temp8 = args(5).matrix_value();
14567 arg8 = &temp8( 0, 0 );
14568 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14569 }
14570 ecode10 = SWIG_AsVal_int(args(6), &val10);
14571 if (!SWIG_IsOK(ecode10)) {
14572 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14573 }
14574 arg10 = static_cast< PLINT >(val10);
14575 ecode11 = SWIG_AsVal_int(args(7), &val11);
14576 if (!SWIG_IsOK(ecode11)) {
14577 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14578 }
14579 arg11 = static_cast< PLINT >(val11);
14580 ecode12 = SWIG_AsVal_int(args(8), &val12);
14581 if (!SWIG_IsOK(ecode12)) {
14582 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14583 }
14584 arg12 = static_cast< PLINT >(val12);
14585 ecode13 = SWIG_AsVal_int(args(9), &val13);
14586 if (!SWIG_IsOK(ecode13)) {
14587 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14588 }
14589 arg13 = static_cast< PLBOOL >(val13);
14590 {
14591 if ( _n_dims( args(10) ) > 2 )
14592 {
14593 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14594 }
14595 temp14 = args(10).matrix_value();
14596 arg14 = &temp14( 0, 0 );
14597 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14598 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14599 }
14600 {
14601 if ( _n_dims( args(11) ) > 2 )
14602 {
14603 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14604 }
14605 temp15 = args(11).matrix_value();
14606 arg15 = &temp15( 0, 0 );
14607 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14608 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14609 }
14610 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);
14611 _outv = octave_value();
14612 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14613 {
14614
14615 }
14616 {
14617
14618 }
14619 {
14620
14621 }
14622 {
14623
14624 }
14625 return _out;
14626 fail:
14627 {
14628
14629 }
14630 {
14631
14632 }
14633 {
14634
14635 }
14636 {
14637
14638 }
14639 return octave_value_list();
14640 }
14641 catch(...) {
14642 {
14643
14644 }
14645 {
14646
14647 }
14648 {
14649
14650 }
14651 {
14652
14653 }
14654 throw;
14655 }
14656}
14657
14658
14660 PLFLT *arg1 = (PLFLT *) 0 ;
14661 PLFLT *arg2 = (PLFLT *) 0 ;
14662 PLINT arg3 ;
14663 PLINT arg4 ;
14664 PLFLT arg5 ;
14665 PLFLT *arg6 = (PLFLT *) 0 ;
14666 Matrix temp1 ;
14667 Matrix temp2 ;
14668 double val5 ;
14669 int ecode5 = 0 ;
14670 Matrix temp6 ;
14671 octave_value_list _out;
14672 octave_value_list *_outp=&_out;
14673 octave_value _outv;
14674
14675 try {
14676 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14677 SWIG_fail;
14678 }
14679 {
14680 if ( _n_dims( args(0) ) > 2 )
14681 {
14682 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14683 }
14684 temp1 = args(0).matrix_value();
14685 arg1 = &temp1( 0, 0 );
14686 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14687 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14688 }
14689 {
14690 if ( _n_dims( args(1) ) > 2 )
14691 {
14692 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14693 }
14694 if ( _dim( args(1), 0 ) != Xlen )
14695 {
14696 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14697 }
14698 if ( _dim( args(1), 1 ) != Ylen )
14699 {
14700 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14701 }
14702 temp2 = args(1).matrix_value();
14703 arg2 = &temp2( 0, 0 );
14704 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14705 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14706 }
14707 ecode5 = SWIG_AsVal_double(args(2), &val5);
14708 if (!SWIG_IsOK(ecode5)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14710 }
14711 arg5 = static_cast< PLFLT >(val5);
14712 {
14713 if ( _n_dims( args(3) ) > 1 )
14714 {
14715 error( "argument must be a scalar or vector" ); SWIG_fail;
14716 }
14717 if ( _dim( args(3), 0 ) != 6 )
14718 {
14719 error( "argument vectors must have length of 6" ); SWIG_fail;
14720 }
14721 temp6 = args(3).matrix_value();
14722 arg6 = &temp6( 0, 0 );
14723 }
14724 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14725 _outv = octave_value();
14726 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14727 {
14728
14729 }
14730 {
14731
14732 }
14733 {
14734
14735 }
14736 return _out;
14737 fail:
14738 {
14739
14740 }
14741 {
14742
14743 }
14744 {
14745
14746 }
14747 return octave_value_list();
14748 }
14749 catch(...) {
14750 {
14751
14752 }
14753 {
14754
14755 }
14756 {
14757
14758 }
14759 throw;
14760 }
14761}
14762
14763
14764SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14765 PLFLT *arg1 = (PLFLT *) 0 ;
14766 PLFLT *arg2 = (PLFLT *) 0 ;
14767 PLINT arg3 ;
14768 PLINT arg4 ;
14769 PLFLT arg5 ;
14770 PLFLT *arg6 = (PLFLT *) 0 ;
14771 PLFLT *arg7 = (PLFLT *) 0 ;
14772 Matrix temp1 ;
14773 Matrix temp2 ;
14774 double val5 ;
14775 int ecode5 = 0 ;
14776 Matrix temp6 ;
14777 Matrix temp7 ;
14778 octave_value_list _out;
14779 octave_value_list *_outp=&_out;
14780 octave_value _outv;
14781
14782 try {
14783 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14784 SWIG_fail;
14785 }
14786 {
14787 if ( _n_dims( args(0) ) > 2 )
14788 {
14789 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14790 }
14791 temp1 = args(0).matrix_value();
14792 arg1 = &temp1( 0, 0 );
14793 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14794 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14795 }
14796 {
14797 if ( _n_dims( args(1) ) > 2 )
14798 {
14799 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14800 }
14801 if ( _dim( args(1), 0 ) != Xlen )
14802 {
14803 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14804 }
14805 if ( _dim( args(1), 1 ) != Ylen )
14806 {
14807 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14808 }
14809 temp2 = args(1).matrix_value();
14810 arg2 = &temp2( 0, 0 );
14811 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14812 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14813 }
14814 ecode5 = SWIG_AsVal_double(args(2), &val5);
14815 if (!SWIG_IsOK(ecode5)) {
14816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14817 }
14818 arg5 = static_cast< PLFLT >(val5);
14819 {
14820 if ( _n_dims( args(3) ) > 1 )
14821 {
14822 error( "argument must be a scalar or vector" ); SWIG_fail;
14823 }
14824 if ( _dim( args(3), 0 ) != Xlen )
14825 {
14826 error( "argument vectors must be same length" ); SWIG_fail;
14827 }
14828 temp6 = args(3).matrix_value();
14829 arg6 = &temp6( 0, 0 );
14830 }
14831 {
14832 if ( _n_dims( args(4) ) > 1 )
14833 {
14834 error( "argument must be a scalar or vector" ); SWIG_fail;
14835 }
14836 if ( _dim( args(4), 0 ) != Ylen )
14837 {
14838 error( "argument vectors must be same length" ); SWIG_fail;
14839 }
14840 temp7 = args(4).matrix_value();
14841 arg7 = &temp7( 0, 0 );
14842 }
14843 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14844 _outv = octave_value();
14845 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14846 {
14847
14848 }
14849 {
14850
14851 }
14852 {
14853
14854 }
14855 {
14856
14857 }
14858 return _out;
14859 fail:
14860 {
14861
14862 }
14863 {
14864
14865 }
14866 {
14867
14868 }
14869 {
14870
14871 }
14872 return octave_value_list();
14873 }
14874 catch(...) {
14875 {
14876
14877 }
14878 {
14879
14880 }
14881 {
14882
14883 }
14884 {
14885
14886 }
14887 throw;
14888 }
14889}
14890
14891
14892SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14893 PLFLT *arg1 = (PLFLT *) 0 ;
14894 PLFLT *arg2 = (PLFLT *) 0 ;
14895 PLINT arg3 ;
14896 PLINT arg4 ;
14897 PLFLT arg5 ;
14898 PLFLT *arg6 = (PLFLT *) 0 ;
14899 PLFLT *arg7 = (PLFLT *) 0 ;
14900 Matrix temp1 ;
14901 Matrix temp2 ;
14902 double val5 ;
14903 int ecode5 = 0 ;
14904 Matrix temp6 ;
14905 Matrix temp7 ;
14906 octave_value_list _out;
14907 octave_value_list *_outp=&_out;
14908 octave_value _outv;
14909
14910 try {
14911 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14912 SWIG_fail;
14913 }
14914 {
14915 if ( _n_dims( args(0) ) > 2 )
14916 {
14917 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14918 }
14919 temp1 = args(0).matrix_value();
14920 arg1 = &temp1( 0, 0 );
14921 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14922 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14923 }
14924 {
14925 if ( _n_dims( args(1) ) > 2 )
14926 {
14927 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14928 }
14929 if ( _dim( args(1), 0 ) != Xlen )
14930 {
14931 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14932 }
14933 if ( _dim( args(1), 1 ) != Ylen )
14934 {
14935 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14936 }
14937 temp2 = args(1).matrix_value();
14938 arg2 = &temp2( 0, 0 );
14939 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14940 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14941 }
14942 ecode5 = SWIG_AsVal_double(args(2), &val5);
14943 if (!SWIG_IsOK(ecode5)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14945 }
14946 arg5 = static_cast< PLFLT >(val5);
14947 {
14948 if ( _n_dims( args(3) ) > 2 )
14949 {
14950 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14951 }
14952 temp6 = args(3).matrix_value();
14953 arg6 = &temp6( 0, 0 );
14954 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14955 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14956 }
14957 {
14958 if ( _n_dims( args(4) ) > 2 )
14959 {
14960 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14961 }
14962 temp7 = args(4).matrix_value();
14963 arg7 = &temp7( 0, 0 );
14964 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14965 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14966 }
14967 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14968 _outv = octave_value();
14969 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14970 {
14971
14972 }
14973 {
14974
14975 }
14976 {
14977
14978 }
14979 {
14980
14981 }
14982 return _out;
14983 fail:
14984 {
14985
14986 }
14987 {
14988
14989 }
14990 {
14991
14992 }
14993 {
14994
14995 }
14996 return octave_value_list();
14997 }
14998 catch(...) {
14999 {
15000
15001 }
15002 {
15003
15004 }
15005 {
15006
15007 }
15008 {
15009
15010 }
15011 throw;
15012 }
15013}
15014
15015
15016SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
15017 PLFLT *arg1 = (PLFLT *) 0 ;
15018 PLINT arg2 ;
15019 PLINT arg3 ;
15020 PLFLT arg4 ;
15021 PLFLT arg5 ;
15022 PLFLT arg6 ;
15023 PLFLT arg7 ;
15024 PLFLT arg8 ;
15025 PLFLT arg9 ;
15026 PLFLT arg10 ;
15027 PLFLT arg11 ;
15028 PLFLT arg12 ;
15029 PLFLT arg13 ;
15030 Matrix temp1 ;
15031 double val4 ;
15032 int ecode4 = 0 ;
15033 double val5 ;
15034 int ecode5 = 0 ;
15035 double val6 ;
15036 int ecode6 = 0 ;
15037 double val7 ;
15038 int ecode7 = 0 ;
15039 double val8 ;
15040 int ecode8 = 0 ;
15041 double val9 ;
15042 int ecode9 = 0 ;
15043 double val10 ;
15044 int ecode10 = 0 ;
15045 double val11 ;
15046 int ecode11 = 0 ;
15047 double val12 ;
15048 int ecode12 = 0 ;
15049 double val13 ;
15050 int ecode13 = 0 ;
15051 octave_value_list _out;
15052 octave_value_list *_outp=&_out;
15053 octave_value _outv;
15054
15055 try {
15056 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
15057 SWIG_fail;
15058 }
15059 {
15060 if ( _n_dims( args(0) ) > 2 )
15061 {
15062 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15063 }
15064 temp1 = args(0).matrix_value();
15065 arg1 = &temp1( 0, 0 );
15066 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15067 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15068 }
15069 ecode4 = SWIG_AsVal_double(args(1), &val4);
15070 if (!SWIG_IsOK(ecode4)) {
15071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15072 }
15073 arg4 = static_cast< PLFLT >(val4);
15074 ecode5 = SWIG_AsVal_double(args(2), &val5);
15075 if (!SWIG_IsOK(ecode5)) {
15076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15077 }
15078 arg5 = static_cast< PLFLT >(val5);
15079 ecode6 = SWIG_AsVal_double(args(3), &val6);
15080 if (!SWIG_IsOK(ecode6)) {
15081 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15082 }
15083 arg6 = static_cast< PLFLT >(val6);
15084 ecode7 = SWIG_AsVal_double(args(4), &val7);
15085 if (!SWIG_IsOK(ecode7)) {
15086 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15087 }
15088 arg7 = static_cast< PLFLT >(val7);
15089 ecode8 = SWIG_AsVal_double(args(5), &val8);
15090 if (!SWIG_IsOK(ecode8)) {
15091 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15092 }
15093 arg8 = static_cast< PLFLT >(val8);
15094 ecode9 = SWIG_AsVal_double(args(6), &val9);
15095 if (!SWIG_IsOK(ecode9)) {
15096 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15097 }
15098 arg9 = static_cast< PLFLT >(val9);
15099 ecode10 = SWIG_AsVal_double(args(7), &val10);
15100 if (!SWIG_IsOK(ecode10)) {
15101 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15102 }
15103 arg10 = static_cast< PLFLT >(val10);
15104 ecode11 = SWIG_AsVal_double(args(8), &val11);
15105 if (!SWIG_IsOK(ecode11)) {
15106 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15107 }
15108 arg11 = static_cast< PLFLT >(val11);
15109 ecode12 = SWIG_AsVal_double(args(9), &val12);
15110 if (!SWIG_IsOK(ecode12)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15112 }
15113 arg12 = static_cast< PLFLT >(val12);
15114 ecode13 = SWIG_AsVal_double(args(10), &val13);
15115 if (!SWIG_IsOK(ecode13)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15117 }
15118 arg13 = static_cast< PLFLT >(val13);
15119 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15120 _outv = octave_value();
15121 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15122 {
15123
15124 }
15125 return _out;
15126 fail:
15127 {
15128
15129 }
15130 return octave_value_list();
15131 }
15132 catch(...) {
15133 {
15134
15135 }
15136 throw;
15137 }
15138}
15139
15140
15142 PLFLT *arg1 = (PLFLT *) 0 ;
15143 PLINT arg2 ;
15144 PLINT arg3 ;
15145 PLFLT arg4 ;
15146 PLFLT arg5 ;
15147 PLFLT arg6 ;
15148 PLFLT arg7 ;
15149 PLFLT arg8 ;
15150 PLFLT arg9 ;
15151 PLFLT arg10 ;
15152 PLFLT arg11 ;
15153 Matrix temp1 ;
15154 double val4 ;
15155 int ecode4 = 0 ;
15156 double val5 ;
15157 int ecode5 = 0 ;
15158 double val6 ;
15159 int ecode6 = 0 ;
15160 double val7 ;
15161 int ecode7 = 0 ;
15162 double val8 ;
15163 int ecode8 = 0 ;
15164 double val9 ;
15165 int ecode9 = 0 ;
15166 double val10 ;
15167 int ecode10 = 0 ;
15168 double val11 ;
15169 int ecode11 = 0 ;
15170 octave_value_list _out;
15171 octave_value_list *_outp=&_out;
15172 octave_value _outv;
15173
15174 try {
15175 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15176 SWIG_fail;
15177 }
15178 {
15179 if ( _n_dims( args(0) ) > 2 )
15180 {
15181 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15182 }
15183 temp1 = args(0).matrix_value();
15184 arg1 = &temp1( 0, 0 );
15185 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15186 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15187 }
15188 ecode4 = SWIG_AsVal_double(args(1), &val4);
15189 if (!SWIG_IsOK(ecode4)) {
15190 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15191 }
15192 arg4 = static_cast< PLFLT >(val4);
15193 ecode5 = SWIG_AsVal_double(args(2), &val5);
15194 if (!SWIG_IsOK(ecode5)) {
15195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15196 }
15197 arg5 = static_cast< PLFLT >(val5);
15198 ecode6 = SWIG_AsVal_double(args(3), &val6);
15199 if (!SWIG_IsOK(ecode6)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15201 }
15202 arg6 = static_cast< PLFLT >(val6);
15203 ecode7 = SWIG_AsVal_double(args(4), &val7);
15204 if (!SWIG_IsOK(ecode7)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15206 }
15207 arg7 = static_cast< PLFLT >(val7);
15208 ecode8 = SWIG_AsVal_double(args(5), &val8);
15209 if (!SWIG_IsOK(ecode8)) {
15210 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15211 }
15212 arg8 = static_cast< PLFLT >(val8);
15213 ecode9 = SWIG_AsVal_double(args(6), &val9);
15214 if (!SWIG_IsOK(ecode9)) {
15215 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15216 }
15217 arg9 = static_cast< PLFLT >(val9);
15218 ecode10 = SWIG_AsVal_double(args(7), &val10);
15219 if (!SWIG_IsOK(ecode10)) {
15220 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15221 }
15222 arg10 = static_cast< PLFLT >(val10);
15223 ecode11 = SWIG_AsVal_double(args(8), &val11);
15224 if (!SWIG_IsOK(ecode11)) {
15225 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15226 }
15227 arg11 = static_cast< PLFLT >(val11);
15228 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15229 _outv = octave_value();
15230 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15231 {
15232
15233 }
15234 return _out;
15235 fail:
15236 {
15237
15238 }
15239 return octave_value_list();
15240 }
15241 catch(...) {
15242 {
15243
15244 }
15245 throw;
15246 }
15247}
15248
15249
15250SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15251 PLFLT *arg1 = (PLFLT *) 0 ;
15252 PLINT arg2 ;
15253 PLINT arg3 ;
15254 PLFLT arg4 ;
15255 PLFLT arg5 ;
15256 PLFLT arg6 ;
15257 PLFLT arg7 ;
15258 PLFLT arg8 ;
15259 PLFLT arg9 ;
15260 PLFLT arg10 ;
15261 PLFLT arg11 ;
15262 PLFLT *arg12 = (PLFLT *) 0 ;
15263 Matrix temp1 ;
15264 double val4 ;
15265 int ecode4 = 0 ;
15266 double val5 ;
15267 int ecode5 = 0 ;
15268 double val6 ;
15269 int ecode6 = 0 ;
15270 double val7 ;
15271 int ecode7 = 0 ;
15272 double val8 ;
15273 int ecode8 = 0 ;
15274 double val9 ;
15275 int ecode9 = 0 ;
15276 double val10 ;
15277 int ecode10 = 0 ;
15278 double val11 ;
15279 int ecode11 = 0 ;
15280 Matrix temp12 ;
15281 octave_value_list _out;
15282 octave_value_list *_outp=&_out;
15283 octave_value _outv;
15284
15285 try {
15286 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15287 SWIG_fail;
15288 }
15289 {
15290 if ( _n_dims( args(0) ) > 2 )
15291 {
15292 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15293 }
15294 temp1 = args(0).matrix_value();
15295 arg1 = &temp1( 0, 0 );
15296 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15297 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15298 }
15299 ecode4 = SWIG_AsVal_double(args(1), &val4);
15300 if (!SWIG_IsOK(ecode4)) {
15301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15302 }
15303 arg4 = static_cast< PLFLT >(val4);
15304 ecode5 = SWIG_AsVal_double(args(2), &val5);
15305 if (!SWIG_IsOK(ecode5)) {
15306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15307 }
15308 arg5 = static_cast< PLFLT >(val5);
15309 ecode6 = SWIG_AsVal_double(args(3), &val6);
15310 if (!SWIG_IsOK(ecode6)) {
15311 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15312 }
15313 arg6 = static_cast< PLFLT >(val6);
15314 ecode7 = SWIG_AsVal_double(args(4), &val7);
15315 if (!SWIG_IsOK(ecode7)) {
15316 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15317 }
15318 arg7 = static_cast< PLFLT >(val7);
15319 ecode8 = SWIG_AsVal_double(args(5), &val8);
15320 if (!SWIG_IsOK(ecode8)) {
15321 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15322 }
15323 arg8 = static_cast< PLFLT >(val8);
15324 ecode9 = SWIG_AsVal_double(args(6), &val9);
15325 if (!SWIG_IsOK(ecode9)) {
15326 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15327 }
15328 arg9 = static_cast< PLFLT >(val9);
15329 ecode10 = SWIG_AsVal_double(args(7), &val10);
15330 if (!SWIG_IsOK(ecode10)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15332 }
15333 arg10 = static_cast< PLFLT >(val10);
15334 ecode11 = SWIG_AsVal_double(args(8), &val11);
15335 if (!SWIG_IsOK(ecode11)) {
15336 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15337 }
15338 arg11 = static_cast< PLFLT >(val11);
15339 {
15340 if ( _n_dims( args(9) ) > 1 )
15341 {
15342 error( "argument must be a scalar or vector" ); SWIG_fail;
15343 }
15344 if ( _dim( args(9), 0 ) != 6 )
15345 {
15346 error( "argument vectors must have length of 6" ); SWIG_fail;
15347 }
15348 temp12 = args(9).matrix_value();
15349 arg12 = &temp12( 0, 0 );
15350 }
15351 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15352 _outv = octave_value();
15353 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15354 {
15355
15356 }
15357 {
15358
15359 }
15360 return _out;
15361 fail:
15362 {
15363
15364 }
15365 {
15366
15367 }
15368 return octave_value_list();
15369 }
15370 catch(...) {
15371 {
15372
15373 }
15374 {
15375
15376 }
15377 throw;
15378 }
15379}
15380
15381
15382SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15383 PLFLT *arg1 = (PLFLT *) 0 ;
15384 PLINT arg2 ;
15385 PLINT arg3 ;
15386 PLFLT arg4 ;
15387 PLFLT arg5 ;
15388 PLFLT arg6 ;
15389 PLFLT arg7 ;
15390 PLFLT arg8 ;
15391 PLFLT arg9 ;
15392 PLFLT arg10 ;
15393 PLFLT arg11 ;
15394 PLFLT *arg12 = (PLFLT *) 0 ;
15395 PLFLT *arg13 = (PLFLT *) 0 ;
15396 Matrix temp1 ;
15397 double val4 ;
15398 int ecode4 = 0 ;
15399 double val5 ;
15400 int ecode5 = 0 ;
15401 double val6 ;
15402 int ecode6 = 0 ;
15403 double val7 ;
15404 int ecode7 = 0 ;
15405 double val8 ;
15406 int ecode8 = 0 ;
15407 double val9 ;
15408 int ecode9 = 0 ;
15409 double val10 ;
15410 int ecode10 = 0 ;
15411 double val11 ;
15412 int ecode11 = 0 ;
15413 Matrix temp12 ;
15414 Matrix temp13 ;
15415 octave_value_list _out;
15416 octave_value_list *_outp=&_out;
15417 octave_value _outv;
15418
15419 try {
15420 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15421 SWIG_fail;
15422 }
15423 {
15424 if ( _n_dims( args(0) ) > 2 )
15425 {
15426 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15427 }
15428 temp1 = args(0).matrix_value();
15429 arg1 = &temp1( 0, 0 );
15430 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15431 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15432 }
15433 ecode4 = SWIG_AsVal_double(args(1), &val4);
15434 if (!SWIG_IsOK(ecode4)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15436 }
15437 arg4 = static_cast< PLFLT >(val4);
15438 ecode5 = SWIG_AsVal_double(args(2), &val5);
15439 if (!SWIG_IsOK(ecode5)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15441 }
15442 arg5 = static_cast< PLFLT >(val5);
15443 ecode6 = SWIG_AsVal_double(args(3), &val6);
15444 if (!SWIG_IsOK(ecode6)) {
15445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15446 }
15447 arg6 = static_cast< PLFLT >(val6);
15448 ecode7 = SWIG_AsVal_double(args(4), &val7);
15449 if (!SWIG_IsOK(ecode7)) {
15450 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15451 }
15452 arg7 = static_cast< PLFLT >(val7);
15453 ecode8 = SWIG_AsVal_double(args(5), &val8);
15454 if (!SWIG_IsOK(ecode8)) {
15455 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15456 }
15457 arg8 = static_cast< PLFLT >(val8);
15458 ecode9 = SWIG_AsVal_double(args(6), &val9);
15459 if (!SWIG_IsOK(ecode9)) {
15460 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15461 }
15462 arg9 = static_cast< PLFLT >(val9);
15463 ecode10 = SWIG_AsVal_double(args(7), &val10);
15464 if (!SWIG_IsOK(ecode10)) {
15465 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15466 }
15467 arg10 = static_cast< PLFLT >(val10);
15468 ecode11 = SWIG_AsVal_double(args(8), &val11);
15469 if (!SWIG_IsOK(ecode11)) {
15470 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15471 }
15472 arg11 = static_cast< PLFLT >(val11);
15473 {
15474 if ( _n_dims( args(9) ) > 1 )
15475 {
15476 error( "argument must be a scalar or vector" ); SWIG_fail;
15477 }
15478 if ( _dim( args(9), 0 ) != Xlen )
15479 {
15480 error( "argument vectors must be same length" ); SWIG_fail;
15481 }
15482 temp12 = args(9).matrix_value();
15483 arg12 = &temp12( 0, 0 );
15484 }
15485 {
15486 if ( _n_dims( args(10) ) > 1 )
15487 {
15488 error( "argument must be a scalar or vector" ); SWIG_fail;
15489 }
15490 if ( _dim( args(10), 0 ) != Ylen )
15491 {
15492 error( "argument vectors must be same length" ); SWIG_fail;
15493 }
15494 temp13 = args(10).matrix_value();
15495 arg13 = &temp13( 0, 0 );
15496 }
15497 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15498 _outv = octave_value();
15499 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15500 {
15501
15502 }
15503 {
15504
15505 }
15506 {
15507
15508 }
15509 return _out;
15510 fail:
15511 {
15512
15513 }
15514 {
15515
15516 }
15517 {
15518
15519 }
15520 return octave_value_list();
15521 }
15522 catch(...) {
15523 {
15524
15525 }
15526 {
15527
15528 }
15529 {
15530
15531 }
15532 throw;
15533 }
15534}
15535
15536
15537SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15538 PLFLT *arg1 = (PLFLT *) 0 ;
15539 PLINT arg2 ;
15540 PLINT arg3 ;
15541 PLFLT arg4 ;
15542 PLFLT arg5 ;
15543 PLFLT arg6 ;
15544 PLFLT arg7 ;
15545 PLFLT arg8 ;
15546 PLFLT arg9 ;
15547 PLFLT arg10 ;
15548 PLFLT arg11 ;
15549 PLFLT *arg12 = (PLFLT *) 0 ;
15550 PLFLT *arg13 = (PLFLT *) 0 ;
15551 Matrix temp1 ;
15552 double val4 ;
15553 int ecode4 = 0 ;
15554 double val5 ;
15555 int ecode5 = 0 ;
15556 double val6 ;
15557 int ecode6 = 0 ;
15558 double val7 ;
15559 int ecode7 = 0 ;
15560 double val8 ;
15561 int ecode8 = 0 ;
15562 double val9 ;
15563 int ecode9 = 0 ;
15564 double val10 ;
15565 int ecode10 = 0 ;
15566 double val11 ;
15567 int ecode11 = 0 ;
15568 Matrix temp12 ;
15569 Matrix temp13 ;
15570 octave_value_list _out;
15571 octave_value_list *_outp=&_out;
15572 octave_value _outv;
15573
15574 try {
15575 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15576 SWIG_fail;
15577 }
15578 {
15579 if ( _n_dims( args(0) ) > 2 )
15580 {
15581 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15582 }
15583 temp1 = args(0).matrix_value();
15584 arg1 = &temp1( 0, 0 );
15585 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15586 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15587 }
15588 ecode4 = SWIG_AsVal_double(args(1), &val4);
15589 if (!SWIG_IsOK(ecode4)) {
15590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15591 }
15592 arg4 = static_cast< PLFLT >(val4);
15593 ecode5 = SWIG_AsVal_double(args(2), &val5);
15594 if (!SWIG_IsOK(ecode5)) {
15595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15596 }
15597 arg5 = static_cast< PLFLT >(val5);
15598 ecode6 = SWIG_AsVal_double(args(3), &val6);
15599 if (!SWIG_IsOK(ecode6)) {
15600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15601 }
15602 arg6 = static_cast< PLFLT >(val6);
15603 ecode7 = SWIG_AsVal_double(args(4), &val7);
15604 if (!SWIG_IsOK(ecode7)) {
15605 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15606 }
15607 arg7 = static_cast< PLFLT >(val7);
15608 ecode8 = SWIG_AsVal_double(args(5), &val8);
15609 if (!SWIG_IsOK(ecode8)) {
15610 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15611 }
15612 arg8 = static_cast< PLFLT >(val8);
15613 ecode9 = SWIG_AsVal_double(args(6), &val9);
15614 if (!SWIG_IsOK(ecode9)) {
15615 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15616 }
15617 arg9 = static_cast< PLFLT >(val9);
15618 ecode10 = SWIG_AsVal_double(args(7), &val10);
15619 if (!SWIG_IsOK(ecode10)) {
15620 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15621 }
15622 arg10 = static_cast< PLFLT >(val10);
15623 ecode11 = SWIG_AsVal_double(args(8), &val11);
15624 if (!SWIG_IsOK(ecode11)) {
15625 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15626 }
15627 arg11 = static_cast< PLFLT >(val11);
15628 {
15629 if ( _n_dims( args(9) ) > 2 )
15630 {
15631 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15632 }
15633 temp12 = args(9).matrix_value();
15634 arg12 = &temp12( 0, 0 );
15635 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15636 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15637 }
15638 {
15639 if ( _n_dims( args(10) ) > 2 )
15640 {
15641 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15642 }
15643 temp13 = args(10).matrix_value();
15644 arg13 = &temp13( 0, 0 );
15645 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15646 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15647 }
15648 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15649 _outv = octave_value();
15650 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15651 {
15652
15653 }
15654 {
15655
15656 }
15657 {
15658
15659 }
15660 return _out;
15661 fail:
15662 {
15663
15664 }
15665 {
15666
15667 }
15668 {
15669
15670 }
15671 return octave_value_list();
15672 }
15673 catch(...) {
15674 {
15675
15676 }
15677 {
15678
15679 }
15680 {
15681
15682 }
15683 throw;
15684 }
15685}
15686
15687
15688SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15689 PLFLT *arg1 = (PLFLT *) 0 ;
15690 PLFLT *arg2 = (PLFLT *) 0 ;
15691 PLINT arg3 ;
15692 PLINT arg4 ;
15693 PLFLT arg5 ;
15694 PLFLT arg6 ;
15695 PLFLT arg7 ;
15696 PLFLT arg8 ;
15697 PLINT arg9 ;
15698 PLINT arg10 ;
15699 PLINT arg11 ;
15700 PLFLT arg12 ;
15701 PLFLT arg13 ;
15702 PLINT arg14 ;
15703 PLFLT arg15 ;
15704 PLINT arg16 ;
15705 PLINT *arg17 = (PLINT *) 0 ;
15706 char **arg18 = (char **) 0 ;
15707 PLINT arg19 ;
15708 char **arg20 = (char **) 0 ;
15709 PLFLT *arg21 = (PLFLT *) 0 ;
15710 PLINT *arg22 = (PLINT *) 0 ;
15711 PLINT *arg23 = (PLINT *) 0 ;
15712 PLFLT *arg24 = (PLFLT *) 0 ;
15713 PLFLT temp1 ;
15714 int res1 = SWIG_TMPOBJ ;
15715 PLFLT temp2 ;
15716 int res2 = SWIG_TMPOBJ ;
15717 int val3 ;
15718 int ecode3 = 0 ;
15719 int val4 ;
15720 int ecode4 = 0 ;
15721 double val5 ;
15722 int ecode5 = 0 ;
15723 double val6 ;
15724 int ecode6 = 0 ;
15725 double val7 ;
15726 int ecode7 = 0 ;
15727 double val8 ;
15728 int ecode8 = 0 ;
15729 int val9 ;
15730 int ecode9 = 0 ;
15731 int val10 ;
15732 int ecode10 = 0 ;
15733 int val11 ;
15734 int ecode11 = 0 ;
15735 double val12 ;
15736 int ecode12 = 0 ;
15737 double val13 ;
15738 int ecode13 = 0 ;
15739 int val14 ;
15740 int ecode14 = 0 ;
15741 double val15 ;
15742 int ecode15 = 0 ;
15743 Matrix temp16 ;
15744 Matrix temp21 ;
15745 Matrix temp22 ;
15746 Matrix temp23 ;
15747 Matrix temp24 ;
15748 octave_value_list _out;
15749 octave_value_list *_outp=&_out;
15750 octave_value _outv;
15751
15752 try {
15753 arg1 = &temp1;
15754 arg2 = &temp2;
15755 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15756 SWIG_fail;
15757 }
15758 ecode3 = SWIG_AsVal_int(args(0), &val3);
15759 if (!SWIG_IsOK(ecode3)) {
15760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15761 }
15762 arg3 = static_cast< PLINT >(val3);
15763 ecode4 = SWIG_AsVal_int(args(1), &val4);
15764 if (!SWIG_IsOK(ecode4)) {
15765 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15766 }
15767 arg4 = static_cast< PLINT >(val4);
15768 ecode5 = SWIG_AsVal_double(args(2), &val5);
15769 if (!SWIG_IsOK(ecode5)) {
15770 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15771 }
15772 arg5 = static_cast< PLFLT >(val5);
15773 ecode6 = SWIG_AsVal_double(args(3), &val6);
15774 if (!SWIG_IsOK(ecode6)) {
15775 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15776 }
15777 arg6 = static_cast< PLFLT >(val6);
15778 ecode7 = SWIG_AsVal_double(args(4), &val7);
15779 if (!SWIG_IsOK(ecode7)) {
15780 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15781 }
15782 arg7 = static_cast< PLFLT >(val7);
15783 ecode8 = SWIG_AsVal_double(args(5), &val8);
15784 if (!SWIG_IsOK(ecode8)) {
15785 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15786 }
15787 arg8 = static_cast< PLFLT >(val8);
15788 ecode9 = SWIG_AsVal_int(args(6), &val9);
15789 if (!SWIG_IsOK(ecode9)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15791 }
15792 arg9 = static_cast< PLINT >(val9);
15793 ecode10 = SWIG_AsVal_int(args(7), &val10);
15794 if (!SWIG_IsOK(ecode10)) {
15795 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15796 }
15797 arg10 = static_cast< PLINT >(val10);
15798 ecode11 = SWIG_AsVal_int(args(8), &val11);
15799 if (!SWIG_IsOK(ecode11)) {
15800 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15801 }
15802 arg11 = static_cast< PLINT >(val11);
15803 ecode12 = SWIG_AsVal_double(args(9), &val12);
15804 if (!SWIG_IsOK(ecode12)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15806 }
15807 arg12 = static_cast< PLFLT >(val12);
15808 ecode13 = SWIG_AsVal_double(args(10), &val13);
15809 if (!SWIG_IsOK(ecode13)) {
15810 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15811 }
15812 arg13 = static_cast< PLFLT >(val13);
15813 ecode14 = SWIG_AsVal_int(args(11), &val14);
15814 if (!SWIG_IsOK(ecode14)) {
15815 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15816 }
15817 arg14 = static_cast< PLINT >(val14);
15818 ecode15 = SWIG_AsVal_double(args(12), &val15);
15819 if (!SWIG_IsOK(ecode15)) {
15820 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15821 }
15822 arg15 = static_cast< PLFLT >(val15);
15823 {
15824 if ( _n_dims( args(13) ) > 1 )
15825 {
15826 error( "argument must be a scalar or vector" ); SWIG_fail;
15827 }
15828 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15829 arg17 = new PLINT[Alen];
15830 temp16 = args(13).matrix_value();
15831 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15832 }
15833 {
15834 charMatrix temp_matrix;
15835 Cell temp_cell;
15836 char *tmp_cstring;
15837 std::string str;
15838 size_t max_length = 0, non_blank_length;
15839 int i, ifcell;
15840 if ( _n_dims( args(14) ) > 2 )
15841 {
15842 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15843 }
15844#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15845 if ( !args(14).isempty() )
15846#else
15847 if ( !args(14).is_empty() )
15848#endif
15849 {
15850 if ( _dim( args(14), 0 ) != Alen )
15851 {
15852 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15853 }
15854 arg18 = new char*[Alen];
15855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15856 ifcell = args(14).iscell();
15857#else
15858 ifcell = args(14).is_cell();
15859#endif
15860 if ( ifcell )
15861 {
15862 temp_cell = args(14).cell_value();
15863 }
15864 else
15865 {
15866 temp_matrix = args(14).char_matrix_value();
15867 // Allow one extra space for null termination.
15868 max_length = _dim( args(14), 1 ) + 1;
15869 }
15870
15871 for ( i = 0; i < Alen; i++ )
15872 {
15873 // Must copy string to "permanent" location because the string
15874 // location corresponding to tmp_cstring gets
15875 // overwritten for each iteration of loop.
15876 if ( ifcell )
15877 {
15878 if ( temp_cell.elem( i ).is_string() )
15879 {
15880 str = temp_cell.elem( i ).string_value();
15881 // leave room for null termination.
15882 max_length = str.size() + 1;
15883 tmp_cstring = (char *) str.c_str();
15884 }
15885 else
15886 {
15887 // Use null string if user attempts to pass a cell array
15888 // with a non-string element (likely an empty element
15889 // since that should be allowed by the PLplot interface
15890 // if that element is going to be unused).
15891 // leave room for null termination.
15892 max_length = 1;
15893 tmp_cstring = (char *) "";
15894 }
15895 }
15896 else
15897 {
15898 str = temp_matrix.row_as_string( i );
15899 tmp_cstring = (char *) str.c_str();
15900 }
15901 arg18[i] = new char[max_length];
15902 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15903 arg18[i][max_length - 1] = '\0';
15904 // All the trailing blank crapola should not be needed for
15905 // string cell arrays.
15906 if ( !ifcell )
15907 {
15908 // remove trailing-blank padding that is used by the
15909 // charMatrix class to insure all strings in a given
15910 // charMatrix instance have the same length.
15911 // This transformation also removes legitimate trailing
15912 // blanks but there is nothing we can do about that
15913 // for the charMatrix class.
15914
15915 // Look for trailing nulls first (just in case, although that
15916 // shouldn't happen if charMatrix implemented as documented)
15917 // before looking for trailing blanks.
15918 non_blank_length = max_length - 2;
15919 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15920 {
15921 non_blank_length--;
15922 }
15923 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15924 {
15925 non_blank_length--;
15926 }
15927 arg18[i][non_blank_length + 1] = '\0';
15928 }
15929 }
15930 }
15931 else
15932 {
15933 arg18 = NULL;
15934 }
15935 }
15936 {
15937 charMatrix temp_matrix;
15938 Cell temp_cell;
15939 char *tmp_cstring;
15940 std::string str;
15941 size_t max_length = 0, non_blank_length;
15942 int i, ifcell;
15943 if ( _n_dims( args(15) ) > 2 )
15944 {
15945 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15946 }
15947#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15948 if ( !args(15).isempty() )
15949#else
15950 if ( !args(15).is_empty() )
15951#endif
15952 {
15953 Alen = _dim( args(15), 0 );
15954 arg19 = Alen;
15955 arg20 = new char*[Alen];
15956#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15957 ifcell = args(15).iscell();
15958#else
15959 ifcell = args(15).is_cell();
15960#endif
15961 if ( ifcell )
15962 {
15963 temp_cell = args(15).cell_value();
15964 }
15965 else
15966 {
15967 temp_matrix = args(15).char_matrix_value();
15968 // Allow one extra space for null termination.
15969 max_length = _dim( args(15), 1 ) + 1;
15970 }
15971
15972 for ( i = 0; i < Alen; i++ )
15973 {
15974 // Must copy string to "permanent" location because the string
15975 // location corresponding to tmp_cstring gets
15976 // overwritten for each iteration of loop.
15977 if ( ifcell )
15978 {
15979 if ( temp_cell.elem( i ).is_string() )
15980 {
15981 str = temp_cell.elem( i ).string_value();
15982 // leave room for null termination.
15983 max_length = str.size() + 1;
15984 tmp_cstring = (char *) str.c_str();
15985 }
15986 else
15987 {
15988 // Use null string if user attempts to pass a cell array
15989 // with a non-string element (likely an empty element
15990 // since that should be allowed by the PLplot interface
15991 // if that element is going to be unused).
15992 // leave room for null termination.
15993 max_length = 1;
15994 tmp_cstring = (char *) "";
15995 }
15996 }
15997 else
15998 {
15999 str = temp_matrix.row_as_string( i );
16000 tmp_cstring = (char *) str.c_str();
16001 }
16002 arg20[i] = new char[max_length];
16003 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16004 arg20[i][max_length - 1] = '\0';
16005 // All the trailing blank crapola should not be needed for
16006 // string cell arrays.
16007 if ( !ifcell )
16008 {
16009 // remove trailing-blank padding that is used by the
16010 // charMatrix class to insure all strings in a given
16011 // charMatrix instance have the same length.
16012 // This transformation also removes legitimate trailing
16013 // blanks but there is nothing we can do about that
16014 // for the charMatrix class.
16015
16016 // Look for trailing nulls first (just in case, although that
16017 // shouldn't happen if charMatrix implemented as documented)
16018 // before looking for trailing blanks.
16019 non_blank_length = max_length - 2;
16020 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16021 {
16022 non_blank_length--;
16023 }
16024 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16025 {
16026 non_blank_length--;
16027 }
16028 arg20[i][non_blank_length + 1] = '\0';
16029 }
16030 }
16031 }
16032 else
16033 {
16034 arg19 = 0;
16035 arg20 = NULL;
16036 }
16037 }
16038 {
16039 if ( _n_dims( args(16) ) > 1 )
16040 {
16041 error( "argument must be a scalar or vector" ); SWIG_fail;
16042 }
16043 if ( _dim( args(16), 0 ) != Alen )
16044 {
16045 error( "argument vectors must be same length" ); SWIG_fail;
16046 }
16047 temp21 = args(16).matrix_value();
16048 arg21 = &temp21( 0, 0 );
16049 }
16050 {
16051 if ( _n_dims( args(17) ) > 1 )
16052 {
16053 error( "argument must be a scalar or vector" ); SWIG_fail;
16054 }
16055 if ( _dim( args(17), 0 ) != Alen )
16056 {
16057 error( "argument vectors must be same length" ); SWIG_fail;
16058 }
16059 temp22 = args(17).matrix_value();
16060 arg22 = new PLINT[Alen];
16061 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16062 }
16063 {
16064 int i;
16065 if ( _n_dims( args(18) ) > 1 )
16066 {
16067 error( "argument must be a scalar or vector" ); SWIG_fail;
16068 }
16069 if ( _dim( args(18), 0 ) != Alen )
16070 {
16071 error( "argument vectors must be same length" ); SWIG_fail;
16072 }
16073 Xlen = Alen;
16074 temp23 = args(18).matrix_value();
16075 arg23 = new PLINT[Alen];
16076 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16077 Ylen = -1;
16078 for ( i = 0; i < Xlen; i++ )
16079 if ( arg23[i] > Ylen )
16080 Ylen = arg23[i];
16081 }
16082 {
16083 if ( _n_dims( args(19) ) > 2 )
16084 {
16085 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16086 }
16087 if ( _dim( args(19), 0 ) != Xlen )
16088 {
16089 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16090 }
16091 if ( _dim( args(19), 1 ) != Ylen )
16092 {
16093 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16094 }
16095 temp24 = args(19).matrix_value();
16096 arg24 = &temp24( 0, 0 );
16097 }
16098 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);
16099 _outv = octave_value();
16100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16101 if (SWIG_IsTmpObj(res1)) {
16102 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16103 } else {
16104 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16105 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16106 }
16107 if (SWIG_IsTmpObj(res2)) {
16108 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16109 } else {
16110 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16111 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16112 }
16113 {
16114 delete [] arg17;
16115 }
16116 {
16117 int i;
16118 if ( arg18 != NULL )
16119 {
16120 for ( i = 0; i < Alen; i++ )
16121 {
16122 delete[] arg18[i];
16123 }
16124 delete[] arg18;
16125 }
16126 }
16127 {
16128 int i;
16129 if ( arg20 != NULL )
16130 {
16131 for ( i = 0; i < Alen; i++ )
16132 {
16133 delete[] arg20[i];
16134 }
16135 delete[] arg20;
16136 }
16137 }
16138 {
16139
16140 }
16141 {
16142 delete [] arg22;
16143 }
16144 {
16145 delete [] arg23;
16146 }
16147 {
16148
16149 }
16150 return _out;
16151 fail:
16152 {
16153 delete [] arg17;
16154 }
16155 {
16156 int i;
16157 if ( arg18 != NULL )
16158 {
16159 for ( i = 0; i < Alen; i++ )
16160 {
16161 delete[] arg18[i];
16162 }
16163 delete[] arg18;
16164 }
16165 }
16166 {
16167 int i;
16168 if ( arg20 != NULL )
16169 {
16170 for ( i = 0; i < Alen; i++ )
16171 {
16172 delete[] arg20[i];
16173 }
16174 delete[] arg20;
16175 }
16176 }
16177 {
16178
16179 }
16180 {
16181 delete [] arg22;
16182 }
16183 {
16184 delete [] arg23;
16185 }
16186 {
16187
16188 }
16189 return octave_value_list();
16190 }
16191 catch(...) {
16192 {
16193 delete [] arg17;
16194 }
16195 {
16196 int i;
16197 if ( arg18 != NULL )
16198 {
16199 for ( i = 0; i < Alen; i++ )
16200 {
16201 delete[] arg18[i];
16202 }
16203 delete[] arg18;
16204 }
16205 }
16206 {
16207 int i;
16208 if ( arg20 != NULL )
16209 {
16210 for ( i = 0; i < Alen; i++ )
16211 {
16212 delete[] arg20[i];
16213 }
16214 delete[] arg20;
16215 }
16216 }
16217 {
16218
16219 }
16220 {
16221 delete [] arg22;
16222 }
16223 {
16224 delete [] arg23;
16225 }
16226 {
16227
16228 }
16229 throw;
16230 }
16231}
16232
16233
16234SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16235 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16236 int arg2 ;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 int val2 ;
16240 int ecode2 = 0 ;
16241 octave_value_list _out;
16242 octave_value_list *_outp=&_out;
16243 octave_value _outv;
16244
16245 try {
16246 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16247 SWIG_fail;
16248 }
16249 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16250 if (!SWIG_IsOK(res1)) {
16251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16252 }
16253 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16254 ecode2 = SWIG_AsVal_int(args(1), &val2);
16255 if (!SWIG_IsOK(ecode2)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16257 }
16258 arg2 = static_cast< int >(val2);
16259 if (arg1) (arg1)->type = arg2;
16260 _outv = octave_value();
16261 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16262 return _out;
16263 fail:
16264 return octave_value_list();
16265 }
16266 catch(...) {
16267 throw;
16268 }
16269}
16270
16271
16272SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16273 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16274 void *argp1 = 0 ;
16275 int res1 = 0 ;
16276 octave_value_list _out;
16277 octave_value_list *_outp=&_out;
16278 octave_value _outv;
16279 int result;
16280
16281 try {
16282 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16283 SWIG_fail;
16284 }
16285 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16286 if (!SWIG_IsOK(res1)) {
16287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16288 }
16289 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16290 result = (int) ((arg1)->type);
16291 _outv = SWIG_From_int(static_cast< int >(result));
16292 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16293 return _out;
16294 fail:
16295 return octave_value_list();
16296 }
16297 catch(...) {
16298 throw;
16299 }
16300}
16301
16302
16303SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16304 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16305 unsigned int arg2 ;
16306 void *argp1 = 0 ;
16307 int res1 = 0 ;
16308 unsigned int val2 ;
16309 int ecode2 = 0 ;
16310 octave_value_list _out;
16311 octave_value_list *_outp=&_out;
16312 octave_value _outv;
16313
16314 try {
16315 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16316 SWIG_fail;
16317 }
16318 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16321 }
16322 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16323 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16324 if (!SWIG_IsOK(ecode2)) {
16325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16326 }
16327 arg2 = static_cast< unsigned int >(val2);
16328 if (arg1) (arg1)->state = arg2;
16329 _outv = octave_value();
16330 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16331 return _out;
16332 fail:
16333 return octave_value_list();
16334 }
16335 catch(...) {
16336 throw;
16337 }
16338}
16339
16340
16341SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16342 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16343 void *argp1 = 0 ;
16344 int res1 = 0 ;
16345 octave_value_list _out;
16346 octave_value_list *_outp=&_out;
16347 octave_value _outv;
16348 unsigned int result;
16349
16350 try {
16351 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16352 SWIG_fail;
16353 }
16354 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16357 }
16358 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16359 result = (unsigned int) ((arg1)->state);
16360 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16362 return _out;
16363 fail:
16364 return octave_value_list();
16365 }
16366 catch(...) {
16367 throw;
16368 }
16369}
16370
16371
16372SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16373 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16374 unsigned int arg2 ;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 unsigned int val2 ;
16378 int ecode2 = 0 ;
16379 octave_value_list _out;
16380 octave_value_list *_outp=&_out;
16381 octave_value _outv;
16382
16383 try {
16384 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16385 SWIG_fail;
16386 }
16387 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16388 if (!SWIG_IsOK(res1)) {
16389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16390 }
16391 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16392 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16393 if (!SWIG_IsOK(ecode2)) {
16394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16395 }
16396 arg2 = static_cast< unsigned int >(val2);
16397 if (arg1) (arg1)->keysym = arg2;
16398 _outv = octave_value();
16399 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16400 return _out;
16401 fail:
16402 return octave_value_list();
16403 }
16404 catch(...) {
16405 throw;
16406 }
16407}
16408
16409
16410SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16411 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16412 void *argp1 = 0 ;
16413 int res1 = 0 ;
16414 octave_value_list _out;
16415 octave_value_list *_outp=&_out;
16416 octave_value _outv;
16417 unsigned int result;
16418
16419 try {
16420 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16421 SWIG_fail;
16422 }
16423 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16426 }
16427 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16428 result = (unsigned int) ((arg1)->keysym);
16429 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16430 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16431 return _out;
16432 fail:
16433 return octave_value_list();
16434 }
16435 catch(...) {
16436 throw;
16437 }
16438}
16439
16440
16441SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16442 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16443 unsigned int arg2 ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 unsigned int val2 ;
16447 int ecode2 = 0 ;
16448 octave_value_list _out;
16449 octave_value_list *_outp=&_out;
16450 octave_value _outv;
16451
16452 try {
16453 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16454 SWIG_fail;
16455 }
16456 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16457 if (!SWIG_IsOK(res1)) {
16458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16459 }
16460 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16461 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16462 if (!SWIG_IsOK(ecode2)) {
16463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16464 }
16465 arg2 = static_cast< unsigned int >(val2);
16466 if (arg1) (arg1)->button = arg2;
16467 _outv = octave_value();
16468 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16469 return _out;
16470 fail:
16471 return octave_value_list();
16472 }
16473 catch(...) {
16474 throw;
16475 }
16476}
16477
16478
16479SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16480 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16481 void *argp1 = 0 ;
16482 int res1 = 0 ;
16483 octave_value_list _out;
16484 octave_value_list *_outp=&_out;
16485 octave_value _outv;
16486 unsigned int result;
16487
16488 try {
16489 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16490 SWIG_fail;
16491 }
16492 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16493 if (!SWIG_IsOK(res1)) {
16494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16495 }
16496 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16497 result = (unsigned int) ((arg1)->button);
16498 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16499 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16500 return _out;
16501 fail:
16502 return octave_value_list();
16503 }
16504 catch(...) {
16505 throw;
16506 }
16507}
16508
16509
16510SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16511 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16512 PLINT arg2 ;
16513 void *argp1 = 0 ;
16514 int res1 = 0 ;
16515 int val2 ;
16516 int ecode2 = 0 ;
16517 octave_value_list _out;
16518 octave_value_list *_outp=&_out;
16519 octave_value _outv;
16520
16521 try {
16522 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16523 SWIG_fail;
16524 }
16525 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16528 }
16529 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16530 ecode2 = SWIG_AsVal_int(args(1), &val2);
16531 if (!SWIG_IsOK(ecode2)) {
16532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16533 }
16534 arg2 = static_cast< PLINT >(val2);
16535 if (arg1) (arg1)->subwindow = arg2;
16536 _outv = octave_value();
16537 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16538 return _out;
16539 fail:
16540 return octave_value_list();
16541 }
16542 catch(...) {
16543 throw;
16544 }
16545}
16546
16547
16548SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16549 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16550 void *argp1 = 0 ;
16551 int res1 = 0 ;
16552 octave_value_list _out;
16553 octave_value_list *_outp=&_out;
16554 octave_value _outv;
16555 PLINT result;
16556
16557 try {
16558 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16559 SWIG_fail;
16560 }
16561 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16562 if (!SWIG_IsOK(res1)) {
16563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16564 }
16565 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16566 result = (PLINT) ((arg1)->subwindow);
16567 _outv = SWIG_From_int(static_cast< int >(result));
16568 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16569 return _out;
16570 fail:
16571 return octave_value_list();
16572 }
16573 catch(...) {
16574 throw;
16575 }
16576}
16577
16578
16579SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16580 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16581 char *arg2 = (char *) (char *)0 ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 char temp2[16] ;
16585 int res2 ;
16586 octave_value_list _out;
16587 octave_value_list *_outp=&_out;
16588 octave_value _outv;
16589
16590 try {
16591 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16592 SWIG_fail;
16593 }
16594 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16595 if (!SWIG_IsOK(res1)) {
16596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16597 }
16598 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16599 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16600 if (!SWIG_IsOK(res2)) {
16601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16602 }
16603 arg2 = reinterpret_cast< char * >(temp2);
16604 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16605 else memset(arg1->string,0,16*sizeof(char));
16606 _outv = octave_value();
16607 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16608 return _out;
16609 fail:
16610 return octave_value_list();
16611 }
16612 catch(...) {
16613 throw;
16614 }
16615}
16616
16617
16618SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16619 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16620 void *argp1 = 0 ;
16621 int res1 = 0 ;
16622 octave_value_list _out;
16623 octave_value_list *_outp=&_out;
16624 octave_value _outv;
16625 char *result = 0 ;
16626
16627 try {
16628 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16629 SWIG_fail;
16630 }
16631 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16632 if (!SWIG_IsOK(res1)) {
16633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16634 }
16635 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16636 result = (char *)(char *) ((arg1)->string);
16637 {
16638 size_t size = SWIG_strnlen(result, 16);
16639
16640
16641
16642 _outv = SWIG_FromCharPtrAndSize(result, size);
16643 }
16644 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16645 return _out;
16646 fail:
16647 return octave_value_list();
16648 }
16649 catch(...) {
16650 throw;
16651 }
16652}
16653
16654
16655SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16656 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16657 int arg2 ;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 octave_value_list _out;
16663 octave_value_list *_outp=&_out;
16664 octave_value _outv;
16665
16666 try {
16667 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16668 SWIG_fail;
16669 }
16670 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16673 }
16674 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16675 ecode2 = SWIG_AsVal_int(args(1), &val2);
16676 if (!SWIG_IsOK(ecode2)) {
16677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16678 }
16679 arg2 = static_cast< int >(val2);
16680 if (arg1) (arg1)->pX = arg2;
16681 _outv = octave_value();
16682 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16683 return _out;
16684 fail:
16685 return octave_value_list();
16686 }
16687 catch(...) {
16688 throw;
16689 }
16690}
16691
16692
16693SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16694 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16695 void *argp1 = 0 ;
16696 int res1 = 0 ;
16697 octave_value_list _out;
16698 octave_value_list *_outp=&_out;
16699 octave_value _outv;
16700 int result;
16701
16702 try {
16703 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16704 SWIG_fail;
16705 }
16706 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16707 if (!SWIG_IsOK(res1)) {
16708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16709 }
16710 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16711 result = (int) ((arg1)->pX);
16712 _outv = SWIG_From_int(static_cast< int >(result));
16713 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16714 return _out;
16715 fail:
16716 return octave_value_list();
16717 }
16718 catch(...) {
16719 throw;
16720 }
16721}
16722
16723
16724SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16725 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16726 int arg2 ;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 int val2 ;
16730 int ecode2 = 0 ;
16731 octave_value_list _out;
16732 octave_value_list *_outp=&_out;
16733 octave_value _outv;
16734
16735 try {
16736 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16737 SWIG_fail;
16738 }
16739 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16740 if (!SWIG_IsOK(res1)) {
16741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16742 }
16743 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16744 ecode2 = SWIG_AsVal_int(args(1), &val2);
16745 if (!SWIG_IsOK(ecode2)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16747 }
16748 arg2 = static_cast< int >(val2);
16749 if (arg1) (arg1)->pY = arg2;
16750 _outv = octave_value();
16751 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16752 return _out;
16753 fail:
16754 return octave_value_list();
16755 }
16756 catch(...) {
16757 throw;
16758 }
16759}
16760
16761
16762SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16763 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16764 void *argp1 = 0 ;
16765 int res1 = 0 ;
16766 octave_value_list _out;
16767 octave_value_list *_outp=&_out;
16768 octave_value _outv;
16769 int result;
16770
16771 try {
16772 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16773 SWIG_fail;
16774 }
16775 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16778 }
16779 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16780 result = (int) ((arg1)->pY);
16781 _outv = SWIG_From_int(static_cast< int >(result));
16782 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16783 return _out;
16784 fail:
16785 return octave_value_list();
16786 }
16787 catch(...) {
16788 throw;
16789 }
16790}
16791
16792
16793SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16794 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16795 PLFLT arg2 ;
16796 void *argp1 = 0 ;
16797 int res1 = 0 ;
16798 double val2 ;
16799 int ecode2 = 0 ;
16800 octave_value_list _out;
16801 octave_value_list *_outp=&_out;
16802 octave_value _outv;
16803
16804 try {
16805 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16806 SWIG_fail;
16807 }
16808 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16809 if (!SWIG_IsOK(res1)) {
16810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16811 }
16812 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16813 ecode2 = SWIG_AsVal_double(args(1), &val2);
16814 if (!SWIG_IsOK(ecode2)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16816 }
16817 arg2 = static_cast< PLFLT >(val2);
16818 if (arg1) (arg1)->dX = arg2;
16819 _outv = octave_value();
16820 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16821 return _out;
16822 fail:
16823 return octave_value_list();
16824 }
16825 catch(...) {
16826 throw;
16827 }
16828}
16829
16830
16831SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16832 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16833 void *argp1 = 0 ;
16834 int res1 = 0 ;
16835 octave_value_list _out;
16836 octave_value_list *_outp=&_out;
16837 octave_value _outv;
16838 PLFLT result;
16839
16840 try {
16841 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16842 SWIG_fail;
16843 }
16844 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16845 if (!SWIG_IsOK(res1)) {
16846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16847 }
16848 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16849 result = (PLFLT) ((arg1)->dX);
16850 _outv = SWIG_From_double(static_cast< double >(result));
16851 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16852 return _out;
16853 fail:
16854 return octave_value_list();
16855 }
16856 catch(...) {
16857 throw;
16858 }
16859}
16860
16861
16862SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16863 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16864 PLFLT arg2 ;
16865 void *argp1 = 0 ;
16866 int res1 = 0 ;
16867 double val2 ;
16868 int ecode2 = 0 ;
16869 octave_value_list _out;
16870 octave_value_list *_outp=&_out;
16871 octave_value _outv;
16872
16873 try {
16874 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16875 SWIG_fail;
16876 }
16877 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16880 }
16881 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16882 ecode2 = SWIG_AsVal_double(args(1), &val2);
16883 if (!SWIG_IsOK(ecode2)) {
16884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16885 }
16886 arg2 = static_cast< PLFLT >(val2);
16887 if (arg1) (arg1)->dY = arg2;
16888 _outv = octave_value();
16889 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16890 return _out;
16891 fail:
16892 return octave_value_list();
16893 }
16894 catch(...) {
16895 throw;
16896 }
16897}
16898
16899
16900SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16901 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16902 void *argp1 = 0 ;
16903 int res1 = 0 ;
16904 octave_value_list _out;
16905 octave_value_list *_outp=&_out;
16906 octave_value _outv;
16907 PLFLT result;
16908
16909 try {
16910 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16911 SWIG_fail;
16912 }
16913 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16914 if (!SWIG_IsOK(res1)) {
16915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16916 }
16917 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16918 result = (PLFLT) ((arg1)->dY);
16919 _outv = SWIG_From_double(static_cast< double >(result));
16920 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16921 return _out;
16922 fail:
16923 return octave_value_list();
16924 }
16925 catch(...) {
16926 throw;
16927 }
16928}
16929
16930
16931SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16932 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16933 PLFLT arg2 ;
16934 void *argp1 = 0 ;
16935 int res1 = 0 ;
16936 double val2 ;
16937 int ecode2 = 0 ;
16938 octave_value_list _out;
16939 octave_value_list *_outp=&_out;
16940 octave_value _outv;
16941
16942 try {
16943 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16944 SWIG_fail;
16945 }
16946 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16947 if (!SWIG_IsOK(res1)) {
16948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16949 }
16950 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16951 ecode2 = SWIG_AsVal_double(args(1), &val2);
16952 if (!SWIG_IsOK(ecode2)) {
16953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16954 }
16955 arg2 = static_cast< PLFLT >(val2);
16956 if (arg1) (arg1)->wX = arg2;
16957 _outv = octave_value();
16958 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16959 return _out;
16960 fail:
16961 return octave_value_list();
16962 }
16963 catch(...) {
16964 throw;
16965 }
16966}
16967
16968
16969SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16970 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16971 void *argp1 = 0 ;
16972 int res1 = 0 ;
16973 octave_value_list _out;
16974 octave_value_list *_outp=&_out;
16975 octave_value _outv;
16976 PLFLT result;
16977
16978 try {
16979 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16980 SWIG_fail;
16981 }
16982 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16983 if (!SWIG_IsOK(res1)) {
16984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16985 }
16986 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16987 result = (PLFLT) ((arg1)->wX);
16988 _outv = SWIG_From_double(static_cast< double >(result));
16989 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16990 return _out;
16991 fail:
16992 return octave_value_list();
16993 }
16994 catch(...) {
16995 throw;
16996 }
16997}
16998
16999
17000SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
17001 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17002 PLFLT arg2 ;
17003 void *argp1 = 0 ;
17004 int res1 = 0 ;
17005 double val2 ;
17006 int ecode2 = 0 ;
17007 octave_value_list _out;
17008 octave_value_list *_outp=&_out;
17009 octave_value _outv;
17010
17011 try {
17012 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
17013 SWIG_fail;
17014 }
17015 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17016 if (!SWIG_IsOK(res1)) {
17017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17018 }
17019 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17020 ecode2 = SWIG_AsVal_double(args(1), &val2);
17021 if (!SWIG_IsOK(ecode2)) {
17022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
17023 }
17024 arg2 = static_cast< PLFLT >(val2);
17025 if (arg1) (arg1)->wY = arg2;
17026 _outv = octave_value();
17027 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17028 return _out;
17029 fail:
17030 return octave_value_list();
17031 }
17032 catch(...) {
17033 throw;
17034 }
17035}
17036
17037
17038SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
17039 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17040 void *argp1 = 0 ;
17041 int res1 = 0 ;
17042 octave_value_list _out;
17043 octave_value_list *_outp=&_out;
17044 octave_value _outv;
17045 PLFLT result;
17046
17047 try {
17048 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
17049 SWIG_fail;
17050 }
17051 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
17052 if (!SWIG_IsOK(res1)) {
17053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17054 }
17055 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17056 result = (PLFLT) ((arg1)->wY);
17057 _outv = SWIG_From_double(static_cast< double >(result));
17058 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17059 return _out;
17060 fail:
17061 return octave_value_list();
17062 }
17063 catch(...) {
17064 throw;
17065 }
17066}
17067
17068
17069SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
17070 octave_value_list _out;
17071 octave_value_list *_outp=&_out;
17072 octave_value _outv;
17073 PLGraphicsIn *result = 0 ;
17074
17075 try {
17076 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17077 SWIG_fail;
17078 }
17079 result = (PLGraphicsIn *)new PLGraphicsIn();
17081 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17082 return _out;
17083 fail:
17084 return octave_value_list();
17085 }
17086 catch(...) {
17087 throw;
17088 }
17089}
17090
17091
17092SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17093 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17094 void *argp1 = 0 ;
17095 int res1 = 0 ;
17096 octave_value_list _out;
17097 octave_value_list *_outp=&_out;
17098 octave_value _outv;
17099
17100 try {
17101 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17102 SWIG_fail;
17103 }
17104 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17105 if (!SWIG_IsOK(res1)) {
17106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17107 }
17108 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17109 delete arg1;
17110 _outv = octave_value();
17111 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17112 return _out;
17113 fail:
17114 return octave_value_list();
17115 }
17116 catch(...) {
17117 throw;
17118 }
17119}
17120
17121
17137static const char *swig_PLGraphicsIn_base_names[] = {0};
17140
17142 PLINT arg1 ;
17143 PLINT arg2 ;
17144 int val1 ;
17145 int ecode1 = 0 ;
17146 int val2 ;
17147 int ecode2 = 0 ;
17148 octave_value_list _out;
17149 octave_value_list *_outp=&_out;
17150 octave_value _outv;
17151
17152 try {
17153 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17154 SWIG_fail;
17155 }
17156 ecode1 = SWIG_AsVal_int(args(0), &val1);
17157 if (!SWIG_IsOK(ecode1)) {
17158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17159 }
17160 arg1 = static_cast< PLINT >(val1);
17161 ecode2 = SWIG_AsVal_int(args(1), &val2);
17162 if (!SWIG_IsOK(ecode2)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17164 }
17165 arg2 = static_cast< PLINT >(val2);
17166 pl_setcontlabelformat(arg1,arg2);
17167 _outv = octave_value();
17168 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17169 return _out;
17170 fail:
17171 return octave_value_list();
17172 }
17173 catch(...) {
17174 throw;
17175 }
17176}
17177
17178
17180 PLFLT arg1 ;
17181 PLFLT arg2 ;
17182 PLFLT arg3 ;
17183 PLINT arg4 ;
17184 double val1 ;
17185 int ecode1 = 0 ;
17186 double val2 ;
17187 int ecode2 = 0 ;
17188 double val3 ;
17189 int ecode3 = 0 ;
17190 int val4 ;
17191 int ecode4 = 0 ;
17192 octave_value_list _out;
17193 octave_value_list *_outp=&_out;
17194 octave_value _outv;
17195
17196 try {
17197 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17198 SWIG_fail;
17199 }
17200 ecode1 = SWIG_AsVal_double(args(0), &val1);
17201 if (!SWIG_IsOK(ecode1)) {
17202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17203 }
17204 arg1 = static_cast< PLFLT >(val1);
17205 ecode2 = SWIG_AsVal_double(args(1), &val2);
17206 if (!SWIG_IsOK(ecode2)) {
17207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17208 }
17209 arg2 = static_cast< PLFLT >(val2);
17210 ecode3 = SWIG_AsVal_double(args(2), &val3);
17211 if (!SWIG_IsOK(ecode3)) {
17212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17213 }
17214 arg3 = static_cast< PLFLT >(val3);
17215 ecode4 = SWIG_AsVal_int(args(3), &val4);
17216 if (!SWIG_IsOK(ecode4)) {
17217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17218 }
17219 arg4 = static_cast< PLINT >(val4);
17220 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17221 _outv = octave_value();
17222 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17223 return _out;
17224 fail:
17225 return octave_value_list();
17226 }
17227 catch(...) {
17228 throw;
17229 }
17230}
17231
17232
17234 PLINT arg1 ;
17235 int val1 ;
17236 int ecode1 = 0 ;
17237 octave_value_list _out;
17238 octave_value_list *_outp=&_out;
17239 octave_value _outv;
17240
17241 try {
17242 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17243 SWIG_fail;
17244 }
17245 ecode1 = SWIG_AsVal_int(args(0), &val1);
17246 if (!SWIG_IsOK(ecode1)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17248 }
17249 arg1 = static_cast< PLINT >(val1);
17250 pladv(arg1);
17251 _outv = octave_value();
17252 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17253 return _out;
17254 fail:
17255 return octave_value_list();
17256 }
17257 catch(...) {
17258 throw;
17259 }
17260}
17261
17262
17264 PLFLT arg1 ;
17265 PLFLT arg2 ;
17266 PLFLT arg3 ;
17267 PLFLT arg4 ;
17268 PLFLT arg5 ;
17269 PLFLT arg6 ;
17270 PLFLT arg7 ;
17271 PLBOOL arg8 ;
17272 double val1 ;
17273 int ecode1 = 0 ;
17274 double val2 ;
17275 int ecode2 = 0 ;
17276 double val3 ;
17277 int ecode3 = 0 ;
17278 double val4 ;
17279 int ecode4 = 0 ;
17280 double val5 ;
17281 int ecode5 = 0 ;
17282 double val6 ;
17283 int ecode6 = 0 ;
17284 double val7 ;
17285 int ecode7 = 0 ;
17286 int val8 ;
17287 int ecode8 = 0 ;
17288 octave_value_list _out;
17289 octave_value_list *_outp=&_out;
17290 octave_value _outv;
17291
17292 try {
17293 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17294 SWIG_fail;
17295 }
17296 ecode1 = SWIG_AsVal_double(args(0), &val1);
17297 if (!SWIG_IsOK(ecode1)) {
17298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17299 }
17300 arg1 = static_cast< PLFLT >(val1);
17301 ecode2 = SWIG_AsVal_double(args(1), &val2);
17302 if (!SWIG_IsOK(ecode2)) {
17303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17304 }
17305 arg2 = static_cast< PLFLT >(val2);
17306 ecode3 = SWIG_AsVal_double(args(2), &val3);
17307 if (!SWIG_IsOK(ecode3)) {
17308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17309 }
17310 arg3 = static_cast< PLFLT >(val3);
17311 ecode4 = SWIG_AsVal_double(args(3), &val4);
17312 if (!SWIG_IsOK(ecode4)) {
17313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17314 }
17315 arg4 = static_cast< PLFLT >(val4);
17316 ecode5 = SWIG_AsVal_double(args(4), &val5);
17317 if (!SWIG_IsOK(ecode5)) {
17318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17319 }
17320 arg5 = static_cast< PLFLT >(val5);
17321 ecode6 = SWIG_AsVal_double(args(5), &val6);
17322 if (!SWIG_IsOK(ecode6)) {
17323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17324 }
17325 arg6 = static_cast< PLFLT >(val6);
17326 ecode7 = SWIG_AsVal_double(args(6), &val7);
17327 if (!SWIG_IsOK(ecode7)) {
17328 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17329 }
17330 arg7 = static_cast< PLFLT >(val7);
17331 ecode8 = SWIG_AsVal_int(args(7), &val8);
17332 if (!SWIG_IsOK(ecode8)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17334 }
17335 arg8 = static_cast< PLBOOL >(val8);
17336 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17337 _outv = octave_value();
17338 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17339 return _out;
17340 fail:
17341 return octave_value_list();
17342 }
17343 catch(...) {
17344 throw;
17345 }
17346}
17347
17348
17350 PLFLT arg1 ;
17351 PLFLT arg2 ;
17352 char *arg3 = (char *) 0 ;
17353 PLFLT arg4 ;
17354 PLINT arg5 ;
17355 char *arg6 = (char *) 0 ;
17356 PLFLT arg7 ;
17357 PLINT arg8 ;
17358 double val1 ;
17359 int ecode1 = 0 ;
17360 double val2 ;
17361 int ecode2 = 0 ;
17362 int res3 ;
17363 char *buf3 = 0 ;
17364 int alloc3 = 0 ;
17365 double val4 ;
17366 int ecode4 = 0 ;
17367 int val5 ;
17368 int ecode5 = 0 ;
17369 int res6 ;
17370 char *buf6 = 0 ;
17371 int alloc6 = 0 ;
17372 double val7 ;
17373 int ecode7 = 0 ;
17374 int val8 ;
17375 int ecode8 = 0 ;
17376 octave_value_list _out;
17377 octave_value_list *_outp=&_out;
17378 octave_value _outv;
17379
17380 try {
17381 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17382 SWIG_fail;
17383 }
17384 ecode1 = SWIG_AsVal_double(args(0), &val1);
17385 if (!SWIG_IsOK(ecode1)) {
17386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17387 }
17388 arg1 = static_cast< PLFLT >(val1);
17389 ecode2 = SWIG_AsVal_double(args(1), &val2);
17390 if (!SWIG_IsOK(ecode2)) {
17391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17392 }
17393 arg2 = static_cast< PLFLT >(val2);
17394 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17395 if (!SWIG_IsOK(res3)) {
17396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17397 }
17398 arg3 = reinterpret_cast< char * >(buf3);
17399 ecode4 = SWIG_AsVal_double(args(3), &val4);
17400 if (!SWIG_IsOK(ecode4)) {
17401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17402 }
17403 arg4 = static_cast< PLFLT >(val4);
17404 ecode5 = SWIG_AsVal_int(args(4), &val5);
17405 if (!SWIG_IsOK(ecode5)) {
17406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17407 }
17408 arg5 = static_cast< PLINT >(val5);
17409 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17410 if (!SWIG_IsOK(res6)) {
17411 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17412 }
17413 arg6 = reinterpret_cast< char * >(buf6);
17414 ecode7 = SWIG_AsVal_double(args(6), &val7);
17415 if (!SWIG_IsOK(ecode7)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17417 }
17418 arg7 = static_cast< PLFLT >(val7);
17419 ecode8 = SWIG_AsVal_int(args(7), &val8);
17420 if (!SWIG_IsOK(ecode8)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17422 }
17423 arg8 = static_cast< PLINT >(val8);
17424 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17425 _outv = octave_value();
17426 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17427 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17428 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17429 return _out;
17430 fail:
17431 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17432 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17433 return octave_value_list();
17434 }
17435 catch(...) {
17436 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17437 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17438 throw;
17439 }
17440}
17441
17442
17444 PLINT arg1 ;
17445 PLFLT *arg2 = (PLFLT *) 0 ;
17446 PLFLT *arg3 = (PLFLT *) 0 ;
17447 PLINT arg4 ;
17448 Matrix temp1 ;
17449 Matrix temp3 ;
17450 int val4 ;
17451 int ecode4 = 0 ;
17452 octave_value_list _out;
17453 octave_value_list *_outp=&_out;
17454 octave_value _outv;
17455
17456 try {
17457 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17458 SWIG_fail;
17459 }
17460 {
17461 if ( _n_dims( args(0) ) > 1 )
17462 {
17463 error( "argument must be a scalar or vector" ); SWIG_fail;
17464 }
17465 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17466 temp1 = args(0).matrix_value();
17467 arg2 = &temp1( 0, 0 );
17468 }
17469 {
17470 if ( _n_dims( args(1) ) > 1 )
17471 {
17472 error( "argument must be a scalar or vector" ); SWIG_fail;
17473 }
17474 if ( _dim( args(1), 0 ) != Alen )
17475 {
17476 error( "argument vectors must be same length" ); SWIG_fail;
17477 }
17478 temp3 = args(1).matrix_value();
17479 arg3 = &temp3( 0, 0 );
17480 }
17481 ecode4 = SWIG_AsVal_int(args(2), &val4);
17482 if (!SWIG_IsOK(ecode4)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17484 }
17485 arg4 = static_cast< PLINT >(val4);
17486 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17487 _outv = octave_value();
17488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17489 {
17490
17491 }
17492 {
17493
17494 }
17495 return _out;
17496 fail:
17497 {
17498
17499 }
17500 {
17501
17502 }
17503 return octave_value_list();
17504 }
17505 catch(...) {
17506 {
17507
17508 }
17509 {
17510
17511 }
17512 throw;
17513 }
17514}
17515
17516
17518 PLINT *arg1 = (PLINT *) 0 ;
17519 PLINT *arg2 = (PLINT *) 0 ;
17520 PLINT *arg3 = (PLINT *) 0 ;
17521 PLINT *arg4 = (PLINT *) 0 ;
17522 PLINT *arg5 = (PLINT *) 0 ;
17523 PLFLT *arg6 = (PLFLT *) 0 ;
17524 PLFLT arg7 ;
17525 PLINT temp1 ;
17526 int res1 = SWIG_TMPOBJ ;
17527 PLINT temp2 ;
17528 int res2 = SWIG_TMPOBJ ;
17529 PLINT temp3 ;
17530 int res3 = SWIG_TMPOBJ ;
17531 PLINT temp4 ;
17532 int res4 = SWIG_TMPOBJ ;
17533 PLINT temp5 ;
17534 int res5 = SWIG_TMPOBJ ;
17535 PLFLT temp6 ;
17536 int res6 = SWIG_TMPOBJ ;
17537 double val7 ;
17538 int ecode7 = 0 ;
17539 octave_value_list _out;
17540 octave_value_list *_outp=&_out;
17541 octave_value _outv;
17542
17543 try {
17544 arg1 = &temp1;
17545 arg2 = &temp2;
17546 arg3 = &temp3;
17547 arg4 = &temp4;
17548 arg5 = &temp5;
17549 arg6 = &temp6;
17550 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17551 SWIG_fail;
17552 }
17553 ecode7 = SWIG_AsVal_double(args(0), &val7);
17554 if (!SWIG_IsOK(ecode7)) {
17555 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17556 }
17557 arg7 = static_cast< PLFLT >(val7);
17558 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17559 _outv = octave_value();
17560 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17561 if (SWIG_IsTmpObj(res1)) {
17562 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17563 } else {
17564 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17565 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17566 }
17567 if (SWIG_IsTmpObj(res2)) {
17568 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17569 } else {
17570 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17571 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17572 }
17573 if (SWIG_IsTmpObj(res3)) {
17574 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17575 } else {
17576 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17577 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17578 }
17579 if (SWIG_IsTmpObj(res4)) {
17580 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17581 } else {
17582 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17583 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17584 }
17585 if (SWIG_IsTmpObj(res5)) {
17586 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17587 } else {
17588 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17589 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17590 }
17591 if (SWIG_IsTmpObj(res6)) {
17592 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17593 } else {
17594 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17595 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17596 }
17597 return _out;
17598 fail:
17599 return octave_value_list();
17600 }
17601 catch(...) {
17602 throw;
17603 }
17604}
17605
17606
17608 octave_value_list _out;
17609 octave_value_list *_outp=&_out;
17610 octave_value _outv;
17611
17612 try {
17613 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17614 SWIG_fail;
17615 }
17616 plbop();
17617 _outv = octave_value();
17618 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17619 return _out;
17620 fail:
17621 return octave_value_list();
17622 }
17623 catch(...) {
17624 throw;
17625 }
17626}
17627
17628
17630 char *arg1 = (char *) 0 ;
17631 PLFLT arg2 ;
17632 PLINT arg3 ;
17633 char *arg4 = (char *) 0 ;
17634 PLFLT arg5 ;
17635 PLINT arg6 ;
17636 int res1 ;
17637 char *buf1 = 0 ;
17638 int alloc1 = 0 ;
17639 double val2 ;
17640 int ecode2 = 0 ;
17641 int val3 ;
17642 int ecode3 = 0 ;
17643 int res4 ;
17644 char *buf4 = 0 ;
17645 int alloc4 = 0 ;
17646 double val5 ;
17647 int ecode5 = 0 ;
17648 int val6 ;
17649 int ecode6 = 0 ;
17650 octave_value_list _out;
17651 octave_value_list *_outp=&_out;
17652 octave_value _outv;
17653
17654 try {
17655 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17656 SWIG_fail;
17657 }
17658 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17659 if (!SWIG_IsOK(res1)) {
17660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17661 }
17662 arg1 = reinterpret_cast< char * >(buf1);
17663 ecode2 = SWIG_AsVal_double(args(1), &val2);
17664 if (!SWIG_IsOK(ecode2)) {
17665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17666 }
17667 arg2 = static_cast< PLFLT >(val2);
17668 ecode3 = SWIG_AsVal_int(args(2), &val3);
17669 if (!SWIG_IsOK(ecode3)) {
17670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17671 }
17672 arg3 = static_cast< PLINT >(val3);
17673 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17674 if (!SWIG_IsOK(res4)) {
17675 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17676 }
17677 arg4 = reinterpret_cast< char * >(buf4);
17678 ecode5 = SWIG_AsVal_double(args(4), &val5);
17679 if (!SWIG_IsOK(ecode5)) {
17680 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17681 }
17682 arg5 = static_cast< PLFLT >(val5);
17683 ecode6 = SWIG_AsVal_int(args(5), &val6);
17684 if (!SWIG_IsOK(ecode6)) {
17685 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17686 }
17687 arg6 = static_cast< PLINT >(val6);
17688 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17689 _outv = octave_value();
17690 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17691 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17692 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17693 return _out;
17694 fail:
17695 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17696 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17697 return octave_value_list();
17698 }
17699 catch(...) {
17700 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17701 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17702 throw;
17703 }
17704}
17705
17706
17708 char *arg1 = (char *) 0 ;
17709 char *arg2 = (char *) 0 ;
17710 PLFLT arg3 ;
17711 PLINT arg4 ;
17712 char *arg5 = (char *) 0 ;
17713 char *arg6 = (char *) 0 ;
17714 PLFLT arg7 ;
17715 PLINT arg8 ;
17716 char *arg9 = (char *) 0 ;
17717 char *arg10 = (char *) 0 ;
17718 PLFLT arg11 ;
17719 PLINT arg12 ;
17720 int res1 ;
17721 char *buf1 = 0 ;
17722 int alloc1 = 0 ;
17723 int res2 ;
17724 char *buf2 = 0 ;
17725 int alloc2 = 0 ;
17726 double val3 ;
17727 int ecode3 = 0 ;
17728 int val4 ;
17729 int ecode4 = 0 ;
17730 int res5 ;
17731 char *buf5 = 0 ;
17732 int alloc5 = 0 ;
17733 int res6 ;
17734 char *buf6 = 0 ;
17735 int alloc6 = 0 ;
17736 double val7 ;
17737 int ecode7 = 0 ;
17738 int val8 ;
17739 int ecode8 = 0 ;
17740 int res9 ;
17741 char *buf9 = 0 ;
17742 int alloc9 = 0 ;
17743 int res10 ;
17744 char *buf10 = 0 ;
17745 int alloc10 = 0 ;
17746 double val11 ;
17747 int ecode11 = 0 ;
17748 int val12 ;
17749 int ecode12 = 0 ;
17750 octave_value_list _out;
17751 octave_value_list *_outp=&_out;
17752 octave_value _outv;
17753
17754 try {
17755 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17756 SWIG_fail;
17757 }
17758 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17759 if (!SWIG_IsOK(res1)) {
17760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17761 }
17762 arg1 = reinterpret_cast< char * >(buf1);
17763 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17764 if (!SWIG_IsOK(res2)) {
17765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17766 }
17767 arg2 = reinterpret_cast< char * >(buf2);
17768 ecode3 = SWIG_AsVal_double(args(2), &val3);
17769 if (!SWIG_IsOK(ecode3)) {
17770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17771 }
17772 arg3 = static_cast< PLFLT >(val3);
17773 ecode4 = SWIG_AsVal_int(args(3), &val4);
17774 if (!SWIG_IsOK(ecode4)) {
17775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17776 }
17777 arg4 = static_cast< PLINT >(val4);
17778 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17779 if (!SWIG_IsOK(res5)) {
17780 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17781 }
17782 arg5 = reinterpret_cast< char * >(buf5);
17783 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17784 if (!SWIG_IsOK(res6)) {
17785 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17786 }
17787 arg6 = reinterpret_cast< char * >(buf6);
17788 ecode7 = SWIG_AsVal_double(args(6), &val7);
17789 if (!SWIG_IsOK(ecode7)) {
17790 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17791 }
17792 arg7 = static_cast< PLFLT >(val7);
17793 ecode8 = SWIG_AsVal_int(args(7), &val8);
17794 if (!SWIG_IsOK(ecode8)) {
17795 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17796 }
17797 arg8 = static_cast< PLINT >(val8);
17798 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17799 if (!SWIG_IsOK(res9)) {
17800 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17801 }
17802 arg9 = reinterpret_cast< char * >(buf9);
17803 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17804 if (!SWIG_IsOK(res10)) {
17805 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17806 }
17807 arg10 = reinterpret_cast< char * >(buf10);
17808 ecode11 = SWIG_AsVal_double(args(10), &val11);
17809 if (!SWIG_IsOK(ecode11)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17811 }
17812 arg11 = static_cast< PLFLT >(val11);
17813 ecode12 = SWIG_AsVal_int(args(11), &val12);
17814 if (!SWIG_IsOK(ecode12)) {
17815 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17816 }
17817 arg12 = static_cast< PLINT >(val12);
17818 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);
17819 _outv = octave_value();
17820 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17821 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17822 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17823 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17824 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17825 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17826 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17827 return _out;
17828 fail:
17829 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17830 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17831 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17832 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17833 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17834 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17835 return octave_value_list();
17836 }
17837 catch(...) {
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 throw;
17845 }
17846}
17847
17848
17850 PLFLT arg1 ;
17851 PLFLT arg2 ;
17852 PLFLT *arg3 = (PLFLT *) 0 ;
17853 PLFLT *arg4 = (PLFLT *) 0 ;
17854 PLINT *arg5 = (PLINT *) 0 ;
17855 double val1 ;
17856 int ecode1 = 0 ;
17857 double val2 ;
17858 int ecode2 = 0 ;
17859 PLFLT temp3 ;
17860 int res3 = SWIG_TMPOBJ ;
17861 PLFLT temp4 ;
17862 int res4 = SWIG_TMPOBJ ;
17863 PLINT temp5 ;
17864 int res5 = SWIG_TMPOBJ ;
17865 octave_value_list _out;
17866 octave_value_list *_outp=&_out;
17867 octave_value _outv;
17868
17869 try {
17870 arg3 = &temp3;
17871 arg4 = &temp4;
17872 arg5 = &temp5;
17873 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17874 SWIG_fail;
17875 }
17876 ecode1 = SWIG_AsVal_double(args(0), &val1);
17877 if (!SWIG_IsOK(ecode1)) {
17878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17879 }
17880 arg1 = static_cast< PLFLT >(val1);
17881 ecode2 = SWIG_AsVal_double(args(1), &val2);
17882 if (!SWIG_IsOK(ecode2)) {
17883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17884 }
17885 arg2 = static_cast< PLFLT >(val2);
17886 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17887 _outv = octave_value();
17888 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17889 if (SWIG_IsTmpObj(res3)) {
17890 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17891 } else {
17892 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17893 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17894 }
17895 if (SWIG_IsTmpObj(res4)) {
17896 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17897 } else {
17898 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17899 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17900 }
17901 if (SWIG_IsTmpObj(res5)) {
17902 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17903 } else {
17904 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17905 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17906 }
17907 return _out;
17908 fail:
17909 return octave_value_list();
17910 }
17911 catch(...) {
17912 throw;
17913 }
17914}
17915
17916
17918 octave_value_list _out;
17919 octave_value_list *_outp=&_out;
17920 octave_value _outv;
17921
17922 try {
17923 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17924 SWIG_fail;
17925 }
17926 plclear();
17927 _outv = octave_value();
17928 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17929 return _out;
17930 fail:
17931 return octave_value_list();
17932 }
17933 catch(...) {
17934 throw;
17935 }
17936}
17937
17938
17940 PLINT arg1 ;
17941 int val1 ;
17942 int ecode1 = 0 ;
17943 octave_value_list _out;
17944 octave_value_list *_outp=&_out;
17945 octave_value _outv;
17946
17947 try {
17948 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17949 SWIG_fail;
17950 }
17951 ecode1 = SWIG_AsVal_int(args(0), &val1);
17952 if (!SWIG_IsOK(ecode1)) {
17953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17954 }
17955 arg1 = static_cast< PLINT >(val1);
17956 plcol0(arg1);
17957 _outv = octave_value();
17958 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17959 return _out;
17960 fail:
17961 return octave_value_list();
17962 }
17963 catch(...) {
17964 throw;
17965 }
17966}
17967
17968
17970 PLFLT arg1 ;
17971 double val1 ;
17972 int ecode1 = 0 ;
17973 octave_value_list _out;
17974 octave_value_list *_outp=&_out;
17975 octave_value _outv;
17976
17977 try {
17978 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17979 SWIG_fail;
17980 }
17981 ecode1 = SWIG_AsVal_double(args(0), &val1);
17982 if (!SWIG_IsOK(ecode1)) {
17983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17984 }
17985 arg1 = static_cast< PLFLT >(val1);
17986 plcol1(arg1);
17987 _outv = octave_value();
17988 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17989 return _out;
17990 fail:
17991 return octave_value_list();
17992 }
17993 catch(...) {
17994 throw;
17995 }
17996}
17997
17998
18000 PLFLT arg1 ;
18001 PLFLT arg2 ;
18002 PLFLT arg3 ;
18003 PLINT arg4 ;
18004 PLBOOL arg5 ;
18005 PLINT arg6 ;
18006 PLINT arg7 ;
18007 PLINT arg8 ;
18008 PLINT arg9 ;
18009 PLINT arg10 ;
18010 PLFLT arg11 ;
18011 double val1 ;
18012 int ecode1 = 0 ;
18013 double val2 ;
18014 int ecode2 = 0 ;
18015 double val3 ;
18016 int ecode3 = 0 ;
18017 int val4 ;
18018 int ecode4 = 0 ;
18019 int val5 ;
18020 int ecode5 = 0 ;
18021 int val6 ;
18022 int ecode6 = 0 ;
18023 int val7 ;
18024 int ecode7 = 0 ;
18025 int val8 ;
18026 int ecode8 = 0 ;
18027 int val9 ;
18028 int ecode9 = 0 ;
18029 int val10 ;
18030 int ecode10 = 0 ;
18031 double val11 ;
18032 int ecode11 = 0 ;
18033 octave_value_list _out;
18034 octave_value_list *_outp=&_out;
18035 octave_value _outv;
18036
18037 try {
18038 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
18039 SWIG_fail;
18040 }
18041 ecode1 = SWIG_AsVal_double(args(0), &val1);
18042 if (!SWIG_IsOK(ecode1)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
18044 }
18045 arg1 = static_cast< PLFLT >(val1);
18046 ecode2 = SWIG_AsVal_double(args(1), &val2);
18047 if (!SWIG_IsOK(ecode2)) {
18048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
18049 }
18050 arg2 = static_cast< PLFLT >(val2);
18051 ecode3 = SWIG_AsVal_double(args(2), &val3);
18052 if (!SWIG_IsOK(ecode3)) {
18053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
18054 }
18055 arg3 = static_cast< PLFLT >(val3);
18056 ecode4 = SWIG_AsVal_int(args(3), &val4);
18057 if (!SWIG_IsOK(ecode4)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
18059 }
18060 arg4 = static_cast< PLINT >(val4);
18061 ecode5 = SWIG_AsVal_int(args(4), &val5);
18062 if (!SWIG_IsOK(ecode5)) {
18063 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
18064 }
18065 arg5 = static_cast< PLBOOL >(val5);
18066 ecode6 = SWIG_AsVal_int(args(5), &val6);
18067 if (!SWIG_IsOK(ecode6)) {
18068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
18069 }
18070 arg6 = static_cast< PLINT >(val6);
18071 ecode7 = SWIG_AsVal_int(args(6), &val7);
18072 if (!SWIG_IsOK(ecode7)) {
18073 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18074 }
18075 arg7 = static_cast< PLINT >(val7);
18076 ecode8 = SWIG_AsVal_int(args(7), &val8);
18077 if (!SWIG_IsOK(ecode8)) {
18078 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18079 }
18080 arg8 = static_cast< PLINT >(val8);
18081 ecode9 = SWIG_AsVal_int(args(8), &val9);
18082 if (!SWIG_IsOK(ecode9)) {
18083 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18084 }
18085 arg9 = static_cast< PLINT >(val9);
18086 ecode10 = SWIG_AsVal_int(args(9), &val10);
18087 if (!SWIG_IsOK(ecode10)) {
18088 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18089 }
18090 arg10 = static_cast< PLINT >(val10);
18091 ecode11 = SWIG_AsVal_double(args(10), &val11);
18092 if (!SWIG_IsOK(ecode11)) {
18093 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18094 }
18095 arg11 = static_cast< PLFLT >(val11);
18096 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18097 _outv = octave_value();
18098 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18099 return _out;
18100 fail:
18101 return octave_value_list();
18102 }
18103 catch(...) {
18104 throw;
18105 }
18106}
18107
18108
18110 PLINT arg1 ;
18111 PLINT arg2 ;
18112 PLINT arg3 ;
18113 PLINT arg4 ;
18114 PLINT arg5 ;
18115 PLFLT arg6 ;
18116 PLFLT *arg7 = (PLFLT *) 0 ;
18117 int val1 ;
18118 int ecode1 = 0 ;
18119 int val2 ;
18120 int ecode2 = 0 ;
18121 int val3 ;
18122 int ecode3 = 0 ;
18123 int val4 ;
18124 int ecode4 = 0 ;
18125 int val5 ;
18126 int ecode5 = 0 ;
18127 double val6 ;
18128 int ecode6 = 0 ;
18129 PLFLT temp7 ;
18130 int res7 = SWIG_TMPOBJ ;
18131 octave_value_list _out;
18132 octave_value_list *_outp=&_out;
18133 octave_value _outv;
18134
18135 try {
18136 arg7 = &temp7;
18137 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18138 SWIG_fail;
18139 }
18140 ecode1 = SWIG_AsVal_int(args(0), &val1);
18141 if (!SWIG_IsOK(ecode1)) {
18142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18143 }
18144 arg1 = static_cast< PLINT >(val1);
18145 ecode2 = SWIG_AsVal_int(args(1), &val2);
18146 if (!SWIG_IsOK(ecode2)) {
18147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18148 }
18149 arg2 = static_cast< PLINT >(val2);
18150 ecode3 = SWIG_AsVal_int(args(2), &val3);
18151 if (!SWIG_IsOK(ecode3)) {
18152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18153 }
18154 arg3 = static_cast< PLINT >(val3);
18155 ecode4 = SWIG_AsVal_int(args(3), &val4);
18156 if (!SWIG_IsOK(ecode4)) {
18157 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18158 }
18159 arg4 = static_cast< PLINT >(val4);
18160 ecode5 = SWIG_AsVal_int(args(4), &val5);
18161 if (!SWIG_IsOK(ecode5)) {
18162 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18163 }
18164 arg5 = static_cast< PLINT >(val5);
18165 ecode6 = SWIG_AsVal_double(args(5), &val6);
18166 if (!SWIG_IsOK(ecode6)) {
18167 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18168 }
18169 arg6 = static_cast< PLFLT >(val6);
18170 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18171 _outv = octave_value();
18172 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18173 if (SWIG_IsTmpObj(res7)) {
18174 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18175 } else {
18176 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18177 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18178 }
18179 return _out;
18180 fail:
18181 return octave_value_list();
18182 }
18183 catch(...) {
18184 throw;
18185 }
18186}
18187
18188
18190 PLINT arg1 ;
18191 PLBOOL arg2 ;
18192 int val1 ;
18193 int ecode1 = 0 ;
18194 int val2 ;
18195 int ecode2 = 0 ;
18196 octave_value_list _out;
18197 octave_value_list *_outp=&_out;
18198 octave_value _outv;
18199
18200 try {
18201 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18202 SWIG_fail;
18203 }
18204 ecode1 = SWIG_AsVal_int(args(0), &val1);
18205 if (!SWIG_IsOK(ecode1)) {
18206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18207 }
18208 arg1 = static_cast< PLINT >(val1);
18209 ecode2 = SWIG_AsVal_int(args(1), &val2);
18210 if (!SWIG_IsOK(ecode2)) {
18211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18212 }
18213 arg2 = static_cast< PLBOOL >(val2);
18214 plcpstrm(arg1,arg2);
18215 _outv = octave_value();
18216 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18217 return _out;
18218 fail:
18219 return octave_value_list();
18220 }
18221 catch(...) {
18222 throw;
18223 }
18224}
18225
18226
18228 octave_value_list _out;
18229 octave_value_list *_outp=&_out;
18230 octave_value _outv;
18231
18232 try {
18233 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18234 SWIG_fail;
18235 }
18236 plend();
18237 _outv = octave_value();
18238 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18239 return _out;
18240 fail:
18241 return octave_value_list();
18242 }
18243 catch(...) {
18244 throw;
18245 }
18246}
18247
18248
18250 octave_value_list _out;
18251 octave_value_list *_outp=&_out;
18252 octave_value _outv;
18253
18254 try {
18255 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18256 SWIG_fail;
18257 }
18258 plend1();
18259 _outv = octave_value();
18260 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18261 return _out;
18262 fail:
18263 return octave_value_list();
18264 }
18265 catch(...) {
18266 throw;
18267 }
18268}
18269
18270
18272 PLFLT arg1 ;
18273 PLFLT arg2 ;
18274 PLFLT arg3 ;
18275 PLFLT arg4 ;
18276 PLINT arg5 ;
18277 PLINT arg6 ;
18278 double val1 ;
18279 int ecode1 = 0 ;
18280 double val2 ;
18281 int ecode2 = 0 ;
18282 double val3 ;
18283 int ecode3 = 0 ;
18284 double val4 ;
18285 int ecode4 = 0 ;
18286 int val5 ;
18287 int ecode5 = 0 ;
18288 int val6 ;
18289 int ecode6 = 0 ;
18290 octave_value_list _out;
18291 octave_value_list *_outp=&_out;
18292 octave_value _outv;
18293
18294 try {
18295 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18296 SWIG_fail;
18297 }
18298 ecode1 = SWIG_AsVal_double(args(0), &val1);
18299 if (!SWIG_IsOK(ecode1)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18301 }
18302 arg1 = static_cast< PLFLT >(val1);
18303 ecode2 = SWIG_AsVal_double(args(1), &val2);
18304 if (!SWIG_IsOK(ecode2)) {
18305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18306 }
18307 arg2 = static_cast< PLFLT >(val2);
18308 ecode3 = SWIG_AsVal_double(args(2), &val3);
18309 if (!SWIG_IsOK(ecode3)) {
18310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18311 }
18312 arg3 = static_cast< PLFLT >(val3);
18313 ecode4 = SWIG_AsVal_double(args(3), &val4);
18314 if (!SWIG_IsOK(ecode4)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18316 }
18317 arg4 = static_cast< PLFLT >(val4);
18318 ecode5 = SWIG_AsVal_int(args(4), &val5);
18319 if (!SWIG_IsOK(ecode5)) {
18320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18321 }
18322 arg5 = static_cast< PLINT >(val5);
18323 ecode6 = SWIG_AsVal_int(args(5), &val6);
18324 if (!SWIG_IsOK(ecode6)) {
18325 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18326 }
18327 arg6 = static_cast< PLINT >(val6);
18328 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18329 _outv = octave_value();
18330 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18331 return _out;
18332 fail:
18333 return octave_value_list();
18334 }
18335 catch(...) {
18336 throw;
18337 }
18338}
18339
18340
18342 PLFLT arg1 ;
18343 PLFLT arg2 ;
18344 PLFLT arg3 ;
18345 PLFLT arg4 ;
18346 PLINT arg5 ;
18347 PLINT arg6 ;
18348 double val1 ;
18349 int ecode1 = 0 ;
18350 double val2 ;
18351 int ecode2 = 0 ;
18352 double val3 ;
18353 int ecode3 = 0 ;
18354 double val4 ;
18355 int ecode4 = 0 ;
18356 int val5 ;
18357 int ecode5 = 0 ;
18358 int val6 ;
18359 int ecode6 = 0 ;
18360 octave_value_list _out;
18361 octave_value_list *_outp=&_out;
18362 octave_value _outv;
18363
18364 try {
18365 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18366 SWIG_fail;
18367 }
18368 ecode1 = SWIG_AsVal_double(args(0), &val1);
18369 if (!SWIG_IsOK(ecode1)) {
18370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18371 }
18372 arg1 = static_cast< PLFLT >(val1);
18373 ecode2 = SWIG_AsVal_double(args(1), &val2);
18374 if (!SWIG_IsOK(ecode2)) {
18375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18376 }
18377 arg2 = static_cast< PLFLT >(val2);
18378 ecode3 = SWIG_AsVal_double(args(2), &val3);
18379 if (!SWIG_IsOK(ecode3)) {
18380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18381 }
18382 arg3 = static_cast< PLFLT >(val3);
18383 ecode4 = SWIG_AsVal_double(args(3), &val4);
18384 if (!SWIG_IsOK(ecode4)) {
18385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18386 }
18387 arg4 = static_cast< PLFLT >(val4);
18388 ecode5 = SWIG_AsVal_int(args(4), &val5);
18389 if (!SWIG_IsOK(ecode5)) {
18390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18391 }
18392 arg5 = static_cast< PLINT >(val5);
18393 ecode6 = SWIG_AsVal_int(args(5), &val6);
18394 if (!SWIG_IsOK(ecode6)) {
18395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18396 }
18397 arg6 = static_cast< PLINT >(val6);
18398 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18399 _outv = octave_value();
18400 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18401 return _out;
18402 fail:
18403 return octave_value_list();
18404 }
18405 catch(...) {
18406 throw;
18407 }
18408}
18409
18410
18412 octave_value_list _out;
18413 octave_value_list *_outp=&_out;
18414 octave_value _outv;
18415
18416 try {
18417 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18418 SWIG_fail;
18419 }
18420 pleop();
18421 _outv = octave_value();
18422 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18423 return _out;
18424 fail:
18425 return octave_value_list();
18426 }
18427 catch(...) {
18428 throw;
18429 }
18430}
18431
18432
18434 PLINT arg1 ;
18435 PLFLT *arg2 = (PLFLT *) 0 ;
18436 PLFLT *arg3 = (PLFLT *) 0 ;
18437 PLFLT *arg4 = (PLFLT *) 0 ;
18438 Matrix temp1 ;
18439 Matrix temp3 ;
18440 Matrix temp4 ;
18441 octave_value_list _out;
18442 octave_value_list *_outp=&_out;
18443 octave_value _outv;
18444
18445 try {
18446 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18447 SWIG_fail;
18448 }
18449 {
18450 if ( _n_dims( args(0) ) > 1 )
18451 {
18452 error( "argument must be a scalar or vector" ); SWIG_fail;
18453 }
18454 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18455 temp1 = args(0).matrix_value();
18456 arg2 = &temp1( 0, 0 );
18457 }
18458 {
18459 if ( _n_dims( args(1) ) > 1 )
18460 {
18461 error( "argument must be a scalar or vector" ); SWIG_fail;
18462 }
18463 if ( _dim( args(1), 0 ) != Alen )
18464 {
18465 error( "argument vectors must be same length" ); SWIG_fail;
18466 }
18467 temp3 = args(1).matrix_value();
18468 arg3 = &temp3( 0, 0 );
18469 }
18470 {
18471 if ( _n_dims( args(2) ) > 1 )
18472 {
18473 error( "argument must be a scalar or vector" ); SWIG_fail;
18474 }
18475 if ( _dim( args(2), 0 ) != Alen )
18476 {
18477 error( "argument vectors must be same length" ); SWIG_fail;
18478 }
18479 temp4 = args(2).matrix_value();
18480 arg4 = &temp4( 0, 0 );
18481 }
18482 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18483 _outv = octave_value();
18484 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18485 {
18486
18487 }
18488 {
18489
18490 }
18491 {
18492
18493 }
18494 return _out;
18495 fail:
18496 {
18497
18498 }
18499 {
18500
18501 }
18502 {
18503
18504 }
18505 return octave_value_list();
18506 }
18507 catch(...) {
18508 {
18509
18510 }
18511 {
18512
18513 }
18514 {
18515
18516 }
18517 throw;
18518 }
18519}
18520
18521
18523 PLINT arg1 ;
18524 PLFLT *arg2 = (PLFLT *) 0 ;
18525 PLFLT *arg3 = (PLFLT *) 0 ;
18526 PLFLT *arg4 = (PLFLT *) 0 ;
18527 Matrix temp1 ;
18528 Matrix temp3 ;
18529 Matrix temp4 ;
18530 octave_value_list _out;
18531 octave_value_list *_outp=&_out;
18532 octave_value _outv;
18533
18534 try {
18535 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18536 SWIG_fail;
18537 }
18538 {
18539 if ( _n_dims( args(0) ) > 1 )
18540 {
18541 error( "argument must be a scalar or vector" ); SWIG_fail;
18542 }
18543 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18544 temp1 = args(0).matrix_value();
18545 arg2 = &temp1( 0, 0 );
18546 }
18547 {
18548 if ( _n_dims( args(1) ) > 1 )
18549 {
18550 error( "argument must be a scalar or vector" ); SWIG_fail;
18551 }
18552 if ( _dim( args(1), 0 ) != Alen )
18553 {
18554 error( "argument vectors must be same length" ); SWIG_fail;
18555 }
18556 temp3 = args(1).matrix_value();
18557 arg3 = &temp3( 0, 0 );
18558 }
18559 {
18560 if ( _n_dims( args(2) ) > 1 )
18561 {
18562 error( "argument must be a scalar or vector" ); SWIG_fail;
18563 }
18564 if ( _dim( args(2), 0 ) != Alen )
18565 {
18566 error( "argument vectors must be same length" ); SWIG_fail;
18567 }
18568 temp4 = args(2).matrix_value();
18569 arg4 = &temp4( 0, 0 );
18570 }
18571 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18572 _outv = octave_value();
18573 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18574 {
18575
18576 }
18577 {
18578
18579 }
18580 {
18581
18582 }
18583 return _out;
18584 fail:
18585 {
18586
18587 }
18588 {
18589
18590 }
18591 {
18592
18593 }
18594 return octave_value_list();
18595 }
18596 catch(...) {
18597 {
18598
18599 }
18600 {
18601
18602 }
18603 {
18604
18605 }
18606 throw;
18607 }
18608}
18609
18610
18612 octave_value_list _out;
18613 octave_value_list *_outp=&_out;
18614 octave_value _outv;
18615
18616 try {
18617 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18618 SWIG_fail;
18619 }
18620 plfamadv();
18621 _outv = octave_value();
18622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18623 return _out;
18624 fail:
18625 return octave_value_list();
18626 }
18627 catch(...) {
18628 throw;
18629 }
18630}
18631
18632
18634 PLINT arg1 ;
18635 PLFLT *arg2 = (PLFLT *) 0 ;
18636 PLFLT *arg3 = (PLFLT *) 0 ;
18637 Matrix temp1 ;
18638 Matrix temp3 ;
18639 octave_value_list _out;
18640 octave_value_list *_outp=&_out;
18641 octave_value _outv;
18642
18643 try {
18644 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18645 SWIG_fail;
18646 }
18647 {
18648 if ( _n_dims( args(0) ) > 1 )
18649 {
18650 error( "argument must be a scalar or vector" ); SWIG_fail;
18651 }
18652 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18653 temp1 = args(0).matrix_value();
18654 arg2 = &temp1( 0, 0 );
18655 }
18656 {
18657 if ( _n_dims( args(1) ) > 1 )
18658 {
18659 error( "argument must be a scalar or vector" ); SWIG_fail;
18660 }
18661 if ( _dim( args(1), 0 ) != Alen )
18662 {
18663 error( "argument vectors must be same length" ); SWIG_fail;
18664 }
18665 temp3 = args(1).matrix_value();
18666 arg3 = &temp3( 0, 0 );
18667 }
18668 plfill(arg1,(double const *)arg2,(double const *)arg3);
18669 _outv = octave_value();
18670 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18671 {
18672
18673 }
18674 {
18675
18676 }
18677 return _out;
18678 fail:
18679 {
18680
18681 }
18682 {
18683
18684 }
18685 return octave_value_list();
18686 }
18687 catch(...) {
18688 {
18689
18690 }
18691 {
18692
18693 }
18694 throw;
18695 }
18696}
18697
18698
18700 PLINT arg1 ;
18701 PLFLT *arg2 = (PLFLT *) 0 ;
18702 PLFLT *arg3 = (PLFLT *) 0 ;
18703 PLFLT *arg4 = (PLFLT *) 0 ;
18704 Matrix temp1 ;
18705 Matrix temp3 ;
18706 Matrix temp4 ;
18707 octave_value_list _out;
18708 octave_value_list *_outp=&_out;
18709 octave_value _outv;
18710
18711 try {
18712 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18713 SWIG_fail;
18714 }
18715 {
18716 if ( _n_dims( args(0) ) > 1 )
18717 {
18718 error( "argument must be a scalar or vector" ); SWIG_fail;
18719 }
18720 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18721 temp1 = args(0).matrix_value();
18722 arg2 = &temp1( 0, 0 );
18723 }
18724 {
18725 if ( _n_dims( args(1) ) > 1 )
18726 {
18727 error( "argument must be a scalar or vector" ); SWIG_fail;
18728 }
18729 if ( _dim( args(1), 0 ) != Alen )
18730 {
18731 error( "argument vectors must be same length" ); SWIG_fail;
18732 }
18733 temp3 = args(1).matrix_value();
18734 arg3 = &temp3( 0, 0 );
18735 }
18736 {
18737 if ( _n_dims( args(2) ) > 1 )
18738 {
18739 error( "argument must be a scalar or vector" ); SWIG_fail;
18740 }
18741 if ( _dim( args(2), 0 ) != Alen )
18742 {
18743 error( "argument vectors must be same length" ); SWIG_fail;
18744 }
18745 temp4 = args(2).matrix_value();
18746 arg4 = &temp4( 0, 0 );
18747 }
18748 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18749 _outv = octave_value();
18750 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18751 {
18752
18753 }
18754 {
18755
18756 }
18757 {
18758
18759 }
18760 return _out;
18761 fail:
18762 {
18763
18764 }
18765 {
18766
18767 }
18768 {
18769
18770 }
18771 return octave_value_list();
18772 }
18773 catch(...) {
18774 {
18775
18776 }
18777 {
18778
18779 }
18780 {
18781
18782 }
18783 throw;
18784 }
18785}
18786
18787
18789 PLINT arg1 ;
18790 PLFLT *arg2 = (PLFLT *) 0 ;
18791 PLFLT *arg3 = (PLFLT *) 0 ;
18792 PLFLT arg4 ;
18793 Matrix temp1 ;
18794 Matrix temp3 ;
18795 double val4 ;
18796 int ecode4 = 0 ;
18797 octave_value_list _out;
18798 octave_value_list *_outp=&_out;
18799 octave_value _outv;
18800
18801 try {
18802 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18803 SWIG_fail;
18804 }
18805 {
18806 if ( _n_dims( args(0) ) > 1 )
18807 {
18808 error( "argument must be a scalar or vector" ); SWIG_fail;
18809 }
18810 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18811 temp1 = args(0).matrix_value();
18812 arg2 = &temp1( 0, 0 );
18813 }
18814 {
18815 if ( _n_dims( args(1) ) > 1 )
18816 {
18817 error( "argument must be a scalar or vector" ); SWIG_fail;
18818 }
18819 if ( _dim( args(1), 0 ) != Alen )
18820 {
18821 error( "argument vectors must be same length" ); SWIG_fail;
18822 }
18823 temp3 = args(1).matrix_value();
18824 arg3 = &temp3( 0, 0 );
18825 }
18826 ecode4 = SWIG_AsVal_double(args(2), &val4);
18827 if (!SWIG_IsOK(ecode4)) {
18828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18829 }
18830 arg4 = static_cast< PLFLT >(val4);
18831 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18832 _outv = octave_value();
18833 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18834 {
18835
18836 }
18837 {
18838
18839 }
18840 return _out;
18841 fail:
18842 {
18843
18844 }
18845 {
18846
18847 }
18848 return octave_value_list();
18849 }
18850 catch(...) {
18851 {
18852
18853 }
18854 {
18855
18856 }
18857 throw;
18858 }
18859}
18860
18861
18863 octave_value_list _out;
18864 octave_value_list *_outp=&_out;
18865 octave_value _outv;
18866
18867 try {
18868 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18869 SWIG_fail;
18870 }
18871 plflush();
18872 _outv = octave_value();
18873 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18874 return _out;
18875 fail:
18876 return octave_value_list();
18877 }
18878 catch(...) {
18879 throw;
18880 }
18881}
18882
18883
18885 PLINT arg1 ;
18886 int val1 ;
18887 int ecode1 = 0 ;
18888 octave_value_list _out;
18889 octave_value_list *_outp=&_out;
18890 octave_value _outv;
18891
18892 try {
18893 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18894 SWIG_fail;
18895 }
18896 ecode1 = SWIG_AsVal_int(args(0), &val1);
18897 if (!SWIG_IsOK(ecode1)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18899 }
18900 arg1 = static_cast< PLINT >(val1);
18901 plfont(arg1);
18902 _outv = octave_value();
18903 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18904 return _out;
18905 fail:
18906 return octave_value_list();
18907 }
18908 catch(...) {
18909 throw;
18910 }
18911}
18912
18913
18915 PLINT arg1 ;
18916 int val1 ;
18917 int ecode1 = 0 ;
18918 octave_value_list _out;
18919 octave_value_list *_outp=&_out;
18920 octave_value _outv;
18921
18922 try {
18923 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18924 SWIG_fail;
18925 }
18926 ecode1 = SWIG_AsVal_int(args(0), &val1);
18927 if (!SWIG_IsOK(ecode1)) {
18928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18929 }
18930 arg1 = static_cast< PLINT >(val1);
18931 plfontld(arg1);
18932 _outv = octave_value();
18933 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18934 return _out;
18935 fail:
18936 return octave_value_list();
18937 }
18938 catch(...) {
18939 throw;
18940 }
18941}
18942
18943
18945 PLFLT *arg1 = (PLFLT *) 0 ;
18946 PLFLT *arg2 = (PLFLT *) 0 ;
18947 PLFLT temp1 ;
18948 int res1 = SWIG_TMPOBJ ;
18949 PLFLT temp2 ;
18950 int res2 = SWIG_TMPOBJ ;
18951 octave_value_list _out;
18952 octave_value_list *_outp=&_out;
18953 octave_value _outv;
18954
18955 try {
18956 arg1 = &temp1;
18957 arg2 = &temp2;
18958 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18959 SWIG_fail;
18960 }
18961 plgchr(arg1,arg2);
18962 _outv = octave_value();
18963 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18964 if (SWIG_IsTmpObj(res1)) {
18965 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18966 } else {
18967 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18969 }
18970 if (SWIG_IsTmpObj(res2)) {
18971 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18972 } else {
18973 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18974 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18975 }
18976 return _out;
18977 fail:
18978 return octave_value_list();
18979 }
18980 catch(...) {
18981 throw;
18982 }
18983}
18984
18985
18987 PLINT arg1 ;
18988 PLINT *arg2 = (PLINT *) 0 ;
18989 PLINT *arg3 = (PLINT *) 0 ;
18990 PLINT *arg4 = (PLINT *) 0 ;
18991 int val1 ;
18992 int ecode1 = 0 ;
18993 PLINT temp2 ;
18994 int res2 = SWIG_TMPOBJ ;
18995 PLINT temp3 ;
18996 int res3 = SWIG_TMPOBJ ;
18997 PLINT temp4 ;
18998 int res4 = SWIG_TMPOBJ ;
18999 octave_value_list _out;
19000 octave_value_list *_outp=&_out;
19001 octave_value _outv;
19002
19003 try {
19004 arg2 = &temp2;
19005 arg3 = &temp3;
19006 arg4 = &temp4;
19007 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
19008 SWIG_fail;
19009 }
19010 ecode1 = SWIG_AsVal_int(args(0), &val1);
19011 if (!SWIG_IsOK(ecode1)) {
19012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
19013 }
19014 arg1 = static_cast< PLINT >(val1);
19015 plgcol0(arg1,arg2,arg3,arg4);
19016 _outv = octave_value();
19017 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19018 if (SWIG_IsTmpObj(res2)) {
19019 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19020 } else {
19021 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19022 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19023 }
19024 if (SWIG_IsTmpObj(res3)) {
19025 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19026 } else {
19027 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19028 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19029 }
19030 if (SWIG_IsTmpObj(res4)) {
19031 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19032 } else {
19033 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19035 }
19036 return _out;
19037 fail:
19038 return octave_value_list();
19039 }
19040 catch(...) {
19041 throw;
19042 }
19043}
19044
19045
19047 PLINT arg1 ;
19048 PLINT *arg2 = (PLINT *) 0 ;
19049 PLINT *arg3 = (PLINT *) 0 ;
19050 PLINT *arg4 = (PLINT *) 0 ;
19051 PLFLT *arg5 = (PLFLT *) 0 ;
19052 int val1 ;
19053 int ecode1 = 0 ;
19054 PLINT temp2 ;
19055 int res2 = SWIG_TMPOBJ ;
19056 PLINT temp3 ;
19057 int res3 = SWIG_TMPOBJ ;
19058 PLINT temp4 ;
19059 int res4 = SWIG_TMPOBJ ;
19060 PLFLT temp5 ;
19061 int res5 = SWIG_TMPOBJ ;
19062 octave_value_list _out;
19063 octave_value_list *_outp=&_out;
19064 octave_value _outv;
19065
19066 try {
19067 arg2 = &temp2;
19068 arg3 = &temp3;
19069 arg4 = &temp4;
19070 arg5 = &temp5;
19071 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19072 SWIG_fail;
19073 }
19074 ecode1 = SWIG_AsVal_int(args(0), &val1);
19075 if (!SWIG_IsOK(ecode1)) {
19076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19077 }
19078 arg1 = static_cast< PLINT >(val1);
19079 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19080 _outv = octave_value();
19081 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19082 if (SWIG_IsTmpObj(res2)) {
19083 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19084 } else {
19085 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19086 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19087 }
19088 if (SWIG_IsTmpObj(res3)) {
19089 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19090 } else {
19091 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19092 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19093 }
19094 if (SWIG_IsTmpObj(res4)) {
19095 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19096 } else {
19097 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19098 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19099 }
19100 if (SWIG_IsTmpObj(res5)) {
19101 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19102 } else {
19103 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19104 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19105 }
19106 return _out;
19107 fail:
19108 return octave_value_list();
19109 }
19110 catch(...) {
19111 throw;
19112 }
19113}
19114
19115
19117 PLINT *arg1 = (PLINT *) 0 ;
19118 PLINT *arg2 = (PLINT *) 0 ;
19119 PLINT *arg3 = (PLINT *) 0 ;
19120 PLINT temp1 ;
19121 int res1 = SWIG_TMPOBJ ;
19122 PLINT temp2 ;
19123 int res2 = SWIG_TMPOBJ ;
19124 PLINT temp3 ;
19125 int res3 = SWIG_TMPOBJ ;
19126 octave_value_list _out;
19127 octave_value_list *_outp=&_out;
19128 octave_value _outv;
19129
19130 try {
19131 arg1 = &temp1;
19132 arg2 = &temp2;
19133 arg3 = &temp3;
19134 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19135 SWIG_fail;
19136 }
19137 plgcolbg(arg1,arg2,arg3);
19138 _outv = octave_value();
19139 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19140 if (SWIG_IsTmpObj(res1)) {
19141 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19142 } else {
19143 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19144 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19145 }
19146 if (SWIG_IsTmpObj(res2)) {
19147 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19148 } else {
19149 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19150 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19151 }
19152 if (SWIG_IsTmpObj(res3)) {
19153 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19154 } else {
19155 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19156 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19157 }
19158 return _out;
19159 fail:
19160 return octave_value_list();
19161 }
19162 catch(...) {
19163 throw;
19164 }
19165}
19166
19167
19169 PLINT *arg1 = (PLINT *) 0 ;
19170 PLINT *arg2 = (PLINT *) 0 ;
19171 PLINT *arg3 = (PLINT *) 0 ;
19172 PLFLT *arg4 = (PLFLT *) 0 ;
19173 PLINT temp1 ;
19174 int res1 = SWIG_TMPOBJ ;
19175 PLINT temp2 ;
19176 int res2 = SWIG_TMPOBJ ;
19177 PLINT temp3 ;
19178 int res3 = SWIG_TMPOBJ ;
19179 PLFLT temp4 ;
19180 int res4 = SWIG_TMPOBJ ;
19181 octave_value_list _out;
19182 octave_value_list *_outp=&_out;
19183 octave_value _outv;
19184
19185 try {
19186 arg1 = &temp1;
19187 arg2 = &temp2;
19188 arg3 = &temp3;
19189 arg4 = &temp4;
19190 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19191 SWIG_fail;
19192 }
19193 plgcolbga(arg1,arg2,arg3,arg4);
19194 _outv = octave_value();
19195 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19196 if (SWIG_IsTmpObj(res1)) {
19197 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19198 } else {
19199 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19200 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19201 }
19202 if (SWIG_IsTmpObj(res2)) {
19203 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19204 } else {
19205 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19206 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19207 }
19208 if (SWIG_IsTmpObj(res3)) {
19209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19210 } else {
19211 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19213 }
19214 if (SWIG_IsTmpObj(res4)) {
19215 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19216 } else {
19217 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19218 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19219 }
19220 return _out;
19221 fail:
19222 return octave_value_list();
19223 }
19224 catch(...) {
19225 throw;
19226 }
19227}
19228
19229
19230SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19231 PLINT *arg1 = (PLINT *) 0 ;
19232 PLINT temp1 ;
19233 int res1 = SWIG_TMPOBJ ;
19234 octave_value_list _out;
19235 octave_value_list *_outp=&_out;
19236 octave_value _outv;
19237
19238 try {
19239 arg1 = &temp1;
19240 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19241 SWIG_fail;
19242 }
19243 plgcompression(arg1);
19244 _outv = octave_value();
19245 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19246 if (SWIG_IsTmpObj(res1)) {
19247 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19248 } else {
19249 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19250 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19251 }
19252 return _out;
19253 fail:
19254 return octave_value_list();
19255 }
19256 catch(...) {
19257 throw;
19258 }
19259}
19260
19261
19263 char *arg1 = (char *) 0 ;
19264 char local_string1[80] ;
19265 size_t local_string_length1 ;
19266 charMatrix local_charMatrix1 ;
19267 octave_value_list retval1 ;
19268 octave_value_list _out;
19269 octave_value_list *_outp=&_out;
19270 octave_value _outv;
19271
19272 try {
19273 {
19274 arg1 = local_string1;
19275 }
19276 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19277 SWIG_fail;
19278 }
19279 plgdev(arg1);
19280 _outv = octave_value();
19281 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19282 {
19283 local_string_length1 = strlen( local_string1 );
19284 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19285 local_charMatrix1.insert( local_string1, 0, 0 );
19286 retval1( 0 ) = octave_value( local_charMatrix1 );
19287 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19288 }
19289 return _out;
19290 fail:
19291 return octave_value_list();
19292 }
19293 catch(...) {
19294 throw;
19295 }
19296}
19297
19298
19300 PLFLT *arg1 = (PLFLT *) 0 ;
19301 PLFLT *arg2 = (PLFLT *) 0 ;
19302 PLFLT *arg3 = (PLFLT *) 0 ;
19303 PLFLT *arg4 = (PLFLT *) 0 ;
19304 PLFLT temp1 ;
19305 int res1 = SWIG_TMPOBJ ;
19306 PLFLT temp2 ;
19307 int res2 = SWIG_TMPOBJ ;
19308 PLFLT temp3 ;
19309 int res3 = SWIG_TMPOBJ ;
19310 PLFLT temp4 ;
19311 int res4 = SWIG_TMPOBJ ;
19312 octave_value_list _out;
19313 octave_value_list *_outp=&_out;
19314 octave_value _outv;
19315
19316 try {
19317 arg1 = &temp1;
19318 arg2 = &temp2;
19319 arg3 = &temp3;
19320 arg4 = &temp4;
19321 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19322 SWIG_fail;
19323 }
19324 plgdidev(arg1,arg2,arg3,arg4);
19325 _outv = octave_value();
19326 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19327 if (SWIG_IsTmpObj(res1)) {
19328 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19329 } else {
19330 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19331 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19332 }
19333 if (SWIG_IsTmpObj(res2)) {
19334 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19335 } else {
19336 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19337 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19338 }
19339 if (SWIG_IsTmpObj(res3)) {
19340 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19341 } else {
19342 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19343 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19344 }
19345 if (SWIG_IsTmpObj(res4)) {
19346 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19347 } else {
19348 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19349 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19350 }
19351 return _out;
19352 fail:
19353 return octave_value_list();
19354 }
19355 catch(...) {
19356 throw;
19357 }
19358}
19359
19360
19362 PLFLT *arg1 = (PLFLT *) 0 ;
19363 PLFLT temp1 ;
19364 int res1 = SWIG_TMPOBJ ;
19365 octave_value_list _out;
19366 octave_value_list *_outp=&_out;
19367 octave_value _outv;
19368
19369 try {
19370 arg1 = &temp1;
19371 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19372 SWIG_fail;
19373 }
19374 plgdiori(arg1);
19375 _outv = octave_value();
19376 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19377 if (SWIG_IsTmpObj(res1)) {
19378 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19379 } else {
19380 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19381 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19382 }
19383 return _out;
19384 fail:
19385 return octave_value_list();
19386 }
19387 catch(...) {
19388 throw;
19389 }
19390}
19391
19392
19394 PLFLT *arg1 = (PLFLT *) 0 ;
19395 PLFLT *arg2 = (PLFLT *) 0 ;
19396 PLFLT *arg3 = (PLFLT *) 0 ;
19397 PLFLT *arg4 = (PLFLT *) 0 ;
19398 PLFLT temp1 ;
19399 int res1 = SWIG_TMPOBJ ;
19400 PLFLT temp2 ;
19401 int res2 = SWIG_TMPOBJ ;
19402 PLFLT temp3 ;
19403 int res3 = SWIG_TMPOBJ ;
19404 PLFLT temp4 ;
19405 int res4 = SWIG_TMPOBJ ;
19406 octave_value_list _out;
19407 octave_value_list *_outp=&_out;
19408 octave_value _outv;
19409
19410 try {
19411 arg1 = &temp1;
19412 arg2 = &temp2;
19413 arg3 = &temp3;
19414 arg4 = &temp4;
19415 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19416 SWIG_fail;
19417 }
19418 plgdiplt(arg1,arg2,arg3,arg4);
19419 _outv = octave_value();
19420 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19421 if (SWIG_IsTmpObj(res1)) {
19422 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19423 } else {
19424 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19425 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19426 }
19427 if (SWIG_IsTmpObj(res2)) {
19428 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19429 } else {
19430 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19431 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19432 }
19433 if (SWIG_IsTmpObj(res3)) {
19434 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19435 } else {
19436 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19437 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19438 }
19439 if (SWIG_IsTmpObj(res4)) {
19440 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19441 } else {
19442 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19443 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19444 }
19445 return _out;
19446 fail:
19447 return octave_value_list();
19448 }
19449 catch(...) {
19450 throw;
19451 }
19452}
19453
19454
19456 PLINT *arg1 = (PLINT *) 0 ;
19457 PLINT *arg2 = (PLINT *) 0 ;
19458 PLINT *arg3 = (PLINT *) 0 ;
19459 PLINT temp1 ;
19460 int res1 = SWIG_TMPOBJ ;
19461 PLINT temp2 ;
19462 int res2 = SWIG_TMPOBJ ;
19463 PLINT temp3 ;
19464 int res3 = SWIG_TMPOBJ ;
19465 octave_value_list _out;
19466 octave_value_list *_outp=&_out;
19467 octave_value _outv;
19468
19469 try {
19470 arg1 = &temp1;
19471 arg2 = &temp2;
19472 arg3 = &temp3;
19473 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19474 SWIG_fail;
19475 }
19476 plgfam(arg1,arg2,arg3);
19477 _outv = octave_value();
19478 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19479 if (SWIG_IsTmpObj(res1)) {
19480 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19481 } else {
19482 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19483 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19484 }
19485 if (SWIG_IsTmpObj(res2)) {
19486 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19487 } else {
19488 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19489 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19490 }
19491 if (SWIG_IsTmpObj(res3)) {
19492 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19493 } else {
19494 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19495 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19496 }
19497 return _out;
19498 fail:
19499 return octave_value_list();
19500 }
19501 catch(...) {
19502 throw;
19503 }
19504}
19505
19506
19508 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19509 PLUNICODE temp1 ;
19510 int res1 = SWIG_TMPOBJ ;
19511 octave_value_list _out;
19512 octave_value_list *_outp=&_out;
19513 octave_value _outv;
19514
19515 try {
19516 arg1 = &temp1;
19517 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19518 SWIG_fail;
19519 }
19520 plgfci(arg1);
19521 _outv = octave_value();
19522 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19523 if (SWIG_IsTmpObj(res1)) {
19524 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19525 } else {
19526 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19528 }
19529 return _out;
19530 fail:
19531 return octave_value_list();
19532 }
19533 catch(...) {
19534 throw;
19535 }
19536}
19537
19538
19540 char *arg1 = (char *) 0 ;
19541 char local_string1[80] ;
19542 size_t local_string_length1 ;
19543 charMatrix local_charMatrix1 ;
19544 octave_value_list retval1 ;
19545 octave_value_list _out;
19546 octave_value_list *_outp=&_out;
19547 octave_value _outv;
19548
19549 try {
19550 {
19551 arg1 = local_string1;
19552 }
19553 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19554 SWIG_fail;
19555 }
19556 plgfnam(arg1);
19557 _outv = octave_value();
19558 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19559 {
19560 local_string_length1 = strlen( local_string1 );
19561 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19562 local_charMatrix1.insert( local_string1, 0, 0 );
19563 retval1( 0 ) = octave_value( local_charMatrix1 );
19564 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19565 }
19566 return _out;
19567 fail:
19568 return octave_value_list();
19569 }
19570 catch(...) {
19571 throw;
19572 }
19573}
19574
19575
19577 PLINT *arg1 = (PLINT *) 0 ;
19578 PLINT *arg2 = (PLINT *) 0 ;
19579 PLINT *arg3 = (PLINT *) 0 ;
19580 PLINT temp1 ;
19581 int res1 = SWIG_TMPOBJ ;
19582 PLINT temp2 ;
19583 int res2 = SWIG_TMPOBJ ;
19584 PLINT temp3 ;
19585 int res3 = SWIG_TMPOBJ ;
19586 octave_value_list _out;
19587 octave_value_list *_outp=&_out;
19588 octave_value _outv;
19589
19590 try {
19591 arg1 = &temp1;
19592 arg2 = &temp2;
19593 arg3 = &temp3;
19594 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19595 SWIG_fail;
19596 }
19597 plgfont(arg1,arg2,arg3);
19598 _outv = octave_value();
19599 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19600 if (SWIG_IsTmpObj(res1)) {
19601 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19602 } else {
19603 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19604 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19605 }
19606 if (SWIG_IsTmpObj(res2)) {
19607 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19608 } else {
19609 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19610 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19611 }
19612 if (SWIG_IsTmpObj(res3)) {
19613 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19614 } else {
19615 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19616 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19617 }
19618 return _out;
19619 fail:
19620 return octave_value_list();
19621 }
19622 catch(...) {
19623 throw;
19624 }
19625}
19626
19627
19629 PLINT *arg1 = (PLINT *) 0 ;
19630 PLINT temp1 ;
19631 int res1 = SWIG_TMPOBJ ;
19632 octave_value_list _out;
19633 octave_value_list *_outp=&_out;
19634 octave_value _outv;
19635
19636 try {
19637 arg1 = &temp1;
19638 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19639 SWIG_fail;
19640 }
19641 plglevel(arg1);
19642 _outv = octave_value();
19643 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19644 if (SWIG_IsTmpObj(res1)) {
19645 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19646 } else {
19647 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19648 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19649 }
19650 return _out;
19651 fail:
19652 return octave_value_list();
19653 }
19654 catch(...) {
19655 throw;
19656 }
19657}
19658
19659
19661 PLFLT *arg1 = (PLFLT *) 0 ;
19662 PLFLT *arg2 = (PLFLT *) 0 ;
19663 PLINT *arg3 = (PLINT *) 0 ;
19664 PLINT *arg4 = (PLINT *) 0 ;
19665 PLINT *arg5 = (PLINT *) 0 ;
19666 PLINT *arg6 = (PLINT *) 0 ;
19667 PLFLT temp1 ;
19668 int res1 = SWIG_TMPOBJ ;
19669 PLFLT temp2 ;
19670 int res2 = SWIG_TMPOBJ ;
19671 PLINT temp3 ;
19672 int res3 = SWIG_TMPOBJ ;
19673 PLINT temp4 ;
19674 int res4 = SWIG_TMPOBJ ;
19675 PLINT temp5 ;
19676 int res5 = SWIG_TMPOBJ ;
19677 PLINT temp6 ;
19678 int res6 = SWIG_TMPOBJ ;
19679 octave_value_list _out;
19680 octave_value_list *_outp=&_out;
19681 octave_value _outv;
19682
19683 try {
19684 arg1 = &temp1;
19685 arg2 = &temp2;
19686 arg3 = &temp3;
19687 arg4 = &temp4;
19688 arg5 = &temp5;
19689 arg6 = &temp6;
19690 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19691 SWIG_fail;
19692 }
19693 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19694 _outv = octave_value();
19695 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19696 if (SWIG_IsTmpObj(res1)) {
19697 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19698 } else {
19699 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19700 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19701 }
19702 if (SWIG_IsTmpObj(res2)) {
19703 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19704 } else {
19705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19706 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19707 }
19708 if (SWIG_IsTmpObj(res3)) {
19709 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19710 } else {
19711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19712 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19713 }
19714 if (SWIG_IsTmpObj(res4)) {
19715 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19716 } else {
19717 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19718 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19719 }
19720 if (SWIG_IsTmpObj(res5)) {
19721 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19722 } else {
19723 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19724 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19725 }
19726 if (SWIG_IsTmpObj(res6)) {
19727 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19728 } else {
19729 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19730 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19731 }
19732 return _out;
19733 fail:
19734 return octave_value_list();
19735 }
19736 catch(...) {
19737 throw;
19738 }
19739}
19740
19741
19743 octave_value_list _out;
19744 octave_value_list *_outp=&_out;
19745 octave_value _outv;
19746
19747 try {
19748 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19749 SWIG_fail;
19750 }
19751 plgra();
19752 _outv = octave_value();
19753 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19754 return _out;
19755 fail:
19756 return octave_value_list();
19757 }
19758 catch(...) {
19759 throw;
19760 }
19761}
19762
19763
19765 PLFLT *arg1 = (PLFLT *) 0 ;
19766 PLFLT *arg2 = (PLFLT *) 0 ;
19767 PLFLT *arg3 = (PLFLT *) 0 ;
19768 PLFLT *arg4 = (PLFLT *) 0 ;
19769 PLFLT temp1 ;
19770 int res1 = SWIG_TMPOBJ ;
19771 PLFLT temp2 ;
19772 int res2 = SWIG_TMPOBJ ;
19773 PLFLT temp3 ;
19774 int res3 = SWIG_TMPOBJ ;
19775 PLFLT temp4 ;
19776 int res4 = SWIG_TMPOBJ ;
19777 octave_value_list _out;
19778 octave_value_list *_outp=&_out;
19779 octave_value _outv;
19780
19781 try {
19782 arg1 = &temp1;
19783 arg2 = &temp2;
19784 arg3 = &temp3;
19785 arg4 = &temp4;
19786 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19787 SWIG_fail;
19788 }
19789 plgspa(arg1,arg2,arg3,arg4);
19790 _outv = octave_value();
19791 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19792 if (SWIG_IsTmpObj(res1)) {
19793 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19794 } else {
19795 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19796 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19797 }
19798 if (SWIG_IsTmpObj(res2)) {
19799 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19800 } else {
19801 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19802 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19803 }
19804 if (SWIG_IsTmpObj(res3)) {
19805 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19806 } else {
19807 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19808 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19809 }
19810 if (SWIG_IsTmpObj(res4)) {
19811 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19812 } else {
19813 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19814 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19815 }
19816 return _out;
19817 fail:
19818 return octave_value_list();
19819 }
19820 catch(...) {
19821 throw;
19822 }
19823}
19824
19825
19827 PLINT *arg1 = (PLINT *) 0 ;
19828 PLINT temp1 ;
19829 int res1 = SWIG_TMPOBJ ;
19830 octave_value_list _out;
19831 octave_value_list *_outp=&_out;
19832 octave_value _outv;
19833
19834 try {
19835 arg1 = &temp1;
19836 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19837 SWIG_fail;
19838 }
19839 plgstrm(arg1);
19840 _outv = octave_value();
19841 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19842 if (SWIG_IsTmpObj(res1)) {
19843 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19844 } else {
19845 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19846 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19847 }
19848 return _out;
19849 fail:
19850 return octave_value_list();
19851 }
19852 catch(...) {
19853 throw;
19854 }
19855}
19856
19857
19859 char *arg1 = (char *) 0 ;
19860 char local_string1[80] ;
19861 size_t local_string_length1 ;
19862 charMatrix local_charMatrix1 ;
19863 octave_value_list retval1 ;
19864 octave_value_list _out;
19865 octave_value_list *_outp=&_out;
19866 octave_value _outv;
19867
19868 try {
19869 {
19870 arg1 = local_string1;
19871 }
19872 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19873 SWIG_fail;
19874 }
19875 plgver(arg1);
19876 _outv = octave_value();
19877 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19878 {
19879 local_string_length1 = strlen( local_string1 );
19880 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19881 local_charMatrix1.insert( local_string1, 0, 0 );
19882 retval1( 0 ) = octave_value( local_charMatrix1 );
19883 _outp = SWIG_Octave_AppendOutput(_outp, retval1( 0 ));
19884 }
19885 return _out;
19886 fail:
19887 return octave_value_list();
19888 }
19889 catch(...) {
19890 throw;
19891 }
19892}
19893
19894
19896 PLFLT *arg1 = (PLFLT *) 0 ;
19897 PLFLT *arg2 = (PLFLT *) 0 ;
19898 PLFLT *arg3 = (PLFLT *) 0 ;
19899 PLFLT *arg4 = (PLFLT *) 0 ;
19900 PLFLT temp1 ;
19901 int res1 = SWIG_TMPOBJ ;
19902 PLFLT temp2 ;
19903 int res2 = SWIG_TMPOBJ ;
19904 PLFLT temp3 ;
19905 int res3 = SWIG_TMPOBJ ;
19906 PLFLT temp4 ;
19907 int res4 = SWIG_TMPOBJ ;
19908 octave_value_list _out;
19909 octave_value_list *_outp=&_out;
19910 octave_value _outv;
19911
19912 try {
19913 arg1 = &temp1;
19914 arg2 = &temp2;
19915 arg3 = &temp3;
19916 arg4 = &temp4;
19917 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19918 SWIG_fail;
19919 }
19920 plgvpd(arg1,arg2,arg3,arg4);
19921 _outv = octave_value();
19922 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19923 if (SWIG_IsTmpObj(res1)) {
19924 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19925 } else {
19926 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19927 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19928 }
19929 if (SWIG_IsTmpObj(res2)) {
19930 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19931 } else {
19932 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19933 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19934 }
19935 if (SWIG_IsTmpObj(res3)) {
19936 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19937 } else {
19938 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19939 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19940 }
19941 if (SWIG_IsTmpObj(res4)) {
19942 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19943 } else {
19944 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19945 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19946 }
19947 return _out;
19948 fail:
19949 return octave_value_list();
19950 }
19951 catch(...) {
19952 throw;
19953 }
19954}
19955
19956
19958 PLFLT *arg1 = (PLFLT *) 0 ;
19959 PLFLT *arg2 = (PLFLT *) 0 ;
19960 PLFLT *arg3 = (PLFLT *) 0 ;
19961 PLFLT *arg4 = (PLFLT *) 0 ;
19962 PLFLT temp1 ;
19963 int res1 = SWIG_TMPOBJ ;
19964 PLFLT temp2 ;
19965 int res2 = SWIG_TMPOBJ ;
19966 PLFLT temp3 ;
19967 int res3 = SWIG_TMPOBJ ;
19968 PLFLT temp4 ;
19969 int res4 = SWIG_TMPOBJ ;
19970 octave_value_list _out;
19971 octave_value_list *_outp=&_out;
19972 octave_value _outv;
19973
19974 try {
19975 arg1 = &temp1;
19976 arg2 = &temp2;
19977 arg3 = &temp3;
19978 arg4 = &temp4;
19979 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19980 SWIG_fail;
19981 }
19982 plgvpw(arg1,arg2,arg3,arg4);
19983 _outv = octave_value();
19984 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19985 if (SWIG_IsTmpObj(res1)) {
19986 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19987 } else {
19988 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19989 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19990 }
19991 if (SWIG_IsTmpObj(res2)) {
19992 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19993 } else {
19994 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19995 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19996 }
19997 if (SWIG_IsTmpObj(res3)) {
19998 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19999 } else {
20000 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20001 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
20002 }
20003 if (SWIG_IsTmpObj(res4)) {
20004 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20005 } else {
20006 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20007 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20008 }
20009 return _out;
20010 fail:
20011 return octave_value_list();
20012 }
20013 catch(...) {
20014 throw;
20015 }
20016}
20017
20018
20020 PLINT *arg1 = (PLINT *) 0 ;
20021 PLINT *arg2 = (PLINT *) 0 ;
20022 PLINT temp1 ;
20023 int res1 = SWIG_TMPOBJ ;
20024 PLINT temp2 ;
20025 int res2 = SWIG_TMPOBJ ;
20026 octave_value_list _out;
20027 octave_value_list *_outp=&_out;
20028 octave_value _outv;
20029
20030 try {
20031 arg1 = &temp1;
20032 arg2 = &temp2;
20033 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
20034 SWIG_fail;
20035 }
20036 plgxax(arg1,arg2);
20037 _outv = octave_value();
20038 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20039 if (SWIG_IsTmpObj(res1)) {
20040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20041 } else {
20042 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20044 }
20045 if (SWIG_IsTmpObj(res2)) {
20046 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20047 } else {
20048 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20049 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20050 }
20051 return _out;
20052 fail:
20053 return octave_value_list();
20054 }
20055 catch(...) {
20056 throw;
20057 }
20058}
20059
20060
20062 PLINT *arg1 = (PLINT *) 0 ;
20063 PLINT *arg2 = (PLINT *) 0 ;
20064 PLINT temp1 ;
20065 int res1 = SWIG_TMPOBJ ;
20066 PLINT temp2 ;
20067 int res2 = SWIG_TMPOBJ ;
20068 octave_value_list _out;
20069 octave_value_list *_outp=&_out;
20070 octave_value _outv;
20071
20072 try {
20073 arg1 = &temp1;
20074 arg2 = &temp2;
20075 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20076 SWIG_fail;
20077 }
20078 plgyax(arg1,arg2);
20079 _outv = octave_value();
20080 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20081 if (SWIG_IsTmpObj(res1)) {
20082 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20083 } else {
20084 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20085 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20086 }
20087 if (SWIG_IsTmpObj(res2)) {
20088 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20089 } else {
20090 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20091 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20092 }
20093 return _out;
20094 fail:
20095 return octave_value_list();
20096 }
20097 catch(...) {
20098 throw;
20099 }
20100}
20101
20102
20104 PLINT *arg1 = (PLINT *) 0 ;
20105 PLINT *arg2 = (PLINT *) 0 ;
20106 PLINT temp1 ;
20107 int res1 = SWIG_TMPOBJ ;
20108 PLINT temp2 ;
20109 int res2 = SWIG_TMPOBJ ;
20110 octave_value_list _out;
20111 octave_value_list *_outp=&_out;
20112 octave_value _outv;
20113
20114 try {
20115 arg1 = &temp1;
20116 arg2 = &temp2;
20117 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20118 SWIG_fail;
20119 }
20120 plgzax(arg1,arg2);
20121 _outv = octave_value();
20122 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20123 if (SWIG_IsTmpObj(res1)) {
20124 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20125 } else {
20126 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20127 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20128 }
20129 if (SWIG_IsTmpObj(res2)) {
20130 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20131 } else {
20132 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20133 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20134 }
20135 return _out;
20136 fail:
20137 return octave_value_list();
20138 }
20139 catch(...) {
20140 throw;
20141 }
20142}
20143
20144
20146 PLINT arg1 ;
20147 PLFLT *arg2 = (PLFLT *) 0 ;
20148 PLFLT arg3 ;
20149 PLFLT arg4 ;
20150 PLINT arg5 ;
20151 PLINT arg6 ;
20152 Matrix temp1 ;
20153 double val3 ;
20154 int ecode3 = 0 ;
20155 double val4 ;
20156 int ecode4 = 0 ;
20157 int val5 ;
20158 int ecode5 = 0 ;
20159 int val6 ;
20160 int ecode6 = 0 ;
20161 octave_value_list _out;
20162 octave_value_list *_outp=&_out;
20163 octave_value _outv;
20164
20165 try {
20166 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20167 SWIG_fail;
20168 }
20169 {
20170 if ( _n_dims( args(0) ) > 1 )
20171 {
20172 error( "argument must be a scalar or vector" ); SWIG_fail;
20173 }
20174 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20175 temp1 = args(0).matrix_value();
20176 arg2 = &temp1( 0, 0 );
20177 }
20178 ecode3 = SWIG_AsVal_double(args(1), &val3);
20179 if (!SWIG_IsOK(ecode3)) {
20180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20181 }
20182 arg3 = static_cast< PLFLT >(val3);
20183 ecode4 = SWIG_AsVal_double(args(2), &val4);
20184 if (!SWIG_IsOK(ecode4)) {
20185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20186 }
20187 arg4 = static_cast< PLFLT >(val4);
20188 ecode5 = SWIG_AsVal_int(args(3), &val5);
20189 if (!SWIG_IsOK(ecode5)) {
20190 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20191 }
20192 arg5 = static_cast< PLINT >(val5);
20193 ecode6 = SWIG_AsVal_int(args(4), &val6);
20194 if (!SWIG_IsOK(ecode6)) {
20195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20196 }
20197 arg6 = static_cast< PLINT >(val6);
20198 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20199 _outv = octave_value();
20200 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20201 {
20202
20203 }
20204 return _out;
20205 fail:
20206 {
20207
20208 }
20209 return octave_value_list();
20210 }
20211 catch(...) {
20212 {
20213
20214 }
20215 throw;
20216 }
20217}
20218
20219
20221 PLFLT arg1 ;
20222 PLFLT arg2 ;
20223 PLFLT arg3 ;
20224 PLFLT *arg4 = (PLFLT *) 0 ;
20225 PLFLT *arg5 = (PLFLT *) 0 ;
20226 PLFLT *arg6 = (PLFLT *) 0 ;
20227 double val1 ;
20228 int ecode1 = 0 ;
20229 double val2 ;
20230 int ecode2 = 0 ;
20231 double val3 ;
20232 int ecode3 = 0 ;
20233 PLFLT temp4 ;
20234 int res4 = SWIG_TMPOBJ ;
20235 PLFLT temp5 ;
20236 int res5 = SWIG_TMPOBJ ;
20237 PLFLT temp6 ;
20238 int res6 = SWIG_TMPOBJ ;
20239 octave_value_list _out;
20240 octave_value_list *_outp=&_out;
20241 octave_value _outv;
20242
20243 try {
20244 arg4 = &temp4;
20245 arg5 = &temp5;
20246 arg6 = &temp6;
20247 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20248 SWIG_fail;
20249 }
20250 ecode1 = SWIG_AsVal_double(args(0), &val1);
20251 if (!SWIG_IsOK(ecode1)) {
20252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20253 }
20254 arg1 = static_cast< PLFLT >(val1);
20255 ecode2 = SWIG_AsVal_double(args(1), &val2);
20256 if (!SWIG_IsOK(ecode2)) {
20257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20258 }
20259 arg2 = static_cast< PLFLT >(val2);
20260 ecode3 = SWIG_AsVal_double(args(2), &val3);
20261 if (!SWIG_IsOK(ecode3)) {
20262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20263 }
20264 arg3 = static_cast< PLFLT >(val3);
20265 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20266 _outv = octave_value();
20267 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20268 if (SWIG_IsTmpObj(res4)) {
20269 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20270 } else {
20271 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20272 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20273 }
20274 if (SWIG_IsTmpObj(res5)) {
20275 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20276 } else {
20277 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20279 }
20280 if (SWIG_IsTmpObj(res6)) {
20281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20282 } else {
20283 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20285 }
20286 return _out;
20287 fail:
20288 return octave_value_list();
20289 }
20290 catch(...) {
20291 throw;
20292 }
20293}
20294
20295
20297 octave_value_list _out;
20298 octave_value_list *_outp=&_out;
20299 octave_value _outv;
20300
20301 try {
20302 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20303 SWIG_fail;
20304 }
20305 plinit();
20306 _outv = octave_value();
20307 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20308 return _out;
20309 fail:
20310 return octave_value_list();
20311 }
20312 catch(...) {
20313 throw;
20314 }
20315}
20316
20317
20319 PLFLT arg1 ;
20320 PLFLT arg2 ;
20321 PLFLT arg3 ;
20322 PLFLT arg4 ;
20323 double val1 ;
20324 int ecode1 = 0 ;
20325 double val2 ;
20326 int ecode2 = 0 ;
20327 double val3 ;
20328 int ecode3 = 0 ;
20329 double val4 ;
20330 int ecode4 = 0 ;
20331 octave_value_list _out;
20332 octave_value_list *_outp=&_out;
20333 octave_value _outv;
20334
20335 try {
20336 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20337 SWIG_fail;
20338 }
20339 ecode1 = SWIG_AsVal_double(args(0), &val1);
20340 if (!SWIG_IsOK(ecode1)) {
20341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20342 }
20343 arg1 = static_cast< PLFLT >(val1);
20344 ecode2 = SWIG_AsVal_double(args(1), &val2);
20345 if (!SWIG_IsOK(ecode2)) {
20346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20347 }
20348 arg2 = static_cast< PLFLT >(val2);
20349 ecode3 = SWIG_AsVal_double(args(2), &val3);
20350 if (!SWIG_IsOK(ecode3)) {
20351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20352 }
20353 arg3 = static_cast< PLFLT >(val3);
20354 ecode4 = SWIG_AsVal_double(args(3), &val4);
20355 if (!SWIG_IsOK(ecode4)) {
20356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20357 }
20358 arg4 = static_cast< PLFLT >(val4);
20359 pljoin(arg1,arg2,arg3,arg4);
20360 _outv = octave_value();
20361 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20362 return _out;
20363 fail:
20364 return octave_value_list();
20365 }
20366 catch(...) {
20367 throw;
20368 }
20369}
20370
20371
20373 char *arg1 = (char *) 0 ;
20374 char *arg2 = (char *) 0 ;
20375 char *arg3 = (char *) 0 ;
20376 int res1 ;
20377 char *buf1 = 0 ;
20378 int alloc1 = 0 ;
20379 int res2 ;
20380 char *buf2 = 0 ;
20381 int alloc2 = 0 ;
20382 int res3 ;
20383 char *buf3 = 0 ;
20384 int alloc3 = 0 ;
20385 octave_value_list _out;
20386 octave_value_list *_outp=&_out;
20387 octave_value _outv;
20388
20389 try {
20390 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20391 SWIG_fail;
20392 }
20393 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20394 if (!SWIG_IsOK(res1)) {
20395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20396 }
20397 arg1 = reinterpret_cast< char * >(buf1);
20398 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20399 if (!SWIG_IsOK(res2)) {
20400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20401 }
20402 arg2 = reinterpret_cast< char * >(buf2);
20403 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20404 if (!SWIG_IsOK(res3)) {
20405 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20406 }
20407 arg3 = reinterpret_cast< char * >(buf3);
20408 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20409 _outv = octave_value();
20410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20411 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20412 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20413 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20414 return _out;
20415 fail:
20416 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20417 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20418 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20419 return octave_value_list();
20420 }
20421 catch(...) {
20422 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20423 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20424 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20425 throw;
20426 }
20427}
20428
20429
20431 PLFLT *arg1 = (PLFLT *) 0 ;
20432 PLFLT *arg2 = (PLFLT *) 0 ;
20433 PLINT arg3 ;
20434 PLINT arg4 ;
20435 PLFLT arg5 ;
20436 PLFLT arg6 ;
20437 PLFLT arg7 ;
20438 PLINT arg8 ;
20439 PLINT arg9 ;
20440 PLINT arg10 ;
20441 PLINT arg11 ;
20442 PLINT arg12 ;
20443 PLINT arg13 ;
20444 PLINT *arg14 = (PLINT *) 0 ;
20445 PLFLT arg15 ;
20446 PLFLT arg16 ;
20447 PLFLT arg17 ;
20448 PLFLT arg18 ;
20449 PLINT *arg19 = (PLINT *) 0 ;
20450 char **arg20 = (char **) 0 ;
20451 PLINT *arg21 = (PLINT *) 0 ;
20452 PLINT *arg22 = (PLINT *) 0 ;
20453 PLFLT *arg23 = (PLFLT *) 0 ;
20454 PLFLT *arg24 = (PLFLT *) 0 ;
20455 PLINT *arg25 = (PLINT *) 0 ;
20456 PLINT *arg26 = (PLINT *) 0 ;
20457 PLFLT *arg27 = (PLFLT *) 0 ;
20458 PLINT *arg28 = (PLINT *) 0 ;
20459 PLFLT *arg29 = (PLFLT *) 0 ;
20460 PLINT *arg30 = (PLINT *) 0 ;
20461 char **arg31 = (char **) 0 ;
20462 PLFLT temp1 ;
20463 int res1 = SWIG_TMPOBJ ;
20464 PLFLT temp2 ;
20465 int res2 = SWIG_TMPOBJ ;
20466 int val3 ;
20467 int ecode3 = 0 ;
20468 int val4 ;
20469 int ecode4 = 0 ;
20470 double val5 ;
20471 int ecode5 = 0 ;
20472 double val6 ;
20473 int ecode6 = 0 ;
20474 double val7 ;
20475 int ecode7 = 0 ;
20476 int val8 ;
20477 int ecode8 = 0 ;
20478 int val9 ;
20479 int ecode9 = 0 ;
20480 int val10 ;
20481 int ecode10 = 0 ;
20482 int val11 ;
20483 int ecode11 = 0 ;
20484 int val12 ;
20485 int ecode12 = 0 ;
20486 Matrix temp13 ;
20487 double val15 ;
20488 int ecode15 = 0 ;
20489 double val16 ;
20490 int ecode16 = 0 ;
20491 double val17 ;
20492 int ecode17 = 0 ;
20493 double val18 ;
20494 int ecode18 = 0 ;
20495 Matrix temp19 ;
20496 Matrix temp21 ;
20497 Matrix temp22 ;
20498 Matrix temp23 ;
20499 Matrix temp24 ;
20500 Matrix temp25 ;
20501 Matrix temp26 ;
20502 Matrix temp27 ;
20503 Matrix temp28 ;
20504 Matrix temp29 ;
20505 Matrix temp30 ;
20506 octave_value_list _out;
20507 octave_value_list *_outp=&_out;
20508 octave_value _outv;
20509
20510 try {
20511 arg1 = &temp1;
20512 arg2 = &temp2;
20513 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20514 SWIG_fail;
20515 }
20516 ecode3 = SWIG_AsVal_int(args(0), &val3);
20517 if (!SWIG_IsOK(ecode3)) {
20518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20519 }
20520 arg3 = static_cast< PLINT >(val3);
20521 ecode4 = SWIG_AsVal_int(args(1), &val4);
20522 if (!SWIG_IsOK(ecode4)) {
20523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20524 }
20525 arg4 = static_cast< PLINT >(val4);
20526 ecode5 = SWIG_AsVal_double(args(2), &val5);
20527 if (!SWIG_IsOK(ecode5)) {
20528 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20529 }
20530 arg5 = static_cast< PLFLT >(val5);
20531 ecode6 = SWIG_AsVal_double(args(3), &val6);
20532 if (!SWIG_IsOK(ecode6)) {
20533 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20534 }
20535 arg6 = static_cast< PLFLT >(val6);
20536 ecode7 = SWIG_AsVal_double(args(4), &val7);
20537 if (!SWIG_IsOK(ecode7)) {
20538 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20539 }
20540 arg7 = static_cast< PLFLT >(val7);
20541 ecode8 = SWIG_AsVal_int(args(5), &val8);
20542 if (!SWIG_IsOK(ecode8)) {
20543 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20544 }
20545 arg8 = static_cast< PLINT >(val8);
20546 ecode9 = SWIG_AsVal_int(args(6), &val9);
20547 if (!SWIG_IsOK(ecode9)) {
20548 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20549 }
20550 arg9 = static_cast< PLINT >(val9);
20551 ecode10 = SWIG_AsVal_int(args(7), &val10);
20552 if (!SWIG_IsOK(ecode10)) {
20553 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20554 }
20555 arg10 = static_cast< PLINT >(val10);
20556 ecode11 = SWIG_AsVal_int(args(8), &val11);
20557 if (!SWIG_IsOK(ecode11)) {
20558 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20559 }
20560 arg11 = static_cast< PLINT >(val11);
20561 ecode12 = SWIG_AsVal_int(args(9), &val12);
20562 if (!SWIG_IsOK(ecode12)) {
20563 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20564 }
20565 arg12 = static_cast< PLINT >(val12);
20566 {
20567 if ( _n_dims( args(10) ) > 1 )
20568 {
20569 error( "argument must be a scalar or vector" ); SWIG_fail;
20570 }
20571 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20572 arg14 = new PLINT[Alen];
20573 temp13 = args(10).matrix_value();
20574 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20575 }
20576 ecode15 = SWIG_AsVal_double(args(11), &val15);
20577 if (!SWIG_IsOK(ecode15)) {
20578 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20579 }
20580 arg15 = static_cast< PLFLT >(val15);
20581 ecode16 = SWIG_AsVal_double(args(12), &val16);
20582 if (!SWIG_IsOK(ecode16)) {
20583 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20584 }
20585 arg16 = static_cast< PLFLT >(val16);
20586 ecode17 = SWIG_AsVal_double(args(13), &val17);
20587 if (!SWIG_IsOK(ecode17)) {
20588 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20589 }
20590 arg17 = static_cast< PLFLT >(val17);
20591 ecode18 = SWIG_AsVal_double(args(14), &val18);
20592 if (!SWIG_IsOK(ecode18)) {
20593 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20594 }
20595 arg18 = static_cast< PLFLT >(val18);
20596 {
20597 if ( _n_dims( args(15) ) > 1 )
20598 {
20599 error( "argument must be a scalar or vector" ); SWIG_fail;
20600 }
20601 if ( _dim( args(15), 0 ) != Alen )
20602 {
20603 error( "argument vectors must be same length" ); SWIG_fail;
20604 }
20605 temp19 = args(15).matrix_value();
20606 arg19 = new PLINT[Alen];
20607 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20608 }
20609 {
20610 charMatrix temp_matrix;
20611 Cell temp_cell;
20612 char *tmp_cstring;
20613 std::string str;
20614 size_t max_length = 0, non_blank_length;
20615 int i, ifcell;
20616 if ( _n_dims( args(16) ) > 2 )
20617 {
20618 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20619 }
20620#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20621 if ( !args(16).isempty() )
20622#else
20623 if ( !args(16).is_empty() )
20624#endif
20625 {
20626 if ( _dim( args(16), 0 ) != Alen )
20627 {
20628 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20629 }
20630 arg20 = new char*[Alen];
20631#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20632 ifcell = args(16).iscell();
20633#else
20634 ifcell = args(16).is_cell();
20635#endif
20636 if ( ifcell )
20637 {
20638 temp_cell = args(16).cell_value();
20639 }
20640 else
20641 {
20642 temp_matrix = args(16).char_matrix_value();
20643 // Allow one extra space for null termination.
20644 max_length = _dim( args(16), 1 ) + 1;
20645 }
20646
20647 for ( i = 0; i < Alen; i++ )
20648 {
20649 // Must copy string to "permanent" location because the string
20650 // location corresponding to tmp_cstring gets
20651 // overwritten for each iteration of loop.
20652 if ( ifcell )
20653 {
20654 if ( temp_cell.elem( i ).is_string() )
20655 {
20656 str = temp_cell.elem( i ).string_value();
20657 // leave room for null termination.
20658 max_length = str.size() + 1;
20659 tmp_cstring = (char *) str.c_str();
20660 }
20661 else
20662 {
20663 // Use null string if user attempts to pass a cell array
20664 // with a non-string element (likely an empty element
20665 // since that should be allowed by the PLplot interface
20666 // if that element is going to be unused).
20667 // leave room for null termination.
20668 max_length = 1;
20669 tmp_cstring = (char *) "";
20670 }
20671 }
20672 else
20673 {
20674 str = temp_matrix.row_as_string( i );
20675 tmp_cstring = (char *) str.c_str();
20676 }
20677 arg20[i] = new char[max_length];
20678 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20679 arg20[i][max_length - 1] = '\0';
20680 // All the trailing blank crapola should not be needed for
20681 // string cell arrays.
20682 if ( !ifcell )
20683 {
20684 // remove trailing-blank padding that is used by the
20685 // charMatrix class to insure all strings in a given
20686 // charMatrix instance have the same length.
20687 // This transformation also removes legitimate trailing
20688 // blanks but there is nothing we can do about that
20689 // for the charMatrix class.
20690
20691 // Look for trailing nulls first (just in case, although that
20692 // shouldn't happen if charMatrix implemented as documented)
20693 // before looking for trailing blanks.
20694 non_blank_length = max_length - 2;
20695 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20696 {
20697 non_blank_length--;
20698 }
20699 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20700 {
20701 non_blank_length--;
20702 }
20703 arg20[i][non_blank_length + 1] = '\0';
20704 }
20705 }
20706 }
20707 else
20708 {
20709 arg20 = NULL;
20710 }
20711 }
20712 {
20713 if ( _n_dims( args(17) ) > 1 )
20714 {
20715 error( "argument must be a scalar or vector" ); SWIG_fail;
20716 }
20717#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20718 if ( !args(17).isempty() )
20719#else
20720 if ( !args(17).is_empty() )
20721#endif
20722 {
20723 if ( _dim( args(17), 0 ) != Alen )
20724 {
20725 error( "argument vectors must be same length" ); SWIG_fail;
20726 }
20727 temp21 = args(17).matrix_value();
20728 arg21 = new PLINT[Alen];
20729 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20730 }
20731 else
20732 {
20733 arg21 = NULL;
20734 }
20735 }
20736 {
20737 if ( _n_dims( args(18) ) > 1 )
20738 {
20739 error( "argument must be a scalar or vector" ); SWIG_fail;
20740 }
20741#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20742 if ( !args(18).isempty() )
20743#else
20744 if ( !args(18).is_empty() )
20745#endif
20746 {
20747 if ( _dim( args(18), 0 ) != Alen )
20748 {
20749 error( "argument vectors must be same length" ); SWIG_fail;
20750 }
20751 temp22 = args(18).matrix_value();
20752 arg22 = new PLINT[Alen];
20753 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20754 }
20755 else
20756 {
20757 arg22 = NULL;
20758 }
20759 }
20760 {
20761 if ( _n_dims( args(19) ) > 1 )
20762 {
20763 error( "argument must be a scalar or vector" ); SWIG_fail;
20764 }
20765#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20766 if ( !args(19).isempty() )
20767#else
20768 if ( !args(19).is_empty() )
20769#endif
20770 {
20771 if ( _dim( args(19), 0 ) != Alen )
20772 {
20773 error( "argument vectors must be same length" ); SWIG_fail;
20774 }
20775 temp23 = args(19).matrix_value();
20776 arg23 = &temp23( 0, 0 );
20777 }
20778 else
20779 {
20780 arg23 = NULL;
20781 }
20782 }
20783 {
20784 if ( _n_dims( args(20) ) > 1 )
20785 {
20786 error( "argument must be a scalar or vector" ); SWIG_fail;
20787 }
20788#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20789 if ( !args(20).isempty() )
20790#else
20791 if ( !args(20).is_empty() )
20792#endif
20793 {
20794 if ( _dim( args(20), 0 ) != Alen )
20795 {
20796 error( "argument vectors must be same length" ); SWIG_fail;
20797 }
20798 temp24 = args(20).matrix_value();
20799 arg24 = &temp24( 0, 0 );
20800 }
20801 else
20802 {
20803 arg24 = NULL;
20804 }
20805 }
20806 {
20807 if ( _n_dims( args(21) ) > 1 )
20808 {
20809 error( "argument must be a scalar or vector" ); SWIG_fail;
20810 }
20811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20812 if ( !args(21).isempty() )
20813#else
20814 if ( !args(21).is_empty() )
20815#endif
20816 {
20817 if ( _dim( args(21), 0 ) != Alen )
20818 {
20819 error( "argument vectors must be same length" ); SWIG_fail;
20820 }
20821 temp25 = args(21).matrix_value();
20822 arg25 = new PLINT[Alen];
20823 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20824 }
20825 else
20826 {
20827 arg25 = NULL;
20828 }
20829 }
20830 {
20831 if ( _n_dims( args(22) ) > 1 )
20832 {
20833 error( "argument must be a scalar or vector" ); SWIG_fail;
20834 }
20835#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20836 if ( !args(22).isempty() )
20837#else
20838 if ( !args(22).is_empty() )
20839#endif
20840 {
20841 if ( _dim( args(22), 0 ) != Alen )
20842 {
20843 error( "argument vectors must be same length" ); SWIG_fail;
20844 }
20845 temp26 = args(22).matrix_value();
20846 arg26 = new PLINT[Alen];
20847 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20848 }
20849 else
20850 {
20851 arg26 = NULL;
20852 }
20853 }
20854 {
20855 if ( _n_dims( args(23) ) > 1 )
20856 {
20857 error( "argument must be a scalar or vector" ); SWIG_fail;
20858 }
20859#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20860 if ( !args(23).isempty() )
20861#else
20862 if ( !args(23).is_empty() )
20863#endif
20864 {
20865 if ( _dim( args(23), 0 ) != Alen )
20866 {
20867 error( "argument vectors must be same length" ); SWIG_fail;
20868 }
20869 temp27 = args(23).matrix_value();
20870 arg27 = &temp27( 0, 0 );
20871 }
20872 else
20873 {
20874 arg27 = NULL;
20875 }
20876 }
20877 {
20878 if ( _n_dims( args(24) ) > 1 )
20879 {
20880 error( "argument must be a scalar or vector" ); SWIG_fail;
20881 }
20882#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20883 if ( !args(24).isempty() )
20884#else
20885 if ( !args(24).is_empty() )
20886#endif
20887 {
20888 if ( _dim( args(24), 0 ) != Alen )
20889 {
20890 error( "argument vectors must be same length" ); SWIG_fail;
20891 }
20892 temp28 = args(24).matrix_value();
20893 arg28 = new PLINT[Alen];
20894 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20895 }
20896 else
20897 {
20898 arg28 = NULL;
20899 }
20900 }
20901 {
20902 if ( _n_dims( args(25) ) > 1 )
20903 {
20904 error( "argument must be a scalar or vector" ); SWIG_fail;
20905 }
20906#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20907 if ( !args(25).isempty() )
20908#else
20909 if ( !args(25).is_empty() )
20910#endif
20911 {
20912 if ( _dim( args(25), 0 ) != Alen )
20913 {
20914 error( "argument vectors must be same length" ); SWIG_fail;
20915 }
20916 temp29 = args(25).matrix_value();
20917 arg29 = &temp29( 0, 0 );
20918 }
20919 else
20920 {
20921 arg29 = NULL;
20922 }
20923 }
20924 {
20925 if ( _n_dims( args(26) ) > 1 )
20926 {
20927 error( "argument must be a scalar or vector" ); SWIG_fail;
20928 }
20929#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20930 if ( !args(26).isempty() )
20931#else
20932 if ( !args(26).is_empty() )
20933#endif
20934 {
20935 if ( _dim( args(26), 0 ) != Alen )
20936 {
20937 error( "argument vectors must be same length" ); SWIG_fail;
20938 }
20939 temp30 = args(26).matrix_value();
20940 arg30 = new PLINT[Alen];
20941 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20942 }
20943 else
20944 {
20945 arg30 = NULL;
20946 }
20947 }
20948 {
20949 charMatrix temp_matrix;
20950 Cell temp_cell;
20951 char *tmp_cstring;
20952 std::string str;
20953 size_t max_length = 0, non_blank_length;
20954 int i, ifcell;
20955 if ( _n_dims( args(27) ) > 2 )
20956 {
20957 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20958 }
20959#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20960 if ( !args(27).isempty() )
20961#else
20962 if ( !args(27).is_empty() )
20963#endif
20964 {
20965 if ( _dim( args(27), 0 ) != Alen )
20966 {
20967 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20968 }
20969 arg31 = new char*[Alen];
20970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20971 ifcell = args(27).iscell();
20972#else
20973 ifcell = args(27).is_cell();
20974#endif
20975 if ( ifcell )
20976 {
20977 temp_cell = args(27).cell_value();
20978 }
20979 else
20980 {
20981 temp_matrix = args(27).char_matrix_value();
20982 // Allow one extra space for null termination.
20983 max_length = _dim( args(27), 1 ) + 1;
20984 }
20985
20986 for ( i = 0; i < Alen; i++ )
20987 {
20988 // Must copy string to "permanent" location because the string
20989 // location corresponding to tmp_cstring gets
20990 // overwritten for each iteration of loop.
20991 if ( ifcell )
20992 {
20993 if ( temp_cell.elem( i ).is_string() )
20994 {
20995 str = temp_cell.elem( i ).string_value();
20996 // leave room for null termination.
20997 max_length = str.size() + 1;
20998 tmp_cstring = (char *) str.c_str();
20999 }
21000 else
21001 {
21002 // Use null string if user attempts to pass a cell array
21003 // with a non-string element (likely an empty element
21004 // since that should be allowed by the PLplot interface
21005 // if that element is going to be unused).
21006 // leave room for null termination.
21007 max_length = 1;
21008 tmp_cstring = (char *) "";
21009 }
21010 }
21011 else
21012 {
21013 str = temp_matrix.row_as_string( i );
21014 tmp_cstring = (char *) str.c_str();
21015 }
21016 arg31[i] = new char[max_length];
21017 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21018 arg31[i][max_length - 1] = '\0';
21019 // All the trailing blank crapola should not be needed for
21020 // string cell arrays.
21021 if ( !ifcell )
21022 {
21023 // remove trailing-blank padding that is used by the
21024 // charMatrix class to insure all strings in a given
21025 // charMatrix instance have the same length.
21026 // This transformation also removes legitimate trailing
21027 // blanks but there is nothing we can do about that
21028 // for the charMatrix class.
21029
21030 // Look for trailing nulls first (just in case, although that
21031 // shouldn't happen if charMatrix implemented as documented)
21032 // before looking for trailing blanks.
21033 non_blank_length = max_length - 2;
21034 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
21035 {
21036 non_blank_length--;
21037 }
21038 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
21039 {
21040 non_blank_length--;
21041 }
21042 arg31[i][non_blank_length + 1] = '\0';
21043 }
21044 }
21045 }
21046 else
21047 {
21048 arg31 = NULL;
21049 }
21050 }
21051 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);
21052 _outv = octave_value();
21053 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21054 if (SWIG_IsTmpObj(res1)) {
21055 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21056 } else {
21057 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21058 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21059 }
21060 if (SWIG_IsTmpObj(res2)) {
21061 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21062 } else {
21063 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21064 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21065 }
21066 {
21067 delete [] arg14;
21068 }
21069 {
21070 delete [] arg19;
21071 }
21072 {
21073 int i;
21074 if ( arg20 != NULL )
21075 {
21076 for ( i = 0; i < Alen; i++ )
21077 {
21078 delete[] arg20[i];
21079 }
21080 delete[] arg20;
21081 }
21082 }
21083 {
21084 if ( arg21 != NULL )
21085 delete [] arg21;
21086 }
21087 {
21088 if ( arg22 != NULL )
21089 delete [] arg22;
21090 }
21091 {
21092
21093 }
21094 {
21095
21096 }
21097 {
21098 if ( arg25 != NULL )
21099 delete [] arg25;
21100 }
21101 {
21102 if ( arg26 != NULL )
21103 delete [] arg26;
21104 }
21105 {
21106
21107 }
21108 {
21109 if ( arg28 != NULL )
21110 delete [] arg28;
21111 }
21112 {
21113
21114 }
21115 {
21116 if ( arg30 != NULL )
21117 delete [] arg30;
21118 }
21119 {
21120 int i;
21121 if ( arg31 != NULL )
21122 {
21123 for ( i = 0; i < Alen; i++ )
21124 {
21125 delete[] arg31[i];
21126 }
21127 delete[] arg31;
21128 }
21129 }
21130 return _out;
21131 fail:
21132 {
21133 delete [] arg14;
21134 }
21135 {
21136 delete [] arg19;
21137 }
21138 {
21139 int i;
21140 if ( arg20 != NULL )
21141 {
21142 for ( i = 0; i < Alen; i++ )
21143 {
21144 delete[] arg20[i];
21145 }
21146 delete[] arg20;
21147 }
21148 }
21149 {
21150 if ( arg21 != NULL )
21151 delete [] arg21;
21152 }
21153 {
21154 if ( arg22 != NULL )
21155 delete [] arg22;
21156 }
21157 {
21158
21159 }
21160 {
21161
21162 }
21163 {
21164 if ( arg25 != NULL )
21165 delete [] arg25;
21166 }
21167 {
21168 if ( arg26 != NULL )
21169 delete [] arg26;
21170 }
21171 {
21172
21173 }
21174 {
21175 if ( arg28 != NULL )
21176 delete [] arg28;
21177 }
21178 {
21179
21180 }
21181 {
21182 if ( arg30 != NULL )
21183 delete [] arg30;
21184 }
21185 {
21186 int i;
21187 if ( arg31 != NULL )
21188 {
21189 for ( i = 0; i < Alen; i++ )
21190 {
21191 delete[] arg31[i];
21192 }
21193 delete[] arg31;
21194 }
21195 }
21196 return octave_value_list();
21197 }
21198 catch(...) {
21199 {
21200 delete [] arg14;
21201 }
21202 {
21203 delete [] arg19;
21204 }
21205 {
21206 int i;
21207 if ( arg20 != NULL )
21208 {
21209 for ( i = 0; i < Alen; i++ )
21210 {
21211 delete[] arg20[i];
21212 }
21213 delete[] arg20;
21214 }
21215 }
21216 {
21217 if ( arg21 != NULL )
21218 delete [] arg21;
21219 }
21220 {
21221 if ( arg22 != NULL )
21222 delete [] arg22;
21223 }
21224 {
21225
21226 }
21227 {
21228
21229 }
21230 {
21231 if ( arg25 != NULL )
21232 delete [] arg25;
21233 }
21234 {
21235 if ( arg26 != NULL )
21236 delete [] arg26;
21237 }
21238 {
21239
21240 }
21241 {
21242 if ( arg28 != NULL )
21243 delete [] arg28;
21244 }
21245 {
21246
21247 }
21248 {
21249 if ( arg30 != NULL )
21250 delete [] arg30;
21251 }
21252 {
21253 int i;
21254 if ( arg31 != NULL )
21255 {
21256 for ( i = 0; i < Alen; i++ )
21257 {
21258 delete[] arg31[i];
21259 }
21260 delete[] arg31;
21261 }
21262 }
21263 throw;
21264 }
21265}
21266
21267
21269 PLFLT arg1 ;
21270 PLFLT arg2 ;
21271 PLFLT arg3 ;
21272 double val1 ;
21273 int ecode1 = 0 ;
21274 double val2 ;
21275 int ecode2 = 0 ;
21276 double val3 ;
21277 int ecode3 = 0 ;
21278 octave_value_list _out;
21279 octave_value_list *_outp=&_out;
21280 octave_value _outv;
21281
21282 try {
21283 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21284 SWIG_fail;
21285 }
21286 ecode1 = SWIG_AsVal_double(args(0), &val1);
21287 if (!SWIG_IsOK(ecode1)) {
21288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21289 }
21290 arg1 = static_cast< PLFLT >(val1);
21291 ecode2 = SWIG_AsVal_double(args(1), &val2);
21292 if (!SWIG_IsOK(ecode2)) {
21293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21294 }
21295 arg2 = static_cast< PLFLT >(val2);
21296 ecode3 = SWIG_AsVal_double(args(2), &val3);
21297 if (!SWIG_IsOK(ecode3)) {
21298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21299 }
21300 arg3 = static_cast< PLFLT >(val3);
21301 pllightsource(arg1,arg2,arg3);
21302 _outv = octave_value();
21303 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21304 return _out;
21305 fail:
21306 return octave_value_list();
21307 }
21308 catch(...) {
21309 throw;
21310 }
21311}
21312
21313
21315 PLINT arg1 ;
21316 PLFLT *arg2 = (PLFLT *) 0 ;
21317 PLFLT *arg3 = (PLFLT *) 0 ;
21318 Matrix temp1 ;
21319 Matrix temp3 ;
21320 octave_value_list _out;
21321 octave_value_list *_outp=&_out;
21322 octave_value _outv;
21323
21324 try {
21325 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21326 SWIG_fail;
21327 }
21328 {
21329 if ( _n_dims( args(0) ) > 1 )
21330 {
21331 error( "argument must be a scalar or vector" ); SWIG_fail;
21332 }
21333 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21334 temp1 = args(0).matrix_value();
21335 arg2 = &temp1( 0, 0 );
21336 }
21337 {
21338 if ( _n_dims( args(1) ) > 1 )
21339 {
21340 error( "argument must be a scalar or vector" ); SWIG_fail;
21341 }
21342 if ( _dim( args(1), 0 ) != Alen )
21343 {
21344 error( "argument vectors must be same length" ); SWIG_fail;
21345 }
21346 temp3 = args(1).matrix_value();
21347 arg3 = &temp3( 0, 0 );
21348 }
21349 plline(arg1,(double const *)arg2,(double const *)arg3);
21350 _outv = octave_value();
21351 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21352 {
21353
21354 }
21355 {
21356
21357 }
21358 return _out;
21359 fail:
21360 {
21361
21362 }
21363 {
21364
21365 }
21366 return octave_value_list();
21367 }
21368 catch(...) {
21369 {
21370
21371 }
21372 {
21373
21374 }
21375 throw;
21376 }
21377}
21378
21379
21381 PLINT arg1 ;
21382 PLFLT *arg2 = (PLFLT *) 0 ;
21383 PLFLT *arg3 = (PLFLT *) 0 ;
21384 PLFLT *arg4 = (PLFLT *) 0 ;
21385 Matrix temp1 ;
21386 Matrix temp3 ;
21387 Matrix temp4 ;
21388 octave_value_list _out;
21389 octave_value_list *_outp=&_out;
21390 octave_value _outv;
21391
21392 try {
21393 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21394 SWIG_fail;
21395 }
21396 {
21397 if ( _n_dims( args(0) ) > 1 )
21398 {
21399 error( "argument must be a scalar or vector" ); SWIG_fail;
21400 }
21401 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21402 temp1 = args(0).matrix_value();
21403 arg2 = &temp1( 0, 0 );
21404 }
21405 {
21406 if ( _n_dims( args(1) ) > 1 )
21407 {
21408 error( "argument must be a scalar or vector" ); SWIG_fail;
21409 }
21410 if ( _dim( args(1), 0 ) != Alen )
21411 {
21412 error( "argument vectors must be same length" ); SWIG_fail;
21413 }
21414 temp3 = args(1).matrix_value();
21415 arg3 = &temp3( 0, 0 );
21416 }
21417 {
21418 if ( _n_dims( args(2) ) > 1 )
21419 {
21420 error( "argument must be a scalar or vector" ); SWIG_fail;
21421 }
21422 if ( _dim( args(2), 0 ) != Alen )
21423 {
21424 error( "argument vectors must be same length" ); SWIG_fail;
21425 }
21426 temp4 = args(2).matrix_value();
21427 arg4 = &temp4( 0, 0 );
21428 }
21429 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21430 _outv = octave_value();
21431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21432 {
21433
21434 }
21435 {
21436
21437 }
21438 {
21439
21440 }
21441 return _out;
21442 fail:
21443 {
21444
21445 }
21446 {
21447
21448 }
21449 {
21450
21451 }
21452 return octave_value_list();
21453 }
21454 catch(...) {
21455 {
21456
21457 }
21458 {
21459
21460 }
21461 {
21462
21463 }
21464 throw;
21465 }
21466}
21467
21468
21470 PLINT arg1 ;
21471 int val1 ;
21472 int ecode1 = 0 ;
21473 octave_value_list _out;
21474 octave_value_list *_outp=&_out;
21475 octave_value _outv;
21476
21477 try {
21478 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21479 SWIG_fail;
21480 }
21481 ecode1 = SWIG_AsVal_int(args(0), &val1);
21482 if (!SWIG_IsOK(ecode1)) {
21483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21484 }
21485 arg1 = static_cast< PLINT >(val1);
21486 pllsty(arg1);
21487 _outv = octave_value();
21488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21489 return _out;
21490 fail:
21491 return octave_value_list();
21492 }
21493 catch(...) {
21494 throw;
21495 }
21496}
21497
21498
21500 PLINT *arg1 = (PLINT *) 0 ;
21501 PLINT temp1 ;
21502 int res1 = SWIG_TMPOBJ ;
21503 octave_value_list _out;
21504 octave_value_list *_outp=&_out;
21505 octave_value _outv;
21506
21507 try {
21508 arg1 = &temp1;
21509 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21510 SWIG_fail;
21511 }
21512 plmkstrm(arg1);
21513 _outv = octave_value();
21514 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21515 if (SWIG_IsTmpObj(res1)) {
21516 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21517 } else {
21518 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21519 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21520 }
21521 return _out;
21522 fail:
21523 return octave_value_list();
21524 }
21525 catch(...) {
21526 throw;
21527 }
21528}
21529
21530
21532 char *arg1 = (char *) 0 ;
21533 PLFLT arg2 ;
21534 PLFLT arg3 ;
21535 PLFLT arg4 ;
21536 char *arg5 = (char *) 0 ;
21537 int res1 ;
21538 char *buf1 = 0 ;
21539 int alloc1 = 0 ;
21540 double val2 ;
21541 int ecode2 = 0 ;
21542 double val3 ;
21543 int ecode3 = 0 ;
21544 double val4 ;
21545 int ecode4 = 0 ;
21546 int res5 ;
21547 char *buf5 = 0 ;
21548 int alloc5 = 0 ;
21549 octave_value_list _out;
21550 octave_value_list *_outp=&_out;
21551 octave_value _outv;
21552
21553 try {
21554 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21555 SWIG_fail;
21556 }
21557 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21560 }
21561 arg1 = reinterpret_cast< char * >(buf1);
21562 ecode2 = SWIG_AsVal_double(args(1), &val2);
21563 if (!SWIG_IsOK(ecode2)) {
21564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21565 }
21566 arg2 = static_cast< PLFLT >(val2);
21567 ecode3 = SWIG_AsVal_double(args(2), &val3);
21568 if (!SWIG_IsOK(ecode3)) {
21569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21570 }
21571 arg3 = static_cast< PLFLT >(val3);
21572 ecode4 = SWIG_AsVal_double(args(3), &val4);
21573 if (!SWIG_IsOK(ecode4)) {
21574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21575 }
21576 arg4 = static_cast< PLFLT >(val4);
21577 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21578 if (!SWIG_IsOK(res5)) {
21579 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21580 }
21581 arg5 = reinterpret_cast< char * >(buf5);
21582 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21583 _outv = octave_value();
21584 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21585 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21586 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21587 return _out;
21588 fail:
21589 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21590 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21591 return octave_value_list();
21592 }
21593 catch(...) {
21594 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21595 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21596 throw;
21597 }
21598}
21599
21600
21602 char *arg1 = (char *) 0 ;
21603 PLFLT arg2 ;
21604 PLFLT arg3 ;
21605 PLFLT arg4 ;
21606 char *arg5 = (char *) 0 ;
21607 int res1 ;
21608 char *buf1 = 0 ;
21609 int alloc1 = 0 ;
21610 double val2 ;
21611 int ecode2 = 0 ;
21612 double val3 ;
21613 int ecode3 = 0 ;
21614 double val4 ;
21615 int ecode4 = 0 ;
21616 int res5 ;
21617 char *buf5 = 0 ;
21618 int alloc5 = 0 ;
21619 octave_value_list _out;
21620 octave_value_list *_outp=&_out;
21621 octave_value _outv;
21622
21623 try {
21624 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21625 SWIG_fail;
21626 }
21627 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21628 if (!SWIG_IsOK(res1)) {
21629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21630 }
21631 arg1 = reinterpret_cast< char * >(buf1);
21632 ecode2 = SWIG_AsVal_double(args(1), &val2);
21633 if (!SWIG_IsOK(ecode2)) {
21634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21635 }
21636 arg2 = static_cast< PLFLT >(val2);
21637 ecode3 = SWIG_AsVal_double(args(2), &val3);
21638 if (!SWIG_IsOK(ecode3)) {
21639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21640 }
21641 arg3 = static_cast< PLFLT >(val3);
21642 ecode4 = SWIG_AsVal_double(args(3), &val4);
21643 if (!SWIG_IsOK(ecode4)) {
21644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21645 }
21646 arg4 = static_cast< PLFLT >(val4);
21647 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21648 if (!SWIG_IsOK(res5)) {
21649 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21650 }
21651 arg5 = reinterpret_cast< char * >(buf5);
21652 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21653 _outv = octave_value();
21654 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21655 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21656 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21657 return _out;
21658 fail:
21659 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21660 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21661 return octave_value_list();
21662 }
21663 catch(...) {
21664 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21665 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21666 throw;
21667 }
21668}
21669
21670
21672 int *arg1 = (int *) 0 ;
21673 char **arg2 = (char **) 0 ;
21674 PLINT arg3 ;
21675 void *argp1 = 0 ;
21676 int res1 = 0 ;
21677 void *argp2 = 0 ;
21678 int res2 = 0 ;
21679 int val3 ;
21680 int ecode3 = 0 ;
21681 octave_value_list _out;
21682 octave_value_list *_outp=&_out;
21683 octave_value _outv;
21684 PLINT result;
21685
21686 try {
21687 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21688 SWIG_fail;
21689 }
21690 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21691 if (!SWIG_IsOK(res1)) {
21692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21693 }
21694 arg1 = reinterpret_cast< int * >(argp1);
21695 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21696 if (!SWIG_IsOK(res2)) {
21697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21698 }
21699 arg2 = reinterpret_cast< char ** >(argp2);
21700 ecode3 = SWIG_AsVal_int(args(2), &val3);
21701 if (!SWIG_IsOK(ecode3)) {
21702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21703 }
21704 arg3 = static_cast< PLINT >(val3);
21705 result = (PLINT)plparseopts(arg1,arg2,arg3);
21706 _outv = SWIG_From_int(static_cast< int >(result));
21707 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21708 return _out;
21709 fail:
21710 return octave_value_list();
21711 }
21712 catch(...) {
21713 throw;
21714 }
21715}
21716
21717
21719 PLINT arg1 ;
21720 PLINT *arg2 = (PLINT *) 0 ;
21721 PLINT *arg3 = (PLINT *) 0 ;
21722 Matrix temp1 ;
21723 Matrix temp3 ;
21724 octave_value_list _out;
21725 octave_value_list *_outp=&_out;
21726 octave_value _outv;
21727
21728 try {
21729 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21730 SWIG_fail;
21731 }
21732 {
21733 if ( _n_dims( args(0) ) > 1 )
21734 {
21735 error( "argument must be a scalar or vector" ); SWIG_fail;
21736 }
21737 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21738 arg2 = new PLINT[Alen];
21739 temp1 = args(0).matrix_value();
21740 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21741 }
21742 {
21743 if ( _n_dims( args(1) ) > 1 )
21744 {
21745 error( "argument must be a scalar or vector" ); SWIG_fail;
21746 }
21747 if ( _dim( args(1), 0 ) != Alen )
21748 {
21749 error( "argument vectors must be same length" ); SWIG_fail;
21750 }
21751 temp3 = args(1).matrix_value();
21752 arg3 = new PLINT[Alen];
21753 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21754 }
21755 plpat(arg1,(int const *)arg2,(int const *)arg3);
21756 _outv = octave_value();
21757 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21758 {
21759 delete [] arg2;
21760 }
21761 {
21762 delete [] arg3;
21763 }
21764 return _out;
21765 fail:
21766 {
21767 delete [] arg2;
21768 }
21769 {
21770 delete [] arg3;
21771 }
21772 return octave_value_list();
21773 }
21774 catch(...) {
21775 {
21776 delete [] arg2;
21777 }
21778 {
21779 delete [] arg3;
21780 }
21781 throw;
21782 }
21783}
21784
21785
21787 PLINT arg1 ;
21788 PLFLT arg2 ;
21789 PLFLT arg3 ;
21790 PLFLT arg4 ;
21791 PLFLT arg5 ;
21792 int val1 ;
21793 int ecode1 = 0 ;
21794 double val2 ;
21795 int ecode2 = 0 ;
21796 double val3 ;
21797 int ecode3 = 0 ;
21798 double val4 ;
21799 int ecode4 = 0 ;
21800 double val5 ;
21801 int ecode5 = 0 ;
21802 octave_value_list _out;
21803 octave_value_list *_outp=&_out;
21804 octave_value _outv;
21805
21806 try {
21807 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21808 SWIG_fail;
21809 }
21810 ecode1 = SWIG_AsVal_int(args(0), &val1);
21811 if (!SWIG_IsOK(ecode1)) {
21812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21813 }
21814 arg1 = static_cast< PLINT >(val1);
21815 ecode2 = SWIG_AsVal_double(args(1), &val2);
21816 if (!SWIG_IsOK(ecode2)) {
21817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21818 }
21819 arg2 = static_cast< PLFLT >(val2);
21820 ecode3 = SWIG_AsVal_double(args(2), &val3);
21821 if (!SWIG_IsOK(ecode3)) {
21822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21823 }
21824 arg3 = static_cast< PLFLT >(val3);
21825 ecode4 = SWIG_AsVal_double(args(3), &val4);
21826 if (!SWIG_IsOK(ecode4)) {
21827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21828 }
21829 arg4 = static_cast< PLFLT >(val4);
21830 ecode5 = SWIG_AsVal_double(args(4), &val5);
21831 if (!SWIG_IsOK(ecode5)) {
21832 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21833 }
21834 arg5 = static_cast< PLFLT >(val5);
21835 plpath(arg1,arg2,arg3,arg4,arg5);
21836 _outv = octave_value();
21837 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21838 return _out;
21839 fail:
21840 return octave_value_list();
21841 }
21842 catch(...) {
21843 throw;
21844 }
21845}
21846
21847
21849 PLINT arg1 ;
21850 PLFLT *arg2 = (PLFLT *) 0 ;
21851 PLFLT *arg3 = (PLFLT *) 0 ;
21852 PLINT arg4 ;
21853 Matrix temp1 ;
21854 Matrix temp3 ;
21855 int val4 ;
21856 int ecode4 = 0 ;
21857 octave_value_list _out;
21858 octave_value_list *_outp=&_out;
21859 octave_value _outv;
21860
21861 try {
21862 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21863 SWIG_fail;
21864 }
21865 {
21866 if ( _n_dims( args(0) ) > 1 )
21867 {
21868 error( "argument must be a scalar or vector" ); SWIG_fail;
21869 }
21870 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21871 temp1 = args(0).matrix_value();
21872 arg2 = &temp1( 0, 0 );
21873 }
21874 {
21875 if ( _n_dims( args(1) ) > 1 )
21876 {
21877 error( "argument must be a scalar or vector" ); SWIG_fail;
21878 }
21879 if ( _dim( args(1), 0 ) != Alen )
21880 {
21881 error( "argument vectors must be same length" ); SWIG_fail;
21882 }
21883 temp3 = args(1).matrix_value();
21884 arg3 = &temp3( 0, 0 );
21885 }
21886 ecode4 = SWIG_AsVal_int(args(2), &val4);
21887 if (!SWIG_IsOK(ecode4)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21889 }
21890 arg4 = static_cast< PLINT >(val4);
21891 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21892 _outv = octave_value();
21893 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21894 {
21895
21896 }
21897 {
21898
21899 }
21900 return _out;
21901 fail:
21902 {
21903
21904 }
21905 {
21906
21907 }
21908 return octave_value_list();
21909 }
21910 catch(...) {
21911 {
21912
21913 }
21914 {
21915
21916 }
21917 throw;
21918 }
21919}
21920
21921
21923 PLINT arg1 ;
21924 PLFLT *arg2 = (PLFLT *) 0 ;
21925 PLFLT *arg3 = (PLFLT *) 0 ;
21926 PLFLT *arg4 = (PLFLT *) 0 ;
21927 PLINT arg5 ;
21928 Matrix temp1 ;
21929 Matrix temp3 ;
21930 Matrix temp4 ;
21931 int val5 ;
21932 int ecode5 = 0 ;
21933 octave_value_list _out;
21934 octave_value_list *_outp=&_out;
21935 octave_value _outv;
21936
21937 try {
21938 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21939 SWIG_fail;
21940 }
21941 {
21942 if ( _n_dims( args(0) ) > 1 )
21943 {
21944 error( "argument must be a scalar or vector" ); SWIG_fail;
21945 }
21946 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21947 temp1 = args(0).matrix_value();
21948 arg2 = &temp1( 0, 0 );
21949 }
21950 {
21951 if ( _n_dims( args(1) ) > 1 )
21952 {
21953 error( "argument must be a scalar or vector" ); SWIG_fail;
21954 }
21955 if ( _dim( args(1), 0 ) != Alen )
21956 {
21957 error( "argument vectors must be same length" ); SWIG_fail;
21958 }
21959 temp3 = args(1).matrix_value();
21960 arg3 = &temp3( 0, 0 );
21961 }
21962 {
21963 if ( _n_dims( args(2) ) > 1 )
21964 {
21965 error( "argument must be a scalar or vector" ); SWIG_fail;
21966 }
21967 if ( _dim( args(2), 0 ) != Alen )
21968 {
21969 error( "argument vectors must be same length" ); SWIG_fail;
21970 }
21971 temp4 = args(2).matrix_value();
21972 arg4 = &temp4( 0, 0 );
21973 }
21974 ecode5 = SWIG_AsVal_int(args(3), &val5);
21975 if (!SWIG_IsOK(ecode5)) {
21976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21977 }
21978 arg5 = static_cast< PLINT >(val5);
21979 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21980 _outv = octave_value();
21981 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21982 {
21983
21984 }
21985 {
21986
21987 }
21988 {
21989
21990 }
21991 return _out;
21992 fail:
21993 {
21994
21995 }
21996 {
21997
21998 }
21999 {
22000
22001 }
22002 return octave_value_list();
22003 }
22004 catch(...) {
22005 {
22006
22007 }
22008 {
22009
22010 }
22011 {
22012
22013 }
22014 throw;
22015 }
22016}
22017
22018
22020 PLINT arg1 ;
22021 PLFLT *arg2 = (PLFLT *) 0 ;
22022 PLFLT *arg3 = (PLFLT *) 0 ;
22023 PLFLT *arg4 = (PLFLT *) 0 ;
22024 PLBOOL *arg5 = (PLBOOL *) 0 ;
22025 PLBOOL arg6 ;
22026 Matrix temp1 ;
22027 Matrix temp3 ;
22028 Matrix temp4 ;
22029 Matrix temp5 ;
22030 int val6 ;
22031 int ecode6 = 0 ;
22032 octave_value_list _out;
22033 octave_value_list *_outp=&_out;
22034 octave_value _outv;
22035
22036 try {
22037 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
22038 SWIG_fail;
22039 }
22040 {
22041 if ( _n_dims( args(0) ) > 1 )
22042 {
22043 error( "argument must be a scalar or vector" ); SWIG_fail;
22044 }
22045 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22046 temp1 = args(0).matrix_value();
22047 arg2 = &temp1( 0, 0 );
22048 }
22049 {
22050 if ( _n_dims( args(1) ) > 1 )
22051 {
22052 error( "argument must be a scalar or vector" ); SWIG_fail;
22053 }
22054 if ( _dim( args(1), 0 ) != Alen )
22055 {
22056 error( "argument vectors must be same length" ); SWIG_fail;
22057 }
22058 temp3 = args(1).matrix_value();
22059 arg3 = &temp3( 0, 0 );
22060 }
22061 {
22062 if ( _n_dims( args(2) ) > 1 )
22063 {
22064 error( "argument must be a scalar or vector" ); SWIG_fail;
22065 }
22066 if ( _dim( args(2), 0 ) != Alen )
22067 {
22068 error( "argument vectors must be same length" ); SWIG_fail;
22069 }
22070 temp4 = args(2).matrix_value();
22071 arg4 = &temp4( 0, 0 );
22072 }
22073 {
22074 if ( _n_dims( args(3) ) > 1 )
22075 {
22076 error( "argument must be a scalar or vector" ); SWIG_fail;
22077 }
22078 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22079 {
22080 error( "argument vector must be same length or one less" ); SWIG_fail;
22081 }
22082 temp5 = args(3).matrix_value();
22083 arg5 = new PLINT[Alen];
22084 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22085 }
22086 ecode6 = SWIG_AsVal_int(args(4), &val6);
22087 if (!SWIG_IsOK(ecode6)) {
22088 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22089 }
22090 arg6 = static_cast< PLBOOL >(val6);
22091 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22092 _outv = octave_value();
22093 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22094 {
22095
22096 }
22097 {
22098
22099 }
22100 {
22101
22102 }
22103 {
22104 delete [] arg5;
22105 }
22106 return _out;
22107 fail:
22108 {
22109
22110 }
22111 {
22112
22113 }
22114 {
22115
22116 }
22117 {
22118 delete [] arg5;
22119 }
22120 return octave_value_list();
22121 }
22122 catch(...) {
22123 {
22124
22125 }
22126 {
22127
22128 }
22129 {
22130
22131 }
22132 {
22133 delete [] arg5;
22134 }
22135 throw;
22136 }
22137}
22138
22139
22141 PLINT arg1 ;
22142 PLINT arg2 ;
22143 int val1 ;
22144 int ecode1 = 0 ;
22145 int val2 ;
22146 int ecode2 = 0 ;
22147 octave_value_list _out;
22148 octave_value_list *_outp=&_out;
22149 octave_value _outv;
22150
22151 try {
22152 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22153 SWIG_fail;
22154 }
22155 ecode1 = SWIG_AsVal_int(args(0), &val1);
22156 if (!SWIG_IsOK(ecode1)) {
22157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22158 }
22159 arg1 = static_cast< PLINT >(val1);
22160 ecode2 = SWIG_AsVal_int(args(1), &val2);
22161 if (!SWIG_IsOK(ecode2)) {
22162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22163 }
22164 arg2 = static_cast< PLINT >(val2);
22165 plprec(arg1,arg2);
22166 _outv = octave_value();
22167 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22168 return _out;
22169 fail:
22170 return octave_value_list();
22171 }
22172 catch(...) {
22173 throw;
22174 }
22175}
22176
22177
22179 PLINT arg1 ;
22180 int val1 ;
22181 int ecode1 = 0 ;
22182 octave_value_list _out;
22183 octave_value_list *_outp=&_out;
22184 octave_value _outv;
22185
22186 try {
22187 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22188 SWIG_fail;
22189 }
22190 ecode1 = SWIG_AsVal_int(args(0), &val1);
22191 if (!SWIG_IsOK(ecode1)) {
22192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22193 }
22194 arg1 = static_cast< PLINT >(val1);
22195 plpsty(arg1);
22196 _outv = octave_value();
22197 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22198 return _out;
22199 fail:
22200 return octave_value_list();
22201 }
22202 catch(...) {
22203 throw;
22204 }
22205}
22206
22207
22209 PLFLT arg1 ;
22210 PLFLT arg2 ;
22211 PLFLT arg3 ;
22212 PLFLT arg4 ;
22213 PLFLT arg5 ;
22214 char *arg6 = (char *) 0 ;
22215 double val1 ;
22216 int ecode1 = 0 ;
22217 double val2 ;
22218 int ecode2 = 0 ;
22219 double val3 ;
22220 int ecode3 = 0 ;
22221 double val4 ;
22222 int ecode4 = 0 ;
22223 double val5 ;
22224 int ecode5 = 0 ;
22225 int res6 ;
22226 char *buf6 = 0 ;
22227 int alloc6 = 0 ;
22228 octave_value_list _out;
22229 octave_value_list *_outp=&_out;
22230 octave_value _outv;
22231
22232 try {
22233 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22234 SWIG_fail;
22235 }
22236 ecode1 = SWIG_AsVal_double(args(0), &val1);
22237 if (!SWIG_IsOK(ecode1)) {
22238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22239 }
22240 arg1 = static_cast< PLFLT >(val1);
22241 ecode2 = SWIG_AsVal_double(args(1), &val2);
22242 if (!SWIG_IsOK(ecode2)) {
22243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22244 }
22245 arg2 = static_cast< PLFLT >(val2);
22246 ecode3 = SWIG_AsVal_double(args(2), &val3);
22247 if (!SWIG_IsOK(ecode3)) {
22248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22249 }
22250 arg3 = static_cast< PLFLT >(val3);
22251 ecode4 = SWIG_AsVal_double(args(3), &val4);
22252 if (!SWIG_IsOK(ecode4)) {
22253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22254 }
22255 arg4 = static_cast< PLFLT >(val4);
22256 ecode5 = SWIG_AsVal_double(args(4), &val5);
22257 if (!SWIG_IsOK(ecode5)) {
22258 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22259 }
22260 arg5 = static_cast< PLFLT >(val5);
22261 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22262 if (!SWIG_IsOK(res6)) {
22263 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22264 }
22265 arg6 = reinterpret_cast< char * >(buf6);
22266 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22267 _outv = octave_value();
22268 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22269 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22270 return _out;
22271 fail:
22272 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22273 return octave_value_list();
22274 }
22275 catch(...) {
22276 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22277 throw;
22278 }
22279}
22280
22281
22283 PLFLT arg1 ;
22284 PLFLT arg2 ;
22285 PLFLT arg3 ;
22286 PLFLT arg4 ;
22287 PLFLT arg5 ;
22288 PLFLT arg6 ;
22289 PLFLT arg7 ;
22290 PLFLT arg8 ;
22291 PLFLT arg9 ;
22292 PLFLT arg10 ;
22293 char *arg11 = (char *) 0 ;
22294 double val1 ;
22295 int ecode1 = 0 ;
22296 double val2 ;
22297 int ecode2 = 0 ;
22298 double val3 ;
22299 int ecode3 = 0 ;
22300 double val4 ;
22301 int ecode4 = 0 ;
22302 double val5 ;
22303 int ecode5 = 0 ;
22304 double val6 ;
22305 int ecode6 = 0 ;
22306 double val7 ;
22307 int ecode7 = 0 ;
22308 double val8 ;
22309 int ecode8 = 0 ;
22310 double val9 ;
22311 int ecode9 = 0 ;
22312 double val10 ;
22313 int ecode10 = 0 ;
22314 int res11 ;
22315 char *buf11 = 0 ;
22316 int alloc11 = 0 ;
22317 octave_value_list _out;
22318 octave_value_list *_outp=&_out;
22319 octave_value _outv;
22320
22321 try {
22322 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22323 SWIG_fail;
22324 }
22325 ecode1 = SWIG_AsVal_double(args(0), &val1);
22326 if (!SWIG_IsOK(ecode1)) {
22327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22328 }
22329 arg1 = static_cast< PLFLT >(val1);
22330 ecode2 = SWIG_AsVal_double(args(1), &val2);
22331 if (!SWIG_IsOK(ecode2)) {
22332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22333 }
22334 arg2 = static_cast< PLFLT >(val2);
22335 ecode3 = SWIG_AsVal_double(args(2), &val3);
22336 if (!SWIG_IsOK(ecode3)) {
22337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22338 }
22339 arg3 = static_cast< PLFLT >(val3);
22340 ecode4 = SWIG_AsVal_double(args(3), &val4);
22341 if (!SWIG_IsOK(ecode4)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22343 }
22344 arg4 = static_cast< PLFLT >(val4);
22345 ecode5 = SWIG_AsVal_double(args(4), &val5);
22346 if (!SWIG_IsOK(ecode5)) {
22347 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22348 }
22349 arg5 = static_cast< PLFLT >(val5);
22350 ecode6 = SWIG_AsVal_double(args(5), &val6);
22351 if (!SWIG_IsOK(ecode6)) {
22352 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22353 }
22354 arg6 = static_cast< PLFLT >(val6);
22355 ecode7 = SWIG_AsVal_double(args(6), &val7);
22356 if (!SWIG_IsOK(ecode7)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22358 }
22359 arg7 = static_cast< PLFLT >(val7);
22360 ecode8 = SWIG_AsVal_double(args(7), &val8);
22361 if (!SWIG_IsOK(ecode8)) {
22362 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22363 }
22364 arg8 = static_cast< PLFLT >(val8);
22365 ecode9 = SWIG_AsVal_double(args(8), &val9);
22366 if (!SWIG_IsOK(ecode9)) {
22367 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22368 }
22369 arg9 = static_cast< PLFLT >(val9);
22370 ecode10 = SWIG_AsVal_double(args(9), &val10);
22371 if (!SWIG_IsOK(ecode10)) {
22372 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22373 }
22374 arg10 = static_cast< PLFLT >(val10);
22375 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22376 if (!SWIG_IsOK(res11)) {
22377 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22378 }
22379 arg11 = reinterpret_cast< char * >(buf11);
22380 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22381 _outv = octave_value();
22382 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22383 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22384 return _out;
22385 fail:
22386 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22387 return octave_value_list();
22388 }
22389 catch(...) {
22390 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22391 throw;
22392 }
22393}
22394
22395
22397 octave_value_list _out;
22398 octave_value_list *_outp=&_out;
22399 octave_value _outv;
22400 PLFLT result;
22401
22402 try {
22403 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22404 SWIG_fail;
22405 }
22406 result = (PLFLT)plrandd();
22407 _outv = SWIG_From_double(static_cast< double >(result));
22408 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22409 return _out;
22410 fail:
22411 return octave_value_list();
22412 }
22413 catch(...) {
22414 throw;
22415 }
22416}
22417
22418
22420 octave_value_list _out;
22421 octave_value_list *_outp=&_out;
22422 octave_value _outv;
22423
22424 try {
22425 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22426 SWIG_fail;
22427 }
22428 plreplot();
22429 _outv = octave_value();
22430 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22431 return _out;
22432 fail:
22433 return octave_value_list();
22434 }
22435 catch(...) {
22436 throw;
22437 }
22438}
22439
22440
22442 PLFLT arg1 ;
22443 PLFLT arg2 ;
22444 PLFLT arg3 ;
22445 PLFLT *arg4 = (PLFLT *) 0 ;
22446 PLFLT *arg5 = (PLFLT *) 0 ;
22447 PLFLT *arg6 = (PLFLT *) 0 ;
22448 double val1 ;
22449 int ecode1 = 0 ;
22450 double val2 ;
22451 int ecode2 = 0 ;
22452 double val3 ;
22453 int ecode3 = 0 ;
22454 PLFLT temp4 ;
22455 int res4 = SWIG_TMPOBJ ;
22456 PLFLT temp5 ;
22457 int res5 = SWIG_TMPOBJ ;
22458 PLFLT temp6 ;
22459 int res6 = SWIG_TMPOBJ ;
22460 octave_value_list _out;
22461 octave_value_list *_outp=&_out;
22462 octave_value _outv;
22463
22464 try {
22465 arg4 = &temp4;
22466 arg5 = &temp5;
22467 arg6 = &temp6;
22468 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22469 SWIG_fail;
22470 }
22471 ecode1 = SWIG_AsVal_double(args(0), &val1);
22472 if (!SWIG_IsOK(ecode1)) {
22473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22474 }
22475 arg1 = static_cast< PLFLT >(val1);
22476 ecode2 = SWIG_AsVal_double(args(1), &val2);
22477 if (!SWIG_IsOK(ecode2)) {
22478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22479 }
22480 arg2 = static_cast< PLFLT >(val2);
22481 ecode3 = SWIG_AsVal_double(args(2), &val3);
22482 if (!SWIG_IsOK(ecode3)) {
22483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22484 }
22485 arg3 = static_cast< PLFLT >(val3);
22486 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22487 _outv = octave_value();
22488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22489 if (SWIG_IsTmpObj(res4)) {
22490 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22491 } else {
22492 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22493 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22494 }
22495 if (SWIG_IsTmpObj(res5)) {
22496 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22497 } else {
22498 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22499 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22500 }
22501 if (SWIG_IsTmpObj(res6)) {
22502 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22503 } else {
22504 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22505 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22506 }
22507 return _out;
22508 fail:
22509 return octave_value_list();
22510 }
22511 catch(...) {
22512 throw;
22513 }
22514}
22515
22516
22518 PLFLT arg1 ;
22519 PLFLT arg2 ;
22520 double val1 ;
22521 int ecode1 = 0 ;
22522 double val2 ;
22523 int ecode2 = 0 ;
22524 octave_value_list _out;
22525 octave_value_list *_outp=&_out;
22526 octave_value _outv;
22527
22528 try {
22529 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22530 SWIG_fail;
22531 }
22532 ecode1 = SWIG_AsVal_double(args(0), &val1);
22533 if (!SWIG_IsOK(ecode1)) {
22534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22535 }
22536 arg1 = static_cast< PLFLT >(val1);
22537 ecode2 = SWIG_AsVal_double(args(1), &val2);
22538 if (!SWIG_IsOK(ecode2)) {
22539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22540 }
22541 arg2 = static_cast< PLFLT >(val2);
22542 plschr(arg1,arg2);
22543 _outv = octave_value();
22544 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22545 return _out;
22546 fail:
22547 return octave_value_list();
22548 }
22549 catch(...) {
22550 throw;
22551 }
22552}
22553
22554
22556 PLINT *arg1 = (PLINT *) 0 ;
22557 PLINT *arg2 = (PLINT *) 0 ;
22558 PLINT *arg3 = (PLINT *) 0 ;
22559 PLINT arg4 ;
22560 Matrix temp1 ;
22561 Matrix temp2 ;
22562 Matrix temp3 ;
22563 octave_value_list _out;
22564 octave_value_list *_outp=&_out;
22565 octave_value _outv;
22566
22567 try {
22568 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22569 SWIG_fail;
22570 }
22571 {
22572 if ( _n_dims( args(0) ) > 1 )
22573 {
22574 error( "argument must be a scalar or vector" ); SWIG_fail;
22575 }
22576 Alen = (PLINT) ( _dim( args(0), 0 ) );
22577 temp1 = args(0).matrix_value();
22578 arg1 = new PLINT[Alen];
22579 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22580 }
22581 {
22582 if ( _n_dims( args(1) ) > 1 )
22583 {
22584 error( "argument must be a scalar or vector" ); SWIG_fail;
22585 }
22586 if ( _dim( args(1), 0 ) != Alen )
22587 {
22588 error( "argument vectors must be same length" ); SWIG_fail;
22589 }
22590 temp2 = args(1).matrix_value();
22591 arg2 = new PLINT[Alen];
22592 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22593 }
22594 {
22595 if ( _n_dims( args(2) ) > 1 )
22596 {
22597 error( "argument must be a scalar or vector" ); SWIG_fail;
22598 }
22599 if ( _dim( args(2), 0 ) != Alen )
22600 {
22601 error( "argument vectors must be same length" ); SWIG_fail;
22602 }
22603 temp3 = args(2).matrix_value();
22604 arg3 = new PLINT[Alen];
22605 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22606 arg4 = Alen;
22607 }
22608 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22609 _outv = octave_value();
22610 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22611 {
22612 delete [] arg1;
22613 }
22614 {
22615 delete [] arg2;
22616 }
22617 {
22618 delete [] arg3;
22619 }
22620 return _out;
22621 fail:
22622 {
22623 delete [] arg1;
22624 }
22625 {
22626 delete [] arg2;
22627 }
22628 {
22629 delete [] arg3;
22630 }
22631 return octave_value_list();
22632 }
22633 catch(...) {
22634 {
22635 delete [] arg1;
22636 }
22637 {
22638 delete [] arg2;
22639 }
22640 {
22641 delete [] arg3;
22642 }
22643 throw;
22644 }
22645}
22646
22647
22649 PLINT *arg1 = (PLINT *) 0 ;
22650 PLINT *arg2 = (PLINT *) 0 ;
22651 PLINT *arg3 = (PLINT *) 0 ;
22652 PLFLT *arg4 = (PLFLT *) 0 ;
22653 PLINT arg5 ;
22654 Matrix temp1 ;
22655 Matrix temp2 ;
22656 Matrix temp3 ;
22657 Matrix temp4 ;
22658 octave_value_list _out;
22659 octave_value_list *_outp=&_out;
22660 octave_value _outv;
22661
22662 try {
22663 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22664 SWIG_fail;
22665 }
22666 {
22667 if ( _n_dims( args(0) ) > 1 )
22668 {
22669 error( "argument must be a scalar or vector" ); SWIG_fail;
22670 }
22671 Alen = (PLINT) ( _dim( args(0), 0 ) );
22672 temp1 = args(0).matrix_value();
22673 arg1 = new PLINT[Alen];
22674 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22675 }
22676 {
22677 if ( _n_dims( args(1) ) > 1 )
22678 {
22679 error( "argument must be a scalar or vector" ); SWIG_fail;
22680 }
22681 if ( _dim( args(1), 0 ) != Alen )
22682 {
22683 error( "argument vectors must be same length" ); SWIG_fail;
22684 }
22685 temp2 = args(1).matrix_value();
22686 arg2 = new PLINT[Alen];
22687 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22688 }
22689 {
22690 if ( _n_dims( args(2) ) > 1 )
22691 {
22692 error( "argument must be a scalar or vector" ); SWIG_fail;
22693 }
22694 if ( _dim( args(2), 0 ) != Alen )
22695 {
22696 error( "argument vectors must be same length" ); SWIG_fail;
22697 }
22698 temp3 = args(2).matrix_value();
22699 arg3 = new PLINT[Alen];
22700 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22701 }
22702 {
22703 if ( _n_dims( args(3) ) > 1 )
22704 {
22705 error( "argument must be a scalar or vector" ); SWIG_fail;
22706 }
22707 if ( _dim( args(3), 0 ) != Alen )
22708 {
22709 error( "argument vectors must be same length" ); SWIG_fail;
22710 }
22711 temp4 = args(3).matrix_value();
22712 arg4 = &temp4( 0, 0 );
22713 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22714 }
22715 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22716 _outv = octave_value();
22717 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22718 {
22719 delete [] arg1;
22720 }
22721 {
22722 delete [] arg2;
22723 }
22724 {
22725 delete [] arg3;
22726 }
22727 {
22728
22729 }
22730 return _out;
22731 fail:
22732 {
22733 delete [] arg1;
22734 }
22735 {
22736 delete [] arg2;
22737 }
22738 {
22739 delete [] arg3;
22740 }
22741 {
22742
22743 }
22744 return octave_value_list();
22745 }
22746 catch(...) {
22747 {
22748 delete [] arg1;
22749 }
22750 {
22751 delete [] arg2;
22752 }
22753 {
22754 delete [] arg3;
22755 }
22756 {
22757
22758 }
22759 throw;
22760 }
22761}
22762
22763
22765 PLINT arg1 ;
22766 int val1 ;
22767 int ecode1 = 0 ;
22768 octave_value_list _out;
22769 octave_value_list *_outp=&_out;
22770 octave_value _outv;
22771
22772 try {
22773 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22774 SWIG_fail;
22775 }
22776 ecode1 = SWIG_AsVal_int(args(0), &val1);
22777 if (!SWIG_IsOK(ecode1)) {
22778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22779 }
22780 arg1 = static_cast< PLINT >(val1);
22781 plscmap0n(arg1);
22782 _outv = octave_value();
22783 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22784 return _out;
22785 fail:
22786 return octave_value_list();
22787 }
22788 catch(...) {
22789 throw;
22790 }
22791}
22792
22793
22795 PLINT *arg1 = (PLINT *) 0 ;
22796 PLINT *arg2 = (PLINT *) 0 ;
22797 PLINT *arg3 = (PLINT *) 0 ;
22798 PLINT arg4 ;
22799 Matrix temp1 ;
22800 Matrix temp2 ;
22801 Matrix temp3 ;
22802 octave_value_list _out;
22803 octave_value_list *_outp=&_out;
22804 octave_value _outv;
22805
22806 try {
22807 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22808 SWIG_fail;
22809 }
22810 {
22811 if ( _n_dims( args(0) ) > 1 )
22812 {
22813 error( "argument must be a scalar or vector" ); SWIG_fail;
22814 }
22815 Alen = (PLINT) ( _dim( args(0), 0 ) );
22816 temp1 = args(0).matrix_value();
22817 arg1 = new PLINT[Alen];
22818 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22819 }
22820 {
22821 if ( _n_dims( args(1) ) > 1 )
22822 {
22823 error( "argument must be a scalar or vector" ); SWIG_fail;
22824 }
22825 if ( _dim( args(1), 0 ) != Alen )
22826 {
22827 error( "argument vectors must be same length" ); SWIG_fail;
22828 }
22829 temp2 = args(1).matrix_value();
22830 arg2 = new PLINT[Alen];
22831 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22832 }
22833 {
22834 if ( _n_dims( args(2) ) > 1 )
22835 {
22836 error( "argument must be a scalar or vector" ); SWIG_fail;
22837 }
22838 if ( _dim( args(2), 0 ) != Alen )
22839 {
22840 error( "argument vectors must be same length" ); SWIG_fail;
22841 }
22842 temp3 = args(2).matrix_value();
22843 arg3 = new PLINT[Alen];
22844 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22845 arg4 = Alen;
22846 }
22847 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22848 _outv = octave_value();
22849 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22850 {
22851 delete [] arg1;
22852 }
22853 {
22854 delete [] arg2;
22855 }
22856 {
22857 delete [] arg3;
22858 }
22859 return _out;
22860 fail:
22861 {
22862 delete [] arg1;
22863 }
22864 {
22865 delete [] arg2;
22866 }
22867 {
22868 delete [] arg3;
22869 }
22870 return octave_value_list();
22871 }
22872 catch(...) {
22873 {
22874 delete [] arg1;
22875 }
22876 {
22877 delete [] arg2;
22878 }
22879 {
22880 delete [] arg3;
22881 }
22882 throw;
22883 }
22884}
22885
22886
22888 PLINT *arg1 = (PLINT *) 0 ;
22889 PLINT *arg2 = (PLINT *) 0 ;
22890 PLINT *arg3 = (PLINT *) 0 ;
22891 PLFLT *arg4 = (PLFLT *) 0 ;
22892 PLINT arg5 ;
22893 Matrix temp1 ;
22894 Matrix temp2 ;
22895 Matrix temp3 ;
22896 Matrix temp4 ;
22897 octave_value_list _out;
22898 octave_value_list *_outp=&_out;
22899 octave_value _outv;
22900
22901 try {
22902 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22903 SWIG_fail;
22904 }
22905 {
22906 if ( _n_dims( args(0) ) > 1 )
22907 {
22908 error( "argument must be a scalar or vector" ); SWIG_fail;
22909 }
22910 Alen = (PLINT) ( _dim( args(0), 0 ) );
22911 temp1 = args(0).matrix_value();
22912 arg1 = new PLINT[Alen];
22913 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22914 }
22915 {
22916 if ( _n_dims( args(1) ) > 1 )
22917 {
22918 error( "argument must be a scalar or vector" ); SWIG_fail;
22919 }
22920 if ( _dim( args(1), 0 ) != Alen )
22921 {
22922 error( "argument vectors must be same length" ); SWIG_fail;
22923 }
22924 temp2 = args(1).matrix_value();
22925 arg2 = new PLINT[Alen];
22926 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22927 }
22928 {
22929 if ( _n_dims( args(2) ) > 1 )
22930 {
22931 error( "argument must be a scalar or vector" ); SWIG_fail;
22932 }
22933 if ( _dim( args(2), 0 ) != Alen )
22934 {
22935 error( "argument vectors must be same length" ); SWIG_fail;
22936 }
22937 temp3 = args(2).matrix_value();
22938 arg3 = new PLINT[Alen];
22939 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22940 }
22941 {
22942 if ( _n_dims( args(3) ) > 1 )
22943 {
22944 error( "argument must be a scalar or vector" ); SWIG_fail;
22945 }
22946 if ( _dim( args(3), 0 ) != Alen )
22947 {
22948 error( "argument vectors must be same length" ); SWIG_fail;
22949 }
22950 temp4 = args(3).matrix_value();
22951 arg4 = &temp4( 0, 0 );
22952 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22953 }
22954 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22955 _outv = octave_value();
22956 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22957 {
22958 delete [] arg1;
22959 }
22960 {
22961 delete [] arg2;
22962 }
22963 {
22964 delete [] arg3;
22965 }
22966 {
22967
22968 }
22969 return _out;
22970 fail:
22971 {
22972 delete [] arg1;
22973 }
22974 {
22975 delete [] arg2;
22976 }
22977 {
22978 delete [] arg3;
22979 }
22980 {
22981
22982 }
22983 return octave_value_list();
22984 }
22985 catch(...) {
22986 {
22987 delete [] arg1;
22988 }
22989 {
22990 delete [] arg2;
22991 }
22992 {
22993 delete [] arg3;
22994 }
22995 {
22996
22997 }
22998 throw;
22999 }
23000}
23001
23002
23004 PLBOOL arg1 ;
23005 PLINT arg2 ;
23006 PLFLT *arg3 = (PLFLT *) 0 ;
23007 PLFLT *arg4 = (PLFLT *) 0 ;
23008 PLFLT *arg5 = (PLFLT *) 0 ;
23009 PLFLT *arg6 = (PLFLT *) 0 ;
23010 PLBOOL *arg7 = (PLBOOL *) 0 ;
23011 int val1 ;
23012 int ecode1 = 0 ;
23013 Matrix temp2 ;
23014 Matrix temp4 ;
23015 Matrix temp5 ;
23016 Matrix temp6 ;
23017 Matrix temp7 ;
23018 octave_value_list _out;
23019 octave_value_list *_outp=&_out;
23020 octave_value _outv;
23021
23022 try {
23023 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
23024 SWIG_fail;
23025 }
23026 ecode1 = SWIG_AsVal_int(args(0), &val1);
23027 if (!SWIG_IsOK(ecode1)) {
23028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
23029 }
23030 arg1 = static_cast< PLBOOL >(val1);
23031 {
23032 if ( _n_dims( args(1) ) > 1 )
23033 {
23034 error( "argument must be a scalar or vector" ); SWIG_fail;
23035 }
23036 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23037 temp2 = args(1).matrix_value();
23038 arg3 = &temp2( 0, 0 );
23039 }
23040 {
23041 if ( _n_dims( args(2) ) > 1 )
23042 {
23043 error( "argument must be a scalar or vector" ); SWIG_fail;
23044 }
23045 if ( _dim( args(2), 0 ) != Alen )
23046 {
23047 error( "argument vectors must be same length" ); SWIG_fail;
23048 }
23049 temp4 = args(2).matrix_value();
23050 arg4 = &temp4( 0, 0 );
23051 }
23052 {
23053 if ( _n_dims( args(3) ) > 1 )
23054 {
23055 error( "argument must be a scalar or vector" ); SWIG_fail;
23056 }
23057 if ( _dim( args(3), 0 ) != Alen )
23058 {
23059 error( "argument vectors must be same length" ); SWIG_fail;
23060 }
23061 temp5 = args(3).matrix_value();
23062 arg5 = &temp5( 0, 0 );
23063 }
23064 {
23065 if ( _n_dims( args(4) ) > 1 )
23066 {
23067 error( "argument must be a scalar or vector" ); SWIG_fail;
23068 }
23069 if ( _dim( args(4), 0 ) != Alen )
23070 {
23071 error( "argument vectors must be same length" ); SWIG_fail;
23072 }
23073 temp6 = args(4).matrix_value();
23074 arg6 = &temp6( 0, 0 );
23075 }
23076 {
23077 if ( _n_dims( args(5) ) > 1 )
23078 {
23079 error( "argument must be a scalar or vector" ); SWIG_fail;
23080 }
23081 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23082 {
23083 error( "argument vector must be same length or one less" ); SWIG_fail;
23084 }
23085 temp7 = args(5).matrix_value();
23086 arg7 = new PLINT[Alen];
23087 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23088 }
23089 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23090 _outv = octave_value();
23091 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23092 {
23093
23094 }
23095 {
23096
23097 }
23098 {
23099
23100 }
23101 {
23102
23103 }
23104 {
23105 delete [] arg7;
23106 }
23107 return _out;
23108 fail:
23109 {
23110
23111 }
23112 {
23113
23114 }
23115 {
23116
23117 }
23118 {
23119
23120 }
23121 {
23122 delete [] arg7;
23123 }
23124 return octave_value_list();
23125 }
23126 catch(...) {
23127 {
23128
23129 }
23130 {
23131
23132 }
23133 {
23134
23135 }
23136 {
23137
23138 }
23139 {
23140 delete [] arg7;
23141 }
23142 throw;
23143 }
23144}
23145
23146
23148 PLBOOL arg1 ;
23149 PLINT arg2 ;
23150 PLFLT *arg3 = (PLFLT *) 0 ;
23151 PLFLT *arg4 = (PLFLT *) 0 ;
23152 PLFLT *arg5 = (PLFLT *) 0 ;
23153 PLFLT *arg6 = (PLFLT *) 0 ;
23154 PLFLT *arg7 = (PLFLT *) 0 ;
23155 PLBOOL *arg8 = (PLBOOL *) 0 ;
23156 int val1 ;
23157 int ecode1 = 0 ;
23158 Matrix temp2 ;
23159 Matrix temp4 ;
23160 Matrix temp5 ;
23161 Matrix temp6 ;
23162 Matrix temp7 ;
23163 Matrix temp8 ;
23164 octave_value_list _out;
23165 octave_value_list *_outp=&_out;
23166 octave_value _outv;
23167
23168 try {
23169 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23170 SWIG_fail;
23171 }
23172 ecode1 = SWIG_AsVal_int(args(0), &val1);
23173 if (!SWIG_IsOK(ecode1)) {
23174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23175 }
23176 arg1 = static_cast< PLBOOL >(val1);
23177 {
23178 if ( _n_dims( args(1) ) > 1 )
23179 {
23180 error( "argument must be a scalar or vector" ); SWIG_fail;
23181 }
23182 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23183 temp2 = args(1).matrix_value();
23184 arg3 = &temp2( 0, 0 );
23185 }
23186 {
23187 if ( _n_dims( args(2) ) > 1 )
23188 {
23189 error( "argument must be a scalar or vector" ); SWIG_fail;
23190 }
23191 if ( _dim( args(2), 0 ) != Alen )
23192 {
23193 error( "argument vectors must be same length" ); SWIG_fail;
23194 }
23195 temp4 = args(2).matrix_value();
23196 arg4 = &temp4( 0, 0 );
23197 }
23198 {
23199 if ( _n_dims( args(3) ) > 1 )
23200 {
23201 error( "argument must be a scalar or vector" ); SWIG_fail;
23202 }
23203 if ( _dim( args(3), 0 ) != Alen )
23204 {
23205 error( "argument vectors must be same length" ); SWIG_fail;
23206 }
23207 temp5 = args(3).matrix_value();
23208 arg5 = &temp5( 0, 0 );
23209 }
23210 {
23211 if ( _n_dims( args(4) ) > 1 )
23212 {
23213 error( "argument must be a scalar or vector" ); SWIG_fail;
23214 }
23215 if ( _dim( args(4), 0 ) != Alen )
23216 {
23217 error( "argument vectors must be same length" ); SWIG_fail;
23218 }
23219 temp6 = args(4).matrix_value();
23220 arg6 = &temp6( 0, 0 );
23221 }
23222 {
23223 if ( _n_dims( args(5) ) > 1 )
23224 {
23225 error( "argument must be a scalar or vector" ); SWIG_fail;
23226 }
23227 if ( _dim( args(5), 0 ) != Alen )
23228 {
23229 error( "argument vectors must be same length" ); SWIG_fail;
23230 }
23231 temp7 = args(5).matrix_value();
23232 arg7 = &temp7( 0, 0 );
23233 }
23234 {
23235 if ( _n_dims( args(6) ) > 1 )
23236 {
23237 error( "argument must be a scalar or vector" ); SWIG_fail;
23238 }
23239 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23240 {
23241 error( "argument vector must be same length or one less" ); SWIG_fail;
23242 }
23243 temp8 = args(6).matrix_value();
23244 arg8 = new PLINT[Alen];
23245 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23246 }
23247 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23248 _outv = octave_value();
23249 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23250 {
23251
23252 }
23253 {
23254
23255 }
23256 {
23257
23258 }
23259 {
23260
23261 }
23262 {
23263
23264 }
23265 {
23266 delete [] arg8;
23267 }
23268 return _out;
23269 fail:
23270 {
23271
23272 }
23273 {
23274
23275 }
23276 {
23277
23278 }
23279 {
23280
23281 }
23282 {
23283
23284 }
23285 {
23286 delete [] arg8;
23287 }
23288 return octave_value_list();
23289 }
23290 catch(...) {
23291 {
23292
23293 }
23294 {
23295
23296 }
23297 {
23298
23299 }
23300 {
23301
23302 }
23303 {
23304
23305 }
23306 {
23307 delete [] arg8;
23308 }
23309 throw;
23310 }
23311}
23312
23313
23315 PLINT arg1 ;
23316 int val1 ;
23317 int ecode1 = 0 ;
23318 octave_value_list _out;
23319 octave_value_list *_outp=&_out;
23320 octave_value _outv;
23321
23322 try {
23323 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23324 SWIG_fail;
23325 }
23326 ecode1 = SWIG_AsVal_int(args(0), &val1);
23327 if (!SWIG_IsOK(ecode1)) {
23328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23329 }
23330 arg1 = static_cast< PLINT >(val1);
23331 plscmap1n(arg1);
23332 _outv = octave_value();
23333 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23334 return _out;
23335 fail:
23336 return octave_value_list();
23337 }
23338 catch(...) {
23339 throw;
23340 }
23341}
23342
23343
23345 PLFLT arg1 ;
23346 PLFLT arg2 ;
23347 double val1 ;
23348 int ecode1 = 0 ;
23349 double val2 ;
23350 int ecode2 = 0 ;
23351 octave_value_list _out;
23352 octave_value_list *_outp=&_out;
23353 octave_value _outv;
23354
23355 try {
23356 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23357 SWIG_fail;
23358 }
23359 ecode1 = SWIG_AsVal_double(args(0), &val1);
23360 if (!SWIG_IsOK(ecode1)) {
23361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23362 }
23363 arg1 = static_cast< PLFLT >(val1);
23364 ecode2 = SWIG_AsVal_double(args(1), &val2);
23365 if (!SWIG_IsOK(ecode2)) {
23366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23367 }
23368 arg2 = static_cast< PLFLT >(val2);
23369 plscmap1_range(arg1,arg2);
23370 _outv = octave_value();
23371 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23372 return _out;
23373 fail:
23374 return octave_value_list();
23375 }
23376 catch(...) {
23377 throw;
23378 }
23379}
23380
23381
23383 PLFLT *arg1 = (PLFLT *) 0 ;
23384 PLFLT *arg2 = (PLFLT *) 0 ;
23385 PLFLT temp1 ;
23386 int res1 = SWIG_TMPOBJ ;
23387 PLFLT temp2 ;
23388 int res2 = SWIG_TMPOBJ ;
23389 octave_value_list _out;
23390 octave_value_list *_outp=&_out;
23391 octave_value _outv;
23392
23393 try {
23394 arg1 = &temp1;
23395 arg2 = &temp2;
23396 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23397 SWIG_fail;
23398 }
23399 plgcmap1_range(arg1,arg2);
23400 _outv = octave_value();
23401 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23402 if (SWIG_IsTmpObj(res1)) {
23403 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23404 } else {
23405 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23406 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23407 }
23408 if (SWIG_IsTmpObj(res2)) {
23409 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23410 } else {
23411 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23412 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23413 }
23414 return _out;
23415 fail:
23416 return octave_value_list();
23417 }
23418 catch(...) {
23419 throw;
23420 }
23421}
23422
23423
23425 PLINT arg1 ;
23426 PLINT arg2 ;
23427 PLINT arg3 ;
23428 PLINT arg4 ;
23429 int val1 ;
23430 int ecode1 = 0 ;
23431 int val2 ;
23432 int ecode2 = 0 ;
23433 int val3 ;
23434 int ecode3 = 0 ;
23435 int val4 ;
23436 int ecode4 = 0 ;
23437 octave_value_list _out;
23438 octave_value_list *_outp=&_out;
23439 octave_value _outv;
23440
23441 try {
23442 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23443 SWIG_fail;
23444 }
23445 ecode1 = SWIG_AsVal_int(args(0), &val1);
23446 if (!SWIG_IsOK(ecode1)) {
23447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23448 }
23449 arg1 = static_cast< PLINT >(val1);
23450 ecode2 = SWIG_AsVal_int(args(1), &val2);
23451 if (!SWIG_IsOK(ecode2)) {
23452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23453 }
23454 arg2 = static_cast< PLINT >(val2);
23455 ecode3 = SWIG_AsVal_int(args(2), &val3);
23456 if (!SWIG_IsOK(ecode3)) {
23457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23458 }
23459 arg3 = static_cast< PLINT >(val3);
23460 ecode4 = SWIG_AsVal_int(args(3), &val4);
23461 if (!SWIG_IsOK(ecode4)) {
23462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23463 }
23464 arg4 = static_cast< PLINT >(val4);
23465 plscol0(arg1,arg2,arg3,arg4);
23466 _outv = octave_value();
23467 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23468 return _out;
23469 fail:
23470 return octave_value_list();
23471 }
23472 catch(...) {
23473 throw;
23474 }
23475}
23476
23477
23479 PLINT arg1 ;
23480 PLINT arg2 ;
23481 PLINT arg3 ;
23482 PLINT arg4 ;
23483 PLFLT arg5 ;
23484 int val1 ;
23485 int ecode1 = 0 ;
23486 int val2 ;
23487 int ecode2 = 0 ;
23488 int val3 ;
23489 int ecode3 = 0 ;
23490 int val4 ;
23491 int ecode4 = 0 ;
23492 double val5 ;
23493 int ecode5 = 0 ;
23494 octave_value_list _out;
23495 octave_value_list *_outp=&_out;
23496 octave_value _outv;
23497
23498 try {
23499 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23500 SWIG_fail;
23501 }
23502 ecode1 = SWIG_AsVal_int(args(0), &val1);
23503 if (!SWIG_IsOK(ecode1)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23505 }
23506 arg1 = static_cast< PLINT >(val1);
23507 ecode2 = SWIG_AsVal_int(args(1), &val2);
23508 if (!SWIG_IsOK(ecode2)) {
23509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23510 }
23511 arg2 = static_cast< PLINT >(val2);
23512 ecode3 = SWIG_AsVal_int(args(2), &val3);
23513 if (!SWIG_IsOK(ecode3)) {
23514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23515 }
23516 arg3 = static_cast< PLINT >(val3);
23517 ecode4 = SWIG_AsVal_int(args(3), &val4);
23518 if (!SWIG_IsOK(ecode4)) {
23519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23520 }
23521 arg4 = static_cast< PLINT >(val4);
23522 ecode5 = SWIG_AsVal_double(args(4), &val5);
23523 if (!SWIG_IsOK(ecode5)) {
23524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23525 }
23526 arg5 = static_cast< PLFLT >(val5);
23527 plscol0a(arg1,arg2,arg3,arg4,arg5);
23528 _outv = octave_value();
23529 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23530 return _out;
23531 fail:
23532 return octave_value_list();
23533 }
23534 catch(...) {
23535 throw;
23536 }
23537}
23538
23539
23541 PLINT arg1 ;
23542 PLINT arg2 ;
23543 PLINT arg3 ;
23544 int val1 ;
23545 int ecode1 = 0 ;
23546 int val2 ;
23547 int ecode2 = 0 ;
23548 int val3 ;
23549 int ecode3 = 0 ;
23550 octave_value_list _out;
23551 octave_value_list *_outp=&_out;
23552 octave_value _outv;
23553
23554 try {
23555 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23556 SWIG_fail;
23557 }
23558 ecode1 = SWIG_AsVal_int(args(0), &val1);
23559 if (!SWIG_IsOK(ecode1)) {
23560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23561 }
23562 arg1 = static_cast< PLINT >(val1);
23563 ecode2 = SWIG_AsVal_int(args(1), &val2);
23564 if (!SWIG_IsOK(ecode2)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23566 }
23567 arg2 = static_cast< PLINT >(val2);
23568 ecode3 = SWIG_AsVal_int(args(2), &val3);
23569 if (!SWIG_IsOK(ecode3)) {
23570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23571 }
23572 arg3 = static_cast< PLINT >(val3);
23573 plscolbg(arg1,arg2,arg3);
23574 _outv = octave_value();
23575 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23576 return _out;
23577 fail:
23578 return octave_value_list();
23579 }
23580 catch(...) {
23581 throw;
23582 }
23583}
23584
23585
23587 PLINT arg1 ;
23588 PLINT arg2 ;
23589 PLINT arg3 ;
23590 PLFLT arg4 ;
23591 int val1 ;
23592 int ecode1 = 0 ;
23593 int val2 ;
23594 int ecode2 = 0 ;
23595 int val3 ;
23596 int ecode3 = 0 ;
23597 double val4 ;
23598 int ecode4 = 0 ;
23599 octave_value_list _out;
23600 octave_value_list *_outp=&_out;
23601 octave_value _outv;
23602
23603 try {
23604 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23605 SWIG_fail;
23606 }
23607 ecode1 = SWIG_AsVal_int(args(0), &val1);
23608 if (!SWIG_IsOK(ecode1)) {
23609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23610 }
23611 arg1 = static_cast< PLINT >(val1);
23612 ecode2 = SWIG_AsVal_int(args(1), &val2);
23613 if (!SWIG_IsOK(ecode2)) {
23614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23615 }
23616 arg2 = static_cast< PLINT >(val2);
23617 ecode3 = SWIG_AsVal_int(args(2), &val3);
23618 if (!SWIG_IsOK(ecode3)) {
23619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23620 }
23621 arg3 = static_cast< PLINT >(val3);
23622 ecode4 = SWIG_AsVal_double(args(3), &val4);
23623 if (!SWIG_IsOK(ecode4)) {
23624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23625 }
23626 arg4 = static_cast< PLFLT >(val4);
23627 plscolbga(arg1,arg2,arg3,arg4);
23628 _outv = octave_value();
23629 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23630 return _out;
23631 fail:
23632 return octave_value_list();
23633 }
23634 catch(...) {
23635 throw;
23636 }
23637}
23638
23639
23641 PLINT arg1 ;
23642 int val1 ;
23643 int ecode1 = 0 ;
23644 octave_value_list _out;
23645 octave_value_list *_outp=&_out;
23646 octave_value _outv;
23647
23648 try {
23649 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23650 SWIG_fail;
23651 }
23652 ecode1 = SWIG_AsVal_int(args(0), &val1);
23653 if (!SWIG_IsOK(ecode1)) {
23654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23655 }
23656 arg1 = static_cast< PLINT >(val1);
23657 plscolor(arg1);
23658 _outv = octave_value();
23659 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23660 return _out;
23661 fail:
23662 return octave_value_list();
23663 }
23664 catch(...) {
23665 throw;
23666 }
23667}
23668
23669
23671 PLINT arg1 ;
23672 int val1 ;
23673 int ecode1 = 0 ;
23674 octave_value_list _out;
23675 octave_value_list *_outp=&_out;
23676 octave_value _outv;
23677
23678 try {
23679 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23680 SWIG_fail;
23681 }
23682 ecode1 = SWIG_AsVal_int(args(0), &val1);
23683 if (!SWIG_IsOK(ecode1)) {
23684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23685 }
23686 arg1 = static_cast< PLINT >(val1);
23687 plscompression(arg1);
23688 _outv = octave_value();
23689 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23690 return _out;
23691 fail:
23692 return octave_value_list();
23693 }
23694 catch(...) {
23695 throw;
23696 }
23697}
23698
23699
23701 char *arg1 = (char *) 0 ;
23702 int res1 ;
23703 char *buf1 = 0 ;
23704 int alloc1 = 0 ;
23705 octave_value_list _out;
23706 octave_value_list *_outp=&_out;
23707 octave_value _outv;
23708
23709 try {
23710 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23711 SWIG_fail;
23712 }
23713 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23716 }
23717 arg1 = reinterpret_cast< char * >(buf1);
23718 plsdev((char const *)arg1);
23719 _outv = octave_value();
23720 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23721 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23722 return _out;
23723 fail:
23724 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23725 return octave_value_list();
23726 }
23727 catch(...) {
23728 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23729 throw;
23730 }
23731}
23732
23733
23735 PLFLT arg1 ;
23736 PLFLT arg2 ;
23737 PLFLT arg3 ;
23738 PLFLT arg4 ;
23739 double val1 ;
23740 int ecode1 = 0 ;
23741 double val2 ;
23742 int ecode2 = 0 ;
23743 double val3 ;
23744 int ecode3 = 0 ;
23745 double val4 ;
23746 int ecode4 = 0 ;
23747 octave_value_list _out;
23748 octave_value_list *_outp=&_out;
23749 octave_value _outv;
23750
23751 try {
23752 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23753 SWIG_fail;
23754 }
23755 ecode1 = SWIG_AsVal_double(args(0), &val1);
23756 if (!SWIG_IsOK(ecode1)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23758 }
23759 arg1 = static_cast< PLFLT >(val1);
23760 ecode2 = SWIG_AsVal_double(args(1), &val2);
23761 if (!SWIG_IsOK(ecode2)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23763 }
23764 arg2 = static_cast< PLFLT >(val2);
23765 ecode3 = SWIG_AsVal_double(args(2), &val3);
23766 if (!SWIG_IsOK(ecode3)) {
23767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23768 }
23769 arg3 = static_cast< PLFLT >(val3);
23770 ecode4 = SWIG_AsVal_double(args(3), &val4);
23771 if (!SWIG_IsOK(ecode4)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23773 }
23774 arg4 = static_cast< PLFLT >(val4);
23775 plsdidev(arg1,arg2,arg3,arg4);
23776 _outv = octave_value();
23777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23778 return _out;
23779 fail:
23780 return octave_value_list();
23781 }
23782 catch(...) {
23783 throw;
23784 }
23785}
23786
23787
23789 PLINT arg1 ;
23790 PLINT arg2 ;
23791 PLINT arg3 ;
23792 PLINT arg4 ;
23793 PLFLT arg5 ;
23794 PLFLT arg6 ;
23795 int val1 ;
23796 int ecode1 = 0 ;
23797 int val2 ;
23798 int ecode2 = 0 ;
23799 int val3 ;
23800 int ecode3 = 0 ;
23801 int val4 ;
23802 int ecode4 = 0 ;
23803 double val5 ;
23804 int ecode5 = 0 ;
23805 double val6 ;
23806 int ecode6 = 0 ;
23807 octave_value_list _out;
23808 octave_value_list *_outp=&_out;
23809 octave_value _outv;
23810
23811 try {
23812 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23813 SWIG_fail;
23814 }
23815 ecode1 = SWIG_AsVal_int(args(0), &val1);
23816 if (!SWIG_IsOK(ecode1)) {
23817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23818 }
23819 arg1 = static_cast< PLINT >(val1);
23820 ecode2 = SWIG_AsVal_int(args(1), &val2);
23821 if (!SWIG_IsOK(ecode2)) {
23822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23823 }
23824 arg2 = static_cast< PLINT >(val2);
23825 ecode3 = SWIG_AsVal_int(args(2), &val3);
23826 if (!SWIG_IsOK(ecode3)) {
23827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23828 }
23829 arg3 = static_cast< PLINT >(val3);
23830 ecode4 = SWIG_AsVal_int(args(3), &val4);
23831 if (!SWIG_IsOK(ecode4)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23833 }
23834 arg4 = static_cast< PLINT >(val4);
23835 ecode5 = SWIG_AsVal_double(args(4), &val5);
23836 if (!SWIG_IsOK(ecode5)) {
23837 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23838 }
23839 arg5 = static_cast< PLFLT >(val5);
23840 ecode6 = SWIG_AsVal_double(args(5), &val6);
23841 if (!SWIG_IsOK(ecode6)) {
23842 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23843 }
23844 arg6 = static_cast< PLFLT >(val6);
23845 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23846 _outv = octave_value();
23847 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23848 return _out;
23849 fail:
23850 return octave_value_list();
23851 }
23852 catch(...) {
23853 throw;
23854 }
23855}
23856
23857
23859 PLFLT arg1 ;
23860 double val1 ;
23861 int ecode1 = 0 ;
23862 octave_value_list _out;
23863 octave_value_list *_outp=&_out;
23864 octave_value _outv;
23865
23866 try {
23867 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23868 SWIG_fail;
23869 }
23870 ecode1 = SWIG_AsVal_double(args(0), &val1);
23871 if (!SWIG_IsOK(ecode1)) {
23872 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23873 }
23874 arg1 = static_cast< PLFLT >(val1);
23875 plsdiori(arg1);
23876 _outv = octave_value();
23877 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23878 return _out;
23879 fail:
23880 return octave_value_list();
23881 }
23882 catch(...) {
23883 throw;
23884 }
23885}
23886
23887
23889 PLFLT arg1 ;
23890 PLFLT arg2 ;
23891 PLFLT arg3 ;
23892 PLFLT arg4 ;
23893 double val1 ;
23894 int ecode1 = 0 ;
23895 double val2 ;
23896 int ecode2 = 0 ;
23897 double val3 ;
23898 int ecode3 = 0 ;
23899 double val4 ;
23900 int ecode4 = 0 ;
23901 octave_value_list _out;
23902 octave_value_list *_outp=&_out;
23903 octave_value _outv;
23904
23905 try {
23906 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23907 SWIG_fail;
23908 }
23909 ecode1 = SWIG_AsVal_double(args(0), &val1);
23910 if (!SWIG_IsOK(ecode1)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23912 }
23913 arg1 = static_cast< PLFLT >(val1);
23914 ecode2 = SWIG_AsVal_double(args(1), &val2);
23915 if (!SWIG_IsOK(ecode2)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23917 }
23918 arg2 = static_cast< PLFLT >(val2);
23919 ecode3 = SWIG_AsVal_double(args(2), &val3);
23920 if (!SWIG_IsOK(ecode3)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23922 }
23923 arg3 = static_cast< PLFLT >(val3);
23924 ecode4 = SWIG_AsVal_double(args(3), &val4);
23925 if (!SWIG_IsOK(ecode4)) {
23926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23927 }
23928 arg4 = static_cast< PLFLT >(val4);
23929 plsdiplt(arg1,arg2,arg3,arg4);
23930 _outv = octave_value();
23931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23932 return _out;
23933 fail:
23934 return octave_value_list();
23935 }
23936 catch(...) {
23937 throw;
23938 }
23939}
23940
23941
23943 PLFLT arg1 ;
23944 PLFLT arg2 ;
23945 PLFLT arg3 ;
23946 PLFLT arg4 ;
23947 double val1 ;
23948 int ecode1 = 0 ;
23949 double val2 ;
23950 int ecode2 = 0 ;
23951 double val3 ;
23952 int ecode3 = 0 ;
23953 double val4 ;
23954 int ecode4 = 0 ;
23955 octave_value_list _out;
23956 octave_value_list *_outp=&_out;
23957 octave_value _outv;
23958
23959 try {
23960 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23961 SWIG_fail;
23962 }
23963 ecode1 = SWIG_AsVal_double(args(0), &val1);
23964 if (!SWIG_IsOK(ecode1)) {
23965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23966 }
23967 arg1 = static_cast< PLFLT >(val1);
23968 ecode2 = SWIG_AsVal_double(args(1), &val2);
23969 if (!SWIG_IsOK(ecode2)) {
23970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23971 }
23972 arg2 = static_cast< PLFLT >(val2);
23973 ecode3 = SWIG_AsVal_double(args(2), &val3);
23974 if (!SWIG_IsOK(ecode3)) {
23975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23976 }
23977 arg3 = static_cast< PLFLT >(val3);
23978 ecode4 = SWIG_AsVal_double(args(3), &val4);
23979 if (!SWIG_IsOK(ecode4)) {
23980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23981 }
23982 arg4 = static_cast< PLFLT >(val4);
23983 plsdiplz(arg1,arg2,arg3,arg4);
23984 _outv = octave_value();
23985 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23986 return _out;
23987 fail:
23988 return octave_value_list();
23989 }
23990 catch(...) {
23991 throw;
23992 }
23993}
23994
23995
23997 unsigned int arg1 ;
23998 unsigned int val1 ;
23999 int ecode1 = 0 ;
24000 octave_value_list _out;
24001 octave_value_list *_outp=&_out;
24002 octave_value _outv;
24003
24004 try {
24005 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
24006 SWIG_fail;
24007 }
24008 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24009 if (!SWIG_IsOK(ecode1)) {
24010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
24011 }
24012 arg1 = static_cast< unsigned int >(val1);
24013 plseed(arg1);
24014 _outv = octave_value();
24015 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24016 return _out;
24017 fail:
24018 return octave_value_list();
24019 }
24020 catch(...) {
24021 throw;
24022 }
24023}
24024
24025
24027 char arg1 ;
24028 char val1 ;
24029 int ecode1 = 0 ;
24030 octave_value_list _out;
24031 octave_value_list *_outp=&_out;
24032 octave_value _outv;
24033
24034 try {
24035 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
24036 SWIG_fail;
24037 }
24038 ecode1 = SWIG_AsVal_char(args(0), &val1);
24039 if (!SWIG_IsOK(ecode1)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
24041 }
24042 arg1 = static_cast< char >(val1);
24043 plsesc(arg1);
24044 _outv = octave_value();
24045 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24046 return _out;
24047 fail:
24048 return octave_value_list();
24049 }
24050 catch(...) {
24051 throw;
24052 }
24053}
24054
24055
24056SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
24057 char *arg1 = (char *) 0 ;
24058 char *arg2 = (char *) 0 ;
24059 int res1 ;
24060 char *buf1 = 0 ;
24061 int alloc1 = 0 ;
24062 int res2 ;
24063 char *buf2 = 0 ;
24064 int alloc2 = 0 ;
24065 octave_value_list _out;
24066 octave_value_list *_outp=&_out;
24067 octave_value _outv;
24068 PLINT result;
24069
24070 try {
24071 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24072 SWIG_fail;
24073 }
24074 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24077 }
24078 arg1 = reinterpret_cast< char * >(buf1);
24079 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24080 if (!SWIG_IsOK(res2)) {
24081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24082 }
24083 arg2 = reinterpret_cast< char * >(buf2);
24084 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24085 _outv = SWIG_From_int(static_cast< int >(result));
24086 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24087 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24088 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24089 return _out;
24090 fail:
24091 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24092 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24093 return octave_value_list();
24094 }
24095 catch(...) {
24096 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24097 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24098 throw;
24099 }
24100}
24101
24102
24104 PLINT arg1 ;
24105 PLINT arg2 ;
24106 PLINT arg3 ;
24107 int val1 ;
24108 int ecode1 = 0 ;
24109 int val2 ;
24110 int ecode2 = 0 ;
24111 int val3 ;
24112 int ecode3 = 0 ;
24113 octave_value_list _out;
24114 octave_value_list *_outp=&_out;
24115 octave_value _outv;
24116
24117 try {
24118 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24119 SWIG_fail;
24120 }
24121 ecode1 = SWIG_AsVal_int(args(0), &val1);
24122 if (!SWIG_IsOK(ecode1)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24124 }
24125 arg1 = static_cast< PLINT >(val1);
24126 ecode2 = SWIG_AsVal_int(args(1), &val2);
24127 if (!SWIG_IsOK(ecode2)) {
24128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24129 }
24130 arg2 = static_cast< PLINT >(val2);
24131 ecode3 = SWIG_AsVal_int(args(2), &val3);
24132 if (!SWIG_IsOK(ecode3)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24134 }
24135 arg3 = static_cast< PLINT >(val3);
24136 plsfam(arg1,arg2,arg3);
24137 _outv = octave_value();
24138 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24139 return _out;
24140 fail:
24141 return octave_value_list();
24142 }
24143 catch(...) {
24144 throw;
24145 }
24146}
24147
24148
24150 PLUNICODE arg1 ;
24151 unsigned int val1 ;
24152 int ecode1 = 0 ;
24153 octave_value_list _out;
24154 octave_value_list *_outp=&_out;
24155 octave_value _outv;
24156
24157 try {
24158 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24159 SWIG_fail;
24160 }
24161 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24162 if (!SWIG_IsOK(ecode1)) {
24163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24164 }
24165 arg1 = static_cast< PLUNICODE >(val1);
24166 plsfci(arg1);
24167 _outv = octave_value();
24168 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24169 return _out;
24170 fail:
24171 return octave_value_list();
24172 }
24173 catch(...) {
24174 throw;
24175 }
24176}
24177
24178
24180 char *arg1 = (char *) 0 ;
24181 int res1 ;
24182 char *buf1 = 0 ;
24183 int alloc1 = 0 ;
24184 octave_value_list _out;
24185 octave_value_list *_outp=&_out;
24186 octave_value _outv;
24187
24188 try {
24189 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24190 SWIG_fail;
24191 }
24192 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24193 if (!SWIG_IsOK(res1)) {
24194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24195 }
24196 arg1 = reinterpret_cast< char * >(buf1);
24197 plsfnam((char const *)arg1);
24198 _outv = octave_value();
24199 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24200 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24201 return _out;
24202 fail:
24203 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24204 return octave_value_list();
24205 }
24206 catch(...) {
24207 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24208 throw;
24209 }
24210}
24211
24212
24214 PLINT arg1 ;
24215 PLINT arg2 ;
24216 PLINT arg3 ;
24217 int val1 ;
24218 int ecode1 = 0 ;
24219 int val2 ;
24220 int ecode2 = 0 ;
24221 int val3 ;
24222 int ecode3 = 0 ;
24223 octave_value_list _out;
24224 octave_value_list *_outp=&_out;
24225 octave_value _outv;
24226
24227 try {
24228 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24229 SWIG_fail;
24230 }
24231 ecode1 = SWIG_AsVal_int(args(0), &val1);
24232 if (!SWIG_IsOK(ecode1)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24234 }
24235 arg1 = static_cast< PLINT >(val1);
24236 ecode2 = SWIG_AsVal_int(args(1), &val2);
24237 if (!SWIG_IsOK(ecode2)) {
24238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24239 }
24240 arg2 = static_cast< PLINT >(val2);
24241 ecode3 = SWIG_AsVal_int(args(2), &val3);
24242 if (!SWIG_IsOK(ecode3)) {
24243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24244 }
24245 arg3 = static_cast< PLINT >(val3);
24246 plsfont(arg1,arg2,arg3);
24247 _outv = octave_value();
24248 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24249 return _out;
24250 fail:
24251 return octave_value_list();
24252 }
24253 catch(...) {
24254 throw;
24255 }
24256}
24257
24258
24260 label_func arg1 = (label_func) 0 ;
24261 PLPointer arg2 = (PLPointer) 0 ;
24262 int res2 ;
24263 octave_value_list _out;
24264 octave_value_list *_outp=&_out;
24265 octave_value _outv;
24266
24267 try {
24268 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24269 SWIG_fail;
24270 }
24271 {
24272 octave_value obj = args(0);
24273#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24274 if ( !obj.isempty() )
24275#else
24276 if ( !obj.is_empty() )
24277#endif
24278 {
24279 if ( obj.is_function_handle() || obj.is_inline_function() )
24280 {
24281 fcnLabelFunc = obj.function_value();
24282 }
24283 else if ( obj.is_string() )
24284 {
24285 nameLabelFunc = obj.string_value();
24286 fcnLabelFunc = NULL;
24287 }
24288 arg1 = labelfunc_octave;
24289 }
24290 else
24291 {
24292 arg1 = NULL;
24293 }
24294 }
24295 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24296 if (!SWIG_IsOK(res2)) {
24297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24298 }
24299 plslabelfunc(arg1,arg2);
24300 _outv = octave_value();
24301 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24302 return _out;
24303 fail:
24304 return octave_value_list();
24305 }
24306 catch(...) {
24307 throw;
24308 }
24309}
24310
24311
24313 PLFLT arg1 ;
24314 PLFLT arg2 ;
24315 double val1 ;
24316 int ecode1 = 0 ;
24317 double val2 ;
24318 int ecode2 = 0 ;
24319 octave_value_list _out;
24320 octave_value_list *_outp=&_out;
24321 octave_value _outv;
24322
24323 try {
24324 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24325 SWIG_fail;
24326 }
24327 ecode1 = SWIG_AsVal_double(args(0), &val1);
24328 if (!SWIG_IsOK(ecode1)) {
24329 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24330 }
24331 arg1 = static_cast< PLFLT >(val1);
24332 ecode2 = SWIG_AsVal_double(args(1), &val2);
24333 if (!SWIG_IsOK(ecode2)) {
24334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24335 }
24336 arg2 = static_cast< PLFLT >(val2);
24337 plsmaj(arg1,arg2);
24338 _outv = octave_value();
24339 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24340 return _out;
24341 fail:
24342 return octave_value_list();
24343 }
24344 catch(...) {
24345 throw;
24346 }
24347}
24348
24349
24351 PLFLT arg1 ;
24352 PLFLT arg2 ;
24353 double val1 ;
24354 int ecode1 = 0 ;
24355 double val2 ;
24356 int ecode2 = 0 ;
24357 octave_value_list _out;
24358 octave_value_list *_outp=&_out;
24359 octave_value _outv;
24360
24361 try {
24362 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24363 SWIG_fail;
24364 }
24365 ecode1 = SWIG_AsVal_double(args(0), &val1);
24366 if (!SWIG_IsOK(ecode1)) {
24367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24368 }
24369 arg1 = static_cast< PLFLT >(val1);
24370 ecode2 = SWIG_AsVal_double(args(1), &val2);
24371 if (!SWIG_IsOK(ecode2)) {
24372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24373 }
24374 arg2 = static_cast< PLFLT >(val2);
24375 plsmin(arg1,arg2);
24376 _outv = octave_value();
24377 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24378 return _out;
24379 fail:
24380 return octave_value_list();
24381 }
24382 catch(...) {
24383 throw;
24384 }
24385}
24386
24387
24389 PLINT arg1 ;
24390 int val1 ;
24391 int ecode1 = 0 ;
24392 octave_value_list _out;
24393 octave_value_list *_outp=&_out;
24394 octave_value _outv;
24395
24396 try {
24397 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24398 SWIG_fail;
24399 }
24400 ecode1 = SWIG_AsVal_int(args(0), &val1);
24401 if (!SWIG_IsOK(ecode1)) {
24402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24403 }
24404 arg1 = static_cast< PLINT >(val1);
24405 plsori(arg1);
24406 _outv = octave_value();
24407 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24408 return _out;
24409 fail:
24410 return octave_value_list();
24411 }
24412 catch(...) {
24413 throw;
24414 }
24415}
24416
24417
24419 PLFLT arg1 ;
24420 PLFLT arg2 ;
24421 PLINT arg3 ;
24422 PLINT arg4 ;
24423 PLINT arg5 ;
24424 PLINT arg6 ;
24425 double val1 ;
24426 int ecode1 = 0 ;
24427 double val2 ;
24428 int ecode2 = 0 ;
24429 int val3 ;
24430 int ecode3 = 0 ;
24431 int val4 ;
24432 int ecode4 = 0 ;
24433 int val5 ;
24434 int ecode5 = 0 ;
24435 int val6 ;
24436 int ecode6 = 0 ;
24437 octave_value_list _out;
24438 octave_value_list *_outp=&_out;
24439 octave_value _outv;
24440
24441 try {
24442 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24443 SWIG_fail;
24444 }
24445 ecode1 = SWIG_AsVal_double(args(0), &val1);
24446 if (!SWIG_IsOK(ecode1)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24448 }
24449 arg1 = static_cast< PLFLT >(val1);
24450 ecode2 = SWIG_AsVal_double(args(1), &val2);
24451 if (!SWIG_IsOK(ecode2)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24453 }
24454 arg2 = static_cast< PLFLT >(val2);
24455 ecode3 = SWIG_AsVal_int(args(2), &val3);
24456 if (!SWIG_IsOK(ecode3)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24458 }
24459 arg3 = static_cast< PLINT >(val3);
24460 ecode4 = SWIG_AsVal_int(args(3), &val4);
24461 if (!SWIG_IsOK(ecode4)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24463 }
24464 arg4 = static_cast< PLINT >(val4);
24465 ecode5 = SWIG_AsVal_int(args(4), &val5);
24466 if (!SWIG_IsOK(ecode5)) {
24467 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24468 }
24469 arg5 = static_cast< PLINT >(val5);
24470 ecode6 = SWIG_AsVal_int(args(5), &val6);
24471 if (!SWIG_IsOK(ecode6)) {
24472 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24473 }
24474 arg6 = static_cast< PLINT >(val6);
24475 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24476 _outv = octave_value();
24477 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24478 return _out;
24479 fail:
24480 return octave_value_list();
24481 }
24482 catch(...) {
24483 throw;
24484 }
24485}
24486
24487
24489 char *arg1 = (char *) 0 ;
24490 int res1 ;
24491 char *buf1 = 0 ;
24492 int alloc1 = 0 ;
24493 octave_value_list _out;
24494 octave_value_list *_outp=&_out;
24495 octave_value _outv;
24496
24497 try {
24498 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24499 SWIG_fail;
24500 }
24501 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24504 }
24505 arg1 = reinterpret_cast< char * >(buf1);
24506 plspal0((char const *)arg1);
24507 _outv = octave_value();
24508 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24509 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24510 return _out;
24511 fail:
24512 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24513 return octave_value_list();
24514 }
24515 catch(...) {
24516 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24517 throw;
24518 }
24519}
24520
24521
24523 char *arg1 = (char *) 0 ;
24524 PLBOOL arg2 ;
24525 int res1 ;
24526 char *buf1 = 0 ;
24527 int alloc1 = 0 ;
24528 int val2 ;
24529 int ecode2 = 0 ;
24530 octave_value_list _out;
24531 octave_value_list *_outp=&_out;
24532 octave_value _outv;
24533
24534 try {
24535 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24536 SWIG_fail;
24537 }
24538 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24541 }
24542 arg1 = reinterpret_cast< char * >(buf1);
24543 ecode2 = SWIG_AsVal_int(args(1), &val2);
24544 if (!SWIG_IsOK(ecode2)) {
24545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24546 }
24547 arg2 = static_cast< PLBOOL >(val2);
24548 plspal1((char const *)arg1,arg2);
24549 _outv = octave_value();
24550 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24551 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24552 return _out;
24553 fail:
24554 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24555 return octave_value_list();
24556 }
24557 catch(...) {
24558 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24559 throw;
24560 }
24561}
24562
24563
24565 PLBOOL arg1 ;
24566 int val1 ;
24567 int ecode1 = 0 ;
24568 octave_value_list _out;
24569 octave_value_list *_outp=&_out;
24570 octave_value _outv;
24571
24572 try {
24573 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24574 SWIG_fail;
24575 }
24576 ecode1 = SWIG_AsVal_int(args(0), &val1);
24577 if (!SWIG_IsOK(ecode1)) {
24578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24579 }
24580 arg1 = static_cast< PLBOOL >(val1);
24581 plspause(arg1);
24582 _outv = octave_value();
24583 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24584 return _out;
24585 fail:
24586 return octave_value_list();
24587 }
24588 catch(...) {
24589 throw;
24590 }
24591}
24592
24593
24594SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24595 PLINT arg1 ;
24596 int val1 ;
24597 int ecode1 = 0 ;
24598 octave_value_list _out;
24599 octave_value_list *_outp=&_out;
24600 octave_value _outv;
24601
24602 try {
24603 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24604 SWIG_fail;
24605 }
24606 ecode1 = SWIG_AsVal_int(args(0), &val1);
24607 if (!SWIG_IsOK(ecode1)) {
24608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24609 }
24610 arg1 = static_cast< PLINT >(val1);
24611 plsstrm(arg1);
24612 _outv = octave_value();
24613 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24614 return _out;
24615 fail:
24616 return octave_value_list();
24617 }
24618 catch(...) {
24619 throw;
24620 }
24621}
24622
24623
24625 PLINT arg1 ;
24626 PLINT arg2 ;
24627 int val1 ;
24628 int ecode1 = 0 ;
24629 int val2 ;
24630 int ecode2 = 0 ;
24631 octave_value_list _out;
24632 octave_value_list *_outp=&_out;
24633 octave_value _outv;
24634
24635 try {
24636 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24637 SWIG_fail;
24638 }
24639 ecode1 = SWIG_AsVal_int(args(0), &val1);
24640 if (!SWIG_IsOK(ecode1)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24642 }
24643 arg1 = static_cast< PLINT >(val1);
24644 ecode2 = SWIG_AsVal_int(args(1), &val2);
24645 if (!SWIG_IsOK(ecode2)) {
24646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24647 }
24648 arg2 = static_cast< PLINT >(val2);
24649 plssub(arg1,arg2);
24650 _outv = octave_value();
24651 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24652 return _out;
24653 fail:
24654 return octave_value_list();
24655 }
24656 catch(...) {
24657 throw;
24658 }
24659}
24660
24661
24663 PLFLT arg1 ;
24664 PLFLT arg2 ;
24665 double val1 ;
24666 int ecode1 = 0 ;
24667 double val2 ;
24668 int ecode2 = 0 ;
24669 octave_value_list _out;
24670 octave_value_list *_outp=&_out;
24671 octave_value _outv;
24672
24673 try {
24674 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24675 SWIG_fail;
24676 }
24677 ecode1 = SWIG_AsVal_double(args(0), &val1);
24678 if (!SWIG_IsOK(ecode1)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24680 }
24681 arg1 = static_cast< PLFLT >(val1);
24682 ecode2 = SWIG_AsVal_double(args(1), &val2);
24683 if (!SWIG_IsOK(ecode2)) {
24684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24685 }
24686 arg2 = static_cast< PLFLT >(val2);
24687 plssym(arg1,arg2);
24688 _outv = octave_value();
24689 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24690 return _out;
24691 fail:
24692 return octave_value_list();
24693 }
24694 catch(...) {
24695 throw;
24696 }
24697}
24698
24699
24701 PLINT arg1 ;
24702 PLINT arg2 ;
24703 int val1 ;
24704 int ecode1 = 0 ;
24705 int val2 ;
24706 int ecode2 = 0 ;
24707 octave_value_list _out;
24708 octave_value_list *_outp=&_out;
24709 octave_value _outv;
24710
24711 try {
24712 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24713 SWIG_fail;
24714 }
24715 ecode1 = SWIG_AsVal_int(args(0), &val1);
24716 if (!SWIG_IsOK(ecode1)) {
24717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24718 }
24719 arg1 = static_cast< PLINT >(val1);
24720 ecode2 = SWIG_AsVal_int(args(1), &val2);
24721 if (!SWIG_IsOK(ecode2)) {
24722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24723 }
24724 arg2 = static_cast< PLINT >(val2);
24725 plstar(arg1,arg2);
24726 _outv = octave_value();
24727 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24728 return _out;
24729 fail:
24730 return octave_value_list();
24731 }
24732 catch(...) {
24733 throw;
24734 }
24735}
24736
24737
24739 char *arg1 = (char *) 0 ;
24740 PLINT arg2 ;
24741 PLINT arg3 ;
24742 int res1 ;
24743 char *buf1 = 0 ;
24744 int alloc1 = 0 ;
24745 int val2 ;
24746 int ecode2 = 0 ;
24747 int val3 ;
24748 int ecode3 = 0 ;
24749 octave_value_list _out;
24750 octave_value_list *_outp=&_out;
24751 octave_value _outv;
24752
24753 try {
24754 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24755 SWIG_fail;
24756 }
24757 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24758 if (!SWIG_IsOK(res1)) {
24759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24760 }
24761 arg1 = reinterpret_cast< char * >(buf1);
24762 ecode2 = SWIG_AsVal_int(args(1), &val2);
24763 if (!SWIG_IsOK(ecode2)) {
24764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24765 }
24766 arg2 = static_cast< PLINT >(val2);
24767 ecode3 = SWIG_AsVal_int(args(2), &val3);
24768 if (!SWIG_IsOK(ecode3)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24770 }
24771 arg3 = static_cast< PLINT >(val3);
24772 plstart((char const *)arg1,arg2,arg3);
24773 _outv = octave_value();
24774 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24775 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24776 return _out;
24777 fail:
24778 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24779 return octave_value_list();
24780 }
24781 catch(...) {
24782 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24783 throw;
24784 }
24785}
24786
24787
24789 ct_func arg1 = (ct_func) 0 ;
24790 PLPointer arg2 = (PLPointer) 0 ;
24791 int res2 ;
24792 octave_value_list _out;
24793 octave_value_list *_outp=&_out;
24794 octave_value _outv;
24795
24796 try {
24797 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24798 SWIG_fail;
24799 }
24800 {
24801 octave_value obj = args(0);
24802#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24803 if ( !obj.isempty() )
24804#else
24805 if ( !obj.is_empty() )
24806#endif
24807 {
24808 if ( obj.is_function_handle() || obj.is_inline_function() )
24809 {
24810 fcnCoordTrans = obj.function_value();
24811 }
24812 else if ( obj.is_string() )
24813 {
24814 nameCoordTrans = obj.string_value();
24815 fcnCoordTrans = NULL;
24816 }
24817 arg1 = ct_octave;
24818 }
24819 else
24820 {
24821 arg1 = NULL;
24822 }
24823 }
24824 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24825 if (!SWIG_IsOK(res2)) {
24826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24827 }
24828 plstransform(arg1,arg2);
24829 _outv = octave_value();
24830 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24831 return _out;
24832 fail:
24833 return octave_value_list();
24834 }
24835 catch(...) {
24836 throw;
24837 }
24838}
24839
24840
24842 PLINT arg1 ;
24843 PLFLT *arg2 = (PLFLT *) 0 ;
24844 PLFLT *arg3 = (PLFLT *) 0 ;
24845 char *arg4 = (char *) 0 ;
24846 Matrix temp1 ;
24847 Matrix temp3 ;
24848 int res4 ;
24849 char *buf4 = 0 ;
24850 int alloc4 = 0 ;
24851 octave_value_list _out;
24852 octave_value_list *_outp=&_out;
24853 octave_value _outv;
24854
24855 try {
24856 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24857 SWIG_fail;
24858 }
24859 {
24860 if ( _n_dims( args(0) ) > 1 )
24861 {
24862 error( "argument must be a scalar or vector" ); SWIG_fail;
24863 }
24864 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24865 temp1 = args(0).matrix_value();
24866 arg2 = &temp1( 0, 0 );
24867 }
24868 {
24869 if ( _n_dims( args(1) ) > 1 )
24870 {
24871 error( "argument must be a scalar or vector" ); SWIG_fail;
24872 }
24873 if ( _dim( args(1), 0 ) != Alen )
24874 {
24875 error( "argument vectors must be same length" ); SWIG_fail;
24876 }
24877 temp3 = args(1).matrix_value();
24878 arg3 = &temp3( 0, 0 );
24879 }
24880 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24881 if (!SWIG_IsOK(res4)) {
24882 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24883 }
24884 arg4 = reinterpret_cast< char * >(buf4);
24885 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24886 _outv = octave_value();
24887 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24888 {
24889
24890 }
24891 {
24892
24893 }
24894 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24895 return _out;
24896 fail:
24897 {
24898
24899 }
24900 {
24901
24902 }
24903 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24904 return octave_value_list();
24905 }
24906 catch(...) {
24907 {
24908
24909 }
24910 {
24911
24912 }
24913 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24914 throw;
24915 }
24916}
24917
24918
24920 PLINT arg1 ;
24921 PLFLT *arg2 = (PLFLT *) 0 ;
24922 PLFLT *arg3 = (PLFLT *) 0 ;
24923 PLFLT *arg4 = (PLFLT *) 0 ;
24924 char *arg5 = (char *) 0 ;
24925 Matrix temp1 ;
24926 Matrix temp3 ;
24927 Matrix temp4 ;
24928 int res5 ;
24929 char *buf5 = 0 ;
24930 int alloc5 = 0 ;
24931 octave_value_list _out;
24932 octave_value_list *_outp=&_out;
24933 octave_value _outv;
24934
24935 try {
24936 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24937 SWIG_fail;
24938 }
24939 {
24940 if ( _n_dims( args(0) ) > 1 )
24941 {
24942 error( "argument must be a scalar or vector" ); SWIG_fail;
24943 }
24944 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24945 temp1 = args(0).matrix_value();
24946 arg2 = &temp1( 0, 0 );
24947 }
24948 {
24949 if ( _n_dims( args(1) ) > 1 )
24950 {
24951 error( "argument must be a scalar or vector" ); SWIG_fail;
24952 }
24953 if ( _dim( args(1), 0 ) != Alen )
24954 {
24955 error( "argument vectors must be same length" ); SWIG_fail;
24956 }
24957 temp3 = args(1).matrix_value();
24958 arg3 = &temp3( 0, 0 );
24959 }
24960 {
24961 if ( _n_dims( args(2) ) > 1 )
24962 {
24963 error( "argument must be a scalar or vector" ); SWIG_fail;
24964 }
24965 if ( _dim( args(2), 0 ) != Alen )
24966 {
24967 error( "argument vectors must be same length" ); SWIG_fail;
24968 }
24969 temp4 = args(2).matrix_value();
24970 arg4 = &temp4( 0, 0 );
24971 }
24972 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24973 if (!SWIG_IsOK(res5)) {
24974 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24975 }
24976 arg5 = reinterpret_cast< char * >(buf5);
24977 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24978 _outv = octave_value();
24979 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24980 {
24981
24982 }
24983 {
24984
24985 }
24986 {
24987
24988 }
24989 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24990 return _out;
24991 fail:
24992 {
24993
24994 }
24995 {
24996
24997 }
24998 {
24999
25000 }
25001 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25002 return octave_value_list();
25003 }
25004 catch(...) {
25005 {
25006
25007 }
25008 {
25009
25010 }
25011 {
25012
25013 }
25014 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
25015 throw;
25016 }
25017}
25018
25019
25021 PLINT arg1 ;
25022 PLINT arg2 ;
25023 PLFLT arg3 ;
25024 PLFLT arg4 ;
25025 int val1 ;
25026 int ecode1 = 0 ;
25027 int val2 ;
25028 int ecode2 = 0 ;
25029 double val3 ;
25030 int ecode3 = 0 ;
25031 double val4 ;
25032 int ecode4 = 0 ;
25033 octave_value_list _out;
25034 octave_value_list *_outp=&_out;
25035 octave_value _outv;
25036
25037 try {
25038 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
25039 SWIG_fail;
25040 }
25041 ecode1 = SWIG_AsVal_int(args(0), &val1);
25042 if (!SWIG_IsOK(ecode1)) {
25043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
25044 }
25045 arg1 = static_cast< PLINT >(val1);
25046 ecode2 = SWIG_AsVal_int(args(1), &val2);
25047 if (!SWIG_IsOK(ecode2)) {
25048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
25049 }
25050 arg2 = static_cast< PLINT >(val2);
25051 ecode3 = SWIG_AsVal_double(args(2), &val3);
25052 if (!SWIG_IsOK(ecode3)) {
25053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
25054 }
25055 arg3 = static_cast< PLFLT >(val3);
25056 ecode4 = SWIG_AsVal_double(args(3), &val4);
25057 if (!SWIG_IsOK(ecode4)) {
25058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
25059 }
25060 arg4 = static_cast< PLFLT >(val4);
25061 plstripa(arg1,arg2,arg3,arg4);
25062 _outv = octave_value();
25063 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25064 return _out;
25065 fail:
25066 return octave_value_list();
25067 }
25068 catch(...) {
25069 throw;
25070 }
25071}
25072
25073
25075 PLINT arg1 ;
25076 int val1 ;
25077 int ecode1 = 0 ;
25078 octave_value_list _out;
25079 octave_value_list *_outp=&_out;
25080 octave_value _outv;
25081
25082 try {
25083 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25084 SWIG_fail;
25085 }
25086 ecode1 = SWIG_AsVal_int(args(0), &val1);
25087 if (!SWIG_IsOK(ecode1)) {
25088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25089 }
25090 arg1 = static_cast< PLINT >(val1);
25091 plstripd(arg1);
25092 _outv = octave_value();
25093 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25094 return _out;
25095 fail:
25096 return octave_value_list();
25097 }
25098 catch(...) {
25099 throw;
25100 }
25101}
25102
25103
25105 PLINT arg1 ;
25106 PLINT *arg2 = (PLINT *) 0 ;
25107 PLINT *arg3 = (PLINT *) 0 ;
25108 Matrix temp1 ;
25109 Matrix temp3 ;
25110 octave_value_list _out;
25111 octave_value_list *_outp=&_out;
25112 octave_value _outv;
25113
25114 try {
25115 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25116 SWIG_fail;
25117 }
25118 {
25119 if ( _n_dims( args(0) ) > 1 )
25120 {
25121 error( "argument must be a scalar or vector" ); SWIG_fail;
25122 }
25123 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25124 arg2 = new PLINT[Alen];
25125 temp1 = args(0).matrix_value();
25126 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25127 }
25128 {
25129 if ( _n_dims( args(1) ) > 1 )
25130 {
25131 error( "argument must be a scalar or vector" ); SWIG_fail;
25132 }
25133 if ( _dim( args(1), 0 ) != Alen )
25134 {
25135 error( "argument vectors must be same length" ); SWIG_fail;
25136 }
25137 temp3 = args(1).matrix_value();
25138 arg3 = new PLINT[Alen];
25139 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25140 }
25141 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25142 _outv = octave_value();
25143 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25144 {
25145 delete [] arg2;
25146 }
25147 {
25148 delete [] arg3;
25149 }
25150 return _out;
25151 fail:
25152 {
25153 delete [] arg2;
25154 }
25155 {
25156 delete [] arg3;
25157 }
25158 return octave_value_list();
25159 }
25160 catch(...) {
25161 {
25162 delete [] arg2;
25163 }
25164 {
25165 delete [] arg3;
25166 }
25167 throw;
25168 }
25169}
25170
25171
25173 PLFLT *arg1 = (PLFLT *) 0 ;
25174 PLFLT *arg2 = (PLFLT *) 0 ;
25175 PLINT arg3 ;
25176 PLBOOL arg4 ;
25177 Matrix temp1 ;
25178 Matrix temp2 ;
25179 int val4 ;
25180 int ecode4 = 0 ;
25181 octave_value_list _out;
25182 octave_value_list *_outp=&_out;
25183 octave_value _outv;
25184
25185 try {
25186 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25187 SWIG_fail;
25188 }
25189 {
25190 if ( _n_dims( args(0) ) > 1 )
25191 {
25192 error( "argument must be a scalar or vector" ); SWIG_fail;
25193 }
25194#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25195 if ( !args(0).isempty() )
25196#else
25197 if ( !args(0).is_empty() )
25198#endif
25199 {
25200 Alen = (PLINT) ( _dim( args(0), 0 ) );
25201 temp1 = args(0).matrix_value();
25202 arg1 = &temp1( 0, 0 );
25203 }
25204 else
25205 {
25206 arg1 = NULL;
25207 Alen = 0;
25208 }
25209 }
25210 {
25211 if ( _n_dims( args(1) ) > 1 )
25212 {
25213 error( "argument must be a scalar or vector" ); SWIG_fail;
25214 }
25215#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25216 if ( !args(1).isempty() )
25217#else
25218 if ( !args(1).is_empty() )
25219#endif
25220 {
25221 if ( _dim( args(1), 0 ) != Alen )
25222 {
25223 error( "argument vectors must be same length" ); SWIG_fail;
25224 }
25225 temp2 = args(1).matrix_value();
25226 arg2 = &temp2( 0, 0 );
25227 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25228 }
25229 else
25230 {
25231 arg2 = NULL;
25232 arg3 = 0;
25233 }
25234 }
25235 ecode4 = SWIG_AsVal_int(args(2), &val4);
25236 if (!SWIG_IsOK(ecode4)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25238 }
25239 arg4 = static_cast< PLBOOL >(val4);
25240 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25241 _outv = octave_value();
25242 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25243 {
25244
25245 }
25246 {
25247
25248 }
25249 return _out;
25250 fail:
25251 {
25252
25253 }
25254 {
25255
25256 }
25257 return octave_value_list();
25258 }
25259 catch(...) {
25260 {
25261
25262 }
25263 {
25264
25265 }
25266 throw;
25267 }
25268}
25269
25270
25272 PLFLT arg1 ;
25273 PLFLT arg2 ;
25274 PLFLT arg3 ;
25275 PLFLT arg4 ;
25276 double val1 ;
25277 int ecode1 = 0 ;
25278 double val2 ;
25279 int ecode2 = 0 ;
25280 double val3 ;
25281 int ecode3 = 0 ;
25282 double val4 ;
25283 int ecode4 = 0 ;
25284 octave_value_list _out;
25285 octave_value_list *_outp=&_out;
25286 octave_value _outv;
25287
25288 try {
25289 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25290 SWIG_fail;
25291 }
25292 ecode1 = SWIG_AsVal_double(args(0), &val1);
25293 if (!SWIG_IsOK(ecode1)) {
25294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25295 }
25296 arg1 = static_cast< PLFLT >(val1);
25297 ecode2 = SWIG_AsVal_double(args(1), &val2);
25298 if (!SWIG_IsOK(ecode2)) {
25299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25300 }
25301 arg2 = static_cast< PLFLT >(val2);
25302 ecode3 = SWIG_AsVal_double(args(2), &val3);
25303 if (!SWIG_IsOK(ecode3)) {
25304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25305 }
25306 arg3 = static_cast< PLFLT >(val3);
25307 ecode4 = SWIG_AsVal_double(args(3), &val4);
25308 if (!SWIG_IsOK(ecode4)) {
25309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25310 }
25311 arg4 = static_cast< PLFLT >(val4);
25312 plsvpa(arg1,arg2,arg3,arg4);
25313 _outv = octave_value();
25314 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25315 return _out;
25316 fail:
25317 return octave_value_list();
25318 }
25319 catch(...) {
25320 throw;
25321 }
25322}
25323
25324
25326 PLINT arg1 ;
25327 PLINT arg2 ;
25328 int val1 ;
25329 int ecode1 = 0 ;
25330 int val2 ;
25331 int ecode2 = 0 ;
25332 octave_value_list _out;
25333 octave_value_list *_outp=&_out;
25334 octave_value _outv;
25335
25336 try {
25337 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25338 SWIG_fail;
25339 }
25340 ecode1 = SWIG_AsVal_int(args(0), &val1);
25341 if (!SWIG_IsOK(ecode1)) {
25342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25343 }
25344 arg1 = static_cast< PLINT >(val1);
25345 ecode2 = SWIG_AsVal_int(args(1), &val2);
25346 if (!SWIG_IsOK(ecode2)) {
25347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25348 }
25349 arg2 = static_cast< PLINT >(val2);
25350 plsxax(arg1,arg2);
25351 _outv = octave_value();
25352 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25353 return _out;
25354 fail:
25355 return octave_value_list();
25356 }
25357 catch(...) {
25358 throw;
25359 }
25360}
25361
25362
25364 PLINT arg1 ;
25365 PLINT arg2 ;
25366 int val1 ;
25367 int ecode1 = 0 ;
25368 int val2 ;
25369 int ecode2 = 0 ;
25370 octave_value_list _out;
25371 octave_value_list *_outp=&_out;
25372 octave_value _outv;
25373
25374 try {
25375 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25376 SWIG_fail;
25377 }
25378 ecode1 = SWIG_AsVal_int(args(0), &val1);
25379 if (!SWIG_IsOK(ecode1)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25381 }
25382 arg1 = static_cast< PLINT >(val1);
25383 ecode2 = SWIG_AsVal_int(args(1), &val2);
25384 if (!SWIG_IsOK(ecode2)) {
25385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25386 }
25387 arg2 = static_cast< PLINT >(val2);
25388 plsyax(arg1,arg2);
25389 _outv = octave_value();
25390 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25391 return _out;
25392 fail:
25393 return octave_value_list();
25394 }
25395 catch(...) {
25396 throw;
25397 }
25398}
25399
25400
25402 PLINT arg1 ;
25403 PLFLT *arg2 = (PLFLT *) 0 ;
25404 PLFLT *arg3 = (PLFLT *) 0 ;
25405 PLINT arg4 ;
25406 Matrix temp1 ;
25407 Matrix temp3 ;
25408 int val4 ;
25409 int ecode4 = 0 ;
25410 octave_value_list _out;
25411 octave_value_list *_outp=&_out;
25412 octave_value _outv;
25413
25414 try {
25415 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25416 SWIG_fail;
25417 }
25418 {
25419 if ( _n_dims( args(0) ) > 1 )
25420 {
25421 error( "argument must be a scalar or vector" ); SWIG_fail;
25422 }
25423 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25424 temp1 = args(0).matrix_value();
25425 arg2 = &temp1( 0, 0 );
25426 }
25427 {
25428 if ( _n_dims( args(1) ) > 1 )
25429 {
25430 error( "argument must be a scalar or vector" ); SWIG_fail;
25431 }
25432 if ( _dim( args(1), 0 ) != Alen )
25433 {
25434 error( "argument vectors must be same length" ); SWIG_fail;
25435 }
25436 temp3 = args(1).matrix_value();
25437 arg3 = &temp3( 0, 0 );
25438 }
25439 ecode4 = SWIG_AsVal_int(args(2), &val4);
25440 if (!SWIG_IsOK(ecode4)) {
25441 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25442 }
25443 arg4 = static_cast< PLINT >(val4);
25444 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25445 _outv = octave_value();
25446 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25447 {
25448
25449 }
25450 {
25451
25452 }
25453 return _out;
25454 fail:
25455 {
25456
25457 }
25458 {
25459
25460 }
25461 return octave_value_list();
25462 }
25463 catch(...) {
25464 {
25465
25466 }
25467 {
25468
25469 }
25470 throw;
25471 }
25472}
25473
25474
25476 PLINT arg1 ;
25477 PLINT arg2 ;
25478 int val1 ;
25479 int ecode1 = 0 ;
25480 int val2 ;
25481 int ecode2 = 0 ;
25482 octave_value_list _out;
25483 octave_value_list *_outp=&_out;
25484 octave_value _outv;
25485
25486 try {
25487 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25488 SWIG_fail;
25489 }
25490 ecode1 = SWIG_AsVal_int(args(0), &val1);
25491 if (!SWIG_IsOK(ecode1)) {
25492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25493 }
25494 arg1 = static_cast< PLINT >(val1);
25495 ecode2 = SWIG_AsVal_int(args(1), &val2);
25496 if (!SWIG_IsOK(ecode2)) {
25497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25498 }
25499 arg2 = static_cast< PLINT >(val2);
25500 plszax(arg1,arg2);
25501 _outv = octave_value();
25502 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25503 return _out;
25504 fail:
25505 return octave_value_list();
25506 }
25507 catch(...) {
25508 throw;
25509 }
25510}
25511
25512
25514 octave_value_list _out;
25515 octave_value_list *_outp=&_out;
25516 octave_value _outv;
25517
25518 try {
25519 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25520 SWIG_fail;
25521 }
25522 pltext();
25523 _outv = octave_value();
25524 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25525 return _out;
25526 fail:
25527 return octave_value_list();
25528 }
25529 catch(...) {
25530 throw;
25531 }
25532}
25533
25534
25536 char *arg1 = (char *) 0 ;
25537 int res1 ;
25538 char *buf1 = 0 ;
25539 int alloc1 = 0 ;
25540 octave_value_list _out;
25541 octave_value_list *_outp=&_out;
25542 octave_value _outv;
25543
25544 try {
25545 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25546 SWIG_fail;
25547 }
25548 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25549 if (!SWIG_IsOK(res1)) {
25550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25551 }
25552 arg1 = reinterpret_cast< char * >(buf1);
25553 pltimefmt((char const *)arg1);
25554 _outv = octave_value();
25555 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25556 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25557 return _out;
25558 fail:
25559 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25560 return octave_value_list();
25561 }
25562 catch(...) {
25563 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25564 throw;
25565 }
25566}
25567
25568
25570 PLFLT arg1 ;
25571 double val1 ;
25572 int ecode1 = 0 ;
25573 octave_value_list _out;
25574 octave_value_list *_outp=&_out;
25575 octave_value _outv;
25576
25577 try {
25578 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25579 SWIG_fail;
25580 }
25581 ecode1 = SWIG_AsVal_double(args(0), &val1);
25582 if (!SWIG_IsOK(ecode1)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25584 }
25585 arg1 = static_cast< PLFLT >(val1);
25586 plvasp(arg1);
25587 _outv = octave_value();
25588 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25589 return _out;
25590 fail:
25591 return octave_value_list();
25592 }
25593 catch(...) {
25594 throw;
25595 }
25596}
25597
25598
25600 PLFLT arg1 ;
25601 PLFLT arg2 ;
25602 PLFLT arg3 ;
25603 PLFLT arg4 ;
25604 PLFLT arg5 ;
25605 double val1 ;
25606 int ecode1 = 0 ;
25607 double val2 ;
25608 int ecode2 = 0 ;
25609 double val3 ;
25610 int ecode3 = 0 ;
25611 double val4 ;
25612 int ecode4 = 0 ;
25613 double val5 ;
25614 int ecode5 = 0 ;
25615 octave_value_list _out;
25616 octave_value_list *_outp=&_out;
25617 octave_value _outv;
25618
25619 try {
25620 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25621 SWIG_fail;
25622 }
25623 ecode1 = SWIG_AsVal_double(args(0), &val1);
25624 if (!SWIG_IsOK(ecode1)) {
25625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25626 }
25627 arg1 = static_cast< PLFLT >(val1);
25628 ecode2 = SWIG_AsVal_double(args(1), &val2);
25629 if (!SWIG_IsOK(ecode2)) {
25630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25631 }
25632 arg2 = static_cast< PLFLT >(val2);
25633 ecode3 = SWIG_AsVal_double(args(2), &val3);
25634 if (!SWIG_IsOK(ecode3)) {
25635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25636 }
25637 arg3 = static_cast< PLFLT >(val3);
25638 ecode4 = SWIG_AsVal_double(args(3), &val4);
25639 if (!SWIG_IsOK(ecode4)) {
25640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25641 }
25642 arg4 = static_cast< PLFLT >(val4);
25643 ecode5 = SWIG_AsVal_double(args(4), &val5);
25644 if (!SWIG_IsOK(ecode5)) {
25645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25646 }
25647 arg5 = static_cast< PLFLT >(val5);
25648 plvpas(arg1,arg2,arg3,arg4,arg5);
25649 _outv = octave_value();
25650 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25651 return _out;
25652 fail:
25653 return octave_value_list();
25654 }
25655 catch(...) {
25656 throw;
25657 }
25658}
25659
25660
25662 PLFLT arg1 ;
25663 PLFLT arg2 ;
25664 PLFLT arg3 ;
25665 PLFLT arg4 ;
25666 double val1 ;
25667 int ecode1 = 0 ;
25668 double val2 ;
25669 int ecode2 = 0 ;
25670 double val3 ;
25671 int ecode3 = 0 ;
25672 double val4 ;
25673 int ecode4 = 0 ;
25674 octave_value_list _out;
25675 octave_value_list *_outp=&_out;
25676 octave_value _outv;
25677
25678 try {
25679 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25680 SWIG_fail;
25681 }
25682 ecode1 = SWIG_AsVal_double(args(0), &val1);
25683 if (!SWIG_IsOK(ecode1)) {
25684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25685 }
25686 arg1 = static_cast< PLFLT >(val1);
25687 ecode2 = SWIG_AsVal_double(args(1), &val2);
25688 if (!SWIG_IsOK(ecode2)) {
25689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25690 }
25691 arg2 = static_cast< PLFLT >(val2);
25692 ecode3 = SWIG_AsVal_double(args(2), &val3);
25693 if (!SWIG_IsOK(ecode3)) {
25694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25695 }
25696 arg3 = static_cast< PLFLT >(val3);
25697 ecode4 = SWIG_AsVal_double(args(3), &val4);
25698 if (!SWIG_IsOK(ecode4)) {
25699 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25700 }
25701 arg4 = static_cast< PLFLT >(val4);
25702 plvpor(arg1,arg2,arg3,arg4);
25703 _outv = octave_value();
25704 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25705 return _out;
25706 fail:
25707 return octave_value_list();
25708 }
25709 catch(...) {
25710 throw;
25711 }
25712}
25713
25714
25716 octave_value_list _out;
25717 octave_value_list *_outp=&_out;
25718 octave_value _outv;
25719
25720 try {
25721 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25722 SWIG_fail;
25723 }
25724 plvsta();
25725 _outv = octave_value();
25726 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25727 return _out;
25728 fail:
25729 return octave_value_list();
25730 }
25731 catch(...) {
25732 throw;
25733 }
25734}
25735
25736
25738 PLFLT arg1 ;
25739 PLFLT arg2 ;
25740 PLFLT arg3 ;
25741 PLFLT arg4 ;
25742 PLFLT arg5 ;
25743 PLFLT arg6 ;
25744 PLFLT arg7 ;
25745 PLFLT arg8 ;
25746 PLFLT arg9 ;
25747 PLFLT arg10 ;
25748 PLFLT arg11 ;
25749 double val1 ;
25750 int ecode1 = 0 ;
25751 double val2 ;
25752 int ecode2 = 0 ;
25753 double val3 ;
25754 int ecode3 = 0 ;
25755 double val4 ;
25756 int ecode4 = 0 ;
25757 double val5 ;
25758 int ecode5 = 0 ;
25759 double val6 ;
25760 int ecode6 = 0 ;
25761 double val7 ;
25762 int ecode7 = 0 ;
25763 double val8 ;
25764 int ecode8 = 0 ;
25765 double val9 ;
25766 int ecode9 = 0 ;
25767 double val10 ;
25768 int ecode10 = 0 ;
25769 double val11 ;
25770 int ecode11 = 0 ;
25771 octave_value_list _out;
25772 octave_value_list *_outp=&_out;
25773 octave_value _outv;
25774
25775 try {
25776 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25777 SWIG_fail;
25778 }
25779 ecode1 = SWIG_AsVal_double(args(0), &val1);
25780 if (!SWIG_IsOK(ecode1)) {
25781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25782 }
25783 arg1 = static_cast< PLFLT >(val1);
25784 ecode2 = SWIG_AsVal_double(args(1), &val2);
25785 if (!SWIG_IsOK(ecode2)) {
25786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25787 }
25788 arg2 = static_cast< PLFLT >(val2);
25789 ecode3 = SWIG_AsVal_double(args(2), &val3);
25790 if (!SWIG_IsOK(ecode3)) {
25791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25792 }
25793 arg3 = static_cast< PLFLT >(val3);
25794 ecode4 = SWIG_AsVal_double(args(3), &val4);
25795 if (!SWIG_IsOK(ecode4)) {
25796 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25797 }
25798 arg4 = static_cast< PLFLT >(val4);
25799 ecode5 = SWIG_AsVal_double(args(4), &val5);
25800 if (!SWIG_IsOK(ecode5)) {
25801 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25802 }
25803 arg5 = static_cast< PLFLT >(val5);
25804 ecode6 = SWIG_AsVal_double(args(5), &val6);
25805 if (!SWIG_IsOK(ecode6)) {
25806 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25807 }
25808 arg6 = static_cast< PLFLT >(val6);
25809 ecode7 = SWIG_AsVal_double(args(6), &val7);
25810 if (!SWIG_IsOK(ecode7)) {
25811 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25812 }
25813 arg7 = static_cast< PLFLT >(val7);
25814 ecode8 = SWIG_AsVal_double(args(7), &val8);
25815 if (!SWIG_IsOK(ecode8)) {
25816 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25817 }
25818 arg8 = static_cast< PLFLT >(val8);
25819 ecode9 = SWIG_AsVal_double(args(8), &val9);
25820 if (!SWIG_IsOK(ecode9)) {
25821 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25822 }
25823 arg9 = static_cast< PLFLT >(val9);
25824 ecode10 = SWIG_AsVal_double(args(9), &val10);
25825 if (!SWIG_IsOK(ecode10)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25827 }
25828 arg10 = static_cast< PLFLT >(val10);
25829 ecode11 = SWIG_AsVal_double(args(10), &val11);
25830 if (!SWIG_IsOK(ecode11)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25832 }
25833 arg11 = static_cast< PLFLT >(val11);
25834 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25835 _outv = octave_value();
25836 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25837 return _out;
25838 fail:
25839 return octave_value_list();
25840 }
25841 catch(...) {
25842 throw;
25843 }
25844}
25845
25846
25848 PLFLT arg1 ;
25849 double val1 ;
25850 int ecode1 = 0 ;
25851 octave_value_list _out;
25852 octave_value_list *_outp=&_out;
25853 octave_value _outv;
25854
25855 try {
25856 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25857 SWIG_fail;
25858 }
25859 ecode1 = SWIG_AsVal_double(args(0), &val1);
25860 if (!SWIG_IsOK(ecode1)) {
25861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25862 }
25863 arg1 = static_cast< PLFLT >(val1);
25864 plwidth(arg1);
25865 _outv = octave_value();
25866 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25867 return _out;
25868 fail:
25869 return octave_value_list();
25870 }
25871 catch(...) {
25872 throw;
25873 }
25874}
25875
25876
25878 PLFLT arg1 ;
25879 PLFLT arg2 ;
25880 PLFLT arg3 ;
25881 PLFLT arg4 ;
25882 double val1 ;
25883 int ecode1 = 0 ;
25884 double val2 ;
25885 int ecode2 = 0 ;
25886 double val3 ;
25887 int ecode3 = 0 ;
25888 double val4 ;
25889 int ecode4 = 0 ;
25890 octave_value_list _out;
25891 octave_value_list *_outp=&_out;
25892 octave_value _outv;
25893
25894 try {
25895 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25896 SWIG_fail;
25897 }
25898 ecode1 = SWIG_AsVal_double(args(0), &val1);
25899 if (!SWIG_IsOK(ecode1)) {
25900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25901 }
25902 arg1 = static_cast< PLFLT >(val1);
25903 ecode2 = SWIG_AsVal_double(args(1), &val2);
25904 if (!SWIG_IsOK(ecode2)) {
25905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25906 }
25907 arg2 = static_cast< PLFLT >(val2);
25908 ecode3 = SWIG_AsVal_double(args(2), &val3);
25909 if (!SWIG_IsOK(ecode3)) {
25910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25911 }
25912 arg3 = static_cast< PLFLT >(val3);
25913 ecode4 = SWIG_AsVal_double(args(3), &val4);
25914 if (!SWIG_IsOK(ecode4)) {
25915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25916 }
25917 arg4 = static_cast< PLFLT >(val4);
25918 plwind(arg1,arg2,arg3,arg4);
25919 _outv = octave_value();
25920 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25921 return _out;
25922 fail:
25923 return octave_value_list();
25924 }
25925 catch(...) {
25926 throw;
25927 }
25928}
25929
25930
25932 PLBOOL arg1 ;
25933 PLBOOL *arg2 = (PLBOOL *) 0 ;
25934 int val1 ;
25935 int ecode1 = 0 ;
25936 PLBOOL temp2 ;
25937 int res2 = SWIG_TMPOBJ ;
25938 octave_value_list _out;
25939 octave_value_list *_outp=&_out;
25940 octave_value _outv;
25941
25942 try {
25943 arg2 = &temp2;
25944 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25945 SWIG_fail;
25946 }
25947 ecode1 = SWIG_AsVal_int(args(0), &val1);
25948 if (!SWIG_IsOK(ecode1)) {
25949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25950 }
25951 arg1 = static_cast< PLBOOL >(val1);
25952 plxormod(arg1,arg2);
25953 _outv = octave_value();
25954 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25955 if (SWIG_IsTmpObj(res2)) {
25956 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25957 } else {
25958 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25959 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25960 }
25961 return _out;
25962 fail:
25963 return octave_value_list();
25964 }
25965 catch(...) {
25966 throw;
25967 }
25968}
25969
25970
25972 mapform_func arg1 = (mapform_func) 0 ;
25973 char *arg2 = (char *) 0 ;
25974 PLFLT arg3 ;
25975 PLFLT arg4 ;
25976 PLFLT arg5 ;
25977 PLFLT arg6 ;
25978 int res2 ;
25979 char *buf2 = 0 ;
25980 int alloc2 = 0 ;
25981 double val3 ;
25982 int ecode3 = 0 ;
25983 double val4 ;
25984 int ecode4 = 0 ;
25985 double val5 ;
25986 int ecode5 = 0 ;
25987 double val6 ;
25988 int ecode6 = 0 ;
25989 octave_value_list _out;
25990 octave_value_list *_outp=&_out;
25991 octave_value _outv;
25992
25993 try {
25994 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25995 SWIG_fail;
25996 }
25997 {
25998 octave_value obj = args(0);
25999#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26000 if ( !obj.isempty() )
26001#else
26002 if ( !obj.is_empty() )
26003#endif
26004 {
26005 if ( obj.is_function_handle() || obj.is_inline_function() )
26006 {
26007 fcnMapForm = obj.function_value();
26008 }
26009 else if ( obj.is_string() )
26010 {
26011 nameMapForm = obj.string_value();
26012 fcnMapForm = NULL;
26013 }
26014 arg1 = mapform_octave;
26015 }
26016 else
26017 {
26018 arg1 = NULL;
26019 }
26020 }
26021 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26022 if (!SWIG_IsOK(res2)) {
26023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
26024 }
26025 arg2 = reinterpret_cast< char * >(buf2);
26026 ecode3 = SWIG_AsVal_double(args(2), &val3);
26027 if (!SWIG_IsOK(ecode3)) {
26028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
26029 }
26030 arg3 = static_cast< PLFLT >(val3);
26031 ecode4 = SWIG_AsVal_double(args(3), &val4);
26032 if (!SWIG_IsOK(ecode4)) {
26033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
26034 }
26035 arg4 = static_cast< PLFLT >(val4);
26036 ecode5 = SWIG_AsVal_double(args(4), &val5);
26037 if (!SWIG_IsOK(ecode5)) {
26038 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
26039 }
26040 arg5 = static_cast< PLFLT >(val5);
26041 ecode6 = SWIG_AsVal_double(args(5), &val6);
26042 if (!SWIG_IsOK(ecode6)) {
26043 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
26044 }
26045 arg6 = static_cast< PLFLT >(val6);
26046 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
26047 _outv = octave_value();
26048 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26049 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26050 return _out;
26051 fail:
26052 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26053 return octave_value_list();
26054 }
26055 catch(...) {
26056 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26057 throw;
26058 }
26059}
26060
26061
26063 mapform_func arg1 = (mapform_func) 0 ;
26064 char *arg2 = (char *) 0 ;
26065 PLFLT arg3 ;
26066 PLFLT arg4 ;
26067 PLFLT arg5 ;
26068 PLFLT arg6 ;
26069 PLINT *arg7 = (PLINT *) 0 ;
26070 PLINT arg8 ;
26071 int res2 ;
26072 char *buf2 = 0 ;
26073 int alloc2 = 0 ;
26074 double val3 ;
26075 int ecode3 = 0 ;
26076 double val4 ;
26077 int ecode4 = 0 ;
26078 double val5 ;
26079 int ecode5 = 0 ;
26080 double val6 ;
26081 int ecode6 = 0 ;
26082 Matrix temp7 ;
26083 octave_value_list _out;
26084 octave_value_list *_outp=&_out;
26085 octave_value _outv;
26086
26087 try {
26088 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26089 SWIG_fail;
26090 }
26091 {
26092 octave_value obj = args(0);
26093#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26094 if ( !obj.isempty() )
26095#else
26096 if ( !obj.is_empty() )
26097#endif
26098 {
26099 if ( obj.is_function_handle() || obj.is_inline_function() )
26100 {
26101 fcnMapForm = obj.function_value();
26102 }
26103 else if ( obj.is_string() )
26104 {
26105 nameMapForm = obj.string_value();
26106 fcnMapForm = NULL;
26107 }
26108 arg1 = mapform_octave;
26109 }
26110 else
26111 {
26112 arg1 = NULL;
26113 }
26114 }
26115 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26116 if (!SWIG_IsOK(res2)) {
26117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26118 }
26119 arg2 = reinterpret_cast< char * >(buf2);
26120 ecode3 = SWIG_AsVal_double(args(2), &val3);
26121 if (!SWIG_IsOK(ecode3)) {
26122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26123 }
26124 arg3 = static_cast< PLFLT >(val3);
26125 ecode4 = SWIG_AsVal_double(args(3), &val4);
26126 if (!SWIG_IsOK(ecode4)) {
26127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26128 }
26129 arg4 = static_cast< PLFLT >(val4);
26130 ecode5 = SWIG_AsVal_double(args(4), &val5);
26131 if (!SWIG_IsOK(ecode5)) {
26132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26133 }
26134 arg5 = static_cast< PLFLT >(val5);
26135 ecode6 = SWIG_AsVal_double(args(5), &val6);
26136 if (!SWIG_IsOK(ecode6)) {
26137 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26138 }
26139 arg6 = static_cast< PLFLT >(val6);
26140 {
26141 if ( _n_dims( args(6) ) > 1 )
26142 {
26143 error( "argument must be a scalar or vector" ); SWIG_fail;
26144 }
26145#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26146 if ( !args(6).isempty() )
26147#else
26148 if ( !args(6).is_empty() )
26149#endif
26150 {
26151 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26152 temp7 = args(6).matrix_value();
26153 arg7 = new PLINT[arg8];
26154 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26155 }
26156 else
26157 {
26158 arg7 = NULL;
26159 arg8 = 0;
26160 }
26161 }
26162 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26163 _outv = octave_value();
26164 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26165 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26166 {
26167 delete [] arg7;
26168 }
26169 return _out;
26170 fail:
26171 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26172 {
26173 delete [] arg7;
26174 }
26175 return octave_value_list();
26176 }
26177 catch(...) {
26178 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26179 {
26180 delete [] arg7;
26181 }
26182 throw;
26183 }
26184}
26185
26186
26188 mapform_func arg1 = (mapform_func) 0 ;
26189 char *arg2 = (char *) 0 ;
26190 char *arg3 = (char *) 0 ;
26191 PLFLT arg4 ;
26192 PLFLT arg5 ;
26193 PLFLT arg6 ;
26194 PLFLT arg7 ;
26195 PLINT *arg8 = (PLINT *) 0 ;
26196 PLINT arg9 ;
26197 int res2 ;
26198 char *buf2 = 0 ;
26199 int alloc2 = 0 ;
26200 int res3 ;
26201 char *buf3 = 0 ;
26202 int alloc3 = 0 ;
26203 double val4 ;
26204 int ecode4 = 0 ;
26205 double val5 ;
26206 int ecode5 = 0 ;
26207 double val6 ;
26208 int ecode6 = 0 ;
26209 double val7 ;
26210 int ecode7 = 0 ;
26211 Matrix temp8 ;
26212 octave_value_list _out;
26213 octave_value_list *_outp=&_out;
26214 octave_value _outv;
26215
26216 try {
26217 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26218 SWIG_fail;
26219 }
26220 {
26221 octave_value obj = args(0);
26222#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26223 if ( !obj.isempty() )
26224#else
26225 if ( !obj.is_empty() )
26226#endif
26227 {
26228 if ( obj.is_function_handle() || obj.is_inline_function() )
26229 {
26230 fcnMapForm = obj.function_value();
26231 }
26232 else if ( obj.is_string() )
26233 {
26234 nameMapForm = obj.string_value();
26235 fcnMapForm = NULL;
26236 }
26237 arg1 = mapform_octave;
26238 }
26239 else
26240 {
26241 arg1 = NULL;
26242 }
26243 }
26244 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26245 if (!SWIG_IsOK(res2)) {
26246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26247 }
26248 arg2 = reinterpret_cast< char * >(buf2);
26249 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26250 if (!SWIG_IsOK(res3)) {
26251 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26252 }
26253 arg3 = reinterpret_cast< char * >(buf3);
26254 ecode4 = SWIG_AsVal_double(args(3), &val4);
26255 if (!SWIG_IsOK(ecode4)) {
26256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26257 }
26258 arg4 = static_cast< PLFLT >(val4);
26259 ecode5 = SWIG_AsVal_double(args(4), &val5);
26260 if (!SWIG_IsOK(ecode5)) {
26261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26262 }
26263 arg5 = static_cast< PLFLT >(val5);
26264 ecode6 = SWIG_AsVal_double(args(5), &val6);
26265 if (!SWIG_IsOK(ecode6)) {
26266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26267 }
26268 arg6 = static_cast< PLFLT >(val6);
26269 ecode7 = SWIG_AsVal_double(args(6), &val7);
26270 if (!SWIG_IsOK(ecode7)) {
26271 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26272 }
26273 arg7 = static_cast< PLFLT >(val7);
26274 {
26275 if ( _n_dims( args(7) ) > 1 )
26276 {
26277 error( "argument must be a scalar or vector" ); SWIG_fail;
26278 }
26279#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26280 if ( !args(7).isempty() )
26281#else
26282 if ( !args(7).is_empty() )
26283#endif
26284 {
26285 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26286 temp8 = args(7).matrix_value();
26287 arg8 = new PLINT[arg9];
26288 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26289 }
26290 else
26291 {
26292 arg8 = NULL;
26293 arg9 = 0;
26294 }
26295 }
26296 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26297 _outv = octave_value();
26298 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26299 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26300 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26301 {
26302 delete [] arg8;
26303 }
26304 return _out;
26305 fail:
26306 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26307 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26308 {
26309 delete [] arg8;
26310 }
26311 return octave_value_list();
26312 }
26313 catch(...) {
26314 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26315 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26316 {
26317 delete [] arg8;
26318 }
26319 throw;
26320 }
26321}
26322
26323
26325 mapform_func arg1 = (mapform_func) 0 ;
26326 char *arg2 = (char *) 0 ;
26327 PLFLT arg3 ;
26328 PLFLT arg4 ;
26329 PLFLT arg5 ;
26330 char *arg6 = (char *) 0 ;
26331 PLFLT arg7 ;
26332 PLFLT arg8 ;
26333 PLFLT arg9 ;
26334 PLFLT arg10 ;
26335 PLINT arg11 ;
26336 int res2 ;
26337 char *buf2 = 0 ;
26338 int alloc2 = 0 ;
26339 double val3 ;
26340 int ecode3 = 0 ;
26341 double val4 ;
26342 int ecode4 = 0 ;
26343 double val5 ;
26344 int ecode5 = 0 ;
26345 int res6 ;
26346 char *buf6 = 0 ;
26347 int alloc6 = 0 ;
26348 double val7 ;
26349 int ecode7 = 0 ;
26350 double val8 ;
26351 int ecode8 = 0 ;
26352 double val9 ;
26353 int ecode9 = 0 ;
26354 double val10 ;
26355 int ecode10 = 0 ;
26356 int val11 ;
26357 int ecode11 = 0 ;
26358 octave_value_list _out;
26359 octave_value_list *_outp=&_out;
26360 octave_value _outv;
26361
26362 try {
26363 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26364 SWIG_fail;
26365 }
26366 {
26367 octave_value obj = args(0);
26368#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26369 if ( !obj.isempty() )
26370#else
26371 if ( !obj.is_empty() )
26372#endif
26373 {
26374 if ( obj.is_function_handle() || obj.is_inline_function() )
26375 {
26376 fcnMapForm = obj.function_value();
26377 }
26378 else if ( obj.is_string() )
26379 {
26380 nameMapForm = obj.string_value();
26381 fcnMapForm = NULL;
26382 }
26383 arg1 = mapform_octave;
26384 }
26385 else
26386 {
26387 arg1 = NULL;
26388 }
26389 }
26390 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26391 if (!SWIG_IsOK(res2)) {
26392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26393 }
26394 arg2 = reinterpret_cast< char * >(buf2);
26395 ecode3 = SWIG_AsVal_double(args(2), &val3);
26396 if (!SWIG_IsOK(ecode3)) {
26397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26398 }
26399 arg3 = static_cast< PLFLT >(val3);
26400 ecode4 = SWIG_AsVal_double(args(3), &val4);
26401 if (!SWIG_IsOK(ecode4)) {
26402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26403 }
26404 arg4 = static_cast< PLFLT >(val4);
26405 ecode5 = SWIG_AsVal_double(args(4), &val5);
26406 if (!SWIG_IsOK(ecode5)) {
26407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26408 }
26409 arg5 = static_cast< PLFLT >(val5);
26410 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26411 if (!SWIG_IsOK(res6)) {
26412 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26413 }
26414 arg6 = reinterpret_cast< char * >(buf6);
26415 ecode7 = SWIG_AsVal_double(args(6), &val7);
26416 if (!SWIG_IsOK(ecode7)) {
26417 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26418 }
26419 arg7 = static_cast< PLFLT >(val7);
26420 ecode8 = SWIG_AsVal_double(args(7), &val8);
26421 if (!SWIG_IsOK(ecode8)) {
26422 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26423 }
26424 arg8 = static_cast< PLFLT >(val8);
26425 ecode9 = SWIG_AsVal_double(args(8), &val9);
26426 if (!SWIG_IsOK(ecode9)) {
26427 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26428 }
26429 arg9 = static_cast< PLFLT >(val9);
26430 ecode10 = SWIG_AsVal_double(args(9), &val10);
26431 if (!SWIG_IsOK(ecode10)) {
26432 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26433 }
26434 arg10 = static_cast< PLFLT >(val10);
26435 ecode11 = SWIG_AsVal_int(args(10), &val11);
26436 if (!SWIG_IsOK(ecode11)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26438 }
26439 arg11 = static_cast< PLINT >(val11);
26440 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26441 _outv = octave_value();
26442 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26443 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26444 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26445 return _out;
26446 fail:
26447 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26448 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26449 return octave_value_list();
26450 }
26451 catch(...) {
26452 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26453 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26454 throw;
26455 }
26456}
26457
26458
26460 mapform_func arg1 = (mapform_func) 0 ;
26461 char *arg2 = (char *) 0 ;
26462 PLFLT arg3 ;
26463 PLFLT arg4 ;
26464 PLFLT arg5 ;
26465 PLFLT arg6 ;
26466 PLINT *arg7 = (PLINT *) 0 ;
26467 PLINT arg8 ;
26468 int res2 ;
26469 char *buf2 = 0 ;
26470 int alloc2 = 0 ;
26471 double val3 ;
26472 int ecode3 = 0 ;
26473 double val4 ;
26474 int ecode4 = 0 ;
26475 double val5 ;
26476 int ecode5 = 0 ;
26477 double val6 ;
26478 int ecode6 = 0 ;
26479 Matrix temp7 ;
26480 octave_value_list _out;
26481 octave_value_list *_outp=&_out;
26482 octave_value _outv;
26483
26484 try {
26485 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26486 SWIG_fail;
26487 }
26488 {
26489 octave_value obj = args(0);
26490#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26491 if ( !obj.isempty() )
26492#else
26493 if ( !obj.is_empty() )
26494#endif
26495 {
26496 if ( obj.is_function_handle() || obj.is_inline_function() )
26497 {
26498 fcnMapForm = obj.function_value();
26499 }
26500 else if ( obj.is_string() )
26501 {
26502 nameMapForm = obj.string_value();
26503 fcnMapForm = NULL;
26504 }
26505 arg1 = mapform_octave;
26506 }
26507 else
26508 {
26509 arg1 = NULL;
26510 }
26511 }
26512 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26513 if (!SWIG_IsOK(res2)) {
26514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26515 }
26516 arg2 = reinterpret_cast< char * >(buf2);
26517 ecode3 = SWIG_AsVal_double(args(2), &val3);
26518 if (!SWIG_IsOK(ecode3)) {
26519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26520 }
26521 arg3 = static_cast< PLFLT >(val3);
26522 ecode4 = SWIG_AsVal_double(args(3), &val4);
26523 if (!SWIG_IsOK(ecode4)) {
26524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26525 }
26526 arg4 = static_cast< PLFLT >(val4);
26527 ecode5 = SWIG_AsVal_double(args(4), &val5);
26528 if (!SWIG_IsOK(ecode5)) {
26529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26530 }
26531 arg5 = static_cast< PLFLT >(val5);
26532 ecode6 = SWIG_AsVal_double(args(5), &val6);
26533 if (!SWIG_IsOK(ecode6)) {
26534 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26535 }
26536 arg6 = static_cast< PLFLT >(val6);
26537 {
26538 if ( _n_dims( args(6) ) > 1 )
26539 {
26540 error( "argument must be a scalar or vector" ); SWIG_fail;
26541 }
26542#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26543 if ( !args(6).isempty() )
26544#else
26545 if ( !args(6).is_empty() )
26546#endif
26547 {
26548 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26549 temp7 = args(6).matrix_value();
26550 arg7 = new PLINT[arg8];
26551 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26552 }
26553 else
26554 {
26555 arg7 = NULL;
26556 arg8 = 0;
26557 }
26558 }
26559 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26560 _outv = octave_value();
26561 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26562 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26563 {
26564 delete [] arg7;
26565 }
26566 return _out;
26567 fail:
26568 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26569 {
26570 delete [] arg7;
26571 }
26572 return octave_value_list();
26573 }
26574 catch(...) {
26575 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26576 {
26577 delete [] arg7;
26578 }
26579 throw;
26580 }
26581}
26582
26583
26585 mapform_func arg1 = (mapform_func) 0 ;
26586 PLFLT arg2 ;
26587 PLFLT arg3 ;
26588 PLFLT arg4 ;
26589 PLFLT arg5 ;
26590 PLFLT arg6 ;
26591 PLFLT arg7 ;
26592 double val2 ;
26593 int ecode2 = 0 ;
26594 double val3 ;
26595 int ecode3 = 0 ;
26596 double val4 ;
26597 int ecode4 = 0 ;
26598 double val5 ;
26599 int ecode5 = 0 ;
26600 double val6 ;
26601 int ecode6 = 0 ;
26602 double val7 ;
26603 int ecode7 = 0 ;
26604 octave_value_list _out;
26605 octave_value_list *_outp=&_out;
26606 octave_value _outv;
26607
26608 try {
26609 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26610 SWIG_fail;
26611 }
26612 {
26613 octave_value obj = args(0);
26614#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26615 if ( !obj.isempty() )
26616#else
26617 if ( !obj.is_empty() )
26618#endif
26619 {
26620 if ( obj.is_function_handle() || obj.is_inline_function() )
26621 {
26622 fcnMapForm = obj.function_value();
26623 }
26624 else if ( obj.is_string() )
26625 {
26626 nameMapForm = obj.string_value();
26627 fcnMapForm = NULL;
26628 }
26629 arg1 = mapform_octave;
26630 }
26631 else
26632 {
26633 arg1 = NULL;
26634 }
26635 }
26636 ecode2 = SWIG_AsVal_double(args(1), &val2);
26637 if (!SWIG_IsOK(ecode2)) {
26638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26639 }
26640 arg2 = static_cast< PLFLT >(val2);
26641 ecode3 = SWIG_AsVal_double(args(2), &val3);
26642 if (!SWIG_IsOK(ecode3)) {
26643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26644 }
26645 arg3 = static_cast< PLFLT >(val3);
26646 ecode4 = SWIG_AsVal_double(args(3), &val4);
26647 if (!SWIG_IsOK(ecode4)) {
26648 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26649 }
26650 arg4 = static_cast< PLFLT >(val4);
26651 ecode5 = SWIG_AsVal_double(args(4), &val5);
26652 if (!SWIG_IsOK(ecode5)) {
26653 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26654 }
26655 arg5 = static_cast< PLFLT >(val5);
26656 ecode6 = SWIG_AsVal_double(args(5), &val6);
26657 if (!SWIG_IsOK(ecode6)) {
26658 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26659 }
26660 arg6 = static_cast< PLFLT >(val6);
26661 ecode7 = SWIG_AsVal_double(args(6), &val7);
26662 if (!SWIG_IsOK(ecode7)) {
26663 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26664 }
26665 arg7 = static_cast< PLFLT >(val7);
26666 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26667 _outv = octave_value();
26668 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26669 return _out;
26670 fail:
26671 return octave_value_list();
26672 }
26673 catch(...) {
26674 throw;
26675 }
26676}
26677
26678
26680 octave_value_list _out;
26681 octave_value_list *_outp=&_out;
26682 octave_value _outv;
26683
26684 try {
26685 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26686 SWIG_fail;
26687 }
26688 plClearOpts();
26689 _outv = octave_value();
26690 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26691 return _out;
26692 fail:
26693 return octave_value_list();
26694 }
26695 catch(...) {
26696 throw;
26697 }
26698}
26699
26700
26702 octave_value_list _out;
26703 octave_value_list *_outp=&_out;
26704 octave_value _outv;
26705
26706 try {
26707 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26708 SWIG_fail;
26709 }
26710 plResetOpts();
26711 _outv = octave_value();
26712 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26713 return _out;
26714 fail:
26715 return octave_value_list();
26716 }
26717 catch(...) {
26718 throw;
26719 }
26720}
26721
26722
26724 char *arg1 = (char *) 0 ;
26725 char *arg2 = (char *) 0 ;
26726 int res1 ;
26727 char *buf1 = 0 ;
26728 int alloc1 = 0 ;
26729 int res2 ;
26730 char *buf2 = 0 ;
26731 int alloc2 = 0 ;
26732 octave_value_list _out;
26733 octave_value_list *_outp=&_out;
26734 octave_value _outv;
26735
26736 try {
26737 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26738 SWIG_fail;
26739 }
26740 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26743 }
26744 arg1 = reinterpret_cast< char * >(buf1);
26745 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26746 if (!SWIG_IsOK(res2)) {
26747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26748 }
26749 arg2 = reinterpret_cast< char * >(buf2);
26750 plSetUsage((char const *)arg1,(char const *)arg2);
26751 _outv = octave_value();
26752 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26753 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26754 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26755 return _out;
26756 fail:
26757 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26758 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26759 return octave_value_list();
26760 }
26761 catch(...) {
26762 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26763 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26764 throw;
26765 }
26766}
26767
26768
26770 octave_value_list _out;
26771 octave_value_list *_outp=&_out;
26772 octave_value _outv;
26773
26774 try {
26775 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26776 SWIG_fail;
26777 }
26778 plOptUsage();
26779 _outv = octave_value();
26780 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26781 return _out;
26782 fail:
26783 return octave_value_list();
26784 }
26785 catch(...) {
26786 throw;
26787 }
26788}
26789
26790
26791
26792static const struct swig_octave_member swig_globals[] = {
26793{"testppchar",_wrap_testppchar,0,0,2,0},
26794{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26795{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26796{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26797{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26798{"plcont0",_wrap_plcont0,0,0,2,0},
26799{"plcont1",_wrap_plcont1,0,0,2,0},
26800{"plcont2",_wrap_plcont2,0,0,2,0},
26801{"plcont2p",_wrap_plcont2p,0,0,2,0},
26802{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26803{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26804{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26805{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26806{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26807{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26808{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26809{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26810{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26811{"plshade1",_wrap_plshade1,0,0,2,0},
26812{"plshade2",_wrap_plshade2,0,0,2,0},
26813{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26814{"plshadesx",_wrap_plshadesx,0,0,2,0},
26815{"plshades1",_wrap_plshades1,0,0,2,0},
26816{"plshades2",_wrap_plshades2,0,0,2,0},
26817{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26818{"plvect1",_wrap_plvect1,0,0,2,0},
26819{"plvect2",_wrap_plvect2,0,0,2,0},
26820{"pplimage",_wrap_pplimage,0,0,2,0},
26821{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26822{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26823{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26824{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26825{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26826{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26827{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26828{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26829{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26830{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26831{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26832{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26833{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26834{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26835{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26836{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26837{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26838{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26839{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26840{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26841{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26842{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26843{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26844{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26845{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26846{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26847{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26848{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26849{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26850{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26851{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26854{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26855{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26856{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26857{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26858{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26859{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26860{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26861{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26862{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26863{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26864{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26865{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26866{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26867{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26868{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26869{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26870{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26871{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26872{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26873{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26874{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26875{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26876{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26877{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26878{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26879{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26880{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26881{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26882{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26883{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26884{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26885{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26886{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26887{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26888{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26889{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26890{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26891{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26892{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26893{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26894{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26895{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26896{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26897{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26898{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26899{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26900{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26901{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26902{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26903{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26904{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26905{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26906{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26907{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26908{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26909{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26910{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26911{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26912{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26913{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26914{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26915{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26916{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26917{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26918{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26919{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26920{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26921{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26922{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26923{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26924{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26925{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26926{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26927{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26928{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26929{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26930{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26931{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26932{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26933{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26934{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26935{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26936{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26937{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26938{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26939{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26940{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26941{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26942{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26943{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26944{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26945{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26946{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26947{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26948{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26949{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26950{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26951{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26952{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26953{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26954{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26955{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26956{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26957{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26958{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26959{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26960{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26961{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26962{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26963{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26964{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26965{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26966{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26967{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26968{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26969{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26970{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26971{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26972{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26973{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26974{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26975{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26976{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26977{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26978{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26979{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26980{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26981{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26982{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26983{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26984{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26985{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26986{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26987{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26988{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26989{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26990{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26991{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26992{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26993{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26994{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26995{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26996{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26997{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26998{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26999{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
27000{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
27001{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
27002{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
27003{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
27004{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
27005{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
27006{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
27007{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
27008{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
27009{0,0,0,0,0,0}
27010};
27011
27012/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
27013
27014static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
27015static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
27016static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
27017static 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};
27018static 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};
27019static 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};
27020static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
27021static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
27022static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
27023
27035
27036static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
27037static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
27038static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
27042static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
27043static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
27044static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
27045
27057
27058
27059/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
27060
27061/* -----------------------------------------------------------------------------
27062 * Type initialization:
27063 * This problem is tough by the requirement that no dynamic
27064 * memory is used. Also, since swig_type_info structures store pointers to
27065 * swig_cast_info structures and swig_cast_info structures store pointers back
27066 * to swig_type_info structures, we need some lookup code at initialization.
27067 * The idea is that swig generates all the structures that are needed.
27068 * The runtime then collects these partially filled structures.
27069 * The SWIG_InitializeModule function takes these initial arrays out of
27070 * swig_module, and does all the lookup, filling in the swig_module.types
27071 * array with the correct data and linking the correct swig_cast_info
27072 * structures together.
27073 *
27074 * The generated swig_type_info structures are assigned statically to an initial
27075 * array. We just loop through that array, and handle each type individually.
27076 * First we lookup if this type has been already loaded, and if so, use the
27077 * loaded structure instead of the generated one. Then we have to fill in the
27078 * cast linked list. The cast data is initially stored in something like a
27079 * two-dimensional array. Each row corresponds to a type (there are the same
27080 * number of rows as there are in the swig_type_initial array). Each entry in
27081 * a column is one of the swig_cast_info structures for that type.
27082 * The cast_initial array is actually an array of arrays, because each row has
27083 * a variable number of columns. So to actually build the cast linked list,
27084 * we find the array of casts associated with the type, and loop through it
27085 * adding the casts to the list. The one last trick we need to do is making
27086 * sure the type pointer in the swig_cast_info struct is correct.
27087 *
27088 * First off, we lookup the cast->type name to see if it is already loaded.
27089 * There are three cases to handle:
27090 * 1) If the cast->type has already been loaded AND the type we are adding
27091 * casting info to has not been loaded (it is in this module), THEN we
27092 * replace the cast->type pointer with the type pointer that has already
27093 * been loaded.
27094 * 2) If BOTH types (the one we are adding casting info to, and the
27095 * cast->type) are loaded, THEN the cast info has already been loaded by
27096 * the previous module so we just ignore it.
27097 * 3) Finally, if cast->type has not already been loaded, then we add that
27098 * swig_cast_info to the linked list (because the cast->type) pointer will
27099 * be correct.
27100 * ----------------------------------------------------------------------------- */
27101
27102#ifdef __cplusplus
27103extern "C" {
27104#if 0
27105} /* c-mode */
27106#endif
27107#endif
27108
27109#if 0
27110#define SWIGRUNTIME_DEBUG
27111#endif
27112
27113#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27114#define SWIG_INIT_CLIENT_DATA_TYPE void *
27115#endif
27116
27117SWIGRUNTIME void
27119 size_t i;
27120 swig_module_info *module_head, *iter;
27121 int init;
27122
27123 /* check to see if the circular list has been setup, if not, set it up */
27124 if (swig_module.next==0) {
27125 /* Initialize the swig_module */
27129 init = 1;
27130 } else {
27131 init = 0;
27132 }
27133
27134 /* Try and load any already created modules */
27135 module_head = SWIG_GetModule(clientdata);
27136 if (!module_head) {
27137 /* This is the first module loaded for this interpreter */
27138 /* so set the swig module into the interpreter */
27139 SWIG_SetModule(clientdata, &swig_module);
27140 } else {
27141 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27142 iter=module_head;
27143 do {
27144 if (iter==&swig_module) {
27145 /* Our module is already in the list, so there's nothing more to do. */
27146 return;
27147 }
27148 iter=iter->next;
27149 } while (iter!= module_head);
27150
27151 /* otherwise we must add our module into the list */
27152 swig_module.next = module_head->next;
27153 module_head->next = &swig_module;
27154 }
27155
27156 /* When multiple interpreters are used, a module could have already been initialized in
27157 a different interpreter, but not yet have a pointer in this interpreter.
27158 In this case, we do not want to continue adding types... everything should be
27159 set up already */
27160 if (init == 0) return;
27161
27162 /* Now work on filling in swig_module.types */
27163#ifdef SWIGRUNTIME_DEBUG
27164 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27165#endif
27166 for (i = 0; i < swig_module.size; ++i) {
27167 swig_type_info *type = 0;
27168 swig_type_info *ret;
27169 swig_cast_info *cast;
27170
27171#ifdef SWIGRUNTIME_DEBUG
27172 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27173#endif
27174
27175 /* if there is another module already loaded */
27176 if (swig_module.next != &swig_module) {
27178 }
27179 if (type) {
27180 /* Overwrite clientdata field */
27181#ifdef SWIGRUNTIME_DEBUG
27182 printf("SWIG_InitializeModule: found type %s\n", type->name);
27183#endif
27185 type->clientdata = swig_module.type_initial[i]->clientdata;
27186#ifdef SWIGRUNTIME_DEBUG
27187 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27188#endif
27189 }
27190 } else {
27191 type = swig_module.type_initial[i];
27192 }
27193
27194 /* Insert casting types */
27195 cast = swig_module.cast_initial[i];
27196 while (cast->type) {
27197
27198 /* Don't need to add information already in the list */
27199 ret = 0;
27200#ifdef SWIGRUNTIME_DEBUG
27201 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27202#endif
27203 if (swig_module.next != &swig_module) {
27205#ifdef SWIGRUNTIME_DEBUG
27206 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27207#endif
27208 }
27209 if (ret) {
27210 if (type == swig_module.type_initial[i]) {
27211#ifdef SWIGRUNTIME_DEBUG
27212 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27213#endif
27214 cast->type = ret;
27215 ret = 0;
27216 } else {
27217 /* Check for casting already in the list */
27218 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27219#ifdef SWIGRUNTIME_DEBUG
27220 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27221#endif
27222 if (!ocast) ret = 0;
27223 }
27224 }
27225
27226 if (!ret) {
27227#ifdef SWIGRUNTIME_DEBUG
27228 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27229#endif
27230 if (type->cast) {
27231 type->cast->prev = cast;
27232 cast->next = type->cast;
27233 }
27234 type->cast = cast;
27235 }
27236 cast++;
27237 }
27238 /* Set entry in modules->types array equal to the type */
27239 swig_module.types[i] = type;
27240 }
27241 swig_module.types[i] = 0;
27242
27243#ifdef SWIGRUNTIME_DEBUG
27244 printf("**** SWIG_InitializeModule: Cast List ******\n");
27245 for (i = 0; i < swig_module.size; ++i) {
27246 int j = 0;
27248 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27249 while (cast->type) {
27250 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27251 cast++;
27252 ++j;
27253 }
27254 printf("---- Total casts: %d\n",j);
27255 }
27256 printf("**** SWIG_InitializeModule: Cast List ******\n");
27257#endif
27258}
27259
27260/* This function will propagate the clientdata field of type to
27261* any new swig_type_info structures that have been added into the list
27262* of equivalent types. It is like calling
27263* SWIG_TypeClientData(type, clientdata) a second time.
27264*/
27265SWIGRUNTIME void
27267 size_t i;
27268 swig_cast_info *equiv;
27269 static int init_run = 0;
27270
27271 if (init_run) return;
27272 init_run = 1;
27273
27274 for (i = 0; i < swig_module.size; i++) {
27275 if (swig_module.types[i]->clientdata) {
27276 equiv = swig_module.types[i]->cast;
27277 while (equiv) {
27278 if (!equiv->converter) {
27279 if (equiv->type && !equiv->type->clientdata)
27281 }
27282 equiv = equiv->next;
27283 }
27284 }
27285 }
27286}
27287
27288#ifdef __cplusplus
27289#if 0
27290{ /* c-mode */
27291#endif
27292}
27293#endif
27294
27295
27296
27297static bool SWIG_init_user(octave_swig_type* module_ns);
27298
27300 bool retn = false;
27301 {
27302#if SWIG_OCTAVE_PREREQ(6,0,0)
27303#elif SWIG_OCTAVE_PREREQ(4,2,0)
27304 octave::unwind_protect frame;
27305 frame.protect_var(discard_error_messages); discard_error_messages = true;
27306 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27307#elif SWIG_OCTAVE_PREREQ(3,3,50)
27308 unwind_protect frame;
27309 frame.protect_var(error_state); error_state = 0;
27310 frame.protect_var(warning_state); warning_state = 0;
27311 frame.protect_var(discard_error_messages); discard_error_messages = true;
27312 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27313#else
27314 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27315 unwind_protect_int(error_state); error_state = 0;
27316 unwind_protect_int(warning_state); warning_state = 0;
27317 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27318 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27319#endif
27320#if SWIG_OCTAVE_PREREQ(4,2,0)
27321 try {
27322#if SWIG_OCTAVE_PREREQ(4,4,0)
27323 octave::feval(name, octave_value_list(), 0);
27324#else
27325 feval(name, octave_value_list(), 0);
27326#endif
27327 retn = true;
27328 } catch (octave::execution_exception&) { }
27329#else
27330 feval(name, octave_value_list(), 0);
27331 retn = (error_state == 0);
27332#endif
27333#if !SWIG_OCTAVE_PREREQ(3,3,50)
27334 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27335#endif
27336 }
27337 if (!retn) {
27338 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27339 }
27340 return retn;
27341}
27342
27343SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27344 bool retn = false;
27345 {
27346#if SWIG_OCTAVE_PREREQ(6,0,0)
27347#elif SWIG_OCTAVE_PREREQ(4,2,0)
27348 octave::unwind_protect frame;
27349 frame.protect_var(discard_error_messages); discard_error_messages = true;
27350 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27351#elif SWIG_OCTAVE_PREREQ(3,3,50)
27352 unwind_protect frame;
27353 frame.protect_var(error_state); error_state = 0;
27354 frame.protect_var(warning_state); warning_state = 0;
27355 frame.protect_var(discard_error_messages); discard_error_messages = true;
27356 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27357#else
27358 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27359 unwind_protect_int(error_state); error_state = 0;
27360 unwind_protect_int(warning_state); warning_state = 0;
27361 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27362 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27363#endif
27364 octave_value_list args;
27365 args.append(name);
27366 args.append(octloadfcn->fcn_file_name());
27367#if SWIG_OCTAVE_PREREQ(4,2,0)
27368 try {
27369#if SWIG_OCTAVE_PREREQ(4,4,0)
27370 octave::feval("autoload", args, 0);
27371#else
27372 feval("autoload", args, 0);
27373#endif
27374 retn = true;
27375 } catch (octave::execution_exception&) { }
27376#else
27377 feval("autoload", args, 0);
27378 retn = (error_state == 0);
27379#endif
27380#if !SWIG_OCTAVE_PREREQ(3,3,50)
27381 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27382#endif
27383 }
27384 if (!retn) {
27385 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27386 }
27387 return retn;
27388}
27389
27390static const char *const subclass_usage = "-*- texinfo -*- \n\
27391@deftypefn {Loadable Function} {} subclass()\n\
27392@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27393Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27394\n\
27395See the SWIG manual for usage examples.\n\
27396@end deftypefn";
27397
27398DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27400 for (int j = 0; j < args.length(); ++j) {
27401 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27402 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27403 octave_swig_type *ost = osr->get_ptr();
27404 if (!ost->is_owned()) {
27405 error("subclass: cannot subclass object not constructed on octave side");
27406 return octave_value_list();
27407 }
27408 top->merge(*ost);
27409 } else if (args(j).is_function_handle()) {
27410 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27411 } else if (args(j).is_string()) {
27412 if (j + 1 >= args.length()) {
27413 error("subclass: member assignments must be of string,value form");
27414 return octave_value_list();
27415 }
27416 top->assign(args(j).string_value(), args(j + 1));
27417 ++j;
27418 } else {
27419 error("subclass: invalid arguments to subclass()");
27420 return octave_value_list();
27421 }
27422 }
27423 return octave_value(Swig::swig_value_ref(top));
27424}
27425
27426static const char *const swig_type_usage = "-*- texinfo -*- \n\
27427@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27428Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27429@end deftypefn";
27430
27431DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27432 if (args.length() != 1) {
27433 error("swig_type: must be called with only a single object");
27434 return octave_value_list();
27435 }
27437 if (!ost) {
27438 error("swig_type: object is not a swig_ref");
27439 return octave_value_list();
27440 }
27441 return octave_value(ost->swig_type_name());
27442}
27443
27444static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27445@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27446Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27447otherwise return `<unknown>'.\n\
27448@end deftypefn";
27449
27450DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27451 if (args.length() != 1 || !args(0).is_string()) {
27452 error("swig_typequery: must be called with single string argument");
27453 return octave_value_list();
27454 }
27455 swig_module_info *module = SWIG_GetModule(0);
27456 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27457 if (!type)
27458 return octave_value("<unknown>");
27459 return octave_value(type->name);
27460}
27461
27462static const char *const swig_this_usage = "-*- texinfo -*- \n\
27463@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27464Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27465@end deftypefn";
27466
27467DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27468 if (args.length() != 1) {
27469 error("swig_this: must be called with only a single object");
27470 return octave_value_list();
27471 }
27472 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27473 return octave_value(octave_uint64(0));
27475 if (!ost) {
27476 error("swig_this: object is not a swig_ref");
27477 return octave_value_list();
27478 }
27479 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27480}
27481
27482static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27483@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27484Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27485@end deftypefn";
27486
27487DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27488 if (args.length() != 3) {
27489 error("swig_octave_prereq: must be called with 3 arguments");
27490 return octave_value_list();
27491 }
27492 const int major = args(0).int_value();
27493 const int minor = args(1).int_value();
27494 const int patch = args(2).int_value();
27495 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27496 return octave_value(prereq);
27497}
27498
27499static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27500@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27501Exit Octave without performing any memory cleanup.\n\
27502@end deftypefn";
27503
27504DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27505 if (args.length() > 1) {
27506 error("swig_exit: must be called with at most one arguments");
27507 return octave_value_list();
27508 }
27509 int exit_status = 0;
27510 if (args.length() == 1) {
27511 exit_status = args(0).int_value();
27512 }
27513 ::_Exit(exit_status);
27514 return octave_value();
27515}
27516
27517static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27518@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27519Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27520@end deftypefn";
27521
27523
27524 static octave_swig_type* module_ns = 0;
27525
27526 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27527 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27528 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27529 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27530 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27531 // can be turned off with macro definition.
27532#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27533#if !SWIG_OCTAVE_PREREQ(4,4,0)
27534#if SWIG_OCTAVE_PREREQ(3,2,0)
27535 octave_exit = ::_Exit;
27536#endif
27537#endif
27538#endif
27539
27540 // check for no input and output args
27541 if (args.length() != 0 || nargout != 0) {
27542 print_usage();
27543 return octave_value_list();
27544 }
27545
27546 // create module on first function call
27547 if (!module_ns) {
27548
27549 // workaround bug in octave where installing global variable of custom type and then
27550 // exiting without explicitly clearing the variable causes octave to segfault.
27551#if SWIG_OCTAVE_PREREQ(3,2,0)
27552 octave_value_list eval_args;
27553 eval_args.append("base");
27554 eval_args.append("function __swig_atexit__; "
27555 " if mislocked() "
27556 " clear -all; "
27557 " else "
27558 " mlock(); "
27559 " endif; "
27560 "endfunction; "
27561 "__swig_atexit__; "
27562 "atexit(\"__swig_atexit__\", false); "
27563 "atexit(\"__swig_atexit__\")");
27564#if SWIG_OCTAVE_PREREQ(4,4,0)
27565 octave::feval("evalin", eval_args, 0);
27566#else
27567 feval("evalin", eval_args, 0);
27568#endif
27569#endif
27570
27571#if SWIG_OCTAVE_PREREQ(4,4,0)
27572 {
27573 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27574 string_vector types = typeinfo.installed_type_names();
27575 bool register_octave_swig_ref = true;
27576 bool register_octave_swig_packed = true;
27577 for (int i = 0; i < types.numel(); ++i) {
27578 if (types(i) == octave_swig_ref::static_type_name()) {
27579 register_octave_swig_ref = false;
27580 octave_swig_ref::set_type_id(i);
27581 }
27582 if (types(i) == octave_swig_packed::static_type_name()) {
27583 register_octave_swig_packed = false;
27584 octave_swig_packed::set_type_id(i);
27585 }
27586 }
27587 if (register_octave_swig_ref) {
27588 octave_swig_ref::register_type();
27589 }
27590 if (register_octave_swig_packed) {
27591 octave_swig_packed::register_type();
27592 }
27593 }
27594#else
27595 octave_swig_ref::register_type();
27596 octave_swig_packed::register_type();
27597#endif
27600
27601#if SWIG_OCTAVE_PREREQ(8,0,0)
27602 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27603 octave_function *me = tree_eval.current_function();
27604#elif SWIG_OCTAVE_PREREQ(6,0,0)
27605 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27606 octave::call_stack& stack = tree_eval.get_call_stack();
27607 octave_function *me = stack.current_function();
27608#elif SWIG_OCTAVE_PREREQ(4,4,0)
27609 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27610 octave_function *me = stack.current();
27611#else
27612 octave_function *me = octave_call_stack::current();
27613#endif
27614
27615 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27616 return octave_value_list();
27617 }
27618 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27619 return octave_value_list();
27620 }
27621 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27622 return octave_value_list();
27623 }
27624 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27625 return octave_value_list();
27626 }
27627 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27628 return octave_value_list();
27629 }
27630 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27631 return octave_value_list();
27632 }
27633
27634 octave_swig_type* cvar_ns=0;
27635 if (std::string(SWIG_global_name) != ".") {
27636 cvar_ns=new octave_swig_type;
27637 for (int j=0;swig_globals[j].name;++j)
27638 if (swig_globals[j].get_method)
27639 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27640 }
27641
27642 module_ns=new octave_swig_type(0, 0, 0, true);
27643 if (std::string(SWIG_global_name) != ".") {
27644 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27645 }
27646 else {
27647 for (int j=0;swig_globals[j].name;++j)
27648 if (swig_globals[j].get_method)
27649 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27650 }
27651 for (int j=0;swig_globals[j].name;++j)
27652 if (swig_globals[j].method)
27653 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27654
27655 // * need better solution here; swig_type -> octave_class mapping is
27656 // * really n-to-1, in some cases such as template partial spec, etc.
27657 // * see failing tests.
27658 for (int j=0;swig_types[j];++j)
27659 if (swig_types[j]->clientdata) {
27661 module_ns->assign(c->name,
27663 (new octave_swig_type(0,swig_types[j])));
27664 }
27665
27666 if (!SWIG_init_user(module_ns)) {
27667 delete module_ns;
27668 module_ns=0;
27669 return octave_value_list();
27670 }
27671
27672 SWIG_InstallOps(octave_swig_ref::static_type_id());
27673
27675 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27676 if (mb->second.first && mb->second.first->method) {
27677 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27678 return octave_value_list();
27679 }
27680 }
27681 }
27682
27683#if SWIG_OCTAVE_PREREQ(4,4,0)
27684 octave::interpreter::the_interpreter()->mlock();
27685#elif SWIG_OCTAVE_PREREQ(3,2,0)
27686 mlock();
27687#else
27688 mlock(me->name());
27689#endif
27690
27691 }
27692
27694 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27695 if (mb->second.second.is_defined()) {
27696 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27697 SWIG_Octave_LinkGlobalValue(mb->first);
27698 }
27699 }
27700
27703
27704 return octave_value_list();
27705
27706}
27707
27708
27709static bool SWIG_init_user(octave_swig_type* module_ns)
27710{
27711 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27712 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27713 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27714 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27715 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27716 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27717 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27718 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27719 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27720 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27721 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27722 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27723 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27724 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27725 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27726 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27727 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27728 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27729 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27730 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27731 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27732 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27733 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27734 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27735 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27736 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27737 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27738 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27739 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27740 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27741 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27742 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27743 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27744 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27745 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27746 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27747 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27748 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27749 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27750 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27751 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27752 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27753 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27754 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27755 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27756 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27757 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27758 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27759 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27760 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27761 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27762 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27763 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27764 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27765 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27766 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27767 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27768 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27769 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27770 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27771 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27772 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27773 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27774 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27775 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27811 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27812 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27813 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27814 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27815 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27816 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27817 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27818 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27819 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27820 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27821 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27822 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27823 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27824 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27825 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27826 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27827 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27828 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27829 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27830 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27831 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27832 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27833 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27834 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27835 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27836 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27837 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27838 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27839 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27840 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27841 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27842 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27843 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27844 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27845 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27846 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27847 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27848 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27849 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27850 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27851 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27852 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27853 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27854 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27855 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27856 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27857 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27858 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27859 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27860 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27861 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27862 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27863 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27864 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27865 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27866 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27867 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27868 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27869 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27870 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27871 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27872 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27873 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27874 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27875 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27876 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27877 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27878 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27879 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27880 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27881 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27882 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27883 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27884 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27885 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27886 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27887 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27888 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27889 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27890 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27891 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27892 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27893 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27894 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27895 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27896 return true;
27897}
27898
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
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