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.1.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 0x040101
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//
143// This header includes all C++ headers required for generated Octave wrapper code.
144// Using a single header file allows pre-compilation of Octave headers, as follows:
145// * Check out this header file:
146// swig -octave -co octheaders.hpp
147// * Pre-compile header file into octheaders.hpp.gch:
148// g++ -c ... octheaders.hpp
149// * Use pre-compiled header file:
150// g++ -c -include octheaders.hpp ...
151//
152
153#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
154#define SWIG_OCTAVE_OCTHEADERS_HPP
155
156// Required C++ headers
157#include <cstdlib>
158#include <climits>
159#include <iostream>
160#include <exception>
161#include <functional>
162#include <complex>
163#include <string>
164#include <vector>
165#include <map>
166
167// Minimal headers to define Octave version
168#include <octave/oct.h>
169#include <octave/version.h>
170
171// Macro for enabling features which require Octave version >= major.minor.patch
172// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
173#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
174 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
175
176// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
177#if !defined(OCTAVE_MAJOR_VERSION)
178
179# if !defined(OCTAVE_API_VERSION_NUMBER)
180
181// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
182// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
183# include <octave/ov.h>
184# if defined(octave_ov_h)
185# define OCTAVE_MAJOR_VERSION 3
186# define OCTAVE_MINOR_VERSION 8
187# define OCTAVE_PATCH_VERSION 0
188# else
189
190// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
191# define ComplexLU __ignore
192# include <octave/CmplxLU.h>
193# undef ComplexLU
194# if defined(octave_Complex_LU_h)
195
196// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
197# define OCTAVE_MAJOR_VERSION 3
198# define OCTAVE_MINOR_VERSION 1
199# define OCTAVE_PATCH_VERSION 99
200
201# else
202
203// OCTAVE_API_VERSION_NUMBER == 37
204# define OCTAVE_MAJOR_VERSION 3
205# define OCTAVE_MINOR_VERSION 2
206# define OCTAVE_PATCH_VERSION 0
207
208# endif // defined(octave_Complex_LU_h)
209
210# endif // defined(octave_ov_h)
211
212// Correlation between Octave API and version numbers extracted from Octave's
213// ChangeLogs; version is the *earliest* released Octave with that API number
214# elif OCTAVE_API_VERSION_NUMBER >= 48
215# define OCTAVE_MAJOR_VERSION 3
216# define OCTAVE_MINOR_VERSION 6
217# define OCTAVE_PATCH_VERSION 0
218
219# elif OCTAVE_API_VERSION_NUMBER >= 45
220# define OCTAVE_MAJOR_VERSION 3
221# define OCTAVE_MINOR_VERSION 4
222# define OCTAVE_PATCH_VERSION 1
223
224# elif OCTAVE_API_VERSION_NUMBER >= 42
225# define OCTAVE_MAJOR_VERSION 3
226# define OCTAVE_MINOR_VERSION 3
227# define OCTAVE_PATCH_VERSION 54
228
229# elif OCTAVE_API_VERSION_NUMBER >= 41
230# define OCTAVE_MAJOR_VERSION 3
231# define OCTAVE_MINOR_VERSION 3
232# define OCTAVE_PATCH_VERSION 53
233
234# elif OCTAVE_API_VERSION_NUMBER >= 40
235# define OCTAVE_MAJOR_VERSION 3
236# define OCTAVE_MINOR_VERSION 3
237# define OCTAVE_PATCH_VERSION 52
238
239# elif OCTAVE_API_VERSION_NUMBER >= 39
240# define OCTAVE_MAJOR_VERSION 3
241# define OCTAVE_MINOR_VERSION 3
242# define OCTAVE_PATCH_VERSION 51
243
244# else // OCTAVE_API_VERSION_NUMBER == 38
245# define OCTAVE_MAJOR_VERSION 3
246# define OCTAVE_MINOR_VERSION 3
247# define OCTAVE_PATCH_VERSION 50
248
249# endif // !defined(OCTAVE_API_VERSION_NUMBER)
250
251#endif // !defined(OCTAVE_MAJOR_VERSION)
252
253// Required Octave headers
254#include <octave/Cell.h>
255#include <octave/dynamic-ld.h>
256#include <octave/oct-env.h>
257#include <octave/oct-map.h>
258#include <octave/ov-scalar.h>
259#include <octave/ov-fcn-handle.h>
260#include <octave/parse.h>
261#if SWIG_OCTAVE_PREREQ(4,2,0)
262#include <octave/interpreter.h>
263#else
264#include <octave/toplev.h>
265#endif
266#include <octave/unwind-prot.h>
267#if SWIG_OCTAVE_PREREQ(4,2,0)
268#include <octave/call-stack.h>
269#endif
270
271#endif // !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
272
273/* -----------------------------------------------------------------------------
274 * swigrun.swg
275 *
276 * This file contains generic C API SWIG runtime support for pointer
277 * type checking.
278 * ----------------------------------------------------------------------------- */
279
280/* This should only be incremented when either the layout of swig_type_info changes,
281 or for whatever reason, the runtime changes incompatibly */
282#define SWIG_RUNTIME_VERSION "4"
283
284/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
285#ifdef SWIG_TYPE_TABLE
286# define SWIG_QUOTE_STRING(x) #x
287# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
288# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
289#else
290# define SWIG_TYPE_TABLE_NAME
291#endif
292
293/*
294 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
295 creating a static or dynamic library from the SWIG runtime code.
296 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
297
298 But only do this if strictly necessary, ie, if you have problems
299 with your compiler or suchlike.
300*/
301
302#ifndef SWIGRUNTIME
303# define SWIGRUNTIME SWIGINTERN
304#endif
305
306#ifndef SWIGRUNTIMEINLINE
307# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
308#endif
309
310/* Generic buffer size */
311#ifndef SWIG_BUFFER_SIZE
312# define SWIG_BUFFER_SIZE 1024
313#endif
314
315/* Flags for pointer conversions */
316#define SWIG_POINTER_DISOWN 0x1
317#define SWIG_CAST_NEW_MEMORY 0x2
318#define SWIG_POINTER_NO_NULL 0x4
319#define SWIG_POINTER_CLEAR 0x8
320#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
321
322/* Flags for new pointer objects */
323#define SWIG_POINTER_OWN 0x1
324
325
326/*
327 Flags/methods for returning states.
328
329 The SWIG conversion methods, as ConvertPtr, return an integer
330 that tells if the conversion was successful or not. And if not,
331 an error code can be returned (see swigerrors.swg for the codes).
332
333 Use the following macros/flags to set or process the returning
334 states.
335
336 In old versions of SWIG, code such as the following was usually written:
337
338 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
339 // success code
340 } else {
341 //fail code
342 }
343
344 Now you can be more explicit:
345
346 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
347 if (SWIG_IsOK(res)) {
348 // success code
349 } else {
350 // fail code
351 }
352
353 which is the same really, but now you can also do
354
355 Type *ptr;
356 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
357 if (SWIG_IsOK(res)) {
358 // success code
359 if (SWIG_IsNewObj(res) {
360 ...
361 delete *ptr;
362 } else {
363 ...
364 }
365 } else {
366 // fail code
367 }
368
369 I.e., now SWIG_ConvertPtr can return new objects and you can
370 identify the case and take care of the deallocation. Of course that
371 also requires SWIG_ConvertPtr to return new result values, such as
372
373 int SWIG_ConvertPtr(obj, ptr,...) {
374 if (<obj is ok>) {
375 if (<need new object>) {
376 *ptr = <ptr to new allocated object>;
377 return SWIG_NEWOBJ;
378 } else {
379 *ptr = <ptr to old object>;
380 return SWIG_OLDOBJ;
381 }
382 } else {
383 return SWIG_BADOBJ;
384 }
385 }
386
387 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
388 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
389 SWIG errors code.
390
391 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
392 allows returning the 'cast rank', for example, if you have this
393
394 int food(double)
395 int fooi(int);
396
397 and you call
398
399 food(1) // cast rank '1' (1 -> 1.0)
400 fooi(1) // cast rank '0'
401
402 just use the SWIG_AddCast()/SWIG_CheckState()
403*/
404
405#define SWIG_OK (0)
406/* Runtime errors are < 0 */
407#define SWIG_ERROR (-1)
408/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
409/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
410/* Errors < -200 are generic runtime specific errors */
411#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
412
413#define SWIG_IsOK(r) (r >= 0)
414#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
415
416/* The CastRankLimit says how many bits are used for the cast rank */
417#define SWIG_CASTRANKLIMIT (1 << 8)
418/* The NewMask denotes the object was created (using new/malloc) */
419#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
420/* The TmpMask is for in/out typemaps that use temporal objects */
421#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
422/* Simple returning values */
423#define SWIG_BADOBJ (SWIG_ERROR)
424#define SWIG_OLDOBJ (SWIG_OK)
425#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
426#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
427/* Check, add and del object mask methods */
428#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
429#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
430#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
431#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
432#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
433#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
434
435/* Cast-Rank Mode */
436#if defined(SWIG_CASTRANK_MODE)
437# ifndef SWIG_TypeRank
438# define SWIG_TypeRank unsigned long
439# endif
440# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
441# define SWIG_MAXCASTRANK (2)
442# endif
443# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
444# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
446 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
447}
449 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
450}
451#else /* no cast-rank mode */
452# define SWIG_AddCast(r) (r)
453# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
454#endif
455
456
457#include <string.h>
458
459#ifdef __cplusplus
460extern "C" {
461#endif
462
463typedef void *(*swig_converter_func)(void *, int *);
464typedef struct swig_type_info *(*swig_dycast_func)(void **);
465
466/* Structure to store information on one type */
467typedef struct swig_type_info {
468 const char *name; /* mangled name of this type */
469 const char *str; /* human readable name of this type */
470 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
471 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
472 void *clientdata; /* language specific type data */
473 int owndata; /* flag if the structure owns the clientdata */
475
476/* Structure to store a type and conversion function used for casting */
477typedef struct swig_cast_info {
478 swig_type_info *type; /* pointer to type that is equivalent to this type */
479 swig_converter_func converter; /* function to cast the void pointers */
480 struct swig_cast_info *next; /* pointer to next cast in linked list */
481 struct swig_cast_info *prev; /* pointer to the previous cast */
483
484/* Structure used to store module information
485 * Each module generates one structure like this, and the runtime collects
486 * all of these structures and stores them in a circularly linked list.*/
487typedef struct swig_module_info {
488 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
489 size_t size; /* Number of types in this module */
490 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
491 swig_type_info **type_initial; /* Array of initially generated type structures */
492 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
493 void *clientdata; /* Language specific module data */
495
496/*
497 Compare two type names skipping the space characters, therefore
498 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
499
500 Return 0 when the two name types are equivalent, as in
501 strncmp, but skipping ' '.
502*/
503SWIGRUNTIME int
504SWIG_TypeNameComp(const char *f1, const char *l1,
505 const char *f2, const char *l2) {
506 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
507 while ((*f1 == ' ') && (f1 != l1)) ++f1;
508 while ((*f2 == ' ') && (f2 != l2)) ++f2;
509 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
510 }
511 return (int)((l1 - f1) - (l2 - f2));
512}
513
514/*
515 Check type equivalence in a name list like <name1>|<name2>|...
516 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
517*/
518SWIGRUNTIME int
519SWIG_TypeCmp(const char *nb, const char *tb) {
520 int equiv = 1;
521 const char* te = tb + strlen(tb);
522 const char* ne = nb;
523 while (equiv != 0 && *ne) {
524 for (nb = ne; *ne; ++ne) {
525 if (*ne == '|') break;
526 }
527 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
528 if (*ne) ++ne;
529 }
530 return equiv;
531}
532
533/*
534 Check type equivalence in a name list like <name1>|<name2>|...
535 Return 0 if not equal, 1 if equal
536*/
537SWIGRUNTIME int
538SWIG_TypeEquiv(const char *nb, const char *tb) {
539 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
540}
541
542/*
543 Check the typename
544*/
546SWIG_TypeCheck(const char *c, swig_type_info *ty) {
547 if (ty) {
548 swig_cast_info *iter = ty->cast;
549 while (iter) {
550 if (strcmp(iter->type->name, c) == 0) {
551 if (iter == ty->cast)
552 return iter;
553 /* Move iter to the top of the linked list */
554 iter->prev->next = iter->next;
555 if (iter->next)
556 iter->next->prev = iter->prev;
557 iter->next = ty->cast;
558 iter->prev = 0;
559 if (ty->cast) ty->cast->prev = iter;
560 ty->cast = iter;
561 return iter;
562 }
563 iter = iter->next;
564 }
565 }
566 return 0;
567}
568
569/*
570 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
571*/
574 if (ty) {
575 swig_cast_info *iter = ty->cast;
576 while (iter) {
577 if (iter->type == from) {
578 if (iter == ty->cast)
579 return iter;
580 /* Move iter to the top of the linked list */
581 iter->prev->next = iter->next;
582 if (iter->next)
583 iter->next->prev = iter->prev;
584 iter->next = ty->cast;
585 iter->prev = 0;
586 if (ty->cast) ty->cast->prev = iter;
587 ty->cast = iter;
588 return iter;
589 }
590 iter = iter->next;
591 }
592 }
593 return 0;
594}
595
596/*
597 Cast a pointer up an inheritance hierarchy
598*/
600SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
601 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
602}
603
604/*
605 Dynamic pointer casting. Down an inheritance hierarchy
606*/
609 swig_type_info *lastty = ty;
610 if (!ty || !ty->dcast) return ty;
611 while (ty && (ty->dcast)) {
612 ty = (*ty->dcast)(ptr);
613 if (ty) lastty = ty;
614 }
615 return lastty;
616}
617
618/*
619 Return the name associated with this type
620*/
621SWIGRUNTIMEINLINE const char *
623 return ty->name;
624}
625
626/*
627 Return the pretty name associated with this type,
628 that is an unmangled type name in a form presentable to the user.
629*/
630SWIGRUNTIME const char *
632 /* The "str" field contains the equivalent pretty names of the
633 type, separated by vertical-bar characters. Choose the last
634 name. It should be the most specific; a fully resolved name
635 but not necessarily with default template parameters expanded. */
636 if (!type) return NULL;
637 if (type->str != NULL) {
638 const char *last_name = type->str;
639 const char *s;
640 for (s = type->str; *s; s++)
641 if (*s == '|') last_name = s+1;
642 return last_name;
643 }
644 else
645 return type->name;
646}
647
648/*
649 Set the clientdata field for a type
650*/
651SWIGRUNTIME void
653 swig_cast_info *cast = ti->cast;
654 /* if (ti->clientdata == clientdata) return; */
656
657 while (cast) {
658 if (!cast->converter) {
659 swig_type_info *tc = cast->type;
660 if (!tc->clientdata) {
662 }
663 }
664 cast = cast->next;
665 }
666}
667SWIGRUNTIME void
670 ti->owndata = 1;
671}
672
673/*
674 Search for a swig_type_info structure only by mangled name
675 Search is a O(log #types)
676
677 We start searching at module start, and finish searching when start == end.
678 Note: if start == end at the beginning of the function, we go all the way around
679 the circular list.
680*/
683 swig_module_info *end,
684 const char *name) {
685 swig_module_info *iter = start;
686 do {
687 if (iter->size) {
688 size_t l = 0;
689 size_t r = iter->size - 1;
690 do {
691 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
692 size_t i = (l + r) >> 1;
693 const char *iname = iter->types[i]->name;
694 if (iname) {
695 int compare = strcmp(name, iname);
696 if (compare == 0) {
697 return iter->types[i];
698 } else if (compare < 0) {
699 if (i) {
700 r = i - 1;
701 } else {
702 break;
703 }
704 } else if (compare > 0) {
705 l = i + 1;
706 }
707 } else {
708 break; /* should never happen */
709 }
710 } while (l <= r);
711 }
712 iter = iter->next;
713 } while (iter != end);
714 return 0;
715}
716
717/*
718 Search for a swig_type_info structure for either a mangled name or a human readable name.
719 It first searches the mangled names of the types, which is a O(log #types)
720 If a type is not found it then searches the human readable names, which is O(#types).
721
722 We start searching at module start, and finish searching when start == end.
723 Note: if start == end at the beginning of the function, we go all the way around
724 the circular list.
725*/
728 swig_module_info *end,
729 const char *name) {
730 /* STEP 1: Search the name field using binary search */
732 if (ret) {
733 return ret;
734 } else {
735 /* STEP 2: If the type hasn't been found, do a complete search
736 of the str field (the human readable name) */
737 swig_module_info *iter = start;
738 do {
739 size_t i = 0;
740 for (; i < iter->size; ++i) {
741 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
742 return iter->types[i];
743 }
744 iter = iter->next;
745 } while (iter != end);
746 }
747
748 /* neither found a match */
749 return 0;
750}
751
752/*
753 Pack binary data into a string
754*/
755SWIGRUNTIME char *
756SWIG_PackData(char *c, void *ptr, size_t sz) {
757 static const char hex[17] = "0123456789abcdef";
758 const unsigned char *u = (unsigned char *) ptr;
759 const unsigned char *eu = u + sz;
760 for (; u != eu; ++u) {
761 unsigned char uu = *u;
762 *(c++) = hex[(uu & 0xf0) >> 4];
763 *(c++) = hex[uu & 0xf];
764 }
765 return c;
766}
767
768/*
769 Unpack binary data from a string
770*/
771SWIGRUNTIME const char *
772SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
773 unsigned char *u = (unsigned char *) ptr;
774 const unsigned char *eu = u + sz;
775 for (; u != eu; ++u) {
776 char d = *(c++);
777 unsigned char uu;
778 if ((d >= '0') && (d <= '9'))
779 uu = (unsigned char)((d - '0') << 4);
780 else if ((d >= 'a') && (d <= 'f'))
781 uu = (unsigned char)((d - ('a'-10)) << 4);
782 else
783 return (char *) 0;
784 d = *(c++);
785 if ((d >= '0') && (d <= '9'))
786 uu |= (unsigned char)(d - '0');
787 else if ((d >= 'a') && (d <= 'f'))
788 uu |= (unsigned char)(d - ('a'-10));
789 else
790 return (char *) 0;
791 *u = uu;
792 }
793 return c;
794}
795
796/*
797 Pack 'void *' into a string buffer.
798*/
799SWIGRUNTIME char *
800SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
801 char *r = buff;
802 if ((2*sizeof(void *) + 2) > bsz) return 0;
803 *(r++) = '_';
804 r = SWIG_PackData(r,&ptr,sizeof(void *));
805 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
806 strcpy(r,name);
807 return buff;
808}
809
810SWIGRUNTIME const char *
811SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
812 if (*c != '_') {
813 if (strcmp(c,"NULL") == 0) {
814 *ptr = (void *) 0;
815 return name;
816 } else {
817 return 0;
818 }
819 }
820 return SWIG_UnpackData(++c,ptr,sizeof(void *));
821}
822
823SWIGRUNTIME char *
824SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
825 char *r = buff;
826 size_t lname = (name ? strlen(name) : 0);
827 if ((2*sz + 2 + lname) > bsz) return 0;
828 *(r++) = '_';
829 r = SWIG_PackData(r,ptr,sz);
830 if (lname) {
831 strncpy(r,name,lname+1);
832 } else {
833 *r = 0;
834 }
835 return buff;
836}
837
838SWIGRUNTIME const char *
839SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
840 if (*c != '_') {
841 if (strcmp(c,"NULL") == 0) {
842 memset(ptr,0,sz);
843 return name;
844 } else {
845 return 0;
846 }
847 }
848 return SWIG_UnpackData(++c,ptr,sz);
849}
850
851#ifdef __cplusplus
852}
853#endif
854
855/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
856#define SWIG_UnknownError -1
857#define SWIG_IOError -2
858#define SWIG_RuntimeError -3
859#define SWIG_IndexError -4
860#define SWIG_TypeError -5
861#define SWIG_DivisionByZero -6
862#define SWIG_OverflowError -7
863#define SWIG_SyntaxError -8
864#define SWIG_ValueError -9
865#define SWIG_SystemError -10
866#define SWIG_AttributeError -11
867#define SWIG_MemoryError -12
868#define SWIG_NullReferenceError -13
869
870
871#if !SWIG_OCTAVE_PREREQ(3,2,0)
872#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
873#else
874#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
875#endif
876
877SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
878 if (num_args > max_args && !varargs)
879 error("function %s takes at most %i arguments", func_name, max_args);
880 else if (num_args < min_args)
881 error("function %s requires at least %i arguments", func_name, min_args);
882 else
883 return true;
884 return false;
885}
886
887SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
888 ovl->append(ov);
889 return ovl;
890}
891
892SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
893 switch (code) {
894 case SWIG_MemoryError:
895 return "SWIG_MemoryError";
896 case SWIG_IOError:
897 return "SWIG_IOError";
899 return "SWIG_RuntimeError";
900 case SWIG_IndexError:
901 return "SWIG_IndexError";
902 case SWIG_TypeError:
903 return "SWIG_TypeError";
905 return "SWIG_DivisionByZero";
907 return "SWIG_OverflowError";
908 case SWIG_SyntaxError:
909 return "SWIG_SyntaxError";
910 case SWIG_ValueError:
911 return "SWIG_ValueError";
912 case SWIG_SystemError:
913 return "SWIG_SystemError";
915 return "SWIG_AttributeError";
916 }
917 return "SWIG unknown error";
918}
919
920SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
921 octave_value type(SWIG_ErrorType(code));
922 std::string r = msg;
923 r += " (" + type.string_value() + ")";
924 error("%s", r.c_str());
925 return octave_value(r);
926}
927
928#define SWIG_fail goto fail
929
930#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
931#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
932#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
933#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
934#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
935#define swig_owntype int
936
937#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
938#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
939
940#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
941#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
942
943#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
944#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
945
946#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
947#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
948#define SWIG_MODULE_CLIENTDATA_TYPE void*
949
950#define Octave_Error_Occurred() 0
951#define SWIG_Octave_AddErrorMsg(msg) {;}
952
955
956// For backward compatibility only
957#define SWIG_POINTER_EXCEPTION 0
958#define SWIG_arg_fail(arg) 0
959
960// Runtime API implementation
961
962typedef octave_value_list(*octave_func) (const octave_value_list &, int);
963class octave_swig_type;
964
965namespace Swig {
966
967#ifdef SWIG_DIRECTORS
968
969 class Director;
970
971 typedef std::map < void *, Director * > rtdir_map;
972 SWIGINTERN rtdir_map* get_rtdir_map();
973 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
974 SWIGINTERNINLINE void erase_rtdir(void *vptr);
975 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
976
977 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
978 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
979 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
980
981#endif
982
983 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
985 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
986}
987
988#ifdef SWIG_DIRECTORS
989SWIGRUNTIME void swig_acquire_ownership(void *vptr);
990SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
991SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
992#endif
993
995 const char *name;
999 int flags; // 1 static, 2 global
1000 const char *doc;
1001 bool is_static() const {
1002 return flags &1;
1003 } bool is_global() const {
1004 return flags &2;
1005 }
1006 };
1007
1009 const char *name;
1013 const char *constructor_doc;
1016 const char **base_names;
1018 };
1019
1020#if SWIG_OCTAVE_PREREQ(4,4,0)
1021 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1022 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1023#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1024 class octave_swig_bound_func : public octave_function {
1025 public:
1026
1027 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1028 { }
1029
1030 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1031 : octave_function("", ""), method(_method), first_args(_first_args)
1032 { }
1033
1034 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1035
1036 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1037
1038 ~octave_swig_bound_func(void) = default;
1039
1040 bool is_function(void) const { return true; }
1041
1042 octave_function* function_value(bool = false) { return this; }
1043
1044#if SWIG_OCTAVE_PREREQ(6,0,0)
1045 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1046 return execute(tw,nargout,args);
1047 }
1048#endif
1049#if SWIG_OCTAVE_PREREQ(6,0,0)
1050 octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1051#else
1052 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1053#endif
1054 octave_value_list all_args;
1055 all_args.append(first_args);
1056 all_args.append(args);
1057 return method->call(tw, nargout, all_args);
1058 }
1059
1060 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1061 octave_value_list ovl = subsref(ops, idx, 1);
1062 return ovl.length() ? ovl(0) : octave_value();
1063 }
1064
1065 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1066 assert(ops.size() > 0);
1067 assert(ops.size() == idx.size());
1068 if (ops != "(")
1069 error("invalid function call");
1070 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1071 return call(tw, nargout, *idx.begin());
1072 }
1073
1074 protected:
1075
1076 octave_function* method;
1077 octave_value_list first_args;
1078
1079 std::set<std::string> dispatch_classes;
1080
1081 };
1082#else
1083#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1084#endif
1085
1086 // octave_swig_type plays the role of both the shadow class and the class
1087 // representation within Octave, since there is no support for classes.
1088 //
1089 // These should really be decoupled, with the class support added to Octave
1090 // and the shadow class given by an m-file script. That would dramatically
1091 // reduce the runtime complexity, and be more in line w/ other modules.
1092
1093 class octave_swig_type:public octave_base_value {
1094 struct cpp_ptr {
1095 void *ptr;
1097 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1098 }};
1099 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1100
1102
1103 const swig_type_info *construct_type; // type of special type object
1104 std::vector < type_ptr_pair > types; // our c++ base classes
1105 int thisown; // whether we call c++ destructors when we die
1106
1107 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1108 typedef std::map < std::string, member_value_pair > member_map;
1111
1112 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1113 if (!type->clientdata)
1114 return 0;
1116 const swig_octave_member *m;
1117 for (m = c->members; m->name; ++m)
1118 if (m->name == name)
1119 return m;
1120 for (int j = 0; c->base_names[j]; ++j) {
1121 if (!c->base[j]) {
1122 if (!module)
1123 module = SWIG_GetModule(0);
1124 assert(module);
1125 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1126 }
1127 if (!c->base[j])
1128 return 0;
1129 if ((m = find_member(c->base[j], name)))
1130 return m;
1131 }
1132 return 0;
1133 }
1134
1135 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1136 member_map::iterator it = members.find(name);
1137 if (it != members.end())
1138 return &it->second;
1139 const swig_octave_member *m;
1140 for (unsigned int j = 0; j < types.size(); ++j)
1141 if ((m = find_member(types[j].first, name)))
1142 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1143 if (!insert_if_not_found)
1144 return 0;
1145 return &members[name];
1146 }
1147
1148 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1149 if (!base) {
1150 for (unsigned int j = 0; j < types.size(); ++j) {
1151 assert(types[j].first->clientdata);
1152 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1153 if (cj->name == name)
1154 return types[j].first;
1155 }
1156 return 0;
1157 }
1158 assert(base->clientdata);
1160 for (int j = 0; c->base_names[j]; ++j) {
1161 if (!c->base[j]) {
1162 if (!module)
1163 module = SWIG_GetModule(0);
1164 assert(module);
1165 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1166 }
1167 if (!c->base[j])
1168 return 0;
1169 assert(c->base[j]->clientdata);
1171 if (cj->name == name)
1172 return c->base[j];
1173 }
1174 return 0;
1175 }
1176
1177 void load_members(const swig_octave_class* c,member_map& out) const {
1178 for (const swig_octave_member *m = c->members; m->name; ++m) {
1179 if (out.find(m->name) == out.end())
1180 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1181 }
1182 for (int j = 0; c->base_names[j]; ++j) {
1183 if (!c->base[j]) {
1184 if (!module)
1185 module = SWIG_GetModule(0);
1186 assert(module);
1187 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1188 }
1189 if (!c->base[j])
1190 continue;
1191 assert(c->base[j]->clientdata);
1192 const swig_octave_class *cj =
1193 (const swig_octave_class *) c->base[j]->clientdata;
1194 load_members(cj,out);
1195 }
1196 }
1197
1198 void load_members(member_map& out) const {
1199 out=members;
1200 for (unsigned int j = 0; j < types.size(); ++j)
1201 if (types[j].first->clientdata)
1202 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1203 }
1204
1205 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1206 if (m->second.is_defined())
1207 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1208 else if (m->first && m->first->method)
1209 return m->first->method(args, nargout);
1210 error("member not defined or not invocable");
1211 return octave_value_list();
1212 }
1213
1214 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1215 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1216 member_value_pair *m = nc_this->find_member(symbol, false);
1217 if (!m || m->first->is_static() || m->first->is_global())
1218 return false;
1219 octave_value_list args;
1220 args.append(nc_this->as_value());
1221 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1222 if (argout.length() < 1)
1223 return false;
1224 ret = argout(0);
1225 return true;
1226 }
1227
1228 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1229 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1230 member_value_pair *m = nc_this->find_member(symbol, false);
1231 if (!m || m->first->is_static() || m->first->is_global())
1232 return false;
1233 octave_value_list args;
1234 args.append(nc_this->as_value());
1235 args.append(make_value_hack(rhs));
1236 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1237 if (argout.length() < 1)
1238 return false;
1239 ret = argout(0);
1240 return true;
1241 }
1242
1243 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1244 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1245 member_value_pair *m = nc_this->find_member(symbol, false);
1246 if (!m || m->first->is_static() || m->first->is_global())
1247 return false;
1248 octave_value_list args;
1249 args.append(nc_this->as_value());
1250 args.append(rhs);
1251 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1252 if (argout.length() >= 1)
1253 ret = argout(0);
1254 return true;
1255 }
1256
1257 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1258 if (m->second.is_defined()) {
1259 if (m->second.is_function() || m->second.is_function_handle()) {
1260 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1261 } else {
1262 return m->second;
1263 }
1264 } else if (m->first) {
1265 if (m->first->get_method)
1266 return m->first->get_method(args, 1);
1267 else if (m->first->method)
1268 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1269 }
1270 error("undefined member");
1271 return octave_value_list();
1272 }
1273
1274 static octave_value make_value_hack(const octave_base_value &x) {
1275 ((octave_swig_type &) x).count++;
1276 return octave_value((octave_base_value *) &x);
1277 }
1278
1281 public:
1282
1283 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1284 bool _always_static = false)
1285 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1286 always_static(_always_static) {
1287 if (_type || _ptr)
1288 types.push_back(std::make_pair(_type, _ptr));
1289#ifdef SWIG_DIRECTORS
1290 if (_ptr) {
1291 Swig::Director *d = Swig::get_rtdir(_ptr);
1292 if (d)
1293 Swig::swig_director_set_self(d, this);
1294 }
1295#endif
1296 }
1297
1299 if (thisown) {
1300 ++count;
1301 for (unsigned int j = 0; j < types.size(); ++j) {
1302 if (!types[j].first || !types[j].first->clientdata)
1303 continue;
1304 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1305 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1306 c->destructor(as_value(), 0);
1307 }
1308 }
1309 }
1310#ifdef SWIG_DIRECTORS
1311 for (unsigned int j = 0; j < types.size(); ++j)
1312 Swig::erase_rtdir(types[j].second.ptr);
1313#endif
1314 }
1315
1316 dim_vector dims(void) const {
1317 octave_value out;
1318 if (!dispatch_unary_op("__dims__", out))
1319 return dim_vector(1,1);
1320
1321 // Return value should be cell or matrix of integers
1322#if SWIG_OCTAVE_PREREQ(4,4,0)
1323 if (out.iscell()) {
1324#else
1325 if (out.is_cell()) {
1326#endif
1327 const Cell & c=out.cell_value();
1328 int ndim = c.rows();
1329 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1330
1331 dim_vector d;
1332 d.resize(ndim < 2 ? 2 : ndim);
1333 d(0) = d(1) = 1;
1334
1335 // Fill in dim_vector
1336 for (int k=0;k<ndim;k++) {
1337 const octave_value& obj = c(k);
1338#if SWIG_OCTAVE_PREREQ(6,0,0)
1339 try {
1340 d.elem(k) = obj.int_value();
1341 }
1342 catch (octave::execution_exception& oee) {
1343 // __dims__ should return a cell filled with integers
1344 return dim_vector(1,1);
1345 }
1346#else
1347 d.elem(k) = obj.int_value();
1348
1349 // __dims__ should return a cell filled with integers
1350 if (error_state) return dim_vector(1,1);
1351#endif
1352 }
1353 return d;
1354#if SWIG_OCTAVE_PREREQ(4,4,0)
1355 } else if (out.is_matrix_type() || out.isnumeric() ) {
1356#else
1357 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1358#endif
1359 if (out.rows()==1 || out.columns()==1) {
1360#if SWIG_OCTAVE_PREREQ(6,0,0)
1361 Array<int> a;
1362 try {
1363 a = out.int_vector_value();
1364 }
1365 catch (octave::execution_exception& oee) {
1366 return dim_vector(1,1);
1367 }
1368#else
1369 Array<int> a = out.int_vector_value();
1370 if (error_state) return dim_vector(1,1);
1371#endif
1372 dim_vector d;
1373 d.resize(a.numel() < 2 ? 2 : a.numel());
1374 d(0) = d(1) = 1;
1375 for (int k=0;k<a.numel();k++) {
1376 d.elem(k) = a(k);
1377 }
1378 return d;
1379 } else {
1380 return dim_vector(1,1);
1381 }
1382 } else {
1383 return dim_vector(1,1);
1384 }
1385 }
1386
1387 octave_value as_value() {
1388 ++count;
1389 return Swig::swig_value_ref(this);
1390 }
1391
1392 void incref() {
1393 ++count;
1394 }
1395
1396 void decref() {
1397 if (!--count)
1398 delete this;
1399 }
1400
1401 size_t swig_this() const {
1402 if (!types.size())
1403 return (size_t) this;
1404 return (size_t) types[0].second.ptr;
1405 }
1406 const char* help_text() const {
1407 if (!types.size())
1408 return 0;
1409 if (!types[0].first->clientdata)
1410 return 0;
1411 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1412 return c->constructor_doc;
1413 }
1414
1415 std::string swig_type_name() const {
1416 // * need some way to manually name subclasses.
1417 // * eg optional first arg to subclass(), or named_subclass()
1418 std::string ret;
1419 for (unsigned int j = 0; j < types.size(); ++j) {
1420 if (j)
1421 ret += "_";
1422 if (types[j].first->clientdata) {
1423 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1424 ret += c->name;
1425 } else
1426 ret += types[j].first->name;
1427 }
1428 return ret;
1429 }
1430
1432 rhs.thisown = 0;
1433 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1434 assert(!rhs.types[j].second.destroyed);
1435#ifdef SWIG_DIRECTORS
1436 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1437 if (d)
1438 Swig::swig_director_set_self(d, this);
1439#endif
1440 }
1441 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1442 members.insert(rhs.members.begin(), rhs.members.end());
1443#if SWIG_OCTAVE_PREREQ(4,4,0)
1444 assign(rhs.swig_type_name(), rhs.as_value());
1445#else
1446 rhs.types.clear();
1447 rhs.members.clear();
1448#endif
1449 }
1450
1451 typedef member_map::const_iterator swig_member_const_iterator;
1454
1455 int cast(void **vptr, swig_type_info *type, int *own, int flags) {
1456 int res = SWIG_ERROR;
1457 int clear_pointer = 0;
1458
1459 if (own)
1460 *own = 0;
1461 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !thisown) {
1463 } else {
1464 if (own)
1465 *own = *own | thisown;
1466 if (flags & SWIG_POINTER_DISOWN) {
1467 thisown = 0;
1468 }
1469 if (flags & SWIG_POINTER_CLEAR) {
1470 clear_pointer = 1;
1471 }
1472 }
1473
1474 if (!type && types.size()) {
1475 if (vptr) {
1476 *vptr = types[0].second.ptr;
1477 if (clear_pointer)
1478 types[0].second.ptr = 0;
1479 }
1480 return SWIG_OK;
1481 }
1482 for (unsigned int j = 0; j < types.size(); ++j)
1483 if (type == types[j].first) {
1484 if (vptr) {
1485 *vptr = types[j].second.ptr;
1486 if (clear_pointer)
1487 types[j].second.ptr = 0;
1488 }
1489 return SWIG_OK;
1490 }
1491 for (unsigned int j = 0; j < types.size(); ++j) {
1492 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1493 if (!tc)
1494 continue;
1495 if (vptr) {
1496 int newmemory = 0;
1497 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1498 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1499 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1500 if (own)
1501 *own = *own | SWIG_CAST_NEW_MEMORY;
1502 }
1503 if (clear_pointer)
1504 types[j].second.ptr = 0;
1505 }
1506 res = SWIG_OK;
1507 break;
1508 }
1509 return res;
1510 }
1511
1512 bool is_owned() const {
1513 return thisown;
1514 }
1515
1516#ifdef SWIG_DIRECTORS
1517 void director_destroyed(Swig::Director *d) {
1518 bool found = false;
1519 for (unsigned int j = 0; j < types.size(); ++j) {
1520 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1521 if (dj == d) {
1522 types[j].second.destroyed = true;
1523 found = true;
1524 }
1525 }
1526 assert(found);
1527 }
1528#endif
1529
1530 void assign(const std::string &name, const octave_value &ov) {
1531 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1532 }
1533
1534 void assign(const std::string &name, const swig_octave_member *m) {
1535 members[name] = std::make_pair(m, octave_value());
1536 }
1537
1538 octave_base_value *clone() const {
1539 // pass-by-value is probably not desired, and is harder;
1540 // requires calling copy constructors of contained types etc.
1541 assert(0);
1542 *(int *) 0 = 0;
1543 return 0;
1544 }
1545
1546 octave_base_value *empty_clone() const {
1547 return new octave_swig_type();
1548 }
1549
1550 bool is_defined() const {
1551 return true;
1552 }
1553
1554#if SWIG_OCTAVE_PREREQ(6,0,0)
1555 virtual bool isstruct() const {
1556#else
1557 virtual bool is_map() const {
1558#endif
1559 return true;
1560 }
1561
1562 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1563 octave_value_list ovl = subsref(ops, idx, 1);
1564 return ovl.length()? ovl(0) : octave_value();
1565 }
1566
1567 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1568 assert(ops.size() > 0);
1569 assert(ops.size() == idx.size());
1570
1571 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1572 int skip = 0;
1573 octave_value_list sub_ovl;
1574
1575 // constructor invocation
1576 if (ops[skip] == '(' && construct_type) {
1577 assert(construct_type->clientdata);
1578 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1579 if (!c->constructor) {
1580 error("cannot create instance");
1581 return octave_value_list();
1582 }
1583 octave_value_list args;
1584 if (c->director)
1585 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1586 args.append(*idx_it++);
1587 ++skip;
1588 sub_ovl = c->constructor(args, nargout);
1589 }
1590 // member dereference or invocation
1591 else if (ops[skip] == '.') {
1592 std::string subname;
1593 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1594 for (;;) {
1595 octave_value_list subname_ovl(*idx_it++);
1596 ++skip;
1597 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1598 subname = subname_ovl(0).string_value();
1599
1600 const swig_type_info *next_base = find_base(subname, base);
1601 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1602 break;
1603 base = next_base;
1604 }
1605
1606 member_value_pair tmp, *m = &tmp;
1607 if (!base || !(m->first = find_member(base, subname)))
1608 m = find_member(subname, false);
1609 if (!m) {
1610 error("member not found");
1611 return octave_value_list();
1612 }
1613
1614 octave_value_list args;
1615 if (!always_static &&
1616 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1617 args.append(as_value());
1618 if (skip < (int) ops.size() && ops[skip] == '(' &&
1619 ((m->first && m->first->method) || m->second.is_function() ||
1620 m->second.is_function_handle())) {
1621 args.append(*idx_it++);
1622 ++skip;
1623 sub_ovl = member_invoke(m, args, nargout);
1624 } else {
1625 sub_ovl = member_deref(m, args);
1626 }
1627 }
1628 // index operator
1629 else {
1630 if (ops[skip] == '(' || ops[skip] == '{') {
1631 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1632 octave_value_list args;
1633 args.append(*idx_it++);
1634 ++skip;
1635 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1636 error("error evaluating index operator");
1637 return octave_value_list();
1638 }
1639 } else {
1640 error("unsupported subsref");
1641 return octave_value_list();
1642 }
1643 }
1644
1645 if (skip >= (int) ops.size())
1646 return sub_ovl;
1647 if (sub_ovl.length() < 1) {
1648 error("bad subs ref");
1649 return octave_value_list();
1650 }
1651 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1652 }
1653
1654 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1655 assert(ops.size() > 0);
1656 assert(ops.size() == idx.size());
1657
1658 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1659 int skip = 0;
1660
1661 if (ops.size() > 1) {
1662 std::list < octave_value_list >::const_iterator last = idx.end();
1663 --last;
1664 std::list < octave_value_list > next_idx(idx.begin(), last);
1665 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1666 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1667 }
1668
1669 else if (ops[skip] == '(' || ops[skip] == '{') {
1670 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1671 member_value_pair *m = find_member(op_name, false);
1672 if (m) {
1673 octave_value_list args;
1674 args.append(as_value());
1675 args.append(*idx_it);
1676 args.append(rhs);
1677 member_invoke(m, args, 1);
1678 } else
1679 error("%s member not found", op_name);
1680 }
1681
1682 else if (ops[skip] == '.') {
1683 octave_value_list subname_ovl(*idx_it++);
1684 ++skip;
1685 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1686 std::string subname = subname_ovl(0).string_value();
1687
1688 member_value_pair *m = find_member(subname, true);
1689 if (!m->first || !m->first->set_method) {
1690 m->first = 0;
1691 m->second = rhs;
1692 } else if (m->first->set_method) {
1693 octave_value_list args;
1694 if (!m->first->is_static() && !m->first->is_global())
1695 args.append(as_value());
1696 args.append(rhs);
1697 m->first->set_method(args, 1);
1698 } else
1699 error("member not assignable");
1700 } else
1701 error("unsupported subsasgn");
1702
1703 return as_value();
1704 }
1705
1706#if SWIG_OCTAVE_PREREQ(4,4,0)
1707 virtual bool isobject() const {
1708#else
1709 virtual bool is_object() const {
1710#endif
1711 return true;
1712 }
1713
1714 virtual bool is_string() const {
1715 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1716 return !!nc_this->find_member("__str__", false);
1717 }
1718
1719 virtual std::string string_value(bool force = false) const {
1720 octave_value ret;
1721 if (!dispatch_unary_op("__str__", ret)) {
1722 error("__str__ method not defined");
1723 return std::string();
1724 }
1725 if (!ret.is_string()) {
1726 error("__str__ method did not return a string");
1727 return std::string();
1728 }
1729 return ret.string_value();
1730 }
1731
1732 virtual double scalar_value(bool frc_str_conv = false) const {
1733 octave_value ret;
1734 if (!dispatch_unary_op("__float__", ret)) {
1735 error("__float__ method not defined");
1736 }
1737 return ret.scalar_value();
1738 }
1739
1740#if SWIG_OCTAVE_PREREQ(4,2,0)
1741 virtual octave_value as_double(void) const {
1742 octave_value ret;
1743 if (!dispatch_unary_op("__float__", ret)) {
1744 error("__float__ method not defined");
1745 }
1746 return ret.as_double();
1747 }
1748
1749 virtual octave_value as_single(void) const {
1750 octave_value ret;
1751 if (!dispatch_unary_op("__float__", ret)) {
1752 error("__float__ method not defined");
1753 }
1754 return ret.as_single();
1755 }
1756#endif
1757
1758#if SWIG_OCTAVE_PREREQ(3,8,0)
1759 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1760 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1761 octave_value ret;
1762 if (!dispatch_unary_op(opname, ret)) {
1763 error("%s", (opname + std::string(" method not found")).c_str());
1764 return octave_value();
1765 }
1766 return ret;
1767 }
1768#endif
1769
1770#if SWIG_OCTAVE_PREREQ(3,3,52)
1771 virtual octave_map map_value() const {
1772 return octave_map();
1773 }
1774#else
1775 virtual Octave_map map_value() const {
1776 return Octave_map();
1777 }
1778#endif
1779
1780 virtual string_vector map_keys() const {
1781 member_map tmp;
1782 load_members(tmp);
1783
1784 string_vector keys(tmp.size());
1785 int k = 0;
1786 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1787 keys(k++) = it->first;
1788
1789 return keys;
1790 }
1791
1792 virtual bool save_ascii (std::ostream& os) {
1793 return true;
1794 }
1795
1796 virtual bool load_ascii (std::istream& is) {
1797 return true;
1798 }
1799
1800 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1801 return true;
1802 }
1803
1804 virtual bool load_binary (std::istream& is, bool swap,
1805#if SWIG_OCTAVE_PREREQ(6,0,0)
1806 octave::mach_info::float_format fmt) {
1807#else
1808 oct_mach_info::float_format fmt) {
1809#endif
1810 return true;
1811 }
1812
1813#if defined (HAVE_HDF5)
1814# if SWIG_OCTAVE_PREREQ(4,0,0)
1815 virtual bool
1816 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1817 return true;
1818 }
1819
1820 virtual bool
1821 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1822 return true;
1823 }
1824# else
1825 virtual bool
1826 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1827 return true;
1828 }
1829
1830 virtual bool
1831 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1832 return true;
1833 }
1834# endif
1835#endif
1836
1837 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1838 return string_value();
1839 }
1840
1841 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1842 return string_value();
1843 }
1844
1845 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1846 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1847 // (rather than any module namespace).
1848
1849 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1850 if (!fcn)
1851 return false;
1852#if SWIG_OCTAVE_PREREQ(4,4,0)
1853 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1854 octave_value_list retval = fcn->call(tw, 1, args);
1855 if (retval.length() == 1)
1856 ret = retval(0);
1857#else
1858 ret = fcn->do_multi_index_op(1, args)(0);
1859#endif
1860 return true;
1861 }
1862
1863 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1865 assert(ost);
1866
1867 octave_value ret;
1868 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1869 return ret;
1870 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1871 octave_value_list args;
1872 args.append(make_value_hack(x));
1873 if (dispatch_global_op(symbol, args, ret))
1874 return ret;
1875
1876 error("could not dispatch unary operator");
1877 return octave_value();
1878 }
1879
1880 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1883
1884 octave_value ret;
1885 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1886 return ret;
1887 if (rhs_ost) {
1888 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1889 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1890 return ret;
1891 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1892 return ret;
1893 }
1894 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1895 return ret;
1896 }
1897
1898 std::string symbol;
1899 octave_value_list args;
1900 args.append(make_value_hack(lhs));
1901 args.append(make_value_hack(rhs));
1902
1903 symbol = SWIG_op_prefix;
1904 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1905 symbol += "_";
1906 symbol += op_name;
1907 symbol += "_";
1908 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1909 if (dispatch_global_op(symbol, args, ret))
1910 return ret;
1911
1912 symbol = SWIG_op_prefix;
1913 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1914 symbol += "_";
1915 symbol += op_name;
1916 symbol += "_";
1917 symbol += "any";
1918 if (dispatch_global_op(symbol, args, ret))
1919 return ret;
1920
1921 symbol = SWIG_op_prefix;
1922 symbol += "any";
1923 symbol += "_";
1924 symbol += op_name;
1925 symbol += "_";
1926 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1927 if (dispatch_global_op(symbol, args, ret))
1928 return ret;
1929
1930 error("could not dispatch binary operator");
1931 return octave_value();
1932 }
1933
1934#if SWIG_OCTAVE_PREREQ(4,0,0)
1935 void print(std::ostream &os, bool pr_as_read_syntax = false)
1936#else
1937 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1938#endif
1939 {
1940 if (is_string()) {
1941 os << string_value();
1942 return;
1943 }
1944
1945 member_map tmp;
1946 load_members(tmp);
1947
1948 indent(os);
1949 os << "{"; newline(os);
1950 increment_indent_level();
1951 for (unsigned int j = 0; j < types.size(); ++j) {
1952 indent(os);
1953 if (types[j].first->clientdata) {
1954 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1955 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1956 } else {
1957 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1958 }
1959 }
1960 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1961 indent(os);
1962 if (it->second.first) {
1963 const char *objtype = it->second.first->method ? "method" : "variable";
1964 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1965 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1966 assert(it->second.first->name == it->first);
1967 } else {
1968 os << it->first; newline(os);
1969 }
1970 }
1971 decrement_indent_level();
1972 indent(os);
1973 os << "}"; newline(os);
1974 }
1975 };
1976
1977 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1978 // will call clone() via make_unique() if there is more than one outstanding
1979 // reference to the lhs, and forces the clone's reference count to 1
1980 // (so you can't just increment your own count and return this).
1981 //
1982 // One way to fix this (without modifying Octave) is to add a level of
1983 // indirection such that clone copies ref-counted pointer and we keep
1984 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1985 //
1986 // Supporting both pass-by-{ref,value} and toggling via %feature/option
1987 // might be nice.
1988
1989 class octave_swig_ref:public octave_base_value {
1991 public:
1993 :ptr(_ptr)
1994 {
1995 // Ensure type_id() is set correctly
1996 if (t_id == -1) {
1997 t_id = octave_swig_ref::static_type_id();
1998 }
1999 }
2000
2002 { if (ptr) ptr->decref(); }
2003
2005 { return ptr; }
2006
2007 octave_base_value *clone() const
2008 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2009
2010 octave_base_value *empty_clone() const
2011 { return new octave_swig_ref(0); }
2012
2013 dim_vector dims(void) const
2014 { return ptr->dims(); }
2015
2016 bool is_defined() const
2017 { return ptr->is_defined(); }
2018
2019#if SWIG_OCTAVE_PREREQ(6,0,0)
2020 virtual bool isstruct() const
2021 { return ptr->isstruct(); }
2022#else
2023 virtual bool is_map() const
2024 { return ptr->is_map(); }
2025#endif
2026
2027 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2028 { return ptr->subsref(ops, idx); }
2029
2030 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2031 { return ptr->subsref(ops, idx, nargout); }
2032
2033 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2034 { return ptr->subsasgn(ops, idx, rhs); }
2035
2036#if SWIG_OCTAVE_PREREQ(4,4,0)
2037 virtual bool isobject() const
2038 { return ptr->isobject(); }
2039#else
2040 virtual bool is_object() const
2041 { return ptr->is_object(); }
2042#endif
2043
2044 virtual bool is_string() const
2045 { return ptr->is_string(); }
2046
2047 virtual std::string string_value(bool force = false) const
2048 { return ptr->string_value(force); }
2049
2050 virtual double scalar_value(bool frc_str_conv = false) const
2051 { return ptr->scalar_value(frc_str_conv); }
2052
2053#if SWIG_OCTAVE_PREREQ(4,2,0)
2054 virtual octave_value as_double(void) const
2055 { return ptr->as_double(); }
2056
2057 virtual octave_value as_single(void) const
2058 { return ptr->as_single(); }
2059#endif
2060
2061#if SWIG_OCTAVE_PREREQ(3,8,0)
2062 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2063 { return ptr->map(umap); }
2064#endif
2065
2066#if SWIG_OCTAVE_PREREQ(3,3,52)
2067 virtual octave_map map_value() const
2068 { return ptr->map_value(); }
2069#else
2070 virtual Octave_map map_value() const
2071 { return ptr->map_value(); }
2072#endif
2073
2074 virtual string_vector map_keys() const
2075 { return ptr->map_keys(); }
2076
2077 virtual bool save_ascii (std::ostream& os)
2078 { return ptr->save_ascii(os); }
2079
2080 virtual bool load_ascii (std::istream& is)
2081 { return ptr->load_ascii(is); }
2082
2083 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2084 { return ptr->save_binary(os, save_as_floats); }
2085
2086 virtual bool load_binary (std::istream& is, bool swap,
2087#if SWIG_OCTAVE_PREREQ(6,0,0)
2088 octave::mach_info::float_format fmt)
2089#else
2090 oct_mach_info::float_format fmt)
2091#endif
2092 { return ptr->load_binary(is, swap, fmt); }
2093
2094#if defined (HAVE_HDF5)
2095# if SWIG_OCTAVE_PREREQ(4,0,0)
2096 virtual bool
2097 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2098 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2099
2100 virtual bool
2101 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2102 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2103# else
2104 virtual bool
2105 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2106 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2107
2108 virtual bool
2109 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2110 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2111# endif
2112#endif
2113
2114 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2115 { return ptr->convert_to_str(pad, force, type); }
2116
2117 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2118 { return ptr->convert_to_str_internal(pad, force, type); }
2119
2120#if SWIG_OCTAVE_PREREQ(4,0,0)
2121 void print(std::ostream &os, bool pr_as_read_syntax = false)
2122#else
2123 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2124#endif
2125 { return ptr->print(os, pr_as_read_syntax); }
2126
2127#if SWIG_OCTAVE_PREREQ(4,4,0)
2128 static void set_type_id(int type_id) { t_id=type_id; }
2129#endif
2130
2131 virtual type_conv_info numeric_conversion_function(void) const {
2132 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2133 octave_scalar::static_type_id ());
2134 }
2135
2136 private:
2137 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2138 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2139 return new octave_scalar(v.scalar_value());
2140 }
2141
2142#if !SWIG_OCTAVE_PREREQ(4,0,0)
2144#endif
2146 };
2147#if !SWIG_OCTAVE_PREREQ(4,0,0)
2149#endif
2151
2152 class octave_swig_packed:public octave_base_value {
2154 std::vector < char > buf;
2155 public:
2156
2157 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2158 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2159 {
2160 // Ensure type_id() is set correctly
2161 if (t_id == -1) {
2162 t_id = octave_swig_packed::static_type_id();
2163 }
2164 }
2165
2166 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2167 if (outtype && outtype != type)
2168 return false;
2169 assert(sz <= buf.size());
2170 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2171 return true;
2172 }
2173
2174 octave_base_value *clone() const {
2175 return new octave_swig_packed(*this);
2176 }
2177
2178 octave_base_value *empty_clone() const {
2179 return new octave_swig_packed();
2180 }
2181
2182 bool is_defined() const {
2183 return true;
2184 }
2185
2186#if SWIG_OCTAVE_PREREQ(4,0,0)
2187 void print(std::ostream &os, bool pr_as_read_syntax = false)
2188#else
2189 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2190#endif
2191 {
2192 indent(os);
2193 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2194 }
2195
2196
2197 virtual bool save_ascii (std::ostream& os) {
2198 return true;
2199 }
2200
2201 virtual bool load_ascii (std::istream& is) {
2202 return true;
2203 }
2204
2205 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2206 return true;
2207 }
2208
2209 virtual bool load_binary (std::istream& is, bool swap,
2210#if SWIG_OCTAVE_PREREQ(6,0,0)
2211 octave::mach_info::float_format fmt) {
2212#else
2213 oct_mach_info::float_format fmt) {
2214#endif
2215 return true;
2216 }
2217
2218#if defined (HAVE_HDF5)
2219# if SWIG_OCTAVE_PREREQ(4,0,0)
2220 virtual bool
2221 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2222 return true;
2223 }
2224
2225 virtual bool
2226 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2227 return true;
2228 }
2229# else
2230 virtual bool
2231 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2232 return true;
2233 }
2234
2235 virtual bool
2236 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2237 return true;
2238 }
2239# endif
2240#endif
2241
2242#if SWIG_OCTAVE_PREREQ(4,4,0)
2243 static void set_type_id(int type_id) { t_id=type_id; }
2244#endif
2245
2246 private:
2247#if !SWIG_OCTAVE_PREREQ(4,0,0)
2249#endif
2251 };
2252#if !SWIG_OCTAVE_PREREQ(4,0,0)
2254#endif
2256
2257 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2258 error("attempt to set immutable member variable");
2259 return octave_value_list();
2260 }
2261
2263 const octave_value_list &ovl;
2264 int j;
2265
2266 octave_value_ref(const octave_value_list &_ovl, int _j)
2267 :ovl(_ovl), j(_j) { }
2268
2269 operator octave_value() const {
2270 return ovl(j);
2271 }
2272
2273 octave_value operator*() const {
2274 return ovl(j);
2275 }
2276 };
2277
2278
2279namespace Swig {
2280
2282 return new octave_swig_ref(ost);
2283 }
2284
2286 if (
2287#if SWIG_OCTAVE_PREREQ(4,4,0)
2288 ov.iscell()
2289#else
2290 ov.is_cell()
2291#endif
2292 && ov.rows() == 1 && ov.columns() == 1)
2293 ov = ov.cell_value()(0);
2294 return swig_value_deref(*ov.internal_rep());
2295 }
2296
2297 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2298 if (ov.type_id() != octave_swig_ref::static_type_id())
2299 return 0;
2300 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2301 return osr->get_ptr();
2302 }
2303
2304}
2305
2306
2307#define swig_unary_op(name) \
2308SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2309 return octave_swig_type::dispatch_unary_op(x,#name); \
2310}
2311#define swig_binary_op(name) \
2312SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2313 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2314}
2315#if SWIG_OCTAVE_PREREQ(4,4,0)
2316#define swigreg_unary_op(name) \
2317if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2318typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2319#else
2320#define swigreg_unary_op(name) \
2321if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2322octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2323#endif
2324#if SWIG_OCTAVE_PREREQ(4,4,0)
2325#define swigreg_binary_op(name) \
2326if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2327typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2328#else
2329#define swigreg_binary_op(name) \
2330if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2331octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2332#endif
2333
2337 swig_unary_op(transpose);
2338 swig_unary_op(hermitian);
2341
2348#if !SWIG_OCTAVE_PREREQ(4,2,0)
2351#endif
2364
2366#if SWIG_OCTAVE_PREREQ(4,4,0)
2367 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2368#endif
2369 swigreg_unary_op(not);
2370 swigreg_unary_op(uplus);
2371 swigreg_unary_op(uminus);
2372 swigreg_unary_op(transpose);
2373 swigreg_unary_op(hermitian);
2374 swigreg_unary_op(incr);
2375 swigreg_unary_op(decr);
2376 }
2377 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2378#if SWIG_OCTAVE_PREREQ(4,4,0)
2379 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2380#endif
2381 swigreg_binary_op(add);
2382 swigreg_binary_op(sub);
2383 swigreg_binary_op(mul);
2384 swigreg_binary_op(div);
2385 swigreg_binary_op(pow);
2386 swigreg_binary_op(ldiv);
2387#if !SWIG_OCTAVE_PREREQ(4,2,0)
2388 swigreg_binary_op(lshift);
2389 swigreg_binary_op(rshift);
2390#endif
2397 swigreg_binary_op(el_mul);
2398 swigreg_binary_op(el_div);
2399 swigreg_binary_op(el_pow);
2400 swigreg_binary_op(el_ldiv);
2401 swigreg_binary_op(el_and);
2402 swigreg_binary_op(el_or);
2403 }
2405 // here we assume that tid are conseq integers increasing from zero, and
2406 // that our tid is the last one. might be better to have explicit string
2407 // list of types we should bind to, and use lookup_type to resolve their tid.
2408
2410 SWIG_InstallBinaryOps(tid, tid);
2411 for (int j = 0; j < tid; ++j) {
2412 SWIG_InstallBinaryOps(j, tid);
2413 SWIG_InstallBinaryOps(tid, j);
2414 }
2415 }
2416
2417SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2418 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2419
2420 if (ptr) {
2421#ifdef SWIG_DIRECTORS
2422 Swig::Director *d = Swig::get_rtdir(ptr);
2423 if (d && Swig::swig_director_get_self(d))
2424 return Swig::swig_director_get_self(d)->as_value();
2425#endif
2426 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2427 }
2428 return octave_value(Matrix()); // null matrix
2429}
2430
2431SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2432 if (
2433#if SWIG_OCTAVE_PREREQ(4,4,0)
2434 ov.iscell()
2435#else
2436 ov.is_cell()
2437#endif
2438 && ov.rows() == 1 && ov.columns() == 1)
2439 ov = ov.cell_value()(0);
2440 if (!ov.is_defined() ||
2441 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2442 if (ptr)
2443 *ptr = 0;
2445 }
2446 if (ov.type_id() != octave_swig_ref::static_type_id())
2447 return SWIG_ERROR;
2448 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2449 octave_swig_type *ost = osr->get_ptr();
2450 return ost->cast(ptr, type, own, flags);
2451}
2452
2453SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2454 return new octave_swig_packed(type, (char *) ptr, sz);
2455}
2456
2457SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2458 if (!ov.is_defined())
2459 return SWIG_ERROR;
2460 if (ov.type_id() != octave_swig_packed::static_type_id())
2461 return SWIG_ERROR;
2462 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2463 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2464}
2465
2466SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2467 module_ns->assign(name, ov);
2468}
2469
2471#if SWIG_OCTAVE_PREREQ(6,0,0)
2472 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2473 return interp->global_varval(name);
2474#else
2475#if SWIG_OCTAVE_PREREQ(4,4,0)
2476 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2477 return symtab.global_varval(name);
2478#else
2479 return get_global_value(name, true);
2480#endif
2481#endif
2482}
2483
2484SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2485#if SWIG_OCTAVE_PREREQ(6,0,0)
2486 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2487 interp->global_assign(name, value);
2488#elif SWIG_OCTAVE_PREREQ(4,4,0)
2489 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2490 symtab.global_assign(name, value);
2491#else
2492 set_global_value(name, value);
2493#endif
2494}
2495
2497#if SWIG_OCTAVE_PREREQ(4,4,0)
2498 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2499#if SWIG_OCTAVE_PREREQ(6,0,0)
2500 octave::interpreter *interp = octave::interpreter::the_interpreter ();
2501 interp->assign(name, interp->global_varval(name));
2502 octave::tree_evaluator& tree_eval = interp->get_evaluator();
2503 octave::call_stack& callStack = tree_eval.get_call_stack();
2504 std::shared_ptr<octave::stack_frame> stackFrame = callStack.get_current_stack_frame();
2505 octave::symbol_record sym=symscope.lookup_symbol(name);
2506 stackFrame->mark_global(sym);
2507#else
2508 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2509 symscope.assign(name, symtab.global_varval(name));
2510 symscope.mark_global(name);
2511#endif
2512#else
2513#if !SWIG_OCTAVE_PREREQ(3,2,0)
2514 link_to_global_variable(curr_sym_tab->lookup(name, true));
2515#else
2516#if !SWIG_OCTAVE_PREREQ(3,8,0)
2517 symbol_table::varref(name);
2518#endif
2519 symbol_table::mark_global(name);
2520#endif
2521#endif
2522}
2523
2525 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2526 if (!ov.is_defined() ||
2527 ov.type_id() != octave_swig_packed::static_type_id())
2528 return 0;
2529 const octave_swig_packed* osp =
2530 static_cast < const octave_swig_packed *> (ov.internal_rep());
2531 swig_module_info *pointer = 0;
2532 osp->copy(0, &pointer, sizeof(swig_module_info *));
2533 return pointer;
2534}
2535
2536SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2537 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2539}
2540
2541
2542SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
2543 if (obj.is_string())
2544 error("%s", obj.string_value().c_str());
2545 else
2546 error("C++ side threw an exception of type %s", type);
2547}
2548
2549
2550
2551#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2552
2553#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2554
2555
2556
2557/* -------- TYPES TABLE (BEGIN) -------- */
2558
2559#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2560#define SWIGTYPE_p_char swig_types[1]
2561#define SWIGTYPE_p_double swig_types[2]
2562#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2563#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2564#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2565#define SWIGTYPE_p_int swig_types[6]
2566#define SWIGTYPE_p_p_char swig_types[7]
2567#define SWIGTYPE_p_unsigned_int swig_types[8]
2569static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2570#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2571#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2572
2573/* -------- TYPES TABLE (END) -------- */
2574
2575
2576#ifdef __cplusplus
2577#include <utility>
2578/* SwigValueWrapper is described in swig.swg */
2579template<typename T> class SwigValueWrapper {
2580 struct SwigSmartPointer {
2581 T *ptr;
2582 SwigSmartPointer(T *p) : ptr(p) { }
2583 ~SwigSmartPointer() { delete ptr; }
2584 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
2585 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
2586 } pointer;
2587 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
2588 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
2589public:
2590 SwigValueWrapper() : pointer(0) { }
2591 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
2592#if __cplusplus >=201103L
2593 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
2594 operator T&&() const { return std::move(*pointer.ptr); }
2595#else
2596 operator T&() const { return *pointer.ptr; }
2597#endif
2598 T *operator&() const { return pointer.ptr; }
2599 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2600};
2601
2602/*
2603 * SwigValueInit() is a generic initialisation solution as the following approach:
2604 *
2605 * T c_result = T();
2606 *
2607 * doesn't compile for all types for example:
2608 *
2609 * unsigned int c_result = unsigned int();
2610 */
2611template <typename T> T SwigValueInit() {
2612 return T();
2613}
2614
2615#if __cplusplus >=201103L
2616# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2617#else
2618# define SWIG_STD_MOVE(OBJ) OBJ
2619#endif
2620
2621#endif
2622
2623
2624#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628#include <stdexcept>
2629
2630
2631// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2632#undef PACKAGE
2633#undef VERSION
2634
2635#include "plplotP.h"
2636
2637// Temporary fix for problems with -fvisibility=hidden and octave headers.
2638#ifdef OCTAVE_EXPORT
2639 #if defined ( __GNUC__ ) && __GNUC__ > 3
2640 #undef OCTAVE_EXPORT
2641 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2642 #endif
2643#endif
2644
2645
2646
2647// I hate global variables but this is the best way I can think of
2648// to manage consistency checking among function arguments.
2649 static PLINT Alen = 0;
2650 static PLINT Xlen = 0, Ylen = 0;
2651
2652
2653// Convenience functions copied from matwrap-based approach (currently
2654// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2655// tricky scalar case and also adopted so that the resulting
2656// swig-generated source code will look similar to the matwrap-generated
2657// source code.
2658
2659 inline int max( int a, int b )
2660 {
2661 return a >= b ? a : b;
2662 }
2663 inline int min( int a, int b )
2664 {
2665 return a >= b ? a : b;
2666 }
2667
2668//
2669// Function to get the total length (rows*columns) of an octave object of
2670// arbitrary type.
2671// Arguments:
2672// 1) The octave object.
2673//
2674// If the object is a scalar, the array length is 1.
2675//
2676 static int
2677 _arraylen( const octave_value &o_obj )
2678 {
2679 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2680 // max is necessary because sometimes
2681 // rows() or columns() return -1 or 0 for
2682 // scalars.
2683 }
2684
2685//
2686// Function to get the number of dimensions of an object.
2687//
2688 static int
2689 _n_dims( const octave_value &o_obj )
2690 {
2691 if ( max( o_obj.columns(), 1 ) > 1 )
2692 return 2;
2693 // max is necessary because sometimes
2694 // rows() or columns() return -1 or 0 for
2695 // scalars.
2696 else if ( max( o_obj.rows(), 1 ) > 1 )
2697 return 1;
2698 else
2699 return 0;
2700 }
2701
2702//
2703// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2704//
2705 static inline int
2706 _dim( const octave_value &o_obj, int dim_idx )
2707 {
2708 if ( dim_idx == 0 )
2709 return max( o_obj.rows(), 0 );
2710 // max is necessary because sometimes
2711 // rows() or columns() return -1 or 0 for
2712 // scalars.
2713 else if ( dim_idx == 1 )
2714 return max( o_obj.columns(), 0 );
2715 else
2716 return 1;
2717 }
2718
2719//
2720// The following function converts an array of doubles into some other
2721// numeric type. Arguments:
2722// 1) Where to store the result. The type is determined from the type of
2723// this pointer.
2724// 2) A vector of doubles to convert.
2725// 3) The number of doubles.
2726//
2727 template <class FLOAT>
2728 static inline void
2729 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2730 {
2731 while ( n_el-- > 0 )
2732 *out_arr++ = (FLOAT) ( *in_arr++ );
2733 }
2734
2735 template void _cvt_double_to( int *, double *, unsigned );
2736 template void _cvt_double_to( unsigned *, double *, unsigned );
2737 template void _cvt_double_to( long *, double *, unsigned );
2738 template void _cvt_double_to( unsigned long *, double *, unsigned );
2739 template void _cvt_double_to( short *, double *, unsigned );
2740 template void _cvt_double_to( unsigned short *, double *, unsigned );
2741 template void _cvt_double_to( float *, double *, unsigned );
2742 // Instantiate our templates. Octave uses
2743 // manual template instantiation.
2744
2745//
2746// Convert an array of some other type into an array of doubles. Arguments:
2747// 1) The array of objects of other type.
2748// 2) The output array of doubles.
2749// 3) The number of elements to convert.
2750//
2751 template <class FLOAT>
2752 static inline void
2753 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2754 {
2755 while ( n_el-- > 0 )
2756 *d_arr++ = double(*arr++);
2757 }
2758
2759 template void _cvt_to_double( int *, double *, unsigned );
2760 template void _cvt_to_double( unsigned *, double *, unsigned );
2761 template void _cvt_to_double( long *, double *, unsigned );
2762 template void _cvt_to_double( unsigned long *, double *, unsigned );
2763 template void _cvt_to_double( short *, double *, unsigned );
2764 template void _cvt_to_double( unsigned short *, double *, unsigned );
2765 template void _cvt_to_double( float *, double *, unsigned );
2766 // Instantiate our templates. Octave uses
2767 // manual template instantiation.
2768
2769
2770 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2771 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2772 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2773 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2774 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2776 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2777
2778
2779#include <iostream>
2780
2781 octave_function *fcnMapForm;
2782 std::string nameMapForm;
2783
2785 {
2786 octave_idx_type i;
2787 octave_value_list functionArguments;
2788 octave_value_list retval;
2789
2790 Matrix xin( n, 1 );
2791 Matrix yin( n, 1 );
2792 Matrix xout;
2793 Matrix yout;
2794
2795 for ( i = 0; i < n; i++ )
2796 {
2797 xin( i, 0 ) = x[i];
2798 yin( i, 0 ) = y[i];
2799 }
2800
2801 functionArguments( 0 ) = xin;
2802 functionArguments( 1 ) = yin;
2803
2804 if ( fcnMapForm != NULL )
2805#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2806 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2807#else
2808 retval = feval( fcnMapForm, functionArguments, 1 );
2809#endif
2810 else
2811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2812 retval = octave::feval( nameMapForm, functionArguments, 1 );
2813#else
2814 retval = feval( nameMapForm, functionArguments, 1 );
2815#endif
2816
2817 if ( retval.length() >= 2 )
2818 {
2819 xout = retval( 0 ).matrix_value();
2820 yout = retval( 1 ).matrix_value();
2821
2822 for ( i = 0; i < n; i++ )
2823 {
2824 x[i] = xout( i, 0 );
2825 y[i] = yout( i, 0 );
2826 }
2827 }
2828 }
2829
2830
2831 octave_function *fcnLabelFunc;
2832 std::string nameLabelFunc;
2833
2834 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2835 {
2836 int i;
2837 octave_value_list functionArguments;
2838 octave_value_list retval;
2839
2840 Matrix inAxis( 1, 1 );
2841 Matrix inValue( 1, 1 );
2842 inAxis( 0, 0 ) = axis;
2843 inValue( 0, 0 ) = value;
2844
2845 functionArguments( 0 ) = inAxis;
2846 functionArguments( 1 ) = inValue;
2847
2848 if ( fcnLabelFunc != NULL )
2849#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2850 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2851#else
2852 retval = feval( fcnLabelFunc, functionArguments, 1 );
2853#endif
2854 else
2855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2856 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2857#else
2858 retval = feval( nameLabelFunc, functionArguments, 1 );
2859#endif
2860
2861 strncpy( label, retval( 0 ).string_value().c_str(), length );
2862 }
2863
2864
2865 octave_function *fcnCoordTrans;
2866 std::string nameCoordTrans;
2867
2868 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2869 {
2870 octave_idx_type i;
2871 octave_value_list functionArguments;
2872 octave_value_list retval;
2873
2874 Matrix xin( 1, 1 );
2875 Matrix yin( 1, 1 );
2876 Matrix xout;
2877 Matrix yout;
2878
2879 xin( 0, 0 ) = x;
2880 yin( 0, 0 ) = y;
2881
2882 functionArguments( 0 ) = xin;
2883 functionArguments( 1 ) = yin;
2884
2885 if ( fcnCoordTrans != NULL )
2886#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2887 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2888#else
2889 retval = feval( fcnCoordTrans, functionArguments, 1 );
2890#endif
2891 else
2892#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2893 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2894#else
2895 retval = feval( nameCoordTrans, functionArguments, 1 );
2896#endif
2897
2898 if ( retval.length() >= 2 )
2899 {
2900 xout = retval( 0 ).matrix_value();
2901 yout = retval( 1 ).matrix_value();
2902
2903 *xt = xout( 0, 0 );
2904 *yt = yout( 0, 0 );
2905 }
2906 }
2907
2908
2909 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2910 {
2911 PLINT i;
2912 printf( "nlegend =%d\n", nlegend );
2913 for ( i = 0; i < nlegend; i++ )
2914 {
2915 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2916 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2917 printf( "text[%d] =%s\n", i, text[i] );
2918 }
2919 }
2920
2921
2922#include <limits.h>
2923#if !defined(SWIG_NO_LLONG_MAX)
2924# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2925# define LLONG_MAX __LONG_LONG_MAX__
2926# define LLONG_MIN (-LLONG_MAX - 1LL)
2927# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2928# endif
2929#endif
2930
2931
2932 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2933 {
2934 if (!ov.is_scalar_type())
2935 return SWIG_TypeError;
2936 if (ov.is_complex_scalar())
2937 return SWIG_TypeError;
2938 if (ov.is_double_type()||ov.is_single_type()) {
2939 double v=ov.double_value();
2940 if (v!=floor(v))
2941 return SWIG_TypeError;
2942 }
2943 if (val)
2944 *val = ov.long_value();
2945 return SWIG_OK;
2946 }
2947
2948
2949SWIGINTERN int
2950SWIG_AsVal_int (octave_value obj, int *val)
2951{
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962}
2963
2964
2965 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 )
2966 {
2967 PLGraphicsIn gin;
2968 int status; status = plGetCursor( &gin );
2969 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2970 strncpy( string, gin.string, PL_MAXKEY - 1 );
2971 string[PL_MAXKEY - 1] = '\0';
2972
2973 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2974 return status;
2975 }
2976
2977
2978SWIGINTERN int
2979SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2980{
2981 if (
2982#if SWIG_OCTAVE_PREREQ(4,4,0)
2983 ov.iscell()
2984#else
2985 ov.is_cell()
2986#endif
2987 && ov.rows() == 1 && ov.columns() == 1)
2988 ov = ov.cell_value()(0);
2989 if (!ov.is_string())
2990 return SWIG_TypeError;
2991
2992 std::string str=ov.string_value();
2993 size_t len=str.size();
2994 char* cstr=(char*)str.c_str();
2995 if (alloc) {
2996 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2997 *alloc = SWIG_NEWOBJ;
2998 } else if (cptr)
2999 *cptr = cstr;
3000 if (psize)
3001 *psize = len + 1;
3002 return SWIG_OK;
3003}
3004
3005
3006
3007
3008
3010 {
3011 return octave_value(value);
3012 }
3013
3014
3015SWIGINTERNINLINE octave_value
3017{
3018 return SWIG_From_long (value);
3019}
3020
3021
3023 {
3024 return octave_value(value);
3025 }
3026
3027
3028// Translates relative device coordinates to world coordinates.
3029 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
3030 {
3031 PLGraphicsIn gin;
3032 int st;
3033 gin.dX = x_in; gin.dY = y_in;
3034 st = plTranslateCursor( &gin );
3035 *x = gin.wX; *y = gin.wY;
3036 return st;
3037 }
3038
3039
3040 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
3041 {
3042 if (!ov.is_scalar_type())
3043 return SWIG_TypeError;
3044 if (ov.is_complex_scalar())
3045 return SWIG_TypeError;
3046 if (val)
3047 *val = ov.double_value();
3048 return SWIG_OK;
3049 }
3050
3051
3052// Create 1d stripchart
3053
3054 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3055 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3056 PLFLT xlpos, PLFLT ylpos,
3057 PLBOOL y_ascl, PLBOOL acc,
3058 PLINT colbox, PLINT collab,
3059 const PLINT *colline, const PLINT *styline,
3060 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3061 const char *labx, const char *laby, const char *labtop )
3062 {
3063 const char *legline[4];
3064 legline[0] = legline1; legline[1] = legline2;
3065 legline[2] = legline3; legline[3] = legline4;
3066 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3067 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3068 labx, laby, labtop );
3069 }
3070
3071
3072// One more hack. As it is not possible (and would not be desirable) to pass
3073// an Octave function to plcont(), I have defined three plcont():
3074// plcont uses a defined here xform()
3075// plcont0 uses pltr0()
3076// plcont1 uses pltr1()
3077// plcont2 uses pltr2()
3078// plcont2p uses pltr2p()
3079//
3080// Also, as plplot expect vectorized bidimensional arrays, I provided a
3081// f2c, which is a #define that does the necessary conversion.
3082//
3083
3084 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3085 {
3086 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3087 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3088 }
3089
3090// convert from Fortran like arrays (one vector), to C like 2D arrays
3091
3092#define f2c( f, ff, nx, ny ) \
3093 PLFLT * *ff; \
3094 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3095 for ( int i = 0; i < nx; i++ ) { \
3096 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3097 for ( int j = 0; j < ny; j++ ) \
3098 *( ff[i] + j ) = *( f + nx * j + i );}
3099
3100// simpler plcont() for use with xform()
3101
3102 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3103 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3104 {
3105 f2c( f, ff, nx, ny );
3106 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3107 }
3108
3109// plcont() for use with pltr0() NOT TESTED
3110
3111 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3112 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3113 {
3114 f2c( f, ff, nx, ny );
3115 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3116 }
3117
3118// plcont() for use with pltr1()
3119
3120 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3121 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3122 {
3123 PLcGrid grid1;
3124 grid1.nx = nx; grid1.ny = ny;
3125 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3126 f2c( f, ff, nx, ny );
3127 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3128 }
3129
3130// plcont() for use with pltr2()
3131 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3132 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3133 {
3134 PLcGrid2 grid2;
3135 f2c( xg, xgg, nx, ny );
3136 f2c( yg, ygg, nx, ny );
3137 grid2.nx = nx; grid2.ny = ny;
3138 grid2.xg = xgg; grid2.yg = ygg;
3139 f2c( f, ff, nx, ny );
3140 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3141 }
3142
3143// plcont() for use with pltr2p()
3144
3145 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3146 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3147 {
3148 PLcGrid2 grid2;
3149 f2c( xg, xgg, nx, ny );
3150 f2c( yg, ygg, nx, ny );
3151 grid2.nx = nx; grid2.ny = ny;
3152 grid2.xg = xgg; grid2.yg = ygg;
3153 f2c( f, ff, nx, ny );
3154 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3155 }
3156
3157
3158 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3159 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3160 PLFLT *zg, int type, PLFLT data )
3161 {
3162 f2c( zg, zgg, nptsx, nptsy );
3163 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3164 for ( int i = 0; i < nptsx; i++ )
3165 for ( int j = 0; j < nptsy; j++ )
3166 *( zg + nptsx * j + i ) = zgg[i][j];
3167 }
3168
3169
3170// Plots a mesh representation of the function z[x][y].
3171
3172 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3173 {
3174 f2c( z, zz, nx, ny );
3175 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3176 }
3177
3178// Plots a mesh representation of the function z[x][y] with contour
3179
3180 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3181 {
3182 f2c( z, zz, nx, ny );
3183 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3184 }
3185
3186
3187// Plots a 3-d representation of the function z[x][y].
3188 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3189 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3190 {
3191 f2c( z, zz, nx, ny );
3192 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3193 }
3194
3195// Plots a 3-d representation of the function z[x][y] with contour
3196 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3197 PLINT nx, PLINT ny, PLINT opt,
3198 const PLFLT *clevel, PLINT nlevel )
3199 {
3200 f2c( z, zz, nx, ny );
3201 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3202 }
3203// Plots a 3-d representation of the function z[x][y] with contour with y
3204// index limits
3205 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3206 PLINT nx, PLINT ny, PLINT opt,
3207 const PLFLT * clevel, PLINT nlevel,
3208 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3209 {
3210 f2c( z, zz, nx, ny );
3211 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3212 indexxmin, indexxmax, indexymin, indexymax );
3213 }
3214
3215
3216 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3217 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3218 {
3219 f2c( z, zz, nx, ny );
3220 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3221 }
3222
3223 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3224 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3225 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3226 {
3227 f2c( z, zz, nx, ny );
3228 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3229 indexxmin, indexxmax, indexymin, indexymax );
3230 }
3231
3232
3233// The same as in plcont. I have hardcoded the first function pointer
3234// to plfill(). The second function pointer will use the same convention
3235// as in plcont().
3236//
3237
3238// the simpler plshade()
3239 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3240 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3241 PLFLT shade_min, PLFLT shade_max,
3242 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3243 PLINT min_color, PLINT min_width,
3244 PLINT max_color, PLINT max_width,
3245 PLINT rectangular, PLFLT *tr )
3246 {
3247 f2c( a, aa, nx, ny );
3248 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3249 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3250 min_color, min_width, max_color, max_width,
3251 plfill, rectangular, xform, tr );
3252 }
3253
3254// plshade() for use with pltr1
3255 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3256 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3257 PLFLT shade_min, PLFLT shade_max,
3258 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3259 PLINT min_color, PLINT min_width,
3260 PLINT max_color, PLINT max_width,
3261 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3262 {
3263 PLcGrid grid1;
3264 grid1.nx = nx; grid1.ny = ny;
3265 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3266 f2c( a, aa, nx, ny );
3267 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3268 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3269 min_color, min_width, max_color, max_width,
3270 plfill, rectangular, pltr1, &grid1 );
3271 }
3272
3273// plshade() for use with pltr2
3274 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3275 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3276 PLFLT shade_min, PLFLT shade_max,
3277 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3278 PLINT min_color, PLINT min_width,
3279 PLINT max_color, PLINT max_width,
3280 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3281 {
3282 PLcGrid2 grid2;
3283 f2c( xg, xgg, nx, ny );
3284 f2c( yg, ygg, nx, ny );
3285 grid2.nx = nx; grid2.ny = ny;
3286 grid2.xg = xgg; grid2.yg = ygg;
3287 f2c( a, aa, nx, ny );
3288 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3289 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3290 min_color, min_width, max_color, max_width,
3291 plfill, rectangular, pltr2, &grid2 );
3292 }
3293
3294
3295
3296 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3297 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3298 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3299 PLINT cont_color, PLINT cont_width,
3300 PLINT rectangular )
3301 {
3302 f2c( a, aa, nx, ny );
3303 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3304 clevel, nlevel, fill_width, cont_color, cont_width,
3305 plfill, rectangular, NULL, NULL );
3306 }
3307
3308 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3309 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3310 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3311 PLINT cont_color, PLINT cont_width,
3312 PLINT rectangular, PLFLT *tr )
3313 {
3314 f2c( a, aa, nx, ny );
3315 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3316 clevel, nlevel, fill_width, cont_color, cont_width,
3317 plfill, rectangular, xform, tr );
3318 }
3319
3320 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3321 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3322 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3323 PLINT cont_color, PLINT cont_width,
3324 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3325 {
3326 PLcGrid grid1;
3327 grid1.nx = nx; grid1.ny = ny;
3328 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3329
3330 f2c( a, aa, nx, ny );
3331 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3332 clevel, nlevel, fill_width, cont_color, cont_width,
3333 plfill, rectangular, pltr1, &grid1 );
3334 }
3335
3336 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3337 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3338 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3339 PLINT cont_color, PLINT cont_width,
3340 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3341 {
3342 PLcGrid2 grid2;
3343 f2c( xg, xgg, nx, ny );
3344 f2c( yg, ygg, nx, ny );
3345 grid2.nx = nx; grid2.ny = ny;
3346 grid2.xg = xgg; grid2.yg = ygg;
3347 f2c( a, aa, nx, ny );
3348 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3349 clevel, nlevel, fill_width, cont_color, cont_width,
3350 plfill, rectangular, pltr2, &grid2 );
3351 }
3352
3353
3354// Plot an array of vector arrows - uses the same function pointer
3355// convention as plcont
3356
3357 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3358 {
3359 f2c( u, uu, nx, ny );
3360 f2c( v, vv, nx, ny );
3361 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3362 }
3363
3364// plvect() for use with pltr1
3365 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3366 {
3367 PLcGrid grid1;
3368 grid1.nx = nx; grid1.ny = ny;
3369 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3370 f2c( u, uu, nx, ny );
3371 f2c( v, vv, nx, ny );
3372 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3373 }
3374
3375// plvect() for use with pltr2
3376 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3377 {
3378 PLcGrid2 grid2;
3379 f2c( xg, xgg, nx, ny );
3380 f2c( yg, ygg, nx, ny );
3381 grid2.nx = nx; grid2.ny = ny;
3382 grid2.xg = xgg; grid2.yg = ygg;
3383 f2c( u, uu, nx, ny );
3384 f2c( v, vv, nx, ny );
3385 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3386 }
3387
3388
3389// Plot an image with distortion - uses the same function pointer
3390 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3391 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3392 PLFLT zmin, PLFLT zmax,
3393 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3394 {
3395 f2c( a, aa, nx, ny );
3396 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3397 }
3398
3399// Plot an image with distortion - uses the same function pointer
3400// convention as plcont
3401 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3402 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3403 PLFLT zmin, PLFLT zmax,
3404 PLFLT valuemin, PLFLT valuemax )
3405 {
3406 f2c( a, aa, nx, ny );
3407 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3408 }
3409
3410 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3411 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3412 PLFLT zmin, PLFLT zmax,
3413 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3414 {
3415 f2c( a, aa, nx, ny );
3416 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3417 }
3418
3419// plimagefr() for use with pltr1
3420 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3421 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3422 PLFLT zmin, PLFLT zmax,
3423 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3424 {
3425 PLcGrid grid1;
3426 grid1.nx = nx + 1; grid1.ny = ny + 1;
3427 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3428 f2c( a, aa, nx, ny );
3429 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3430 }
3431
3432// plimagefr() for use with pltr2
3433 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3434 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3435 PLFLT zmin, PLFLT zmax,
3436 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3437 {
3438 PLcGrid2 grid2;
3439 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3440 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3441 grid2.nx = nx + 1; grid2.ny = ny + 1;
3442 grid2.xg = xgg; grid2.yg = ygg;
3443 f2c( a, aa, nx, ny );
3444 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3445 }
3446
3447
3448
3449 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3450 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3451 PLFLT x_length, PLFLT y_length,
3452 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3453 PLFLT low_cap_color, PLFLT high_cap_color,
3454 PLINT cont_color, PLFLT cont_width,
3455 PLINT n_labels, const PLINT *label_opts, const char **label,
3456 PLINT n_axes, const char ** axis_opts,
3457 const PLFLT *ticks, const PLINT *sub_ticks,
3458 const PLINT *n_values, const PLFLT *a )
3459 {
3460 PLINT nx, ny, i;
3461 nx = n_axes;
3462 ny = -1;
3463 for ( i = 0; i < nx; i++ )
3464 if ( n_values[i] > ny )
3465 ny = n_values[i];
3466 f2c( a, aa, nx, ny );
3467 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3468 opt, position, x, y,
3469 x_length, y_length,
3470 bg_color, bb_color, bb_style,
3471 low_cap_color, high_cap_color,
3472 cont_color, cont_width,
3473 n_labels, label_opts, label,
3474 n_axes, axis_opts,
3475 ticks, sub_ticks,
3476 n_values, aa );
3477 }
3478
3479
3480
3481 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3482 {
3483 if (!ov.is_scalar_type())
3484 return SWIG_TypeError;
3485 if (ov.is_complex_scalar())
3486 return SWIG_TypeError;
3487 if (ov.is_double_type()||ov.is_single_type()) {
3488 double v=ov.double_value();
3489 if (v<0)
3490 return SWIG_OverflowError;
3491 if (v!=floor(v))
3492 return SWIG_TypeError;
3493 }
3494 if (ov.is_int8_type()||ov.is_int16_type()||
3495 ov.is_int32_type()) {
3496 long v=ov.long_value();
3497 if (v<0)
3498 return SWIG_OverflowError;
3499 }
3500 if (ov.is_int64_type()) {
3501 long long v=ov.int64_scalar_value().value();
3502 if (v<0)
3503 return SWIG_OverflowError;
3504 }
3505 if (val)
3506 *val = ov.ulong_value();
3507 return SWIG_OK;
3508 }
3509
3510
3511SWIGINTERN int
3512SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3513{
3514 unsigned long v;
3515 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3516 if (SWIG_IsOK(res)) {
3517 if ((v > UINT_MAX)) {
3518 return SWIG_OverflowError;
3519 } else {
3520 if (val) *val = static_cast< unsigned int >(v);
3521 }
3522 }
3523 return res;
3524}
3525
3526
3528 {
3529 return octave_value(value);
3530 }
3531
3532
3533SWIGINTERNINLINE octave_value
3535{
3537}
3538
3539
3540SWIGINTERN int
3541SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3542{
3543 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3544 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3545 if (SWIG_IsOK(res)) {
3546 /* special case of single char conversion when we don't need space for NUL */
3547 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3548 if (csize <= size) {
3549 if (val) {
3550 if (csize) memcpy(val, cptr, csize*sizeof(char));
3551 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3552 }
3553 if (alloc == SWIG_NEWOBJ) {
3554 delete[] cptr;
3555 res = SWIG_DelNewMask(res);
3556 }
3557 return res;
3558 }
3559 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3560 }
3561 return SWIG_TypeError;
3562}
3563
3564
3567{
3568 static int init = 0;
3569 static swig_type_info* info = 0;
3570 if (!init) {
3571 info = SWIG_TypeQuery("_p_char");
3572 init = 1;
3573 }
3574 return info;
3575}
3576
3577
3578SWIGINTERNINLINE octave_value
3579SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3580{
3581 return std::string(carray,carray+size);
3582}
3583
3584
3585SWIGINTERN size_t
3586SWIG_strnlen(const char* s, size_t maxlen)
3587{
3588 const char *p;
3589 for (p = s; maxlen-- && *p; p++)
3590 ;
3591 return p - s;
3592}
3593
3594
3595SWIGINTERN int
3596SWIG_AsVal_char (octave_value obj, char *val)
3597{
3598 int res = SWIG_AsCharArray(obj, val, 1);
3599 if (!SWIG_IsOK(res)) {
3600 long v;
3601 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3602 if (SWIG_IsOK(res)) {
3603 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3604 if (val) *val = static_cast< char >(v);
3605 } else {
3606 res = SWIG_OverflowError;
3607 }
3608 }
3609 }
3610 return res;
3611}
3612
3613static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3614Set up transformation from metafile coordinates\n\
3615\n\
3616DESCRIPTION:\n\
3617\n\
3618 Set up transformation from metafile coordinates. The size of the plot\n\
3619 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3620 general-purpose facility just yet (not sure why the user would need\n\
3621 it, for one).\n\
3622\n\
3623 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3624 dimypmm)\n\
3625\n\
3626 This function is not used in any examples.\n\
3627\n\
3628\n\
3629\n\
3630SYNOPSIS:\n\
3631\n\
3632plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3633\n\
3634ARGUMENTS:\n\
3635\n\
3636 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3637\n\
3638 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3639\n\
3640 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3641\n\
3642 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3643\n\
3644 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3645\n\
3646 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3647";
3648static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3649Set the cmap0 palette using the specified cmap0*.pal format file\n\
3650\n\
3651DESCRIPTION:\n\
3652\n\
3653 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3654\n\
3655 Redacted form: plspal0(filename)\n\
3656\n\
3657 This function is in example 16.\n\
3658\n\
3659\n\
3660\n\
3661SYNOPSIS:\n\
3662\n\
3663plspal0(filename)\n\
3664\n\
3665ARGUMENTS:\n\
3666\n\
3667 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3668 containing the name of the cmap0*.pal file. If this string is\n\
3669 empty, use the default cmap0*.pal file.\n\
3670";
3671static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3672Set the cmap1 palette using the specified cmap1*.pal format file\n\
3673\n\
3674DESCRIPTION:\n\
3675\n\
3676 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3677\n\
3678 Redacted form: plspal1(filename, interpolate)\n\
3679\n\
3680 This function is used in example 16.\n\
3681\n\
3682\n\
3683\n\
3684SYNOPSIS:\n\
3685\n\
3686plspal1(filename, interpolate)\n\
3687\n\
3688ARGUMENTS:\n\
3689\n\
3690 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3691 containing the name of the cmap1*.pal file. If this string is\n\
3692 empty, use the default cmap1*.pal file.\n\
3693\n\
3694 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3695 columns containing the intensity index, r, g, b, alpha and\n\
3696 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3697 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3698 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3699 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3700 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3701 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3702 are used instead to set the cmap1 palette directly with a call to\n\
3703 plscmap1a.\n\
3704";
3705static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3706Draw a line in 3 space\n\
3707\n\
3708DESCRIPTION:\n\
3709\n\
3710 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3711 first set up the viewport, the 2d viewing window (in world\n\
3712 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3713 more info.\n\
3714\n\
3715 Redacted form: plline3(x, y, z)\n\
3716\n\
3717 This function is used in example 18.\n\
3718\n\
3719\n\
3720\n\
3721SYNOPSIS:\n\
3722\n\
3723plline3(n, x, y, z)\n\
3724\n\
3725ARGUMENTS:\n\
3726\n\
3727 n (PLINT, input) : Number of points defining line.\n\
3728\n\
3729 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3730 points.\n\
3731\n\
3732 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3733 points.\n\
3734\n\
3735 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3736 points.\n\
3737";
3738static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3739Magnitude colored plot surface mesh with contour\n\
3740\n\
3741DESCRIPTION:\n\
3742\n\
3743 A more powerful form of plmesh: the surface mesh can be colored\n\
3744 accordingly to the current z value being plotted, a contour plot can\n\
3745 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3746 plotted function border and the base XY plane.\n\
3747\n\
3748 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3749\n\
3750 This function is used in example 11.\n\
3751\n\
3752\n\
3753\n\
3754SYNOPSIS:\n\
3755\n\
3756plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3757\n\
3758ARGUMENTS:\n\
3759\n\
3760 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3761 which the function is evaluated.\n\
3762\n\
3763 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3764 which the function is evaluated.\n\
3765\n\
3766 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3767 plot. Should have dimensions of\n\
3768 nx by\n\
3769 ny.\n\
3770\n\
3771 nx (PLINT, input) : Number of x values at which function is\n\
3772 evaluated.\n\
3773\n\
3774 ny (PLINT, input) : Number of y values at which function is\n\
3775 evaluated.\n\
3776\n\
3777 opt (PLINT, input) : Determines the way in which the surface is\n\
3778 represented. To specify more than one option just add the options,\n\
3779 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3780 showing z as a function of x for each value of y[j] .\n\
3781 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3782 for each value of x[i] .\n\
3783 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3784 at which function is defined.\n\
3785 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3786 the z value being plotted. The color is used from the current\n\
3787 cmap1.\n\
3788 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3789 using parameters\n\
3790 nlevel and\n\
3791 clevel.\n\
3792 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3793 the borders of the plotted function.\n\
3794\n\
3795\n\
3796 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3797 levels.\n\
3798\n\
3799 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3800";
3801static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3802Draw a line between two points, accounting for coordinate transforms\n\
3803\n\
3804DESCRIPTION:\n\
3805\n\
3806 Joins the point (\n\
3807 x1,\n\
3808 y1) to (\n\
3809 x2,\n\
3810 y2) . If a global coordinate transform is defined then the line is\n\
3811 broken in to n segments to approximate the path. If no transform is\n\
3812 defined then this simply acts like a call to pljoin.\n\
3813\n\
3814 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3815\n\
3816 This function is used in example 22.\n\
3817\n\
3818\n\
3819\n\
3820SYNOPSIS:\n\
3821\n\
3822plpath(n, x1, y1, x2, y2)\n\
3823\n\
3824ARGUMENTS:\n\
3825\n\
3826 n (PLINT, input) : number of points to use to approximate the path.\n\
3827\n\
3828 x1 (PLFLT, input) : x coordinate of first point.\n\
3829\n\
3830 y1 (PLFLT, input) : y coordinate of first point.\n\
3831\n\
3832 x2 (PLFLT, input) : x coordinate of second point.\n\
3833\n\
3834 y2 (PLFLT, input) : y coordinate of second point.\n\
3835";
3836static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3837Write text inside the viewport\n\
3838\n\
3839DESCRIPTION:\n\
3840\n\
3841 Writes text at a specified position and inclination within the\n\
3842 viewport. Text is clipped at the viewport boundaries. The reference\n\
3843 point of a string lies along a line passing through the string at half\n\
3844 the height of a capital letter. The position of the reference point\n\
3845 along this line is determined by just, the reference point is placed\n\
3846 at world coordinates (\n\
3847 x,\n\
3848 y) within the viewport. The inclination of the string is specified\n\
3849 in terms of differences of world coordinates making it easy to write\n\
3850 text parallel to a line in a graph.\n\
3851\n\
3852 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3853\n\
3854 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3855\n\
3856\n\
3857\n\
3858SYNOPSIS:\n\
3859\n\
3860plptex(x, y, dx, dy, just, text)\n\
3861\n\
3862ARGUMENTS:\n\
3863\n\
3864 x (PLFLT, input) : x coordinate of reference point of string.\n\
3865\n\
3866 y (PLFLT, input) : y coordinate of reference point of string.\n\
3867\n\
3868 dx (PLFLT, input) : Together with dy, this specifies the\n\
3869 inclination of the string. The baseline of the string is parallel\n\
3870 to a line joining (\n\
3871 x,\n\
3872 y) to (\n\
3873 x+\n\
3874 dx,\n\
3875 y+\n\
3876 dy) .\n\
3877\n\
3878 dy (PLFLT, input) : Together with dx, this specifies the\n\
3879 inclination of the string.\n\
3880\n\
3881 just (PLFLT, input) : Specifies the position of the string relative\n\
3882 to its reference point. If just=0. , the reference point is at\n\
3883 the left and if just=1. , it is at the right of the string. Other\n\
3884 values of just give intermediate justifications.\n\
3885\n\
3886 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3887 written out.\n\
3888";
3889static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3890Set family file parameters\n\
3891\n\
3892DESCRIPTION:\n\
3893\n\
3894 Sets variables dealing with output file familying. Does nothing if\n\
3895 familying not supported by the driver. This routine, if used, must be\n\
3896 called before initializing PLplot. See the PLplot documentation for\n\
3897 more information.\n\
3898\n\
3899 Redacted form: plsfam(fam, num, bmax)\n\
3900\n\
3901 This function is used in examples 14 and 31.\n\
3902\n\
3903\n\
3904\n\
3905SYNOPSIS:\n\
3906\n\
3907plsfam(fam, num, bmax)\n\
3908\n\
3909ARGUMENTS:\n\
3910\n\
3911 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3912 is enabled.\n\
3913\n\
3914 num (PLINT, input) : Current family file number.\n\
3915\n\
3916 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3917 file.\n\
3918";
3919static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3920Set y axis parameters\n\
3921\n\
3922DESCRIPTION:\n\
3923\n\
3924 Identical to plsxax, except that arguments are flags for y axis. See\n\
3925 the description of plsxax for more detail.\n\
3926\n\
3927 Redacted form: plsyax(digmax, digits)\n\
3928\n\
3929 This function is used in examples 1, 14, and 31.\n\
3930\n\
3931\n\
3932\n\
3933SYNOPSIS:\n\
3934\n\
3935plsyax(digmax, digits)\n\
3936\n\
3937ARGUMENTS:\n\
3938\n\
3939 digmax (PLINT, input) : Variable to set the maximum number of\n\
3940 digits for the y axis. If nonzero, the printed label will be\n\
3941 switched to a floating-point representation when the number of\n\
3942 digits exceeds digmax.\n\
3943\n\
3944 digits (PLINT, input) : Field digits value. Currently, changing\n\
3945 its value here has no effect since it is set only by plbox or\n\
3946 plbox3. However, the user may obtain its value after a call to\n\
3947 either of these functions by calling plgyax.\n\
3948";
3949static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
3950Get z axis parameters\n\
3951\n\
3952DESCRIPTION:\n\
3953\n\
3954 Identical to plgxax, except that arguments are flags for z axis. See\n\
3955 the description of plgxax for more detail.\n\
3956\n\
3957 Redacted form: plgzax(p_digmax, p_digits)\n\
3958\n\
3959 This function is used in example 31.\n\
3960\n\
3961\n\
3962\n\
3963SYNOPSIS:\n\
3964\n\
3965plgzax(p_digmax, p_digits)\n\
3966\n\
3967ARGUMENTS:\n\
3968\n\
3969 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
3970 number of digits for the z axis. If nonzero, the printed label\n\
3971 has been switched to a floating-point representation when the\n\
3972 number of digits exceeds this value.\n\
3973\n\
3974 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
3975 number of digits for the numeric labels (z axis) from the last\n\
3976 plot.\n\
3977";
3978static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
3979Set format of numerical label for contours\n\
3980\n\
3981DESCRIPTION:\n\
3982\n\
3983 Set format of numerical label for contours.\n\
3984\n\
3985 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
3986\n\
3987 This function is used example 9.\n\
3988\n\
3989\n\
3990\n\
3991SYNOPSIS:\n\
3992\n\
3993pl_setcontlabelformat(lexp, sigdig)\n\
3994\n\
3995ARGUMENTS:\n\
3996\n\
3997 lexp (PLINT, input) : If the contour numerical label is greater\n\
3998 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
3999 format is used. Default value of lexp is 4.\n\
4000\n\
4001 sigdig (PLINT, input) : Number of significant digits. Default\n\
4002 value is 2.\n\
4003";
4004static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4005Set pen width\n\
4006\n\
4007DESCRIPTION:\n\
4008\n\
4009 Sets the pen width.\n\
4010\n\
4011 Redacted form: plwidth(width)\n\
4012\n\
4013 This function is used in examples 1 and 2.\n\
4014\n\
4015\n\
4016\n\
4017SYNOPSIS:\n\
4018\n\
4019plwidth(width)\n\
4020\n\
4021ARGUMENTS:\n\
4022\n\
4023 width (PLFLT, input) : The desired pen width. If width is negative\n\
4024 or the same as the previous value no action is taken. width = 0.\n\
4025 should be interpreted as as the minimum valid pen width for the\n\
4026 device. The interpretation of positive width values is also\n\
4027 device dependent.\n\
4028";
4029static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4030Get parameters that define current plot-space window\n\
4031\n\
4032DESCRIPTION:\n\
4033\n\
4034 Get relative minima and maxima that define current plot-space window.\n\
4035 If plsdiplt has not been called the default values pointed to by\n\
4036 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4037\n\
4038 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4039\n\
4040 This function is used in example 31.\n\
4041\n\
4042\n\
4043\n\
4044SYNOPSIS:\n\
4045\n\
4046plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4047\n\
4048ARGUMENTS:\n\
4049\n\
4050 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4051 minimum in x.\n\
4052\n\
4053 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4054 minimum in y.\n\
4055\n\
4056 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4057 maximum in x.\n\
4058\n\
4059 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4060 maximum in y.\n\
4061";
4062static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4063Set the cmap1 argument range for continuous color plots\n\
4064\n\
4065DESCRIPTION:\n\
4066\n\
4067 Set the cmap1 argument range for continuous color plots that\n\
4068 corresponds to the range of data values. The maximum range\n\
4069 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4070 the cmap1 argument range that is specified with this routine, the\n\
4071 smaller the subset of the cmap1 color palette that is used to\n\
4072 represent the continuous data being plotted. If\n\
4073 min_color is greater than\n\
4074 max_color or\n\
4075 max_color is greater than 1.0 or\n\
4076 min_color is less than 0.0 then no change is made to the cmap1\n\
4077 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4078\n\
4079 Redacted form: plscmap1_range(min_color, max_color)\n\
4080\n\
4081 This function is currently used in example 33.\n\
4082\n\
4083\n\
4084\n\
4085SYNOPSIS:\n\
4086\n\
4087plscmap1_range(min_color, max_color)\n\
4088\n\
4089ARGUMENTS:\n\
4090\n\
4091 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4092 than 0.0, then 0.0 is used instead.\n\
4093\n\
4094 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4095 than 1.0, then 1.0 is used instead.\n\
4096";
4097static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4098Select standard viewport\n\
4099\n\
4100DESCRIPTION:\n\
4101\n\
4102 Selects the largest viewport within the subpage that leaves a standard\n\
4103 margin (left-hand margin of eight character heights, and a margin\n\
4104 around the other three sides of five character heights).\n\
4105\n\
4106 Redacted form: plvsta()\n\
4107\n\
4108 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4109\n\
4110\n\
4111\n\
4112SYNOPSIS:\n\
4113\n\
4114plvsta()\n\
4115";
4116static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4117Load Hershey fonts\n\
4118\n\
4119DESCRIPTION:\n\
4120\n\
4121 Loads the Hershey fonts used for text and symbols. This routine may\n\
4122 be called before or after initializing PLplot. If not explicitly\n\
4123 called before PLplot initialization, then by default that\n\
4124 initialization loads Hershey fonts with the extended character set.\n\
4125 This routine only has a practical effect for devices that still use\n\
4126 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4127 system fonts instead of Hershey fonts).\n\
4128\n\
4129 Redacted form: plfontld(fnt)\n\
4130\n\
4131 This function is used in examples 1 and 7.\n\
4132\n\
4133\n\
4134\n\
4135SYNOPSIS:\n\
4136\n\
4137plfontld(fnt)\n\
4138\n\
4139ARGUMENTS:\n\
4140\n\
4141 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4142 A zero value specifies Hershey fonts with the standard character\n\
4143 set and a non-zero value (the default assumed if plfontld is never\n\
4144 called) specifies Hershey fonts with the extended character set.\n\
4145";
4146static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4147Draw error bars in x direction\n\
4148\n\
4149DESCRIPTION:\n\
4150\n\
4151 Draws a set of n error bars in x direction, the i\'th error bar\n\
4152 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4153 of the error bars are of length equal to the minor tick length\n\
4154 (settable using plsmin).\n\
4155\n\
4156 Redacted form: General: plerrx(xmin, ymax, y)\n\
4157\n\
4158\n\
4159 This function is used in example 29.\n\
4160\n\
4161\n\
4162\n\
4163SYNOPSIS:\n\
4164\n\
4165plerrx(n, xmin, xmax, y)\n\
4166\n\
4167ARGUMENTS:\n\
4168\n\
4169 n (PLINT, input) : Number of error bars to draw.\n\
4170\n\
4171 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4172 of the left-hand endpoints of the error bars.\n\
4173\n\
4174 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4175 of the right-hand endpoints of the error bars.\n\
4176\n\
4177 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4178 the error bars.\n\
4179";
4180static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4181Plot shaded 3-d surface plot\n\
4182\n\
4183DESCRIPTION:\n\
4184\n\
4185 Plots a three-dimensional shaded surface plot within the environment\n\
4186 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4187 z[\n\
4188 nx][\n\
4189 ny], the point z[i][j] being the value of the function at (\n\
4190 x[i],\n\
4191 y[j]). Note that the points in vectors x and y do not need to be\n\
4192 equally spaced, but must be stored in ascending order. For further\n\
4193 details see the PLplot documentation.\n\
4194\n\
4195 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4196\n\
4197 This function is not used in any examples.\n\
4198\n\
4199\n\
4200\n\
4201SYNOPSIS:\n\
4202\n\
4203plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4204\n\
4205ARGUMENTS:\n\
4206\n\
4207 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4208 which the function is evaluated.\n\
4209\n\
4210 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4211 which the function is evaluated.\n\
4212\n\
4213 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4214 plot. Should have dimensions of\n\
4215 nx by\n\
4216 ny.\n\
4217\n\
4218 nx (PLINT, input) : Number of x values at which function is\n\
4219 evaluated.\n\
4220\n\
4221 ny (PLINT, input) : Number of y values at which function is\n\
4222 evaluated.\n\
4223\n\
4224 opt (PLINT, input) : Determines the way in which the surface is\n\
4225 represented. To specify more than one option just add the options,\n\
4226 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4227 connecting points at which function is defined.\n\
4228 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4229 using parameters\n\
4230 nlevel and\n\
4231 clevel.\n\
4232 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4233 using parameters\n\
4234 nlevel and\n\
4235 clevel.\n\
4236 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4237 the borders of the plotted function.\n\
4238 opt=MAG_COLOR : the surface is colored according to the value\n\
4239 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4240 according to the intensity of the reflected light in the\n\
4241 surface from a light source whose position is set using\n\
4242 pllightsource.\n\
4243\n\
4244\n\
4245 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4246 levels.\n\
4247\n\
4248 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4249";
4250static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4251Get the current library version number\n\
4252\n\
4253DESCRIPTION:\n\
4254\n\
4255 Get the current library version number. Note: you must have allocated\n\
4256 space for this (80 characters is safe).\n\
4257\n\
4258 Redacted form: plgver(p_ver)\n\
4259\n\
4260 This function is used in example 1.\n\
4261\n\
4262\n\
4263\n\
4264SYNOPSIS:\n\
4265\n\
4266plgver(p_ver)\n\
4267\n\
4268ARGUMENTS:\n\
4269\n\
4270 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4271 (with preallocated length of 80 characters or more) containing the\n\
4272 PLplot version number.\n\
4273";
4274static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4275End plotting session for current stream\n\
4276\n\
4277DESCRIPTION:\n\
4278\n\
4279 Ends a plotting session for the current output stream only. See\n\
4280 plsstrm for more info.\n\
4281\n\
4282 Redacted form: plend1()\n\
4283\n\
4284 This function is used in examples 1 and 20.\n\
4285\n\
4286\n\
4287\n\
4288SYNOPSIS:\n\
4289\n\
4290plend1()\n\
4291";
4292static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4293Draw error bars in the y direction\n\
4294\n\
4295DESCRIPTION:\n\
4296\n\
4297 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4298 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4299 of the error bars are of length equal to the minor tick length\n\
4300 (settable using plsmin).\n\
4301\n\
4302 Redacted form: General: plerry(x, ymin, ymax)\n\
4303\n\
4304\n\
4305 This function is used in example 29.\n\
4306\n\
4307\n\
4308\n\
4309SYNOPSIS:\n\
4310\n\
4311plerry(n, x, ymin, ymax)\n\
4312\n\
4313ARGUMENTS:\n\
4314\n\
4315 n (PLINT, input) : Number of error bars to draw.\n\
4316\n\
4317 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4318 the error bars.\n\
4319\n\
4320 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4321 of the lower endpoints of the error bars.\n\
4322\n\
4323 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4324 of the upper endpoints of the error bars.\n\
4325";
4326static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4327Set seed for internal random number generator.\n\
4328\n\
4329DESCRIPTION:\n\
4330\n\
4331 Set the seed for the internal random number generator. See plrandd for\n\
4332 further details.\n\
4333\n\
4334 Redacted form: plseed(seed)\n\
4335\n\
4336 This function is used in example 21.\n\
4337\n\
4338\n\
4339\n\
4340SYNOPSIS:\n\
4341\n\
4342plseed(seed)\n\
4343\n\
4344ARGUMENTS:\n\
4345\n\
4346 seed (unsigned int, input) : Seed for random number generator.\n\
4347";
4348static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4349Specify viewport using normalized subpage coordinates\n\
4350\n\
4351DESCRIPTION:\n\
4352\n\
4353 Device-independent routine for setting up the viewport. This defines\n\
4354 the viewport in terms of normalized subpage coordinates which run from\n\
4355 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4356 current subpage. Use the alternate routine plsvpa in order to create\n\
4357 a viewport of a definite size.\n\
4358\n\
4359 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4360\n\
4361 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4362 24, 26, 27, and 31.\n\
4363\n\
4364\n\
4365\n\
4366SYNOPSIS:\n\
4367\n\
4368plvpor(xmin, xmax, ymin, ymax)\n\
4369\n\
4370ARGUMENTS:\n\
4371\n\
4372 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4373 left-hand edge of the viewport.\n\
4374\n\
4375 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4376 right-hand edge of the viewport.\n\
4377\n\
4378 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4379 bottom edge of the viewport.\n\
4380\n\
4381 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4382 edge of the viewport.\n\
4383";
4384static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4385Plot surface mesh\n\
4386\n\
4387DESCRIPTION:\n\
4388\n\
4389 Plots a surface mesh within the environment set up by plw3d. The\n\
4390 surface is defined by the matrix z[\n\
4391 nx][\n\
4392 ny] , the point z[i][j] being the value of the function at (\n\
4393 x[i],\n\
4394 y[j]). Note that the points in vectors x and y do not need to be\n\
4395 equally spaced, but must be stored in ascending order. The parameter\n\
4396 opt controls the way in which the surface is displayed. For further\n\
4397 details see the PLplot documentation.\n\
4398\n\
4399 Redacted form: plmesh(x, y, z, opt)\n\
4400\n\
4401 This function is used in example 11.\n\
4402\n\
4403\n\
4404\n\
4405SYNOPSIS:\n\
4406\n\
4407plmesh(x, y, z, nx, ny, opt)\n\
4408\n\
4409ARGUMENTS:\n\
4410\n\
4411 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4412 which the function is evaluated.\n\
4413\n\
4414 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4415 which the function is evaluated.\n\
4416\n\
4417 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4418 plot. Should have dimensions of\n\
4419 nx by\n\
4420 ny.\n\
4421\n\
4422 nx (PLINT, input) : Number of x values at which function has been\n\
4423 evaluated.\n\
4424\n\
4425 ny (PLINT, input) : Number of y values at which function has been\n\
4426 evaluated.\n\
4427\n\
4428 opt (PLINT, input) : Determines the way in which the surface is\n\
4429 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4430 function of x for each value of y[j] .\n\
4431 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4432 for each value of x[i] .\n\
4433 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4434 at which function is defined.\n\
4435";
4436static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4437Get the cmap1 argument range for continuous color plots\n\
4438\n\
4439DESCRIPTION:\n\
4440\n\
4441 Get the cmap1 argument range for continuous color plots. (Use\n\
4442 plscmap1_range to set the cmap1 argument range.)\n\
4443\n\
4444 Redacted form: plgcmap1_range(min_color, max_color)\n\
4445\n\
4446 This function is currently not used in any example.\n\
4447\n\
4448\n\
4449\n\
4450SYNOPSIS:\n\
4451\n\
4452plgcmap1_range(min_color, max_color)\n\
4453\n\
4454ARGUMENTS:\n\
4455\n\
4456 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4457 minimum cmap1 argument.\n\
4458\n\
4459 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4460 maximum cmap1 argument.\n\
4461";
4462static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4463Set arrow style for vector plots\n\
4464\n\
4465DESCRIPTION:\n\
4466\n\
4467 Set the style for the arrow used by plvect to plot vectors.\n\
4468\n\
4469 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4470\n\
4471 This function is used in example 22.\n\
4472\n\
4473\n\
4474\n\
4475SYNOPSIS:\n\
4476\n\
4477plsvect(arrowx, arrowy, npts, fill)\n\
4478\n\
4479ARGUMENTS:\n\
4480\n\
4481 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4482 the x and y points which make up the arrow. The arrow is plotted\n\
4483 by joining these points to form a polygon. The scaling assumes\n\
4484 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4485 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4486 will be reset to its default.\n\
4487\n\
4488 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4489 arrowy.\n\
4490\n\
4491 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4492 fill is false then the arrow is open.\n\
4493";
4494static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4495Draw filled polygon\n\
4496\n\
4497DESCRIPTION:\n\
4498\n\
4499 Fills the polygon defined by the n points (\n\
4500 x[i],\n\
4501 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4502 style is a solid fill. The routine will automatically close the\n\
4503 polygon between the last and first vertices. If multiple closed\n\
4504 polygons are passed in x and y then plfill will fill in between them.\n\
4505\n\
4506 Redacted form: plfill(x,y)\n\
4507\n\
4508 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4509\n\
4510\n\
4511\n\
4512SYNOPSIS:\n\
4513\n\
4514plfill(n, x, y)\n\
4515\n\
4516ARGUMENTS:\n\
4517\n\
4518 n (PLINT, input) : Number of vertices in polygon.\n\
4519\n\
4520 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4521 vertices.\n\
4522\n\
4523 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4524 vertices.\n\
4525";
4526static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4527Convert HLS color to RGB\n\
4528\n\
4529DESCRIPTION:\n\
4530\n\
4531 Convert HLS color coordinates to RGB.\n\
4532\n\
4533 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4534\n\
4535\n\
4536 This function is used in example 2.\n\
4537\n\
4538\n\
4539\n\
4540SYNOPSIS:\n\
4541\n\
4542plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4543\n\
4544ARGUMENTS:\n\
4545\n\
4546 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4547 cylinder.\n\
4548\n\
4549 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4550 the axis of the color cylinder.\n\
4551\n\
4552 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4553 the radius of the color cylinder.\n\
4554\n\
4555 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4556 (0.0-1.0) of the color.\n\
4557\n\
4558 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4559 intensity (0.0-1.0) of the color.\n\
4560\n\
4561 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4562 intensity (0.0-1.0) of the color.\n\
4563";
4564static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4565Set format for date / time labels\n\
4566\n\
4567DESCRIPTION:\n\
4568\n\
4569 Sets the format for date / time labels. To enable date / time format\n\
4570 labels see the options to plbox, plbox3, and plenv.\n\
4571\n\
4572 Redacted form: pltimefmt(fmt)\n\
4573\n\
4574 This function is used in example 29.\n\
4575\n\
4576\n\
4577\n\
4578SYNOPSIS:\n\
4579\n\
4580pltimefmt(fmt)\n\
4581\n\
4582ARGUMENTS:\n\
4583\n\
4584 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4585 interpreted similarly to the format specifier of typical system\n\
4586 strftime routines except that PLplot ignores locale and also\n\
4587 supplies some useful extensions in the context of plotting. All\n\
4588 text in the string is printed as-is other than conversion\n\
4589 specifications which take the form of a \'%\' character followed by\n\
4590 further conversion specification character. The conversion\n\
4591 specifications which are similar to those provided by system\n\
4592 strftime routines are the following: %a: The abbreviated (English)\n\
4593 weekday name.\n\
4594 %A: The full (English) weekday name.\n\
4595 %b: The abbreviated (English) month name.\n\
4596 %B: The full (English) month name.\n\
4597 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4598 %C: The century number (year/100) as a 2-digit integer.\n\
4599 %d: The day of the month as a decimal number (range 01 to 31).\n\
4600 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4601 %e: Like %d, but a leading zero is replaced by a space.\n\
4602 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4603 %h: Equivalent to %b.\n\
4604 %H: The hour as a decimal number using a 24-hour clock (range\n\
4605 00 to 23).\n\
4606 %I: The hour as a decimal number using a 12-hour clock (range\n\
4607 01 to 12).\n\
4608 %j: The day of the year as a decimal number (range 001 to\n\
4609 366).\n\
4610 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4611 23); single digits are preceded by a blank. (See also %H.)\n\
4612 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4613 12); single digits are preceded by a blank. (See also %I.)\n\
4614 %m: The month as a decimal number (range 01 to 12).\n\
4615 %M: The minute as a decimal number (range 00 to 59).\n\
4616 %n: A newline character.\n\
4617 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4618 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4619 %r: Equivalent to %I:%M:%S %p.\n\
4620 %R: The time in 24-hour notation (%H:%M). For a version\n\
4621 including the seconds, see %T below.\n\
4622 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4623 +0000 (UTC).\n\
4624 %S: The second as a decimal number (range 00 to 60). (The\n\
4625 range is up to 60 to allow for occasional leap seconds.)\n\
4626 %t: A tab character.\n\
4627 %T: The time in 24-hour notation (%H:%M:%S).\n\
4628 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4629 being 1. See also %w.\n\
4630 %U: The week number of the current year as a decimal number,\n\
4631 range 00 to 53, starting with the first Sunday as the first\n\
4632 day of week 01. See also %V and %W.\n\
4633 %v: Equivalent to %e-%b-%Y.\n\
4634 %V: The ISO 8601 week number of the current year as a decimal\n\
4635 number, range 01 to 53, where week 1 is the first week that\n\
4636 has at least 4 days in the new year. See also %U and %W.\n\
4637 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4638 being 0. See also %u.\n\
4639 %W: The week number of the current year as a decimal number,\n\
4640 range 00 to 53, starting with the first Monday as the first\n\
4641 day of week 01.\n\
4642 %x: Equivalent to %a %b %d %Y.\n\
4643 %X: Equivalent to %T.\n\
4644 %y: The year as a decimal number without a century (range 00\n\
4645 to 99).\n\
4646 %Y: The year as a decimal number including a century.\n\
4647 %z: The UTC time-zone string = \"+0000\".\n\
4648 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4649 %+: The UTC date and time in default format of the Unix date\n\
4650 command which is equivalent to %a %b %d %T %Z %Y.\n\
4651 %%: A literal \"%\" character.\n\
4652 The conversion specifications which are extensions to those normally\n\
4653 provided by system strftime routines are the following: %(0-9):\n\
4654 The fractional part of the seconds field (including leading\n\
4655 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4656 seconds to millisecond accuracy (00.000).\n\
4657 %.: The fractional part of the seconds field (including\n\
4658 leading decimal point) to the maximum available accuracy. Thus\n\
4659 %S%. would give seconds with fractional part up to 9 decimal\n\
4660 places if available.\n\
4661";
4662static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4663Get current subpage parameters\n\
4664\n\
4665DESCRIPTION:\n\
4666\n\
4667 Gets the size of the current subpage in millimeters measured from the\n\
4668 bottom left hand corner of the output device page or screen. Can be\n\
4669 used in conjunction with plsvpa for setting the size of a viewport in\n\
4670 absolute coordinates (millimeters).\n\
4671\n\
4672 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4673\n\
4674 This function is used in example 23.\n\
4675\n\
4676\n\
4677\n\
4678SYNOPSIS:\n\
4679\n\
4680plgspa(xmin, xmax, ymin, ymax)\n\
4681\n\
4682ARGUMENTS:\n\
4683\n\
4684 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4685 the left hand edge of the subpage in millimeters.\n\
4686\n\
4687 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4688 the right hand edge of the subpage in millimeters.\n\
4689\n\
4690 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4691 the bottom edge of the subpage in millimeters.\n\
4692\n\
4693 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4694 the top edge of the subpage in millimeters.\n\
4695";
4696static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4697Calculate world coordinates and corresponding window index from relative device coordinates\n\
4698\n\
4699DESCRIPTION:\n\
4700\n\
4701 Calculate world coordinates, wx and wy, and corresponding window index\n\
4702 from relative device coordinates, rx and ry.\n\
4703\n\
4704 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4705\n\
4706\n\
4707 This function is used in example 31.\n\
4708\n\
4709\n\
4710\n\
4711SYNOPSIS:\n\
4712\n\
4713plcalc_world(rx, ry, wx, wy, window)\n\
4714\n\
4715ARGUMENTS:\n\
4716\n\
4717 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4718 the x coordinate.\n\
4719\n\
4720 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4721 the y coordinate.\n\
4722\n\
4723 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4724 coordinate corresponding to the relative device coordinates rx and\n\
4725 ry.\n\
4726\n\
4727 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4728 coordinate corresponding to the relative device coordinates rx and\n\
4729 ry.\n\
4730\n\
4731 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4732 defined window index that corresponds to the input relative device\n\
4733 coordinates (and the returned world coordinates). To give some\n\
4734 background on the window index, for each page the initial window\n\
4735 index is set to zero, and each time plwind is called within the\n\
4736 page, world and device coordinates are stored for the window and\n\
4737 the window index is incremented. Thus, for a simple page layout\n\
4738 with non-overlapping viewports and one window per viewport, window\n\
4739 corresponds to the viewport index (in the order which the\n\
4740 viewport/windows were created) of the only viewport/window\n\
4741 corresponding to rx and ry. However, for more complicated layouts\n\
4742 with potentially overlapping viewports and possibly more than one\n\
4743 window (set of world coordinates) per viewport, window and the\n\
4744 corresponding output world coordinates corresponds to the last\n\
4745 window created that fulfills the criterion that the relative\n\
4746 device coordinates are inside it. Finally, in all cases where the\n\
4747 input relative device coordinates are not inside any\n\
4748 viewport/window, then the returned value of the last defined\n\
4749 window index is set to -1.\n\
4750";
4751static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4752Get output file name\n\
4753\n\
4754DESCRIPTION:\n\
4755\n\
4756 Gets the current output file name, if applicable.\n\
4757\n\
4758 Redacted form: plgfnam(fnam)\n\
4759\n\
4760 This function is used in example 31.\n\
4761\n\
4762\n\
4763\n\
4764SYNOPSIS:\n\
4765\n\
4766plgfnam(fnam)\n\
4767\n\
4768ARGUMENTS:\n\
4769\n\
4770 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4771 (with preallocated length of 80 characters or more) containing the\n\
4772 file name.\n\
4773";
4774static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4775Vector plot\n\
4776\n\
4777DESCRIPTION:\n\
4778\n\
4779 Draws a plot of vector data contained in the matrices (\n\
4780 u[\n\
4781 nx][\n\
4782 ny],\n\
4783 v[\n\
4784 nx][\n\
4785 ny]) . The scaling factor for the vectors is given by scale. A\n\
4786 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4787 additional data required by the transformation routine to map indices\n\
4788 within the matrices to the world coordinates. The style of the vector\n\
4789 arrow may be set using plsvect.\n\
4790\n\
4791 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4792 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4793 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4794 with either one or two dimensions.\n\
4795\n\
4796 This function is used in example 22.\n\
4797\n\
4798\n\
4799\n\
4800SYNOPSIS:\n\
4801\n\
4802plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4803\n\
4804ARGUMENTS:\n\
4805\n\
4806 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4807 and y components of the vector data to be plotted.\n\
4808\n\
4809 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4810\n\
4811 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4812 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4813 automatically calculated for the data. If scale < 0 then the\n\
4814 scaling factor is automatically calculated for the data and then\n\
4815 multiplied by -\n\
4816 scale. If scale > 0 then the scaling factor is set to scale.\n\
4817\n\
4818 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4819 defines the transformation between the zero-based indices of the\n\
4820 matrices u and v and world coordinates.For the C case,\n\
4821 transformation functions are provided in the PLplot library: pltr0\n\
4822 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4823 mappings respectively defined by vectors and matrices. In\n\
4824 addition, C callback routines for the transformation can be\n\
4825 supplied by the user such as the mypltr function in\n\
4826 examples/c/x09c.c which provides a general linear transformation\n\
4827 between index coordinates and world coordinates.For languages\n\
4828 other than C you should consult the PLplot documentation for the\n\
4829 details concerning how PLTRANSFORM_callback arguments are\n\
4830 interfaced. However, in general, a particular pattern of\n\
4831 callback-associated arguments such as a tr vector with 6 elements;\n\
4832 xg and yg vectors; or xg and yg matrices are respectively\n\
4833 interfaced to a linear-transformation routine similar to the above\n\
4834 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4835 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4836 support native language callbacks for handling index to\n\
4837 world-coordinate transformations. Examples of these various\n\
4838 approaches are given in examples/<language>x09*,\n\
4839 examples/<language>x16*, examples/<language>x20*,\n\
4840 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4841 supported languages.\n\
4842\n\
4843 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4844 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4845 that is externally supplied.\n\
4846";
4847static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4848Plot a glyph at the specified points\n\
4849\n\
4850DESCRIPTION:\n\
4851\n\
4852 Plot a glyph at the specified points. (This function is largely\n\
4853 superseded by plstring which gives access to many[!] more glyphs.)\n\
4854\n\
4855 Redacted form: plsym(x, y, code)\n\
4856\n\
4857 This function is used in example 7.\n\
4858\n\
4859\n\
4860\n\
4861SYNOPSIS:\n\
4862\n\
4863plsym(n, x, y, code)\n\
4864\n\
4865ARGUMENTS:\n\
4866\n\
4867 n (PLINT, input) : Number of points in the x and y vectors.\n\
4868\n\
4869 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4870 the points.\n\
4871\n\
4872 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4873 the points.\n\
4874\n\
4875 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4876 to be plotted at each of the n points.\n\
4877";
4878static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4879Get viewport limits in normalized device coordinates\n\
4880\n\
4881DESCRIPTION:\n\
4882\n\
4883 Get viewport limits in normalized device coordinates.\n\
4884\n\
4885 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4886\n\
4887\n\
4888 This function is used in example 31.\n\
4889\n\
4890\n\
4891\n\
4892SYNOPSIS:\n\
4893\n\
4894plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4895\n\
4896ARGUMENTS:\n\
4897\n\
4898 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4899 viewport limit of the normalized device coordinate in x.\n\
4900\n\
4901 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4902 viewport limit of the normalized device coordinate in x.\n\
4903\n\
4904 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4905 viewport limit of the normalized device coordinate in y.\n\
4906\n\
4907 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4908 viewport limit of the normalized device coordinate in y.\n\
4909";
4910static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4911Get page parameters\n\
4912\n\
4913DESCRIPTION:\n\
4914\n\
4915 Gets the current page configuration. The length and offset values are\n\
4916 expressed in units that are specific to the current driver. For\n\
4917 instance: screen drivers will usually interpret them as number of\n\
4918 pixels, whereas printer drivers will usually use mm.\n\
4919\n\
4920 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4921\n\
4922 This function is used in examples 14 and 31.\n\
4923\n\
4924\n\
4925\n\
4926SYNOPSIS:\n\
4927\n\
4928plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4929\n\
4930ARGUMENTS:\n\
4931\n\
4932 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4933 pixels/inch (DPI) in x.\n\
4934\n\
4935 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4936 pixels/inch (DPI) in y.\n\
4937\n\
4938 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4939 length.\n\
4940\n\
4941 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4942 length.\n\
4943\n\
4944 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4945 offset.\n\
4946\n\
4947 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4948 offset.\n\
4949";
4950static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
4951Plot a glyph at the specified 3D points\n\
4952\n\
4953DESCRIPTION:\n\
4954\n\
4955 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
4956 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
4957 this function similar to what is done for plline3. The glyph is\n\
4958 specified with a PLplot user string. Note that the user string is not\n\
4959 actually limited to one glyph so it is possible (but not normally\n\
4960 useful) to plot more than one glyph at the specified points with this\n\
4961 function. As with plmtex and plptex, the user string can contain FCI\n\
4962 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4963 else PLplot escapes for Hershey or unicode text to determine the\n\
4964 glyph.\n\
4965\n\
4966 Redacted form: plstring3(x, y, z, string)\n\
4967\n\
4968 This function is used in example 18.\n\
4969\n\
4970\n\
4971\n\
4972SYNOPSIS:\n\
4973\n\
4974plstring3(n, x, y, z, string)\n\
4975\n\
4976ARGUMENTS:\n\
4977\n\
4978 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
4979\n\
4980 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4981 the points.\n\
4982\n\
4983 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4984 the points.\n\
4985\n\
4986 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
4987 the points.\n\
4988\n\
4989 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4990 the glyph(s) to be plotted at each of the n points. points.\n\
4991";
4992static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
4993Shade regions on the basis of value\n\
4994\n\
4995DESCRIPTION:\n\
4996\n\
4997 Shade regions on the basis of value. This is the high-level routine\n\
4998 for making continuous color shaded plots with cmap1 while plshade\n\
4999 should be used to plot individual shaded regions using either cmap0 or\n\
5000 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5001 our supported languages.\n\
5002\n\
5003 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5004 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5005 pltr_data)\n\
5006\n\
5007\n\
5008 This function is used in examples 16, 21, and 22.\n\
5009\n\
5010\n\
5011\n\
5012SYNOPSIS:\n\
5013\n\
5014plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5015\n\
5016ARGUMENTS:\n\
5017\n\
5018 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5019 plot. Should have dimensions of\n\
5020 nx by\n\
5021 ny.\n\
5022\n\
5023 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5024\n\
5025 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5026\n\
5027 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5028 the region that should be plotted in the shade plot. This\n\
5029 function accepts x and y coordinates as input arguments and must\n\
5030 return 1 if the point is to be included in the shade plot and 0\n\
5031 otherwise. If you want to plot the entire shade plot (the usual\n\
5032 case), this argument should be set to NULL.\n\
5033\n\
5034 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5035 pltr below for how these arguments are used (only for the special case\n\
5036 when the callback function\n\
5037 pltr is not supplied).\n\
5038\n\
5039 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5040 corresponding to the edges of each shaded region that will be\n\
5041 plotted by this function. To work properly the levels should be\n\
5042 monotonic.\n\
5043\n\
5044 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5045 of shade edge values in clevel).\n\
5046\n\
5047 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5048 pattern.\n\
5049\n\
5050 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5051 contours defining edges of shaded regions. The pen color is only\n\
5052 temporary set for the contour drawing. Set this value to zero or\n\
5053 less if no shade edge contours are wanted.\n\
5054\n\
5055 cont_width (PLFLT, input) : Defines line width used for contours\n\
5056 defining edges of shaded regions. This value may not be honored\n\
5057 by all drivers. The pen width is only temporary set for the\n\
5058 contour drawing. Set this value to zero or less if no shade edge\n\
5059 contours are wanted.\n\
5060\n\
5061 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5062 region. Use plfill for this purpose.\n\
5063\n\
5064 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5065 map to rectangles after coordinate transformation with pltrl.\n\
5066 Otherwise, set rectangular to false. If rectangular is set to\n\
5067 true, plshade tries to save time by filling large rectangles.\n\
5068 This optimization fails if the coordinate transformation distorts\n\
5069 the shape of rectangles. For example a plot in polar coordinates\n\
5070 has to have rectangular set to false.\n\
5071\n\
5072 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5073 defines the transformation between the zero-based indices of the\n\
5074 matrix a and world coordinates. If\n\
5075 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5076 indices of a are mapped to the range\n\
5077 xmin through\n\
5078 xmax and the y indices of a are mapped to the range\n\
5079 ymin through\n\
5080 ymax.For the C case, transformation functions are provided in the\n\
5081 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5082 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5083 matrices. In addition, C callback routines for the transformation\n\
5084 can be supplied by the user such as the mypltr function in\n\
5085 examples/c/x09c.c which provides a general linear transformation\n\
5086 between index coordinates and world coordinates.For languages\n\
5087 other than C you should consult the PLplot documentation for the\n\
5088 details concerning how PLTRANSFORM_callback arguments are\n\
5089 interfaced. However, in general, a particular pattern of\n\
5090 callback-associated arguments such as a tr vector with 6 elements;\n\
5091 xg and yg vectors; or xg and yg matrices are respectively\n\
5092 interfaced to a linear-transformation routine similar to the above\n\
5093 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5094 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5095 support native language callbacks for handling index to\n\
5096 world-coordinate transformations. Examples of these various\n\
5097 approaches are given in examples/<language>x09*,\n\
5098 examples/<language>x16*, examples/<language>x20*,\n\
5099 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5100 supported languages.\n\
5101\n\
5102 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5103 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5104 externally supplied.\n\
5105";
5106static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5107Set output file name\n\
5108\n\
5109DESCRIPTION:\n\
5110\n\
5111 Sets the current output file name, if applicable. If the file name\n\
5112 has not been specified and is required by the driver, the user will be\n\
5113 prompted for it. If using the X-windows output driver, this sets the\n\
5114 display name. This routine, if used, must be called before\n\
5115 initializing PLplot.\n\
5116\n\
5117 Redacted form: plsfnam(fnam)\n\
5118\n\
5119 This function is used in examples 1 and 20.\n\
5120\n\
5121\n\
5122\n\
5123SYNOPSIS:\n\
5124\n\
5125plsfnam(fnam)\n\
5126\n\
5127ARGUMENTS:\n\
5128\n\
5129 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5130 the file name.\n\
5131";
5132static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5133Contour plot\n\
5134\n\
5135DESCRIPTION:\n\
5136\n\
5137 Draws a contour plot of the data in f[\n\
5138 nx][\n\
5139 ny], using the nlevel contour levels specified by clevel. Only the\n\
5140 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5141 where all these index ranges are interpreted as one-based for\n\
5142 historical reasons. A transformation routine pointed to by pltr with\n\
5143 a generic pointer pltr_data for additional data required by the\n\
5144 transformation routine is used to map indices within the matrix to the\n\
5145 world coordinates.\n\
5146\n\
5147 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5148 where (see above discussion) the pltr, pltr_data callback arguments\n\
5149 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5150 vectors; or xg and yg matrices.\n\
5151\n\
5152 This function is used in examples 9, 14, 16, and 22.\n\
5153\n\
5154\n\
5155\n\
5156SYNOPSIS:\n\
5157\n\
5158plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5159\n\
5160ARGUMENTS:\n\
5161\n\
5162 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5163\n\
5164 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5165\n\
5166 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5167 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5168 zero-based for historical backwards-compatibility reasons.\n\
5169\n\
5170 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5171 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5172 zero-based for historical backwards-compatibility reasons.\n\
5173\n\
5174 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5175 which to draw contours.\n\
5176\n\
5177 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5178\n\
5179 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5180 defines the transformation between the zero-based indices of the\n\
5181 matrix f and the world coordinates.For the C case, transformation\n\
5182 functions are provided in the PLplot library: pltr0 for the\n\
5183 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5184 respectively defined by vectors and matrices. In addition, C\n\
5185 callback routines for the transformation can be supplied by the\n\
5186 user such as the mypltr function in examples/c/x09c.c which\n\
5187 provides a general linear transformation between index coordinates\n\
5188 and world coordinates.For languages other than C you should\n\
5189 consult the PLplot documentation for the details concerning how\n\
5190 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5191 general, a particular pattern of callback-associated arguments\n\
5192 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5193 yg matrices are respectively interfaced to a linear-transformation\n\
5194 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5195 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5196 the PLplot documentation) support native language callbacks for\n\
5197 handling index to world-coordinate transformations. Examples of\n\
5198 these various approaches are given in examples/<language>x09*,\n\
5199 examples/<language>x16*, examples/<language>x20*,\n\
5200 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5201 supported languages.\n\
5202\n\
5203 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5204 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5205 that is externally supplied.\n\
5206";
5207static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5208Set parameters that define current plot-space window\n\
5209\n\
5210DESCRIPTION:\n\
5211\n\
5212 Set relative minima and maxima that define the current plot-space\n\
5213 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5214 xmax, and ymax are 0., 0., 1., and 1.\n\
5215\n\
5216 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5217\n\
5218 This function is used in example 31.\n\
5219\n\
5220\n\
5221\n\
5222SYNOPSIS:\n\
5223\n\
5224plsdiplt(xmin, ymin, xmax, ymax)\n\
5225\n\
5226ARGUMENTS:\n\
5227\n\
5228 xmin (PLFLT, input) : Relative minimum in x.\n\
5229\n\
5230 ymin (PLFLT, input) : Relative minimum in y.\n\
5231\n\
5232 xmax (PLFLT, input) : Relative maximum in x.\n\
5233\n\
5234 ymax (PLFLT, input) : Relative maximum in y.\n\
5235";
5236static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5237Write text inside the viewport of a 3D plot\n\
5238\n\
5239DESCRIPTION:\n\
5240\n\
5241 Writes text at a specified position and inclination and with a\n\
5242 specified shear within the viewport. Text is clipped at the viewport\n\
5243 boundaries. The reference point of a string lies along a line passing\n\
5244 through the string at half the height of a capital letter. The\n\
5245 position of the reference point along this line is determined by just,\n\
5246 and the reference point is placed at world coordinates (\n\
5247 wx,\n\
5248 wy,\n\
5249 wz) within the viewport. The inclination and shear of the string is\n\
5250 specified in terms of differences of world coordinates making it easy\n\
5251 to write text parallel to a line in a graph.\n\
5252\n\
5253 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5254\n\
5255 This function is used in example 28.\n\
5256\n\
5257\n\
5258\n\
5259SYNOPSIS:\n\
5260\n\
5261plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5262\n\
5263ARGUMENTS:\n\
5264\n\
5265 wx (PLFLT, input) : x world coordinate of reference point of\n\
5266 string.\n\
5267\n\
5268 wy (PLFLT, input) : y world coordinate of reference point of\n\
5269 string.\n\
5270\n\
5271 wz (PLFLT, input) : z world coordinate of reference point of\n\
5272 string.\n\
5273\n\
5274 dx (PLFLT, input) : Together with dy and\n\
5275 dz , this specifies the inclination of the string. The baseline of\n\
5276 the string is parallel to a line joining (\n\
5277 x,\n\
5278 y,\n\
5279 z) to (\n\
5280 x+\n\
5281 dx,\n\
5282 y+\n\
5283 dy,\n\
5284 z+\n\
5285 dz) .\n\
5286\n\
5287 dy (PLFLT, input) : Together with dx and\n\
5288 dz, this specifies the inclination of the string.\n\
5289\n\
5290 dz (PLFLT, input) : Together with dx and\n\
5291 dy, this specifies the inclination of the string.\n\
5292\n\
5293 sx (PLFLT, input) : Together with sy and\n\
5294 sz , this specifies the shear of the string. The string is sheared so\n\
5295 that the characters are vertically parallel to a line joining (\n\
5296 x,\n\
5297 y,\n\
5298 z) to (\n\
5299 x+\n\
5300 sx,\n\
5301 y+\n\
5302 sy,\n\
5303 z+\n\
5304 sz) . If sx =\n\
5305 sy =\n\
5306 sz = 0.) then the text is not sheared.\n\
5307\n\
5308 sy (PLFLT, input) : Together with sx and\n\
5309 sz, this specifies shear of the string.\n\
5310\n\
5311 sz (PLFLT, input) : Together with sx and\n\
5312 sy, this specifies shear of the string.\n\
5313\n\
5314 just (PLFLT, input) : Specifies the position of the string relative\n\
5315 to its reference point. If just=0. , the reference point is at\n\
5316 the left and if just=1. , it is at the right of the string. Other\n\
5317 values of just give intermediate justifications.\n\
5318\n\
5319 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5320 written out.\n\
5321";
5322static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5323Plot continental outline or shapefile data in world coordinates\n\
5324\n\
5325DESCRIPTION:\n\
5326\n\
5327 Plots continental outlines or shapefile data in world coordinates. A\n\
5328 demonstration of how to use this function to create different\n\
5329 projections can be found in examples/c/x19c. PLplot is provided with\n\
5330 basic coastal outlines and USA state borders. To use the map\n\
5331 functionality PLplot must be compiled with the shapelib library.\n\
5332 Shapefiles have become a popular standard for geographical data and\n\
5333 data in this format can be easily found from a number of online\n\
5334 sources. Shapefile data is actually provided as three or more files\n\
5335 with the same filename, but different extensions. The .shp and .shx\n\
5336 files are required for plotting Shapefile data with PLplot.\n\
5337\n\
5338 PLplot currently supports the point, multipoint, polyline and polygon\n\
5339 objects within shapefiles. However holes in polygons are not\n\
5340 supported. When plmap is used the type of object is derived from the\n\
5341 shapefile, if you wish to override the type then use one of the other\n\
5342 plmap variants. The built in maps have line data only.\n\
5343\n\
5344 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5345\n\
5346 This function is used in example 19.\n\
5347\n\
5348\n\
5349\n\
5350SYNOPSIS:\n\
5351\n\
5352plmap(mapform, name, minx, maxx, miny, maxy)\n\
5353\n\
5354ARGUMENTS:\n\
5355\n\
5356 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5357 transform the original map data coordinates to a new coordinate\n\
5358 system. The PLplot-supplied map data is provided as latitudes and\n\
5359 longitudes; other Shapefile data may be provided in other\n\
5360 coordinate systems as can be found in their .prj plain text files.\n\
5361 For example, by using this transform we can change from a\n\
5362 longitude, latitude coordinate to a polar stereographic\n\
5363 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5364 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5365 corresponding y coordinates (latitudes for the PLplot supplied\n\
5366 data). After the call to mapform(), x[] and y[] should be\n\
5367 replaced by the corresponding plot coordinates. If no transform is\n\
5368 desired, mapform can be replaced by NULL.\n\
5369\n\
5370 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5371 the type of map plotted. This is either one of the PLplot built-in\n\
5372 maps or the file name of a set of Shapefile files without the file\n\
5373 extensions. For the PLplot built-in maps the possible values are:\n\
5374 \"globe\" -- continental outlines\n\
5375 \"usa\" -- USA and state boundaries\n\
5376 \"cglobe\" -- continental outlines and countries\n\
5377 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5378\n\
5379\n\
5380 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5381 drawn. The units must match the shapefile (built in maps are\n\
5382 degrees lat/lon). Objects in the file which do not encroach on the\n\
5383 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5384 note this is simply an optimisation, not a clipping so for objects\n\
5385 with some points inside the box and some points outside the box\n\
5386 all the points will be rendered. These parameters also define\n\
5387 latitude and longitude wrapping for shapefiles using these units.\n\
5388 Longitude points will be wrapped by integer multiples of 360\n\
5389 degrees to place them in the box. This allows the same data to be\n\
5390 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5391 you plot from -180-540 you will get two cycles of data drawn. The\n\
5392 value of minx must be less than the value of maxx. Passing in a\n\
5393 nan, max/-max floating point number or +/-infinity will case the\n\
5394 bounding box from the shapefile to be used.\n\
5395\n\
5396 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5397 drawn - see minx.\n\
5398\n\
5399 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5400 drawn - see minx.\n\
5401\n\
5402 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5403 drawn - see minx.\n\
5404";
5405static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5406Specify viewport using coordinates and aspect ratio\n\
5407\n\
5408DESCRIPTION:\n\
5409\n\
5410 Device-independent routine for setting up the viewport. The viewport\n\
5411 is chosen to be the largest with the given aspect ratio that fits\n\
5412 within the specified region (in terms of normalized subpage\n\
5413 coordinates). This routine is functionally equivalent to plvpor when\n\
5414 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5415 routine reserves no extra space at the edges for labels.\n\
5416\n\
5417 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5418\n\
5419 This function is used in example 9.\n\
5420\n\
5421\n\
5422\n\
5423SYNOPSIS:\n\
5424\n\
5425plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5426\n\
5427ARGUMENTS:\n\
5428\n\
5429 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5430 left-hand edge of the viewport.\n\
5431\n\
5432 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5433 right-hand edge of the viewport.\n\
5434\n\
5435 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5436 bottom edge of the viewport.\n\
5437\n\
5438 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5439 edge of the viewport.\n\
5440\n\
5441 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5442 axis.\n\
5443";
5444static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5445Set the pause (on end-of-page) status\n\
5446\n\
5447DESCRIPTION:\n\
5448\n\
5449 Set the pause (on end-of-page) status.\n\
5450\n\
5451 Redacted form: plspause(pause)\n\
5452\n\
5453 This function is in examples 14,20.\n\
5454\n\
5455\n\
5456\n\
5457SYNOPSIS:\n\
5458\n\
5459plspause(pause)\n\
5460\n\
5461ARGUMENTS:\n\
5462\n\
5463 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5464 end-of-page for those drivers which support this. Otherwise there\n\
5465 is no pause.\n\
5466";
5467static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5468Plot 3-d surface plot\n\
5469\n\
5470DESCRIPTION:\n\
5471\n\
5472 Plots a three-dimensional surface plot within the environment set up\n\
5473 by plw3d. The surface is defined by the matrix z[\n\
5474 nx][\n\
5475 ny] , the point z[i][j] being the value of the function at (\n\
5476 x[i],\n\
5477 y[j]). Note that the points in vectors x and y do not need to be\n\
5478 equally spaced, but must be stored in ascending order. The parameter\n\
5479 opt controls the way in which the surface is displayed. For further\n\
5480 details see the PLplot documentation. The only difference between\n\
5481 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5482 while plot3d only draws the surface as viewed from the top.\n\
5483\n\
5484 Redacted form: plot3d(x, y, z, opt, side)\n\
5485\n\
5486 This function is used in examples 11 and 21.\n\
5487\n\
5488\n\
5489\n\
5490SYNOPSIS:\n\
5491\n\
5492plot3d(x, y, z, nx, ny, opt, side)\n\
5493\n\
5494ARGUMENTS:\n\
5495\n\
5496 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5497 which the function is evaluated.\n\
5498\n\
5499 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5500 which the function is evaluated.\n\
5501\n\
5502 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5503 plot. Should have dimensions of\n\
5504 nx by\n\
5505 ny.\n\
5506\n\
5507 nx (PLINT, input) : Number of x values at which function is\n\
5508 evaluated.\n\
5509\n\
5510 ny (PLINT, input) : Number of y values at which function is\n\
5511 evaluated.\n\
5512\n\
5513 opt (PLINT, input) : Determines the way in which the surface is\n\
5514 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5515 function of x for each value of y[j] .\n\
5516 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5517 for each value of x[i] .\n\
5518 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5519 at which function is defined.\n\
5520\n\
5521\n\
5522 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5523 should be draw on the figure. If side is true sides are drawn,\n\
5524 otherwise no sides are drawn.\n\
5525";
5526static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5527Copy state parameters from the reference stream to the current stream\n\
5528\n\
5529DESCRIPTION:\n\
5530\n\
5531 Copies state parameters from the reference stream to the current\n\
5532 stream. Tell driver interface to map device coordinates unless flags\n\
5533 == 1.\n\
5534\n\
5535 This function is used for making save files of selected plots (e.g.\n\
5536 from the TK driver). After initializing, you can get a copy of the\n\
5537 current plot to the specified device by switching to this stream and\n\
5538 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5539 appropriate. The plot buffer must have previously been enabled (done\n\
5540 automatically by some display drivers, such as X).\n\
5541\n\
5542 Redacted form: plcpstrm(iplsr, flags)\n\
5543\n\
5544 This function is used in example 1,20.\n\
5545\n\
5546\n\
5547\n\
5548SYNOPSIS:\n\
5549\n\
5550plcpstrm(iplsr, flags)\n\
5551\n\
5552ARGUMENTS:\n\
5553\n\
5554 iplsr (PLINT, input) : Number of reference stream.\n\
5555\n\
5556 flags (PLBOOL, input) : If flags is set to true the device\n\
5557 coordinates are not copied from the reference to current stream.\n\
5558";
5559static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5560Set page parameters\n\
5561\n\
5562DESCRIPTION:\n\
5563\n\
5564 Sets the page configuration (optional). If an individual parameter is\n\
5565 zero then that parameter value is not updated. Not all parameters are\n\
5566 recognized by all drivers and the interpretation is device-dependent.\n\
5567 The X-window driver uses the length and offset parameters to determine\n\
5568 the window size and location. The length and offset values are\n\
5569 expressed in units that are specific to the current driver. For\n\
5570 instance: screen drivers will usually interpret them as number of\n\
5571 pixels, whereas printer drivers will usually use mm.\n\
5572\n\
5573 This routine, if used, must be called before initializing PLplot. It\n\
5574 may be called at later times for interactive drivers to change only\n\
5575 the dpi for subsequent redraws which you can force via a call to\n\
5576 plreplot. If this function is not called then the page size defaults\n\
5577 to landscape A4 for drivers which use real world page sizes and 744\n\
5578 pixels wide by 538 pixels high for raster drivers. The default value\n\
5579 for dx and dy is 90 pixels per inch for raster drivers.\n\
5580\n\
5581\n\
5582\n\
5583 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5584\n\
5585 This function is used in examples 14 and 31.\n\
5586\n\
5587\n\
5588\n\
5589SYNOPSIS:\n\
5590\n\
5591plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5592\n\
5593ARGUMENTS:\n\
5594\n\
5595 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5596 by raster drivers, ignored by drivers which use \"real world\" units\n\
5597 (e.g. mm).\n\
5598\n\
5599 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5600 by raster drivers, ignored by drivers which use \"real world\" units\n\
5601 (e.g. mm).\n\
5602\n\
5603 xleng (PLINT, input) : Page length, x.\n\
5604\n\
5605 yleng (PLINT, input) : Page length, y.\n\
5606\n\
5607 xoff (PLINT, input) : Page offset, x.\n\
5608\n\
5609 yoff (PLINT, input) : Page offset, y.\n\
5610";
5611static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5612Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5613\n\
5614DESCRIPTION:\n\
5615\n\
5616 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5617 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5618 Values are negative if an invalid color id is given.\n\
5619\n\
5620 Redacted form: plgcola(r, g, b)\n\
5621\n\
5622 This function is used in example 30.\n\
5623\n\
5624\n\
5625\n\
5626SYNOPSIS:\n\
5627\n\
5628plgcol0a(icol0, r, g, b, alpha)\n\
5629\n\
5630ARGUMENTS:\n\
5631\n\
5632 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5633\n\
5634 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5635 in the range from 0 to 255.\n\
5636\n\
5637 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5638 in the range from 0 to 255.\n\
5639\n\
5640 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5641 in the range from 0 to 255.\n\
5642\n\
5643 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5644 transparency in the range from (0.0-1.0).\n\
5645";
5646static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5647Returns 8-bit RGB values for given color index from cmap0\n\
5648\n\
5649DESCRIPTION:\n\
5650\n\
5651 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5652 PLplot documentation). Values are negative if an invalid color id is\n\
5653 given.\n\
5654\n\
5655 Redacted form: plgcol0(icol0, r, g, b)\n\
5656\n\
5657 This function is used in example 2.\n\
5658\n\
5659\n\
5660\n\
5661SYNOPSIS:\n\
5662\n\
5663plgcol0(icol0, r, g, b)\n\
5664\n\
5665ARGUMENTS:\n\
5666\n\
5667 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5668\n\
5669 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5670 value.\n\
5671\n\
5672 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5673 value.\n\
5674\n\
5675 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5676 value.\n\
5677";
5678static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5679Set parameters incrementally (zoom mode) that define current plot-space window\n\
5680\n\
5681DESCRIPTION:\n\
5682\n\
5683 Set relative minima and maxima incrementally (zoom mode) that define\n\
5684 the current plot-space window. This function has the same effect as\n\
5685 plsdiplt if that function has not been previously called. Otherwise,\n\
5686 this function implements zoom mode using the transformation min_used =\n\
5687 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5688 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5689 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5690\n\
5691 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5692\n\
5693 This function is used in example 31.\n\
5694\n\
5695\n\
5696\n\
5697SYNOPSIS:\n\
5698\n\
5699plsdiplz(xmin, ymin, xmax, ymax)\n\
5700\n\
5701ARGUMENTS:\n\
5702\n\
5703 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5704\n\
5705 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5706\n\
5707 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5708\n\
5709 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5710";
5711static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5712Plot all or a subset of Shapefile data, filling the polygons\n\
5713\n\
5714DESCRIPTION:\n\
5715\n\
5716 As per plmapline, however the items are filled in the same way as\n\
5717 plfill.\n\
5718\n\
5719 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5720 plotentries)\n\
5721\n\
5722 This function is used in example 19.\n\
5723\n\
5724\n\
5725\n\
5726SYNOPSIS:\n\
5727\n\
5728plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5729\n\
5730ARGUMENTS:\n\
5731\n\
5732 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5733 transform the coordinates given in the shapefile into a plot\n\
5734 coordinate system. By using this transform, we can change from a\n\
5735 longitude, latitude coordinate to a polar stereographic project,\n\
5736 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5737 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5738 mapform(), x[] and y[] should be replaced by the corresponding\n\
5739 plot coordinates. If no transform is desired, mapform can be\n\
5740 replaced by NULL.\n\
5741\n\
5742 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5743 the file name of a set of Shapefile files without the file\n\
5744 extension.\n\
5745\n\
5746 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5747 be in the same units as used by the Shapefile. You could use a\n\
5748 very large negative number to plot everything, but you can improve\n\
5749 performance by limiting the area drawn. The units must match those\n\
5750 of the Shapefile projection, which may be for example longitude or\n\
5751 distance. The value of minx must be less than the value of maxx.\n\
5752\n\
5753 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5754 use a very large number to plot everything, but you can improve\n\
5755 performance by limiting the area drawn.\n\
5756\n\
5757 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5758 be in the same units as used by the Shapefile. You could use a\n\
5759 very large negative number to plot everything, but you can improve\n\
5760 performance by limiting the area drawn. The units must match those\n\
5761 of the Shapefile projection, which may be for example latitude or\n\
5762 distance. The value of miny must be less than the value of maxy.\n\
5763\n\
5764 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5765 use a very large number to plot everything, but you can improve\n\
5766 performance by limiting the area drawn.\n\
5767\n\
5768 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5769 zero-based indices of the Shapefile elements which will be drawn.\n\
5770 Setting\n\
5771 plotentries to NULL will plot all elements of the Shapefile.\n\
5772\n\
5773 nplotentries (PLINT, input) : The number of items in\n\
5774 plotentries. Ignored if\n\
5775 plotentries is NULL.\n\
5776";
5777static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5778Draw a line\n\
5779\n\
5780DESCRIPTION:\n\
5781\n\
5782 Draws line defined by n points in x and y.\n\
5783\n\
5784 Redacted form: plline(x, y)\n\
5785\n\
5786 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5787 25-27, and 29.\n\
5788\n\
5789\n\
5790\n\
5791SYNOPSIS:\n\
5792\n\
5793plline(n, x, y)\n\
5794\n\
5795ARGUMENTS:\n\
5796\n\
5797 n (PLINT, input) : Number of points defining line.\n\
5798\n\
5799 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5800 points.\n\
5801\n\
5802 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5803 points.\n\
5804";
5805static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5806Get viewport limits in world coordinates\n\
5807\n\
5808DESCRIPTION:\n\
5809\n\
5810 Get viewport limits in world coordinates.\n\
5811\n\
5812 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5813\n\
5814\n\
5815 This function is used in example 31.\n\
5816\n\
5817\n\
5818\n\
5819SYNOPSIS:\n\
5820\n\
5821plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5822\n\
5823ARGUMENTS:\n\
5824\n\
5825 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5826 viewport limit of the world coordinate in x.\n\
5827\n\
5828 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5829 viewport limit of the world coordinate in x.\n\
5830\n\
5831 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5832 viewport limit of the world coordinate in y.\n\
5833\n\
5834 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5835 viewport limit of the world coordinate in y.\n\
5836";
5837static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5838Set area line fill pattern\n\
5839\n\
5840DESCRIPTION:\n\
5841\n\
5842 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5843 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5844 inclinations and spacings. The arguments to this routine are the\n\
5845 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5846 elements) specifying the inclinations in tenths of a degree and the\n\
5847 spacing in micrometers. (See also plpsty)\n\
5848\n\
5849 Redacted form: General: plpat(inc, del)\n\
5850\n\
5851\n\
5852 This function is used in example 15.\n\
5853\n\
5854\n\
5855\n\
5856SYNOPSIS:\n\
5857\n\
5858plpat(nlin, inc, del)\n\
5859\n\
5860ARGUMENTS:\n\
5861\n\
5862 nlin (PLINT, input) : Number of sets of lines making up the\n\
5863 pattern, either 1 or 2.\n\
5864\n\
5865 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5866 inclination in tenths of a degree. (Should be between -900 and\n\
5867 900).\n\
5868\n\
5869 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5870 spacing in micrometers between the lines making up the pattern.\n\
5871";
5872static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5873Set x axis parameters\n\
5874\n\
5875DESCRIPTION:\n\
5876\n\
5877 Sets values of the digmax and digits flags for the x axis. See the\n\
5878 PLplot documentation for more information.\n\
5879\n\
5880 Redacted form: plsxax(digmax, digits)\n\
5881\n\
5882 This function is used in example 31.\n\
5883\n\
5884\n\
5885\n\
5886SYNOPSIS:\n\
5887\n\
5888plsxax(digmax, digits)\n\
5889\n\
5890ARGUMENTS:\n\
5891\n\
5892 digmax (PLINT, input) : Variable to set the maximum number of\n\
5893 digits for the x axis. If nonzero, the printed label will be\n\
5894 switched to a floating-point representation when the number of\n\
5895 digits exceeds digmax.\n\
5896\n\
5897 digits (PLINT, input) : Field digits value. Currently, changing\n\
5898 its value here has no effect since it is set only by plbox or\n\
5899 plbox3. However, the user may obtain its value after a call to\n\
5900 either of these functions by calling plgxax.\n\
5901";
5902static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5903Get family file parameters\n\
5904\n\
5905DESCRIPTION:\n\
5906\n\
5907 Gets information about current family file, if familying is enabled.\n\
5908 See the PLplot documentation for more information.\n\
5909\n\
5910 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5911\n\
5912 This function is used in examples 14 and 31.\n\
5913\n\
5914\n\
5915\n\
5916SYNOPSIS:\n\
5917\n\
5918plgfam(p_fam, p_num, p_bmax)\n\
5919\n\
5920ARGUMENTS:\n\
5921\n\
5922 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5923 family flag value. If nonzero, familying is enabled for the\n\
5924 current device.\n\
5925\n\
5926 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5927 family file number.\n\
5928\n\
5929 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5930 file size (in bytes) for a family file.\n\
5931";
5932static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
5933Get y axis parameters\n\
5934\n\
5935DESCRIPTION:\n\
5936\n\
5937 Identical to plgxax, except that arguments are flags for y axis. See\n\
5938 the description of plgxax for more detail.\n\
5939\n\
5940 Redacted form: plgyax(p_digmax, p_digits)\n\
5941\n\
5942 This function is used in example 31.\n\
5943\n\
5944\n\
5945\n\
5946SYNOPSIS:\n\
5947\n\
5948plgyax(p_digmax, p_digits)\n\
5949\n\
5950ARGUMENTS:\n\
5951\n\
5952 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5953 number of digits for the y axis. If nonzero, the printed label\n\
5954 has been switched to a floating-point representation when the\n\
5955 number of digits exceeds this value.\n\
5956\n\
5957 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5958 number of digits for the numeric labels (y axis) from the last\n\
5959 plot.\n\
5960";
5961static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
5962Plot a glyph at the specified points\n\
5963\n\
5964DESCRIPTION:\n\
5965\n\
5966 Plot a glyph at the specified points. (This function is largely\n\
5967 superseded by plstring which gives access to many[!] more glyphs.)\n\
5968 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5969 and a draw at the same place. Not ideal, since a sufficiently\n\
5970 intelligent output device may optimize it away, or there may be faster\n\
5971 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5972 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5973 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5974 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5975 code <= 127 the corresponding printable ASCII character is plotted.\n\
5976\n\
5977 Redacted form: plpoin(x, y, code)\n\
5978\n\
5979 This function is used in examples 1, 6, 14, and 29.\n\
5980\n\
5981\n\
5982\n\
5983SYNOPSIS:\n\
5984\n\
5985plpoin(n, x, y, code)\n\
5986\n\
5987ARGUMENTS:\n\
5988\n\
5989 n (PLINT, input) : Number of points in the x and y vectors.\n\
5990\n\
5991 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5992 points.\n\
5993\n\
5994 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5995 points.\n\
5996\n\
5997 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5998 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5999 each of the n points.\n\
6000";
6001static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6002Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6003\n\
6004DESCRIPTION:\n\
6005\n\
6006 As per plmapline, however the items are plotted as strings or points\n\
6007 in the same way as plstring.\n\
6008\n\
6009 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6010 maxy, plotentries)\n\
6011\n\
6012 This function is not used in any examples.\n\
6013\n\
6014\n\
6015\n\
6016SYNOPSIS:\n\
6017\n\
6018plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6019\n\
6020ARGUMENTS:\n\
6021\n\
6022 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6023 transform the coordinates given in the shapefile into a plot\n\
6024 coordinate system. By using this transform, we can change from a\n\
6025 longitude, latitude coordinate to a polar stereographic project,\n\
6026 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6027 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6028 mapform(), x[] and y[] should be replaced by the corresponding\n\
6029 plot coordinates. If no transform is desired, mapform can be\n\
6030 replaced by NULL.\n\
6031\n\
6032 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6033 the file name of a set of Shapefile files without the file\n\
6034 extension.\n\
6035\n\
6036 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6037 drawn.\n\
6038\n\
6039 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6040 be in the same units as used by the Shapefile. You could use a\n\
6041 very large negative number to plot everything, but you can improve\n\
6042 performance by limiting the area drawn. The units must match those\n\
6043 of the Shapefile projection, which may be for example longitude or\n\
6044 distance. The value of minx must be less than the value of maxx.\n\
6045\n\
6046 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6047 use a very large number to plot everything, but you can improve\n\
6048 performance by limiting the area drawn.\n\
6049\n\
6050 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6051 be in the same units as used by the Shapefile. You could use a\n\
6052 very large negative number to plot everything, but you can improve\n\
6053 performance by limiting the area drawn. The units must match those\n\
6054 of the Shapefile projection, which may be for example latitude or\n\
6055 distance. The value of miny must be less than the value of maxy.\n\
6056\n\
6057 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6058 use a very large number to plot everything, but you can improve\n\
6059 performance by limiting the area drawn.\n\
6060\n\
6061 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6062 zero-based indices of the Shapefile elements which will be drawn.\n\
6063 Setting\n\
6064 plotentries to NULL will plot all elements of the Shapefile.\n\
6065\n\
6066 nplotentries (PLINT, input) : The number of items in\n\
6067 plotentries. Ignored if\n\
6068 plotentries is NULL.\n\
6069";
6070static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6071Select area fill pattern\n\
6072\n\
6073DESCRIPTION:\n\
6074\n\
6075 If\n\
6076 patt is zero or less use either a hardware solid fill if the drivers\n\
6077 have that capability (virtually all do) or fall back to a software\n\
6078 emulation of a solid fill using the eighth area line fill pattern. If\n\
6079 0 <\n\
6080 patt <= 8, then select one of eight predefined area line fill patterns\n\
6081 to use (see plpat if you desire other patterns).\n\
6082\n\
6083 Redacted form: plpsty(patt)\n\
6084\n\
6085 This function is used in examples 12, 13, 15, 16, and 25.\n\
6086\n\
6087\n\
6088\n\
6089SYNOPSIS:\n\
6090\n\
6091plpsty(patt)\n\
6092\n\
6093ARGUMENTS:\n\
6094\n\
6095 patt (PLINT, input) : The desired pattern index. If\n\
6096 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6097 above) used. For\n\
6098 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6099 line fill capability itself (most deliberately do not so that line\n\
6100 fill patterns look identical for those drivers), the patterns\n\
6101 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6102 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6103 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6104 (8) lines at both 45 degrees and -45 degrees.\n\
6105";
6106static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6107Set 8-bit RGB values for given cmap0 color index\n\
6108\n\
6109DESCRIPTION:\n\
6110\n\
6111 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6112 index. Overwrites the previous color value for the given index and,\n\
6113 thus, does not result in any additional allocation of space for\n\
6114 colors.\n\
6115\n\
6116 Redacted form: plscol0(icol0, r, g, b)\n\
6117\n\
6118 This function is used in any example 31.\n\
6119\n\
6120\n\
6121\n\
6122SYNOPSIS:\n\
6123\n\
6124plscol0(icol0, r, g, b)\n\
6125\n\
6126ARGUMENTS:\n\
6127\n\
6128 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6129 number of colors (which is set by default, by plscmap0n, or even\n\
6130 by plscmap0).\n\
6131\n\
6132 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6133 degree of red in the color.\n\
6134\n\
6135 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6136 degree of green in the color.\n\
6137\n\
6138 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6139 degree of blue in the color.\n\
6140";
6141static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6142Used to globally turn color output on/off\n\
6143\n\
6144DESCRIPTION:\n\
6145\n\
6146 Used to globally turn color output on/off for those drivers/devices\n\
6147 that support it.\n\
6148\n\
6149 Redacted form: plscolor(color)\n\
6150\n\
6151 This function is used in example 31.\n\
6152\n\
6153\n\
6154\n\
6155SYNOPSIS:\n\
6156\n\
6157plscolor(color)\n\
6158\n\
6159ARGUMENTS:\n\
6160\n\
6161 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6162 turned off. If non-zero, color is turned on.\n\
6163";
6164static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6165End plotting session\n\
6166\n\
6167DESCRIPTION:\n\
6168\n\
6169 Ends a plotting session, tidies up all the output files, switches\n\
6170 interactive devices back into text mode and frees up any memory that\n\
6171 was allocated. Must be called before end of program.\n\
6172\n\
6173 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6174 wait state after a call to plend or other functions which trigger the\n\
6175 end of a plot page. To avoid this, use the plspause function.\n\
6176\n\
6177 Redacted form: plend()\n\
6178\n\
6179 This function is used in all of the examples.\n\
6180\n\
6181\n\
6182\n\
6183SYNOPSIS:\n\
6184\n\
6185plend()\n\
6186";
6187static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6188Plot a histogram from binned data\n\
6189\n\
6190DESCRIPTION:\n\
6191\n\
6192 Plots a histogram consisting of nbin bins. The value associated with\n\
6193 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6194 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6195 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6196 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6197 placed midway between the values in the x vector. Also see plhist for\n\
6198 drawing histograms from unbinned data.\n\
6199\n\
6200 Redacted form: General: plbin(x, y, opt)\n\
6201 Python: plbin(nbin, x, y, opt)\n\
6202\n\
6203\n\
6204 This function is not used in any examples.\n\
6205\n\
6206\n\
6207\n\
6208SYNOPSIS:\n\
6209\n\
6210plbin(nbin, x, y, opt)\n\
6211\n\
6212ARGUMENTS:\n\
6213\n\
6214 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6215 and y vectors.)\n\
6216\n\
6217 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6218 with bins. These must form a strictly increasing sequence.\n\
6219\n\
6220 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6221 proportional to the number of points in each bin. This is a PLFLT\n\
6222 (instead of PLINT) vector so as to allow histograms of\n\
6223 probabilities, etc.\n\
6224\n\
6225 opt (PLINT, input) : Is a combination of several flags:\n\
6226 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6227 outer bins are expanded to fill up the entire x-axis and bins of\n\
6228 zero height are simply drawn.\n\
6229 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6230 between the x values. If the values in x are equally spaced,\n\
6231 the values are the center values of the bins.\n\
6232 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6233 size as the ones inside.\n\
6234 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6235 (there is a gap for such bins).\n\
6236";
6237static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6238Plot a 2D matrix using cmap1\n\
6239\n\
6240DESCRIPTION:\n\
6241\n\
6242 Plot a 2D matrix using cmap1.\n\
6243\n\
6244 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6245 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6246\n\
6247\n\
6248 This function is used in example 20.\n\
6249\n\
6250\n\
6251\n\
6252SYNOPSIS:\n\
6253\n\
6254plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6255\n\
6256ARGUMENTS:\n\
6257\n\
6258 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6259 plot. Should have dimensions of\n\
6260 nx by\n\
6261 ny.\n\
6262\n\
6263 nx, ny (PLINT, input) : Dimensions of idata\n\
6264\n\
6265 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6266 pltr below for how these arguments are used (only for the special case\n\
6267 when the callback function\n\
6268 pltr is not supplied).\n\
6269\n\
6270 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6271 (inclusive) will be plotted.\n\
6272\n\
6273 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6274 values to use for value to color mappings. A datum equal to or\n\
6275 less than valuemin will be plotted with color 0.0, while a datum\n\
6276 equal to or greater than valuemax will be plotted with color 1.0.\n\
6277 Data between valuemin and valuemax map linearly to colors in the\n\
6278 range (0.0-1.0).\n\
6279\n\
6280 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6281 defines the transformation between the zero-based indices of the\n\
6282 matrix idata and world coordinates. If\n\
6283 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6284 indices of idata are mapped to the range\n\
6285 xmin through\n\
6286 xmax and the y indices of idata are mapped to the range\n\
6287 ymin through\n\
6288 ymax.For the C case, transformation functions are provided in the\n\
6289 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6290 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6291 matrices. In addition, C callback routines for the transformation\n\
6292 can be supplied by the user such as the mypltr function in\n\
6293 examples/c/x09c.c which provides a general linear transformation\n\
6294 between index coordinates and world coordinates.For languages\n\
6295 other than C you should consult the PLplot documentation for the\n\
6296 details concerning how PLTRANSFORM_callback arguments are\n\
6297 interfaced. However, in general, a particular pattern of\n\
6298 callback-associated arguments such as a tr vector with 6 elements;\n\
6299 xg and yg vectors; or xg and yg matrices are respectively\n\
6300 interfaced to a linear-transformation routine similar to the above\n\
6301 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6302 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6303 support native language callbacks for handling index to\n\
6304 world-coordinate transformations. Examples of these various\n\
6305 approaches are given in examples/<language>x09*,\n\
6306 examples/<language>x16*, examples/<language>x20*,\n\
6307 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6308 supported languages.\n\
6309\n\
6310 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6311 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6312 externally supplied.\n\
6313";
6314static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6315Sets the 3D position of the light source\n\
6316\n\
6317DESCRIPTION:\n\
6318\n\
6319 Sets the 3D position of the light source for use with plsurf3d and\n\
6320 plsurf3dl\n\
6321\n\
6322 Redacted form: pllightsource(x, y, z)\n\
6323\n\
6324 This function is used in example 8.\n\
6325\n\
6326\n\
6327\n\
6328SYNOPSIS:\n\
6329\n\
6330pllightsource(x, y, z)\n\
6331\n\
6332ARGUMENTS:\n\
6333\n\
6334 x (PLFLT, input) : X-coordinate of the light source.\n\
6335\n\
6336 y (PLFLT, input) : Y-coordinate of the light source.\n\
6337\n\
6338 z (PLFLT, input) : Z-coordinate of the light source.\n\
6339";
6340static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6341Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6342\n\
6343DESCRIPTION:\n\
6344\n\
6345 When the implementation is completed this variant of plot3dc (see that\n\
6346 function\'s documentation for more details) should be suitable for the\n\
6347 case where the area of the x, y coordinate grid where z is defined can\n\
6348 be non-rectangular. The implementation is incomplete so the last 4\n\
6349 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6350 indexymax; are currently ignored and the functionality is otherwise\n\
6351 identical to that of plot3dc.\n\
6352\n\
6353 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6354 indexymin, indexymax)\n\
6355\n\
6356\n\
6357 This function is not used in any example.\n\
6358\n\
6359\n\
6360\n\
6361SYNOPSIS:\n\
6362\n\
6363plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6364\n\
6365ARGUMENTS:\n\
6366\n\
6367 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6368 which the function is evaluated.\n\
6369\n\
6370 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6371 which the function is evaluated.\n\
6372\n\
6373 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6374 plot. Should have dimensions of\n\
6375 nx by\n\
6376 ny.\n\
6377\n\
6378 nx (PLINT, input) : Number of x values at which the function is\n\
6379 evaluated.\n\
6380\n\
6381 ny (PLINT, input) : Number of y values at which the function is\n\
6382 evaluated.\n\
6383\n\
6384 opt (PLINT, input) : Determines the way in which the surface is\n\
6385 represented. To specify more than one option just add the options,\n\
6386 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6387 showing z as a function of x for each value of y[j] .\n\
6388 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6389 for each value of x[i] .\n\
6390 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6391 at which function is defined.\n\
6392 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6393 the z value being plotted. The color is used from the current\n\
6394 cmap1.\n\
6395 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6396 using parameters\n\
6397 nlevel and\n\
6398 clevel.\n\
6399 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6400 the borders of the plotted function.\n\
6401\n\
6402\n\
6403 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6404 levels.\n\
6405\n\
6406 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6407\n\
6408 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6409 corresponds to the first x index where z is defined.\n\
6410\n\
6411 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6412 which corresponds (by convention) to one more than the last x\n\
6413 index value where z is defined.\n\
6414\n\
6415 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6416 values which all must be ≥ 0. These values are the first y index\n\
6417 where z is defined for a particular x index in the range from\n\
6418 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6419 indexxmax.\n\
6420\n\
6421 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6422 values which all must be ≤ ny. These values correspond (by\n\
6423 convention) to one more than the last y index where z is defined\n\
6424 for a particular x index in the range from indexxmin to indexxmax\n\
6425 - 1. The dimension of indexymax is indexxmax.\n\
6426";
6427static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6428Creates a new stream and makes it the default\n\
6429\n\
6430DESCRIPTION:\n\
6431\n\
6432 Creates a new stream and makes it the default. Differs from using\n\
6433 plsstrm, in that a free stream number is found, and returned.\n\
6434 Unfortunately, I have to start at stream 1 and work upward, since\n\
6435 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6436 that no initial, library-opening call is required. So stream 0 must\n\
6437 be preallocated, and there is no simple way of determining whether it\n\
6438 is already in use or not.\n\
6439\n\
6440 Redacted form: plmkstrm(p_strm)\n\
6441\n\
6442 This function is used in examples 1 and 20.\n\
6443\n\
6444\n\
6445\n\
6446SYNOPSIS:\n\
6447\n\
6448plmkstrm(p_strm)\n\
6449\n\
6450ARGUMENTS:\n\
6451\n\
6452 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6453 number of the created stream.\n\
6454";
6455static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6456Set FCI (font characterization integer)\n\
6457\n\
6458DESCRIPTION:\n\
6459\n\
6460 Sets font characteristics to be used at the start of the next string\n\
6461 using the FCI approach. See the PLplot documentation for more\n\
6462 information. Note, plsfont (which calls plsfci internally) provides a\n\
6463 more user-friendly API for setting the font characterisitics.\n\
6464\n\
6465 Redacted form: General: plsfci(fci)\n\
6466\n\
6467\n\
6468 This function is used in example 23.\n\
6469\n\
6470\n\
6471\n\
6472SYNOPSIS:\n\
6473\n\
6474plsfci(fci)\n\
6475\n\
6476ARGUMENTS:\n\
6477\n\
6478 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6479 of FCI.\n\
6480";
6481static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6482Initialize PLplot\n\
6483\n\
6484DESCRIPTION:\n\
6485\n\
6486 Initializing the plotting package. The program prompts for the device\n\
6487 keyword or number of the desired output device. Hitting a RETURN in\n\
6488 response to the prompt is the same as selecting the first device.\n\
6489 plinit will issue no prompt if either the device was specified\n\
6490 previously (via command line flag, the plsetopt function, or the\n\
6491 plsdev function), or if only one device is enabled when PLplot is\n\
6492 installed. If subpages have been specified, the output device is\n\
6493 divided into nx by ny subpages, each of which may be used\n\
6494 independently. If plinit is called again during a program, the\n\
6495 previously opened file will be closed. The subroutine pladv is used\n\
6496 to advance from one subpage to the next.\n\
6497\n\
6498 Redacted form: plinit()\n\
6499\n\
6500 This function is used in all of the examples.\n\
6501\n\
6502\n\
6503\n\
6504SYNOPSIS:\n\
6505\n\
6506plinit()\n\
6507";
6508static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6509Set line style\n\
6510\n\
6511DESCRIPTION:\n\
6512\n\
6513 This sets up the line style for all lines subsequently drawn. A line\n\
6514 consists of segments in which the pen is alternately down and up. The\n\
6515 lengths of these segments are passed in the vectors mark and space\n\
6516 respectively. The number of mark-space pairs is specified by nms. In\n\
6517 order to return the line style to the default continuous line, plstyl\n\
6518 should be called with nms =0 .(see also pllsty)\n\
6519\n\
6520 Redacted form: plstyl(mark, space)\n\
6521\n\
6522 This function is used in examples 1, 9, and 14.\n\
6523\n\
6524\n\
6525\n\
6526SYNOPSIS:\n\
6527\n\
6528plstyl(nms, mark, space)\n\
6529\n\
6530ARGUMENTS:\n\
6531\n\
6532 nms (PLINT, input) : The number of mark and space elements in a\n\
6533 line. Thus a simple broken line can be obtained by setting nms=1\n\
6534 . A continuous line is specified by setting nms=0 .\n\
6535\n\
6536 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6537 segments during which the pen is down, measured in micrometers.\n\
6538\n\
6539 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6540 the segments during which the pen is up, measured in micrometers.\n\
6541";
6542static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6543Set length of minor ticks\n\
6544\n\
6545DESCRIPTION:\n\
6546\n\
6547 This sets up the length of the minor ticks and the length of the\n\
6548 terminals on error bars. The actual length is the product of the\n\
6549 default length and a scaling factor as for character height.\n\
6550\n\
6551 Redacted form: plsmin(def, scale)\n\
6552\n\
6553 This function is used in example 29.\n\
6554\n\
6555\n\
6556\n\
6557SYNOPSIS:\n\
6558\n\
6559plsmin(def, scale)\n\
6560\n\
6561ARGUMENTS:\n\
6562\n\
6563 def (PLFLT, input) : The default length of a minor tick in\n\
6564 millimeters, should be set to zero if the default length is to\n\
6565 remain unchanged.\n\
6566\n\
6567 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6568 actual tick length.\n\
6569";
6570static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6571Draw a box with axes, etc, in 3-d\n\
6572\n\
6573DESCRIPTION:\n\
6574\n\
6575 Draws axes, numeric and text labels for a three-dimensional surface\n\
6576 plot. For a more complete description of three-dimensional plotting\n\
6577 see the PLplot documentation.\n\
6578\n\
6579 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6580 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6581\n\
6582\n\
6583 This function is used in examples 8, 11, 18, and 21.\n\
6584\n\
6585\n\
6586\n\
6587SYNOPSIS:\n\
6588\n\
6589plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6590\n\
6591ARGUMENTS:\n\
6592\n\
6593 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6594 options for the x axis. The string can include any combination of\n\
6595 the following letters (upper or lower case) in any order: b: Draws\n\
6596 axis at base, at height z=\n\
6597 zmin where zmin is defined by call to plw3d. This character must be\n\
6598 specified in order to use any of the other options.\n\
6599 d: Plot labels as date / time. Values are assumed to be\n\
6600 seconds since the epoch (as used by gmtime).\n\
6601 f: Always use fixed point numeric labels.\n\
6602 i: Inverts tick marks, so they are drawn downwards, rather\n\
6603 than upwards.\n\
6604 l: Labels axis logarithmically. This only affects the labels,\n\
6605 not the data, and so it is necessary to compute the logarithms\n\
6606 of data points before passing them to any of the drawing\n\
6607 routines.\n\
6608 n: Writes numeric labels at major tick intervals.\n\
6609 o: Use custom labelling function to generate axis label text.\n\
6610 The custom labelling function can be defined with the\n\
6611 plslabelfunc command.\n\
6612 s: Enables subticks between major ticks, only valid if t is\n\
6613 also specified.\n\
6614 t: Draws major ticks.\n\
6615 u: If this is specified, the text label for the axis is\n\
6616 written under the axis.\n\
6617\n\
6618\n\
6619 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6620 the text label for the x axis. It is only drawn if u is in the\n\
6621 xopt string.\n\
6622\n\
6623 xtick (PLFLT, input) : World coordinate interval between major\n\
6624 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6625 generates a suitable tick interval.\n\
6626\n\
6627 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6628 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6629 generates a suitable minor tick interval.\n\
6630\n\
6631 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6632 options for the y axis. The string is interpreted in the same way\n\
6633 as xopt.\n\
6634\n\
6635 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6636 the text label for the y axis. It is only drawn if u is in the\n\
6637 yopt string.\n\
6638\n\
6639 ytick (PLFLT, input) : World coordinate interval between major\n\
6640 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6641 generates a suitable tick interval.\n\
6642\n\
6643 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6644 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6645 generates a suitable minor tick interval.\n\
6646\n\
6647 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6648 options for the z axis. The string can include any combination of\n\
6649 the following letters (upper or lower case) in any order: b: Draws\n\
6650 z axis to the left of the surface plot.\n\
6651 c: Draws z axis to the right of the surface plot.\n\
6652 d: Draws grid lines parallel to the x-y plane behind the\n\
6653 figure. These lines are not drawn until after plot3d or\n\
6654 plmesh are called because of the need for hidden line removal.\n\
6655 e: Plot labels as date / time. Values are assumed to be\n\
6656 seconds since the epoch (as used by gmtime). Note this\n\
6657 suboption is interpreted the same as the d suboption for xopt\n\
6658 and yopt, but it has to be identified as e for zopt since d\n\
6659 has already been used for the different purpose above.\n\
6660 f: Always use fixed point numeric labels.\n\
6661 i: Inverts tick marks, so they are drawn away from the center.\n\
6662 l: Labels axis logarithmically. This only affects the labels,\n\
6663 not the data, and so it is necessary to compute the logarithms\n\
6664 of data points before passing them to any of the drawing\n\
6665 routines.\n\
6666 m: Writes numeric labels at major tick intervals on the\n\
6667 right-hand z axis.\n\
6668 n: Writes numeric labels at major tick intervals on the\n\
6669 left-hand z axis.\n\
6670 o: Use custom labelling function to generate axis label text.\n\
6671 The custom labelling function can be defined with the\n\
6672 plslabelfunc command.\n\
6673 s: Enables subticks between major ticks, only valid if t is\n\
6674 also specified.\n\
6675 t: Draws major ticks.\n\
6676 u: If this is specified, the text label is written beside the\n\
6677 left-hand axis.\n\
6678 v: If this is specified, the text label is written beside the\n\
6679 right-hand axis.\n\
6680\n\
6681\n\
6682 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6683 the text label for the z axis. It is only drawn if u or v are in\n\
6684 the zopt string.\n\
6685\n\
6686 ztick (PLFLT, input) : World coordinate interval between major\n\
6687 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6688 generates a suitable tick interval.\n\
6689\n\
6690 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6691 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6692 generates a suitable minor tick interval.\n\
6693";
6694static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6695Set character size\n\
6696\n\
6697DESCRIPTION:\n\
6698\n\
6699 This sets up the size of all subsequent characters drawn. The actual\n\
6700 height of a character is the product of the default character size and\n\
6701 a scaling factor.\n\
6702\n\
6703 Redacted form: plschr(def, scale)\n\
6704\n\
6705 This function is used in examples 2, 13, 23, and 24.\n\
6706\n\
6707\n\
6708\n\
6709SYNOPSIS:\n\
6710\n\
6711plschr(def, scale)\n\
6712\n\
6713ARGUMENTS:\n\
6714\n\
6715 def (PLFLT, input) : The default height of a character in\n\
6716 millimeters, should be set to zero if the default height is to\n\
6717 remain unchanged. For rasterized drivers the dx and dy values\n\
6718 specified in plspage are used to convert from mm to pixels (note\n\
6719 the different unit systems used). This dpi aware scaling is not\n\
6720 implemented for all drivers yet.\n\
6721\n\
6722 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6723 actual character height.\n\
6724";
6725static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6726Calculate continuous time from broken-down time for the current stream\n\
6727\n\
6728DESCRIPTION:\n\
6729\n\
6730 Calculate continuous time, ctime, from broken-down time for the\n\
6731 current stream. The broken-down\n\
6732 time is specified by the following parameters: year, month, day, hour,\n\
6733 min, and sec. This function is the inverse of plbtime.\n\
6734\n\
6735 The PLplot definition of broken-down time is a calendar time that\n\
6736 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6737 responsibility to apply those offsets (if so desired) before using the\n\
6738 PLplot time API. By default broken-down time is defined using the\n\
6739 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6740 continuous time is defined as the number of seconds since the Unix\n\
6741 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6742 broken-down and continuous time are possible, see plconfigtime which\n\
6743 specifies that transformation for the current stream.\n\
6744\n\
6745 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6746 ctime)\n\
6747\n\
6748\n\
6749 This function is used in example 29.\n\
6750\n\
6751\n\
6752\n\
6753SYNOPSIS:\n\
6754\n\
6755plctime(year, month, day, hour, min, sec, ctime)\n\
6756\n\
6757ARGUMENTS:\n\
6758\n\
6759 year (PLINT, input) : Input year.\n\
6760\n\
6761 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6762 (December).\n\
6763\n\
6764 day (PLINT, input) : Input day in range from 1 to 31.\n\
6765\n\
6766 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6767\n\
6768 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6769\n\
6770 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6771\n\
6772 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6773 time calculated from the broken-down time specified by the\n\
6774 previous parameters.\n\
6775";
6776static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6777Set color, cmap0\n\
6778\n\
6779DESCRIPTION:\n\
6780\n\
6781 Sets the color index for cmap0 (see the PLplot documentation).\n\
6782\n\
6783 Redacted form: plcol0(icol0)\n\
6784\n\
6785 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6786\n\
6787\n\
6788\n\
6789SYNOPSIS:\n\
6790\n\
6791plcol0(icol0)\n\
6792\n\
6793ARGUMENTS:\n\
6794\n\
6795 icol0 (PLINT, input) : Integer representing the color. The\n\
6796 defaults at present are (these may change):\n\
6797 0 black (default background)\n\
6798 1 red (default foreground)\n\
6799 2 yellow\n\
6800 3 green\n\
6801 4 aquamarine\n\
6802 5 pink\n\
6803 6 wheat\n\
6804 7 grey\n\
6805 8 brown\n\
6806 9 blue\n\
6807 10 BlueViolet\n\
6808 11 cyan\n\
6809 12 turquoise\n\
6810 13 magenta\n\
6811 14 salmon\n\
6812 15 white\n\
6813\n\
6814 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6815 change an individual color in the cmap0 color palette.\n\
6816";
6817static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6818Set color, cmap1\n\
6819\n\
6820DESCRIPTION:\n\
6821\n\
6822 Sets the color for cmap1 (see the PLplot documentation).\n\
6823\n\
6824 Redacted form: plcol1(col1)\n\
6825\n\
6826 This function is used in examples 12 and 21.\n\
6827\n\
6828\n\
6829\n\
6830SYNOPSIS:\n\
6831\n\
6832plcol1(col1)\n\
6833\n\
6834ARGUMENTS:\n\
6835\n\
6836 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6837 is mapped to color using the continuous cmap1 palette which by\n\
6838 default ranges from blue to the background color to red. The\n\
6839 cmap1 palette can also be straightforwardly changed by the user\n\
6840 with plscmap1 or plscmap1l.\n\
6841";
6842static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6843Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6844\n\
6845DESCRIPTION:\n\
6846\n\
6847 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6848\n\
6849 Redacted form: plgcolbg(r, g, b)\n\
6850\n\
6851 This function is used in example 31.\n\
6852\n\
6853\n\
6854\n\
6855SYNOPSIS:\n\
6856\n\
6857plgcolbg(r, g, b)\n\
6858\n\
6859ARGUMENTS:\n\
6860\n\
6861 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6862 in the range from 0 to 255.\n\
6863\n\
6864 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6865 in the range from 0 to 255.\n\
6866\n\
6867 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6868 in the range from 0 to 255.\n\
6869";
6870static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6871Draw a circular or elliptical arc\n\
6872\n\
6873DESCRIPTION:\n\
6874\n\
6875 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6876 semiminor axis b, starting at angle1 and ending at angle2.\n\
6877\n\
6878 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6879 fill)\n\
6880\n\
6881\n\
6882 This function is used in examples 3 and 27.\n\
6883\n\
6884\n\
6885\n\
6886SYNOPSIS:\n\
6887\n\
6888plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6889\n\
6890ARGUMENTS:\n\
6891\n\
6892 x (PLFLT, input) : X coordinate of arc center.\n\
6893\n\
6894 y (PLFLT, input) : Y coordinate of arc center.\n\
6895\n\
6896 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6897\n\
6898 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6899\n\
6900 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6901 semimajor axis.\n\
6902\n\
6903 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6904 semimajor axis.\n\
6905\n\
6906 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6907 X-axis.\n\
6908\n\
6909 fill (PLBOOL, input) : Draw a filled arc.\n\
6910";
6911static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6912Parse command-line arguments\n\
6913\n\
6914DESCRIPTION:\n\
6915\n\
6916 Parse command-line arguments.\n\
6917\n\
6918 plparseopts removes all recognized flags (decreasing argc\n\
6919 accordingly), so that invalid input may be readily detected. It can\n\
6920 also be used to process user command line flags. The user can merge\n\
6921 an option table of type PLOptionTable into the internal option table\n\
6922 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6923 the external table(s) be parsed by calling plClearOpts before\n\
6924 plMergeOpts.\n\
6925\n\
6926 The default action taken by plparseopts is as follows:\n\
6927 Returns with an error if an unrecognized option or badly formed\n\
6928 option-value pair are encountered.\n\
6929 Returns immediately (return code 0) when the first non-option command\n\
6930 line argument is found.\n\
6931 Returns with the return code of the option handler, if one was called.\n\
6932\n\
6933 Deletes command line arguments from argv list as they are found, and\n\
6934 decrements argc accordingly.\n\
6935 Does not show \"invisible\" options in usage or help messages.\n\
6936 Assumes the program name is contained in argv[0].\n\
6937\n\
6938 These behaviors may be controlled through the\n\
6939 mode argument.\n\
6940\n\
6941 Redacted form: General: plparseopts(argv, mode)\n\
6942\n\
6943\n\
6944 This function is used in all of the examples.\n\
6945\n\
6946\n\
6947\n\
6948SYNOPSIS:\n\
6949\n\
6950PLINT plparseopts(p_argc, argv, mode)\n\
6951\n\
6952ARGUMENTS:\n\
6953\n\
6954 p_argc (int *, input/output) : Number of arguments.\n\
6955\n\
6956 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6957 strings containing *p_argc command-line arguments.\n\
6958\n\
6959 mode (PLINT, input) : Parsing mode with the following\n\
6960 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6961 and all error messages enabled, including program exit when an\n\
6962 error occurs. Anything on the command line that isn\'t recognized\n\
6963 as a valid option or option argument is flagged as an error.\n\
6964 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6965 of errors.\n\
6966 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6967 arguments.\n\
6968 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6969 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6970 pointer to the program name.\n\
6971 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6972 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6973 unrecognized arguments.\n\
6974";
6975static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
6976Get parameters that define current device-space window\n\
6977\n\
6978DESCRIPTION:\n\
6979\n\
6980 Get relative margin width, aspect ratio, and relative justification\n\
6981 that define current device-space window. If plsdidev has not been\n\
6982 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
6983 p_jy will all be 0.\n\
6984\n\
6985 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6986\n\
6987 This function is used in example 31.\n\
6988\n\
6989\n\
6990\n\
6991SYNOPSIS:\n\
6992\n\
6993plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6994\n\
6995ARGUMENTS:\n\
6996\n\
6997 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
6998 margin width.\n\
6999\n\
7000 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7001 ratio.\n\
7002\n\
7003 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7004 justification in x.\n\
7005\n\
7006 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7007 justification in y.\n\
7008";
7009static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7010Assign a function to use for generating custom axis labels\n\
7011\n\
7012DESCRIPTION:\n\
7013\n\
7014 This function allows a user to provide their own function to provide\n\
7015 axis label text. The user function is given the numeric value for a\n\
7016 point on an axis and returns a string label to correspond with that\n\
7017 value. Custom axis labels can be enabled by passing appropriate\n\
7018 arguments to plenv, plbox, plbox3 and similar functions.\n\
7019\n\
7020 This function is used in example 19.\n\
7021\n\
7022\n\
7023\n\
7024SYNOPSIS:\n\
7025\n\
7026plslabelfunc(label_func, label_data)\n\
7027\n\
7028ARGUMENTS:\n\
7029\n\
7030 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7031 label function. In order to reset to the default labelling, set\n\
7032 this to NULL. The labelling function parameters are, in order:\n\
7033 axis: This indicates which axis a label is being requested for.\n\
7034 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7035\n\
7036 value: This is the value along the axis which is being labelled.\n\
7037\n\
7038 label_text: The string representation of the label value.\n\
7039\n\
7040 length: The maximum length in characters allowed for label_text.\n\
7041\n\
7042\n\
7043 label_data (PLPointer, input) : This parameter may be used to pass\n\
7044 data to the label_func function.\n\
7045";
7046static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7047Get the (current) run level\n\
7048\n\
7049DESCRIPTION:\n\
7050\n\
7051 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7052 1, initialized\n\
7053 2, viewport defined\n\
7054 3, world coordinates defined\n\
7055\n\
7056\n\
7057 Redacted form: plglevel(p_level)\n\
7058\n\
7059 This function is used in example 31.\n\
7060\n\
7061\n\
7062\n\
7063SYNOPSIS:\n\
7064\n\
7065plglevel(p_level)\n\
7066\n\
7067ARGUMENTS:\n\
7068\n\
7069 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7070 level.\n\
7071";
7072static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7073Select line style\n\
7074\n\
7075DESCRIPTION:\n\
7076\n\
7077 This sets the line style according to one of eight predefined patterns\n\
7078 (also see plstyl).\n\
7079\n\
7080 Redacted form: pllsty(lin)\n\
7081\n\
7082 This function is used in examples 9, 12, 22, and 25.\n\
7083\n\
7084\n\
7085\n\
7086SYNOPSIS:\n\
7087\n\
7088pllsty(lin)\n\
7089\n\
7090ARGUMENTS:\n\
7091\n\
7092 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7093 a continuous line, line style 2 is a line with short dashes and\n\
7094 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7095 4 has long dashes and short gaps and so on.\n\
7096";
7097static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7098Set up standard window and draw box\n\
7099\n\
7100DESCRIPTION:\n\
7101\n\
7102 Sets up plotter environment for simple graphs by calling pladv and\n\
7103 setting up viewport and window to sensible default values. plenv\n\
7104 leaves a standard margin (left-hand margin of eight character heights,\n\
7105 and a margin around the other three sides of five character heights)\n\
7106 around most graphs for axis labels and a title. When these defaults\n\
7107 are not suitable, use the individual routines plvpas, plvpor, or\n\
7108 plvasp for setting up the viewport, plwind for defining the window,\n\
7109 and plbox for drawing the box.\n\
7110\n\
7111 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7112\n\
7113 This function is used in example 1,3,9,13,14,19-22,29.\n\
7114\n\
7115\n\
7116\n\
7117SYNOPSIS:\n\
7118\n\
7119plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7120\n\
7121ARGUMENTS:\n\
7122\n\
7123 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7124 world coordinates).\n\
7125\n\
7126 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7127 world coordinates).\n\
7128\n\
7129 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7130 coordinates).\n\
7131\n\
7132 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7133 coordinates).\n\
7134\n\
7135 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7136 scales will not be set, the user must set up the scale before\n\
7137 calling plenv using plsvpa, plvasp or other.\n\
7138 0: the x and y axes are scaled independently to use as much of\n\
7139 the screen as possible.\n\
7140 1: the scales of the x and y axes are made equal.\n\
7141 2: the axis of the x and y axes are made equal, and the plot\n\
7142 box will be square.\n\
7143\n\
7144\n\
7145 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7146 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7147 -1: draw box only.\n\
7148 0: draw box, ticks, and numeric tick labels.\n\
7149 1: also draw coordinate axes at x=0 and y=0.\n\
7150 2: also draw a grid at major tick positions in both\n\
7151 coordinates.\n\
7152 3: also draw a grid at minor tick positions in both\n\
7153 coordinates.\n\
7154 10: same as 0 except logarithmic x tick marks. (The x data\n\
7155 have to be converted to logarithms separately.)\n\
7156 11: same as 1 except logarithmic x tick marks. (The x data\n\
7157 have to be converted to logarithms separately.)\n\
7158 12: same as 2 except logarithmic x tick marks. (The x data\n\
7159 have to be converted to logarithms separately.)\n\
7160 13: same as 3 except logarithmic x tick marks. (The x data\n\
7161 have to be converted to logarithms separately.)\n\
7162 20: same as 0 except logarithmic y tick marks. (The y data\n\
7163 have to be converted to logarithms separately.)\n\
7164 21: same as 1 except logarithmic y tick marks. (The y data\n\
7165 have to be converted to logarithms separately.)\n\
7166 22: same as 2 except logarithmic y tick marks. (The y data\n\
7167 have to be converted to logarithms separately.)\n\
7168 23: same as 3 except logarithmic y tick marks. (The y data\n\
7169 have to be converted to logarithms separately.)\n\
7170 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7171 and y data have to be converted to logarithms separately.)\n\
7172 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7173 and y data have to be converted to logarithms separately.)\n\
7174 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7175 and y data have to be converted to logarithms separately.)\n\
7176 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7177 and y data have to be converted to logarithms separately.)\n\
7178 40: same as 0 except date / time x labels.\n\
7179 41: same as 1 except date / time x labels.\n\
7180 42: same as 2 except date / time x labels.\n\
7181 43: same as 3 except date / time x labels.\n\
7182 50: same as 0 except date / time y labels.\n\
7183 51: same as 1 except date / time y labels.\n\
7184 52: same as 2 except date / time y labels.\n\
7185 53: same as 3 except date / time y labels.\n\
7186 60: same as 0 except date / time x and y labels.\n\
7187 61: same as 1 except date / time x and y labels.\n\
7188 62: same as 2 except date / time x and y labels.\n\
7189 63: same as 3 except date / time x and y labels.\n\
7190 70: same as 0 except custom x and y labels.\n\
7191 71: same as 1 except custom x and y labels.\n\
7192 72: same as 2 except custom x and y labels.\n\
7193 73: same as 3 except custom x and y labels.\n\
7194";
7195static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7196Initialization\n\
7197\n\
7198DESCRIPTION:\n\
7199\n\
7200 Alternative to plstar for initializing the plotting package. The\n\
7201 device name keyword for the desired output device must be supplied as\n\
7202 an argument. These keywords are the same as those printed out by\n\
7203 plstar. If the requested device is not available, or if the input\n\
7204 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7205 is used. This routine also divides the output device page into nx by\n\
7206 ny subpages, each of which may be used independently. The subroutine\n\
7207 pladv is used to advance from one subpage to the next.\n\
7208\n\
7209 Redacted form: General: plstart(devname, nx, ny)\n\
7210\n\
7211\n\
7212 This function is not used in any examples.\n\
7213\n\
7214\n\
7215\n\
7216SYNOPSIS:\n\
7217\n\
7218plstart(devname, nx, ny)\n\
7219\n\
7220ARGUMENTS:\n\
7221\n\
7222 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7223 containing the device name keyword of the required output device.\n\
7224 If\n\
7225 devname is NULL or if the first character of the string is a ``?\'\',\n\
7226 the normal (prompted) start up is used.\n\
7227\n\
7228 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7229 x direction.\n\
7230\n\
7231 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7232 y direction.\n\
7233";
7234static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7235Plot a glyph at the specified points\n\
7236\n\
7237DESCRIPTION:\n\
7238\n\
7239 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7240 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7241 is specified with a PLplot user string. Note that the user string is\n\
7242 not actually limited to one glyph so it is possible (but not normally\n\
7243 useful) to plot more than one glyph at the specified points with this\n\
7244 function. As with plmtex and plptex, the user string can contain FCI\n\
7245 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7246 else PLplot escapes for Hershey or unicode text to determine the\n\
7247 glyph.\n\
7248\n\
7249 Redacted form: plstring(x, y, string)\n\
7250\n\
7251 This function is used in examples 4, 21 and 26.\n\
7252\n\
7253\n\
7254\n\
7255SYNOPSIS:\n\
7256\n\
7257plstring(n, x, y, string)\n\
7258\n\
7259ARGUMENTS:\n\
7260\n\
7261 n (PLINT, input) : Number of points in the x and y vectors.\n\
7262\n\
7263 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7264 the points.\n\
7265\n\
7266 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7267 the points.\n\
7268\n\
7269 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7270 the glyph(s) to be plotted at each of the n points.\n\
7271";
7272static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7273Write text relative to viewport boundaries in 3D plots\n\
7274\n\
7275DESCRIPTION:\n\
7276\n\
7277 Writes text at a specified position relative to the viewport\n\
7278 boundaries. Text may be written inside or outside the viewport, but\n\
7279 is clipped at the subpage boundaries. The reference point of a string\n\
7280 lies along a line passing through the string at half the height of a\n\
7281 capital letter. The position of the reference point along this line\n\
7282 is determined by just, and the position of the reference point\n\
7283 relative to the viewport is set by disp and pos.\n\
7284\n\
7285 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7286\n\
7287 This function is used in example 28.\n\
7288\n\
7289\n\
7290\n\
7291SYNOPSIS:\n\
7292\n\
7293plmtex3(side, disp, pos, just, text)\n\
7294\n\
7295ARGUMENTS:\n\
7296\n\
7297 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7298 the side of the viewport along which the text is to be written.\n\
7299 The string should contain one or more of the following characters:\n\
7300 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7301 only label the X axis, not both the X and Y axes. x: Label the X\n\
7302 axis.\n\
7303 y: Label the Y axis.\n\
7304 z: Label the Z axis.\n\
7305 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7306 For X it is the axis that starts at y-min. For Y it is the\n\
7307 axis that starts at x-min.\n\
7308 s: Label the secondary axis.\n\
7309 v: Draw the text perpendicular to the axis.\n\
7310\n\
7311\n\
7312 disp (PLFLT, input) : Position of the reference point of string,\n\
7313 measured outwards from the specified viewport edge in units of the\n\
7314 current character height. Use negative disp to write within the\n\
7315 viewport.\n\
7316\n\
7317 pos (PLFLT, input) : Position of the reference point of string\n\
7318 along the specified edge, expressed as a fraction of the length of\n\
7319 the edge.\n\
7320\n\
7321 just (PLFLT, input) : Specifies the position of the string relative\n\
7322 to its reference point. If just=0. , the reference point is at\n\
7323 the left and if just=1. , it is at the right of the string. Other\n\
7324 values of just give intermediate justifications.\n\
7325\n\
7326 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7327 written out.\n\
7328";
7329static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7330Get plot orientation\n\
7331\n\
7332DESCRIPTION:\n\
7333\n\
7334 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7335 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7336 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7337 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7338 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7339 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7340 not been called the default value pointed to by p_rot will be 0.\n\
7341\n\
7342 Redacted form: plgdiori(p_rot)\n\
7343\n\
7344 This function is not used in any examples.\n\
7345\n\
7346\n\
7347\n\
7348SYNOPSIS:\n\
7349\n\
7350plgdiori(p_rot)\n\
7351\n\
7352ARGUMENTS:\n\
7353\n\
7354 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7355 parameter.\n\
7356";
7357static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7358Simple routine to write labels\n\
7359\n\
7360DESCRIPTION:\n\
7361\n\
7362 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7363\n\
7364 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7365\n\
7366 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7367\n\
7368\n\
7369\n\
7370SYNOPSIS:\n\
7371\n\
7372pllab(xlabel, ylabel, tlabel)\n\
7373\n\
7374ARGUMENTS:\n\
7375\n\
7376 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7377 the label for the x axis.\n\
7378\n\
7379 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7380 the label for the y axis.\n\
7381\n\
7382 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7383 the title of the plot.\n\
7384";
7385static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7386Switch to text screen\n\
7387\n\
7388DESCRIPTION:\n\
7389\n\
7390 Sets an interactive device to text mode, used in conjunction with\n\
7391 plgra to allow graphics and text to be interspersed. On a device\n\
7392 which supports separate text and graphics windows, this command causes\n\
7393 control to be switched to the text window. This can be useful for\n\
7394 printing diagnostic messages or getting user input, which would\n\
7395 otherwise interfere with the plots. The program must switch back to\n\
7396 the graphics window before issuing plot commands, as the text (or\n\
7397 console) device will probably become quite confused otherwise. If\n\
7398 already in text mode, this command is ignored. It is also ignored on\n\
7399 devices which only support a single window or use a different method\n\
7400 for shifting focus (see also plgra).\n\
7401\n\
7402 Redacted form: pltext()\n\
7403\n\
7404 This function is used in example 1.\n\
7405\n\
7406\n\
7407\n\
7408SYNOPSIS:\n\
7409\n\
7410pltext()\n\
7411";
7412static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7413Plot all or a subset of Shapefile data using lines in world coordinates\n\
7414\n\
7415DESCRIPTION:\n\
7416\n\
7417 Plot all or a subset of Shapefile data using lines in world\n\
7418 coordinates. Our 19th standard example demonstrates how to use this\n\
7419 function. This function plots data from a Shapefile using lines as in\n\
7420 plmap, however it also has the option of also only drawing specified\n\
7421 elements from the Shapefile. The vector of indices of the required\n\
7422 elements are passed as a function argument. The Shapefile data should\n\
7423 include a metadata file (extension.dbf) listing all items within the\n\
7424 Shapefile. This file can be opened by most popular spreadsheet\n\
7425 programs and can be used to decide which indices to pass to this\n\
7426 function.\n\
7427\n\
7428 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7429 plotentries)\n\
7430\n\
7431 This function is used in example 19.\n\
7432\n\
7433\n\
7434\n\
7435SYNOPSIS:\n\
7436\n\
7437plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7438\n\
7439ARGUMENTS:\n\
7440\n\
7441 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7442 transform the coordinates given in the shapefile into a plot\n\
7443 coordinate system. By using this transform, we can change from a\n\
7444 longitude, latitude coordinate to a polar stereographic project,\n\
7445 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7446 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7447 mapform(), x[] and y[] should be replaced by the corresponding\n\
7448 plot coordinates. If no transform is desired, mapform can be\n\
7449 replaced by NULL.\n\
7450\n\
7451 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7452 the file name of a set of Shapefile files without the file\n\
7453 extension.\n\
7454\n\
7455 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7456 be in the same units as used by the Shapefile. You could use a\n\
7457 very large negative number to plot everything, but you can improve\n\
7458 performance by limiting the area drawn. The units must match those\n\
7459 of the Shapefile projection, which may be for example longitude or\n\
7460 distance. The value of minx must be less than the value of maxx.\n\
7461\n\
7462 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7463 use a very large number to plot everything, but you can improve\n\
7464 performance by limiting the area drawn.\n\
7465\n\
7466 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7467 be in the same units as used by the Shapefile. You could use a\n\
7468 very large negative number to plot everything, but you can improve\n\
7469 performance by limiting the area drawn. The units must match those\n\
7470 of the Shapefile projection, which may be for example latitude or\n\
7471 distance. The value of miny must be less than the value of maxy.\n\
7472\n\
7473 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7474 use a very large number to plot everything, but you can improve\n\
7475 performance by limiting the area drawn.\n\
7476\n\
7477 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7478 zero-based indices of the Shapefile elements which will be drawn.\n\
7479 Setting\n\
7480 plotentries to NULL will plot all elements of the Shapefile.\n\
7481\n\
7482 nplotentries (PLINT, input) : The number of items in\n\
7483 plotentries. Ignored if\n\
7484 plotentries is NULL.\n\
7485";
7486static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7487Set precision in numeric labels\n\
7488\n\
7489DESCRIPTION:\n\
7490\n\
7491 Sets the number of places after the decimal point in numeric labels.\n\
7492\n\
7493 Redacted form: plprec(setp, prec)\n\
7494\n\
7495 This function is used in example 29.\n\
7496\n\
7497\n\
7498\n\
7499SYNOPSIS:\n\
7500\n\
7501plprec(setp, prec)\n\
7502\n\
7503ARGUMENTS:\n\
7504\n\
7505 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7506 automatically determines the number of places to use after the\n\
7507 decimal point in numeric labels (like those used to label axes).\n\
7508 If setp is 1 then prec sets the number of places.\n\
7509\n\
7510 prec (PLINT, input) : The number of characters to draw after the\n\
7511 decimal point in numeric labels.\n\
7512";
7513static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7514Draw a line between two points\n\
7515\n\
7516DESCRIPTION:\n\
7517\n\
7518 Joins the point (\n\
7519 x1,\n\
7520 y1) to (\n\
7521 x2,\n\
7522 y2).\n\
7523\n\
7524 Redacted form: pljoin(x1,y1,x2,y2)\n\
7525\n\
7526 This function is used in examples 3 and 14.\n\
7527\n\
7528\n\
7529\n\
7530SYNOPSIS:\n\
7531\n\
7532pljoin(x1, y1, x2, y2)\n\
7533\n\
7534ARGUMENTS:\n\
7535\n\
7536 x1 (PLFLT, input) : x coordinate of first point.\n\
7537\n\
7538 y1 (PLFLT, input) : y coordinate of first point.\n\
7539\n\
7540 x2 (PLFLT, input) : x coordinate of second point.\n\
7541\n\
7542 y2 (PLFLT, input) : y coordinate of second point.\n\
7543";
7544static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7545Set the device (keyword) name\n\
7546\n\
7547DESCRIPTION:\n\
7548\n\
7549 Set the device (keyword) name.\n\
7550\n\
7551 Redacted form: plsdev(devname)\n\
7552\n\
7553 This function is used in examples 1, 14, and 20.\n\
7554\n\
7555\n\
7556\n\
7557SYNOPSIS:\n\
7558\n\
7559plsdev(devname)\n\
7560\n\
7561ARGUMENTS:\n\
7562\n\
7563 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7564 containing the device name keyword of the required output device.\n\
7565 If\n\
7566 devname is NULL or if the first character of the string is a ``?\'\',\n\
7567 the normal (prompted) start up is used.\n\
7568";
7569static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7570Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7571\n\
7572DESCRIPTION:\n\
7573\n\
7574 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7575 (see the PLplot documentation) index. Overwrites the previous color\n\
7576 value for the given index and, thus, does not result in any additional\n\
7577 allocation of space for colors.\n\
7578\n\
7579 This function is used in example 30.\n\
7580\n\
7581\n\
7582\n\
7583SYNOPSIS:\n\
7584\n\
7585plscol0a(icol0, r, g, b, alpha)\n\
7586\n\
7587ARGUMENTS:\n\
7588\n\
7589 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7590 number of colors (which is set by default, by plscmap0n, or even\n\
7591 by plscmap0).\n\
7592\n\
7593 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7594 degree of red in the color.\n\
7595\n\
7596 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7597 degree of green in the color.\n\
7598\n\
7599 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7600 degree of blue in the color.\n\
7601\n\
7602 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7603 (0.0-1.0).\n\
7604";
7605static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7606Draw filled polygon in 3D\n\
7607\n\
7608DESCRIPTION:\n\
7609\n\
7610 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7611 vectors using the pattern defined by plpsty or plpat. The routine\n\
7612 will automatically close the polygon between the last and first\n\
7613 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7614 plfill3 will fill in between them.\n\
7615\n\
7616 Redacted form: General: plfill3(x, y, z)\n\
7617\n\
7618\n\
7619 This function is used in example 15.\n\
7620\n\
7621\n\
7622\n\
7623SYNOPSIS:\n\
7624\n\
7625plfill3(n, x, y, z)\n\
7626\n\
7627ARGUMENTS:\n\
7628\n\
7629 n (PLINT, input) : Number of vertices in polygon.\n\
7630\n\
7631 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7632 vertices.\n\
7633\n\
7634 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7635 vertices.\n\
7636\n\
7637 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7638 vertices.\n\
7639";
7640static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7641Specify window\n\
7642\n\
7643DESCRIPTION:\n\
7644\n\
7645 Specify the window, i.e., the world coordinates of the edges of the\n\
7646 viewport.\n\
7647\n\
7648 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7649\n\
7650 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7651 29, and 31.\n\
7652\n\
7653\n\
7654\n\
7655SYNOPSIS:\n\
7656\n\
7657plwind(xmin, xmax, ymin, ymax)\n\
7658\n\
7659ARGUMENTS:\n\
7660\n\
7661 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7662 of the viewport.\n\
7663\n\
7664 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7665 of the viewport.\n\
7666\n\
7667 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7668 the viewport.\n\
7669\n\
7670 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7671 viewport.\n\
7672";
7673static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7674Draw text at points defined by Shapefile data in world coordinates\n\
7675\n\
7676DESCRIPTION:\n\
7677\n\
7678 As per plmapline, however the items are plotted as text in the same\n\
7679 way as plptex.\n\
7680\n\
7681 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7682 miny, maxy, plotentry)\n\
7683\n\
7684 This function is used in example 19.\n\
7685\n\
7686\n\
7687\n\
7688SYNOPSIS:\n\
7689\n\
7690plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7691\n\
7692ARGUMENTS:\n\
7693\n\
7694 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7695 transform the coordinates given in the shapefile into a plot\n\
7696 coordinate system. By using this transform, we can change from a\n\
7697 longitude, latitude coordinate to a polar stereographic project,\n\
7698 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7699 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7700 mapform(), x[] and y[] should be replaced by the corresponding\n\
7701 plot coordinates. If no transform is desired, mapform can be\n\
7702 replaced by NULL.\n\
7703\n\
7704 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7705 the file name of a set of Shapefile files without the file\n\
7706 extension.\n\
7707\n\
7708 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7709 dy/dx.\n\
7710\n\
7711 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7712 dy/dx.\n\
7713\n\
7714 just (PLFLT, input) : Set the justification of the text. The value\n\
7715 given will be the fraction of the distance along the string that\n\
7716 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7717 centralized text and 1.0 gives right aligned text.\n\
7718\n\
7719 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7720\n\
7721 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7722 be in the same units as used by the Shapefile. You could use a\n\
7723 very large negative number to plot everything, but you can improve\n\
7724 performance by limiting the area drawn. The units must match those\n\
7725 of the Shapefile projection, which may be for example longitude or\n\
7726 distance. The value of minx must be less than the value of maxx.\n\
7727\n\
7728 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7729 use a very large number to plot everything, but you can improve\n\
7730 performance by limiting the area drawn.\n\
7731\n\
7732 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7733 be in the same units as used by the Shapefile. You could use a\n\
7734 very large negative number to plot everything, but you can improve\n\
7735 performance by limiting the area drawn. The units must match those\n\
7736 of the Shapefile projection, which may be for example latitude or\n\
7737 distance. The value of miny must be less than the value of maxy.\n\
7738\n\
7739 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7740 use a very large number to plot everything, but you can improve\n\
7741 performance by limiting the area drawn.\n\
7742\n\
7743 plotentry (PLINT, input) : An integer indicating which text string\n\
7744 of the Shapefile (zero indexed) will be drawn.\n\
7745";
7746static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7747Switch to graphics screen\n\
7748\n\
7749DESCRIPTION:\n\
7750\n\
7751 Sets an interactive device to graphics mode, used in conjunction with\n\
7752 pltext to allow graphics and text to be interspersed. On a device\n\
7753 which supports separate text and graphics windows, this command causes\n\
7754 control to be switched to the graphics window. If already in graphics\n\
7755 mode, this command is ignored. It is also ignored on devices which\n\
7756 only support a single window or use a different method for shifting\n\
7757 focus. See also pltext.\n\
7758\n\
7759 Redacted form: plgra()\n\
7760\n\
7761 This function is used in example 1.\n\
7762\n\
7763\n\
7764\n\
7765SYNOPSIS:\n\
7766\n\
7767plgra()\n\
7768";
7769static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7770Set parameters of contour labelling other than format of numerical label\n\
7771\n\
7772DESCRIPTION:\n\
7773\n\
7774 Set parameters of contour labelling other than those handled by\n\
7775 pl_setcontlabelformat.\n\
7776\n\
7777 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7778\n\
7779 This function is used in example 9.\n\
7780\n\
7781\n\
7782\n\
7783SYNOPSIS:\n\
7784\n\
7785pl_setcontlabelparam(offset, size, spacing, active)\n\
7786\n\
7787ARGUMENTS:\n\
7788\n\
7789 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7790 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7791\n\
7792 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7793 Default value is 0.3.\n\
7794\n\
7795 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7796 Default value is 0.1.\n\
7797\n\
7798 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7799 contour labels on. Default is off (0).\n\
7800";
7801static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7802Get family, style and weight of the current font\n\
7803\n\
7804DESCRIPTION:\n\
7805\n\
7806 Gets information about current font. See the PLplot documentation for\n\
7807 more information on font selection.\n\
7808\n\
7809 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7810\n\
7811 This function is used in example 23.\n\
7812\n\
7813\n\
7814\n\
7815SYNOPSIS:\n\
7816\n\
7817plgfont(p_family, p_style, p_weight)\n\
7818\n\
7819ARGUMENTS:\n\
7820\n\
7821 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7822 font family. The available values are given by the PL_FCI_*\n\
7823 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7824 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7825 p_family is NULL then the font family is not returned.\n\
7826\n\
7827 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7828 font style. The available values are given by the PL_FCI_*\n\
7829 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7830 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7831 style is not returned.\n\
7832\n\
7833 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7834 font weight. The available values are given by the PL_FCI_*\n\
7835 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7836 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7837 returned.\n\
7838";
7839static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7840Plot a histogram from unbinned data\n\
7841\n\
7842DESCRIPTION:\n\
7843\n\
7844 Plots a histogram from n data points stored in the data vector. This\n\
7845 routine bins the data into nbin bins equally spaced between datmin and\n\
7846 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7847 opt allows, among other things, the histogram either to be plotted in\n\
7848 an existing window or causes plhist to call plenv with suitable limits\n\
7849 before plotting the histogram.\n\
7850\n\
7851 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7852\n\
7853 This function is used in example 5.\n\
7854\n\
7855\n\
7856\n\
7857SYNOPSIS:\n\
7858\n\
7859plhist(n, data, datmin, datmax, nbin, opt)\n\
7860\n\
7861ARGUMENTS:\n\
7862\n\
7863 n (PLINT, input) : Number of data points.\n\
7864\n\
7865 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7866 n data points.\n\
7867\n\
7868 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7869\n\
7870 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7871\n\
7872 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7873 divide the interval xmin to xmax.\n\
7874\n\
7875 opt (PLINT, input) : Is a combination of several flags:\n\
7876 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7877 the histogram data, the outer bins are expanded to fill up the\n\
7878 entire x-axis, data outside the given extremes are assigned to the\n\
7879 outer bins and bins of zero height are simply drawn.\n\
7880 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7881 to fit the histogram data, without this flag, plenv is called\n\
7882 to set the world coordinates.\n\
7883 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7884 extremes are not taken into account. This option should\n\
7885 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7886 properly present the data.\n\
7887 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7888 size as the ones inside.\n\
7889 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7890 (there is a gap for such bins).\n\
7891";
7892static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7893Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7894\n\
7895DESCRIPTION:\n\
7896\n\
7897 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7898 alpha transparency value.\n\
7899\n\
7900 This function is used in example 31.\n\
7901\n\
7902\n\
7903\n\
7904SYNOPSIS:\n\
7905\n\
7906plgcolbga(r, g, b, alpha)\n\
7907\n\
7908ARGUMENTS:\n\
7909\n\
7910 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7911 in the range from 0 to 255.\n\
7912\n\
7913 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7914 in the range from 0 to 255.\n\
7915\n\
7916 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7917 in the range from 0 to 255.\n\
7918\n\
7919 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7920 transparency in the range (0.0-1.0).\n\
7921";
7922static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
7923Set orientation\n\
7924\n\
7925DESCRIPTION:\n\
7926\n\
7927 Set integer plot orientation parameter. This function is identical to\n\
7928 plsdiori except for the type of the argument, and should be used in\n\
7929 the same way. See the documentation of plsdiori for details.\n\
7930\n\
7931 Redacted form: plsori(ori)\n\
7932\n\
7933 This function is used in example 3.\n\
7934\n\
7935\n\
7936\n\
7937SYNOPSIS:\n\
7938\n\
7939plsori(ori)\n\
7940\n\
7941ARGUMENTS:\n\
7942\n\
7943 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
7944 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
7945 angle.\n\
7946";
7947static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
7948Plot latitude and longitude lines\n\
7949\n\
7950DESCRIPTION:\n\
7951\n\
7952 Displays latitude and longitude on the current plot. The lines are\n\
7953 plotted in the current color and line style.\n\
7954\n\
7955 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
7956 minlat, maxlat)\n\
7957\n\
7958 This function is used in example 19.\n\
7959\n\
7960\n\
7961\n\
7962SYNOPSIS:\n\
7963\n\
7964plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7965\n\
7966ARGUMENTS:\n\
7967\n\
7968 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7969 transform the coordinate longitudes and latitudes to a plot\n\
7970 coordinate system. By using this transform, we can change from a\n\
7971 longitude, latitude coordinate to a polar stereographic project,\n\
7972 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7973 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7974 mapform(), x[] and y[] should be replaced by the corresponding\n\
7975 plot coordinates. If no transform is desired, mapform can be\n\
7976 replaced by NULL.\n\
7977\n\
7978 dlong (PLFLT, input) : The interval in degrees at which the\n\
7979 longitude lines are to be plotted.\n\
7980\n\
7981 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7982 lines are to be plotted.\n\
7983\n\
7984 minlong (PLFLT, input) : The value of the longitude on the left\n\
7985 side of the plot. The value of minlong must be less than the value\n\
7986 of maxlong, and the quantity maxlong-minlong must be less than or\n\
7987 equal to 360.\n\
7988\n\
7989 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7990 side of the plot.\n\
7991\n\
7992 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7993 background. One can always use -90.0 as the boundary outside the\n\
7994 plot window will be automatically eliminated. However, the\n\
7995 program will be faster if one can reduce the size of the\n\
7996 background plotted.\n\
7997\n\
7998 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7999 background. One can always use 90.0 as the boundary outside the\n\
8000 plot window will be automatically eliminated.\n\
8001";
8002static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8003Clear current (sub)page\n\
8004\n\
8005DESCRIPTION:\n\
8006\n\
8007 Clears the current page, effectively erasing everything that have been\n\
8008 drawn. This command only works with interactive drivers; if the\n\
8009 driver does not support this, the page is filled with the background\n\
8010 color in use. If the current page is divided into subpages, only the\n\
8011 current subpage is erased. The nth subpage can be selected with\n\
8012 pladv(n).\n\
8013\n\
8014 Redacted form: General: plclear()\n\
8015\n\
8016\n\
8017 This function is not used in any examples.\n\
8018\n\
8019\n\
8020\n\
8021SYNOPSIS:\n\
8022\n\
8023plclear()\n\
8024";
8025static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8026Initialization\n\
8027\n\
8028DESCRIPTION:\n\
8029\n\
8030 Initializing the plotting package. The program prompts for the device\n\
8031 keyword or number of the desired output device. Hitting a RETURN in\n\
8032 response to the prompt is the same as selecting the first device. If\n\
8033 only one device is enabled when PLplot is installed, plstar will issue\n\
8034 no prompt. The output device is divided into nx by ny subpages, each\n\
8035 of which may be used independently. The subroutine pladv is used to\n\
8036 advance from one subpage to the next.\n\
8037\n\
8038 Redacted form: plstar(nx, ny)\n\
8039\n\
8040 This function is used in example 1.\n\
8041\n\
8042\n\
8043\n\
8044SYNOPSIS:\n\
8045\n\
8046plstar(nx, ny)\n\
8047\n\
8048ARGUMENTS:\n\
8049\n\
8050 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8051 x direction.\n\
8052\n\
8053 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8054 y direction.\n\
8055";
8056static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8057Write text relative to viewport boundaries\n\
8058\n\
8059DESCRIPTION:\n\
8060\n\
8061 Writes text at a specified position relative to the viewport\n\
8062 boundaries. Text may be written inside or outside the viewport, but\n\
8063 is clipped at the subpage boundaries. The reference point of a string\n\
8064 lies along a line passing through the string at half the height of a\n\
8065 capital letter. The position of the reference point along this line\n\
8066 is determined by just, and the position of the reference point\n\
8067 relative to the viewport is set by disp and pos.\n\
8068\n\
8069 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8070\n\
8071\n\
8072 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8073 26.\n\
8074\n\
8075\n\
8076\n\
8077SYNOPSIS:\n\
8078\n\
8079plmtex(side, disp, pos, just, text)\n\
8080\n\
8081ARGUMENTS:\n\
8082\n\
8083 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8084 the side of the viewport along which the text is to be written.\n\
8085 The string must be one of: b: Bottom of viewport, text written\n\
8086 parallel to edge.\n\
8087 bv: Bottom of viewport, text written at right angles to edge.\n\
8088 l: Left of viewport, text written parallel to edge.\n\
8089 lv: Left of viewport, text written at right angles to edge.\n\
8090 r: Right of viewport, text written parallel to edge.\n\
8091 rv: Right of viewport, text written at right angles to edge.\n\
8092 t: Top of viewport, text written parallel to edge.\n\
8093 tv: Top of viewport, text written at right angles to edge.\n\
8094\n\
8095\n\
8096 disp (PLFLT, input) : Position of the reference point of string,\n\
8097 measured outwards from the specified viewport edge in units of the\n\
8098 current character height. Use negative disp to write within the\n\
8099 viewport.\n\
8100\n\
8101 pos (PLFLT, input) : Position of the reference point of string\n\
8102 along the specified edge, expressed as a fraction of the length of\n\
8103 the edge.\n\
8104\n\
8105 just (PLFLT, input) : Specifies the position of the string relative\n\
8106 to its reference point. If just=0. , the reference point is at\n\
8107 the left and if just=1. , it is at the right of the string. Other\n\
8108 values of just give intermediate justifications.\n\
8109\n\
8110 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8111 written out.\n\
8112";
8113static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8114Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8115\n\
8116DESCRIPTION:\n\
8117\n\
8118 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8119 PLFLT alpha transparency value (see the PLplot documentation).\n\
8120\n\
8121 This function is used in example 31.\n\
8122\n\
8123\n\
8124\n\
8125SYNOPSIS:\n\
8126\n\
8127plscolbga(r, g, b, alpha)\n\
8128\n\
8129ARGUMENTS:\n\
8130\n\
8131 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8132 degree of red in the color.\n\
8133\n\
8134 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8135 degree of green in the color.\n\
8136\n\
8137 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8138 degree of blue in the color.\n\
8139\n\
8140 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8141 (0.0-1.0).\n\
8142";
8143static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8144Replays contents of plot buffer to current device/file\n\
8145\n\
8146DESCRIPTION:\n\
8147\n\
8148 Replays contents of plot buffer to current device/file.\n\
8149\n\
8150 Redacted form: plreplot()\n\
8151\n\
8152 This function is used in example 1,20.\n\
8153\n\
8154\n\
8155\n\
8156SYNOPSIS:\n\
8157\n\
8158plreplot()\n\
8159";
8160static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8161Plot a glyph at the specified 3D points\n\
8162\n\
8163DESCRIPTION:\n\
8164\n\
8165 Plot a glyph at the specified 3D points. (This function is largely\n\
8166 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8167 Set up the call to this function similar to what is done for plline3.\n\
8168 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8169 and a draw at the same place. Not ideal, since a sufficiently\n\
8170 intelligent output device may optimize it away, or there may be faster\n\
8171 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8172 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8173 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8174 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8175 code <= 127 the corresponding printable ASCII character is plotted.\n\
8176\n\
8177 Redacted form: plpoin3(x, y, z, code)\n\
8178\n\
8179 This function is not used in any example.\n\
8180\n\
8181\n\
8182\n\
8183SYNOPSIS:\n\
8184\n\
8185plpoin3(n, x, y, z, code)\n\
8186\n\
8187ARGUMENTS:\n\
8188\n\
8189 n (PLINT, input) : Number of points in the x and y vectors.\n\
8190\n\
8191 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8192 points.\n\
8193\n\
8194 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8195 points.\n\
8196\n\
8197 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8198 points.\n\
8199\n\
8200 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8201 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8202 each of the n points.\n\
8203";
8204static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8205Set family, style and weight of the current font\n\
8206\n\
8207DESCRIPTION:\n\
8208\n\
8209 Sets the current font. See the PLplot documentation for more\n\
8210 information on font selection.\n\
8211\n\
8212 Redacted form: plsfont(family, style, weight)\n\
8213\n\
8214 This function is used in example 23.\n\
8215\n\
8216\n\
8217\n\
8218SYNOPSIS:\n\
8219\n\
8220plsfont(family, style, weight)\n\
8221\n\
8222ARGUMENTS:\n\
8223\n\
8224 family (PLINT, input) : Font family to select for the current font.\n\
8225 The available values are given by the PL_FCI_* constants in\n\
8226 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8227 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8228 signifies that the font family should not be altered.\n\
8229\n\
8230 style (PLINT, input) : Font style to select for the current font.\n\
8231 The available values are given by the PL_FCI_* constants in\n\
8232 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8233 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8234 should not be altered.\n\
8235\n\
8236 weight (PLINT, input) : Font weight to select for the current font.\n\
8237 The available values are given by the PL_FCI_* constants in\n\
8238 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8239 negative value signifies that the font weight should not be\n\
8240 altered.\n\
8241";
8242static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8243Draw a box with axes, etc. with arbitrary origin\n\
8244\n\
8245DESCRIPTION:\n\
8246\n\
8247 Draws a box around the currently defined viewport with arbitrary\n\
8248 world-coordinate origin specified by x0 and y0 and labels it with\n\
8249 world coordinate values appropriate to the window. Thus plaxes should\n\
8250 only be called after defining both viewport and window. The ascii\n\
8251 character strings xopt and yopt specify how the box should be drawn as\n\
8252 described below. If ticks and/or subticks are to be drawn for a\n\
8253 particular axis, the tick intervals and number of subintervals may be\n\
8254 specified explicitly, or they may be defaulted by setting the\n\
8255 appropriate arguments to zero.\n\
8256\n\
8257 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8258 ytick, nysub)\n\
8259\n\
8260\n\
8261 This function is not used in any examples.\n\
8262\n\
8263\n\
8264\n\
8265SYNOPSIS:\n\
8266\n\
8267plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8268\n\
8269ARGUMENTS:\n\
8270\n\
8271 x0 (PLFLT, input) : World X coordinate of origin.\n\
8272\n\
8273 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8274\n\
8275 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8276 options for the x axis. The string can include any combination of\n\
8277 the following letters (upper or lower case) in any order: a: Draws\n\
8278 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8279 (x=0).\n\
8280 b: Draws bottom (X) or left (Y) edge of frame.\n\
8281 c: Draws top (X) or right (Y) edge of frame.\n\
8282 d: Plot labels as date / time. Values are assumed to be\n\
8283 seconds since the epoch (as used by gmtime).\n\
8284 f: Always use fixed point numeric labels.\n\
8285 g: Draws a grid at the major tick interval.\n\
8286 h: Draws a grid at the minor tick interval.\n\
8287 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8288 inwards.\n\
8289 l: Labels axis logarithmically. This only affects the labels,\n\
8290 not the data, and so it is necessary to compute the logarithms\n\
8291 of data points before passing them to any of the drawing\n\
8292 routines.\n\
8293 m: Writes numeric labels at major tick intervals in the\n\
8294 unconventional location (above box for X, right of box for Y).\n\
8295 n: Writes numeric labels at major tick intervals in the\n\
8296 conventional location (below box for X, left of box for Y).\n\
8297 o: Use custom labelling function to generate axis label text.\n\
8298 The custom labelling function can be defined with the\n\
8299 plslabelfunc command.\n\
8300 s: Enables subticks between major ticks, only valid if t is\n\
8301 also specified.\n\
8302 t: Draws major ticks.\n\
8303 u: Exactly like \"b\" except don\'t draw edge line.\n\
8304 w: Exactly like \"c\" except don\'t draw edge line.\n\
8305 x: Exactly like \"t\" (including the side effect of the\n\
8306 numerical labels for the major ticks) except exclude drawing\n\
8307 the major and minor tick marks.\n\
8308\n\
8309\n\
8310 xtick (PLFLT, input) : World coordinate interval between major\n\
8311 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8312 generates a suitable tick interval.\n\
8313\n\
8314 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8315 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8316 generates a suitable minor tick interval.\n\
8317\n\
8318 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8319 options for the y axis. The string can include any combination of\n\
8320 the letters defined above for xopt, and in addition may contain:\n\
8321 v: Write numeric labels for the y axis parallel to the base of the\n\
8322 graph, rather than parallel to the axis.\n\
8323\n\
8324\n\
8325 ytick (PLFLT, input) : World coordinate interval between major\n\
8326 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8327 generates a suitable tick interval.\n\
8328\n\
8329 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8330 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8331 generates a suitable minor tick interval.\n\
8332";
8333static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8334Begin a new page\n\
8335\n\
8336DESCRIPTION:\n\
8337\n\
8338 Begins a new page. For a file driver, the output file is opened if\n\
8339 necessary. Advancing the page via pleop and plbop is useful when a\n\
8340 page break is desired at a particular point when plotting to subpages.\n\
8341 Another use for pleop and plbop is when plotting pages to different\n\
8342 files, since you can manually set the file name by calling plsfnam\n\
8343 after the call to pleop. (In fact some drivers may only support a\n\
8344 single page per file, making this a necessity.) One way to handle\n\
8345 this case automatically is to page advance via pladv, but enable\n\
8346 familying (see plsfam) with a small limit on the file size so that a\n\
8347 new family member file will be created on each page break.\n\
8348\n\
8349 Redacted form: plbop()\n\
8350\n\
8351 This function is used in examples 2 and 20.\n\
8352\n\
8353\n\
8354\n\
8355SYNOPSIS:\n\
8356\n\
8357plbop()\n\
8358";
8359static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8360Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8361\n\
8362DESCRIPTION:\n\
8363\n\
8364 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8365 and PLFLT alpha transparency value. This sets the entire color map --\n\
8366 only as many colors as specified will be allocated.\n\
8367\n\
8368 Redacted form: plscmap0a(r, g, b, alpha)\n\
8369\n\
8370 This function is used in examples 30.\n\
8371\n\
8372\n\
8373\n\
8374SYNOPSIS:\n\
8375\n\
8376plscmap0a(r, g, b, alpha, ncol0)\n\
8377\n\
8378ARGUMENTS:\n\
8379\n\
8380 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8381 integers (0-255) representing the degree of red in the color.\n\
8382\n\
8383 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8384 integers (0-255) representing the degree of green in the color.\n\
8385\n\
8386 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8387 integers (0-255) representing the degree of blue in the color.\n\
8388\n\
8389 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8390 representing the alpha transparency of the color.\n\
8391\n\
8392 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8393 vectors.\n\
8394";
8395static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8396Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8397\n\
8398DESCRIPTION:\n\
8399\n\
8400 This is a variant of plscmap1l that supports alpha channel\n\
8401 transparency. It sets cmap1 colors using a piece-wise linear\n\
8402 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8403 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8404 transparency value (0.0-1.0). It may be called at any time.\n\
8405\n\
8406 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8407 alpha, alt_hue_path)\n\
8408\n\
8409 This function is used in example 30.\n\
8410\n\
8411\n\
8412\n\
8413SYNOPSIS:\n\
8414\n\
8415plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8416\n\
8417ARGUMENTS:\n\
8418\n\
8419 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8420\n\
8421 npts (PLINT, input) : number of control points.\n\
8422\n\
8423 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8424 intensity index (0.0-1.0) in ascending order for each control\n\
8425 point.\n\
8426\n\
8427 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8428 coordinate (H or R) for each control point.\n\
8429\n\
8430 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8431 coordinate (L or G) for each control point.\n\
8432\n\
8433 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8434 coordinate (S or B) for each control point.\n\
8435\n\
8436 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8437 transparency value (0.0-1.0) for each control point.\n\
8438\n\
8439 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8440 npts - 1 elements) containing the alternative interpolation method\n\
8441 Boolean value for each control point interval. (alt_hue_path[i]\n\
8442 refers to the interpolation interval between the i and i + 1\n\
8443 control points).\n\
8444";
8445static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8446Enter or leave xor mode\n\
8447\n\
8448DESCRIPTION:\n\
8449\n\
8450 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8451 those drivers (e.g., the xwin driver) that support it. Enables\n\
8452 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8453 is not capable of xor operation it returns a status of false.\n\
8454\n\
8455 Redacted form: plxormod(mode, status)\n\
8456\n\
8457 This function is used in examples 1 and 20.\n\
8458\n\
8459\n\
8460\n\
8461SYNOPSIS:\n\
8462\n\
8463plxormod(mode, status)\n\
8464\n\
8465ARGUMENTS:\n\
8466\n\
8467 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8468 is false means leave xor mode.\n\
8469\n\
8470 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8471 modestatus of true (false) means driver is capable (incapable) of\n\
8472 xor mode.\n\
8473";
8474static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8475Eject current page\n\
8476\n\
8477DESCRIPTION:\n\
8478\n\
8479 Clears the graphics screen of an interactive device, or ejects a page\n\
8480 on a plotter. See plbop for more information.\n\
8481\n\
8482 Redacted form: pleop()\n\
8483\n\
8484 This function is used in example 2,14.\n\
8485\n\
8486\n\
8487\n\
8488SYNOPSIS:\n\
8489\n\
8490pleop()\n\
8491";
8492static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8493Draw a box with axes, etc\n\
8494\n\
8495DESCRIPTION:\n\
8496\n\
8497 Draws a box around the currently defined viewport, and labels it with\n\
8498 world coordinate values appropriate to the window. Thus plbox should\n\
8499 only be called after defining both viewport and window. The ascii\n\
8500 character strings xopt and yopt specify how the box should be drawn as\n\
8501 described below. If ticks and/or subticks are to be drawn for a\n\
8502 particular axis, the tick intervals and number of subintervals may be\n\
8503 specified explicitly, or they may be defaulted by setting the\n\
8504 appropriate arguments to zero.\n\
8505\n\
8506 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8507\n\
8508\n\
8509 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8510 and 29.\n\
8511\n\
8512\n\
8513\n\
8514SYNOPSIS:\n\
8515\n\
8516plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8517\n\
8518ARGUMENTS:\n\
8519\n\
8520 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8521 options for the x axis. The string can include any combination of\n\
8522 the following letters (upper or lower case) in any order: a: Draws\n\
8523 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8524 (x=0).\n\
8525 b: Draws bottom (X) or left (Y) edge of frame.\n\
8526 c: Draws top (X) or right (Y) edge of frame.\n\
8527 d: Plot labels as date / time. Values are assumed to be\n\
8528 seconds since the epoch (as used by gmtime).\n\
8529 f: Always use fixed point numeric labels.\n\
8530 g: Draws a grid at the major tick interval.\n\
8531 h: Draws a grid at the minor tick interval.\n\
8532 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8533 inwards.\n\
8534 l: Labels axis logarithmically. This only affects the labels,\n\
8535 not the data, and so it is necessary to compute the logarithms\n\
8536 of data points before passing them to any of the drawing\n\
8537 routines.\n\
8538 m: Writes numeric labels at major tick intervals in the\n\
8539 unconventional location (above box for X, right of box for Y).\n\
8540 n: Writes numeric labels at major tick intervals in the\n\
8541 conventional location (below box for X, left of box for Y).\n\
8542 o: Use custom labelling function to generate axis label text.\n\
8543 The custom labelling function can be defined with the\n\
8544 plslabelfunc command.\n\
8545 s: Enables subticks between major ticks, only valid if t is\n\
8546 also specified.\n\
8547 t: Draws major ticks.\n\
8548 u: Exactly like \"b\" except don\'t draw edge line.\n\
8549 w: Exactly like \"c\" except don\'t draw edge line.\n\
8550 x: Exactly like \"t\" (including the side effect of the\n\
8551 numerical labels for the major ticks) except exclude drawing\n\
8552 the major and minor tick marks.\n\
8553\n\
8554\n\
8555 xtick (PLFLT, input) : World coordinate interval between major\n\
8556 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8557 generates a suitable tick interval.\n\
8558\n\
8559 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8560 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8561 generates a suitable minor tick interval.\n\
8562\n\
8563 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8564 options for the y axis. The string can include any combination of\n\
8565 the letters defined above for xopt, and in addition may contain:\n\
8566 v: Write numeric labels for the y axis parallel to the base of the\n\
8567 graph, rather than parallel to the axis.\n\
8568\n\
8569\n\
8570 ytick (PLFLT, input) : World coordinate interval between major\n\
8571 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8572 generates a suitable tick interval.\n\
8573\n\
8574 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8575 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8576 generates a suitable minor tick interval.\n\
8577";
8578static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8579Get x axis parameters\n\
8580\n\
8581DESCRIPTION:\n\
8582\n\
8583 Returns current values of the p_digmax and p_digits flags for the x\n\
8584 axis. p_digits is updated after the plot is drawn, so this routine\n\
8585 should only be called after the call to plbox (or plbox3) is complete.\n\
8586 See the PLplot documentation for more information.\n\
8587\n\
8588 Redacted form: plgxax(p_digmax, p_digits)\n\
8589\n\
8590 This function is used in example 31.\n\
8591\n\
8592\n\
8593\n\
8594SYNOPSIS:\n\
8595\n\
8596plgxax(p_digmax, p_digits)\n\
8597\n\
8598ARGUMENTS:\n\
8599\n\
8600 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8601 number of digits for the x axis. If nonzero, the printed label\n\
8602 has been switched to a floating-point representation when the\n\
8603 number of digits exceeds this value.\n\
8604\n\
8605 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8606 number of digits for the numeric labels (x axis) from the last\n\
8607 plot.\n\
8608";
8609static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8610Set font\n\
8611\n\
8612DESCRIPTION:\n\
8613\n\
8614 Sets the font used for subsequent text and symbols. For devices that\n\
8615 still use Hershey fonts this routine has no effect unless the Hershey\n\
8616 fonts with extended character set are loaded (see plfontld). For\n\
8617 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8618 this routine calls the plsfci routine with argument set up\n\
8619 appropriately for the various cases below. However, this method of\n\
8620 specifying the font for unicode-aware devices is deprecated, and the\n\
8621 much more flexible method of calling plsfont directly is recommended\n\
8622 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8623\n\
8624 Redacted form: plfont(ifont)\n\
8625\n\
8626 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8627\n\
8628\n\
8629\n\
8630SYNOPSIS:\n\
8631\n\
8632plfont(ifont)\n\
8633\n\
8634ARGUMENTS:\n\
8635\n\
8636 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8637 (simplest and fastest)\n\
8638 2: Serif font\n\
8639 3: Italic font\n\
8640 4: Script font\n\
8641";
8642static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8643Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8644\n\
8645DESCRIPTION:\n\
8646\n\
8647 Routine for creating a discrete plot legend with a plotted filled box,\n\
8648 line, and/or line of symbols for each annotated legend entry. (See\n\
8649 plcolorbar for similar functionality for creating continuous color\n\
8650 bars.) The arguments of pllegend provide control over the location\n\
8651 and size of the legend as well as the location and characteristics of\n\
8652 the elements (most of which are optional) within that legend. The\n\
8653 resulting legend is clipped at the boundaries of the current subpage.\n\
8654 (N.B. the adopted coordinate system used for some of the parameters is\n\
8655 defined in the documentation of the position parameter.)\n\
8656\n\
8657 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8658 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8659 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8660 test_justification, text_colors, text, box_colors, box_patterns,\n\
8661 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8662 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8663\n\
8664 This function is used in examples 4, 26, and 33.\n\
8665\n\
8666\n\
8667\n\
8668SYNOPSIS:\n\
8669\n\
8670pllegend(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\
8671\n\
8672ARGUMENTS:\n\
8673\n\
8674 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8675 legend width in adopted coordinates. This quantity is calculated\n\
8676 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8677 the routine depending on nlegend and nrow), and the length\n\
8678 (calculated internally) of the longest text string.\n\
8679\n\
8680 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8681 legend height in adopted coordinates. This quantity is calculated\n\
8682 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8683 the routine depending on nlegend and nrow).\n\
8684\n\
8685 opt (PLINT, input) : opt contains bits controlling the overall\n\
8686 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8687 on the left of the legend and the plotted area on the right.\n\
8688 Otherwise, put the text area on the right of the legend and the\n\
8689 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8690 plot a (semitransparent) background for the legend. If the\n\
8691 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8692 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8693 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8694 plot the resulting array of legend entries in row-major order.\n\
8695 Otherwise, plot the legend entries in column-major order.\n\
8696\n\
8697 position (PLINT, input) : position contains bits which control the\n\
8698 overall position of the legend and the definition of the adopted\n\
8699 coordinates used for positions just like what is done for the\n\
8700 position argument for plcolorbar. However, note that the defaults\n\
8701 for the position bits (see below) are different than the\n\
8702 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8703 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8704 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8705 the 16 possible standard positions (the 4 corners and centers of\n\
8706 the 4 sides for both the inside and outside cases) of the legend\n\
8707 relative to the adopted coordinate system. The corner positions\n\
8708 are specified by the appropriate combination of two of the\n\
8709 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8710 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8711 value of one of those bits. The adopted coordinates are\n\
8712 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8713 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8714 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8715 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8716 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8717 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8718 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8719 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8720\n\
8721 x (PLFLT, input) : X offset of the legend position in adopted\n\
8722 coordinates from the specified standard position of the legend.\n\
8723 For positive x, the direction of motion away from the standard\n\
8724 position is inward/outward from the standard corner positions or\n\
8725 standard left or right positions if the\n\
8726 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8727 For the standard top or bottom positions, the direction of motion\n\
8728 is toward positive X.\n\
8729\n\
8730 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8731 coordinates from the specified standard position of the legend.\n\
8732 For positive y, the direction of motion away from the standard\n\
8733 position is inward/outward from the standard corner positions or\n\
8734 standard top or bottom positions if the\n\
8735 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8736 the standard left or right positions, the direction of motion is\n\
8737 toward positive Y.\n\
8738\n\
8739 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8740 of the plot area (where the colored boxes, lines, and/or lines of\n\
8741 symbols are drawn) of the legend.\n\
8742\n\
8743 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8744 legend (PL_LEGEND_BACKGROUND).\n\
8745\n\
8746 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8747 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8748\n\
8749 bb_style (PLINT, input) : The pllsty style number for the\n\
8750 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8751\n\
8752 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8753 render the\n\
8754 nlegend legend entries. For internal transformations of\n\
8755 nrow, see further remarks under\n\
8756 nlegend.\n\
8757\n\
8758 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8759 to render the\n\
8760 nlegend legend entries. For internal transformations of\n\
8761 ncolumn, see further remarks under\n\
8762 nlegend.\n\
8763\n\
8764 nlegend (PLINT, input) : Number of legend entries. The above\n\
8765 nrow and\n\
8766 ncolumn values are transformed internally to be consistent with\n\
8767 nlegend. If either\n\
8768 nrow or\n\
8769 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8770 of\n\
8771 nrow and\n\
8772 ncolumn is less than\n\
8773 nlegend, the smaller of the two (or\n\
8774 nrow, if\n\
8775 nrow ==\n\
8776 ncolumn) is increased so the product is >=\n\
8777 nlegend. Thus, for example, the common\n\
8778 nrow = 0,\n\
8779 ncolumn = 0 case is transformed internally to\n\
8780 nrow =\n\
8781 nlegend,\n\
8782 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8783 column.\n\
8784\n\
8785 opt_array (PLINT_VECTOR, input) : A vector of\n\
8786 nlegend values of options to control each individual plotted area\n\
8787 corresponding to a legend entry. If the\n\
8788 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8789 area. If the\n\
8790 PL_LEGEND_COLOR_BOX,\n\
8791 PL_LEGEND_LINE, and/or\n\
8792 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8793 entry is plotted with a colored box; a line; and/or a line of\n\
8794 symbols.\n\
8795\n\
8796 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8797 area in units of character width.\n\
8798\n\
8799 text_scale (PLFLT, input) : Character height scale for text\n\
8800 annotations.\n\
8801\n\
8802 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8803 character height from one legend entry to the next.\n\
8804\n\
8805 text_justification (PLFLT, input) : Justification parameter used\n\
8806 for text justification. The most common values of\n\
8807 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8808 is left justified, centred, or right justified within the text\n\
8809 area, but other values are allowed as well.\n\
8810\n\
8811 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8812 nlegend cmap0 text colors.\n\
8813\n\
8814 text (PLCHAR_MATRIX, input) : A vector of\n\
8815 nlegend UTF-8 character strings containing the legend annotations.\n\
8816\n\
8817 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8818 nlegend cmap0 colors for the discrete colored boxes (\n\
8819 PL_LEGEND_COLOR_BOX).\n\
8820\n\
8821 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8822 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8823 PL_LEGEND_COLOR_BOX).\n\
8824\n\
8825 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8826 nlegend scales (units of fraction of character height) for the height\n\
8827 of the discrete colored boxes (\n\
8828 PL_LEGEND_COLOR_BOX).\n\
8829\n\
8830 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8831 nlegend line widths for the patterns specified by box_patterns (\n\
8832 PL_LEGEND_COLOR_BOX).\n\
8833\n\
8834 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8835 nlegend cmap0 line colors (\n\
8836 PL_LEGEND_LINE).\n\
8837\n\
8838 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8839 nlegend line styles (plsty indices) (\n\
8840 PL_LEGEND_LINE).\n\
8841\n\
8842 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8843 nlegend line widths (\n\
8844 PL_LEGEND_LINE).\n\
8845\n\
8846 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8847 nlegend cmap0 symbol colors (\n\
8848 PL_LEGEND_SYMBOL).\n\
8849\n\
8850 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8851 nlegend scale values for the symbol height (\n\
8852 PL_LEGEND_SYMBOL).\n\
8853\n\
8854 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8855 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8856 area (\n\
8857 PL_LEGEND_SYMBOL).\n\
8858\n\
8859 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8860 nlegend UTF-8 character strings containing the legend symbols. (\n\
8861 PL_LEGEND_SYMBOL).\n\
8862";
8863static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8864Set the background color by 8-bit RGB value\n\
8865\n\
8866DESCRIPTION:\n\
8867\n\
8868 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8869 the PLplot documentation).\n\
8870\n\
8871 Redacted form: plscolbg(r, g, b)\n\
8872\n\
8873 This function is used in examples 15 and 31.\n\
8874\n\
8875\n\
8876\n\
8877SYNOPSIS:\n\
8878\n\
8879plscolbg(r, g, b)\n\
8880\n\
8881ARGUMENTS:\n\
8882\n\
8883 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8884 degree of red in the color.\n\
8885\n\
8886 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8887 degree of green in the color.\n\
8888\n\
8889 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8890 degree of blue in the color.\n\
8891";
8892static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8893Set parameters that define current device-space window\n\
8894\n\
8895DESCRIPTION:\n\
8896\n\
8897 Set relative margin width, aspect ratio, and relative justification\n\
8898 that define current device-space window. If you want to just use the\n\
8899 previous value for any of these, just pass in the magic value\n\
8900 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8901 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8902 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8903 to a device-specific value.\n\
8904\n\
8905 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8906\n\
8907 This function is used in example 31.\n\
8908\n\
8909\n\
8910\n\
8911SYNOPSIS:\n\
8912\n\
8913plsdidev(mar, aspect, jx, jy)\n\
8914\n\
8915ARGUMENTS:\n\
8916\n\
8917 mar (PLFLT, input) : Relative margin width.\n\
8918\n\
8919 aspect (PLFLT, input) : Aspect ratio.\n\
8920\n\
8921 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8922 the range -0.5 to 0.5.\n\
8923\n\
8924 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8925 the range -0.5 to 0.5.\n\
8926";
8927static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
8928Specify viewport using aspect ratio only\n\
8929\n\
8930DESCRIPTION:\n\
8931\n\
8932 Selects the largest viewport with the given aspect ratio within the\n\
8933 subpage that leaves a standard margin (left-hand margin of eight\n\
8934 character heights, and a margin around the other three sides of five\n\
8935 character heights).\n\
8936\n\
8937 Redacted form: plvasp(aspect)\n\
8938\n\
8939 This function is used in example 13.\n\
8940\n\
8941\n\
8942\n\
8943SYNOPSIS:\n\
8944\n\
8945plvasp(aspect)\n\
8946\n\
8947ARGUMENTS:\n\
8948\n\
8949 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8950 axis of resulting viewport.\n\
8951";
8952static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
8953Configure the transformations required for projecting a 3D surface on a 2D window\n\
8954\n\
8955DESCRIPTION:\n\
8956\n\
8957 Configure the transformations required for projecting a 3D surface on\n\
8958 an existing 2D window. Those transformations (see the PLplot\n\
8959 documentation) are done to a rectangular cuboid enclosing the 3D\n\
8960 surface which has its limits expressed in 3D world coordinates and\n\
8961 also normalized 3D coordinates (used for interpreting the altitude and\n\
8962 azimuth of the viewing angle). The transformations consist of the\n\
8963 linear transform from 3D world coordinates to normalized 3D\n\
8964 coordinates, and the 3D rotation of normalized coordinates required to\n\
8965 align the pole of the new 3D coordinate system with the viewing\n\
8966 direction specified by altitude and azimuth so that x and y of the\n\
8967 surface elements in that transformed coordinate system are the\n\
8968 projection of the 3D surface with given viewing direction on the 2D\n\
8969 window.\n\
8970\n\
8971 The enclosing rectangular cuboid for the surface plot is defined by\n\
8972 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
8973 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
8974 sizes of basex by basey by height so that xmin maps to -\n\
8975 basex/2, xmax maps to basex/2, ymin maps to -\n\
8976 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
8977 The resulting rectangular cuboid in normalized coordinates is then\n\
8978 viewed by an observer at altitude alt and azimuth az. This routine\n\
8979 must be called before plbox3 or any of the 3D surface plotting\n\
8980 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
8981 plsurf3dl or plfill3.\n\
8982\n\
8983 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
8984 zmin, zmax, alt, az)\n\
8985\n\
8986 This function is examples 8, 11, 18, and 21.\n\
8987\n\
8988\n\
8989\n\
8990SYNOPSIS:\n\
8991\n\
8992plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
8993\n\
8994ARGUMENTS:\n\
8995\n\
8996 basex (PLFLT, input) : The normalized x coordinate size of the\n\
8997 rectangular cuboid.\n\
8998\n\
8999 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9000 rectangular cuboid.\n\
9001\n\
9002 height (PLFLT, input) : The normalized z coordinate size of the\n\
9003 rectangular cuboid.\n\
9004\n\
9005 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9006 rectangular cuboid.\n\
9007\n\
9008 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9009 rectangular cuboid.\n\
9010\n\
9011 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9012 rectangular cuboid.\n\
9013\n\
9014 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9015 rectangular cuboid.\n\
9016\n\
9017 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9018 rectangular cuboid.\n\
9019\n\
9020 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9021 rectangular cuboid.\n\
9022\n\
9023 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9024 plane of the rectangular cuboid in normalized coordinates.\n\
9025\n\
9026 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9027 rectangular cuboid in normalized coordinates. When az=0, the\n\
9028 observer is looking face onto the zx plane of the rectangular\n\
9029 cuboid in normalized coordinates, and as az is increased, the\n\
9030 observer moves clockwise around that cuboid when viewed from above\n\
9031 the xy plane.\n\
9032";
9033static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9034Wait for graphics input event and translate to world coordinates.\n\
9035\n\
9036DESCRIPTION:\n\
9037\n\
9038 Wait for graphics input event and translate to world coordinates.\n\
9039 Returns 0 if no translation to world coordinates is possible.\n\
9040\n\
9041 This function returns 1 on success and 0 if no translation to world\n\
9042 coordinates is possible.\n\
9043\n\
9044 Redacted form: plGetCursor(gin)\n\
9045\n\
9046 This function is used in examples 1 and 20.\n\
9047\n\
9048\n\
9049\n\
9050SYNOPSIS:\n\
9051\n\
9052PLINT plGetCursor(gin)\n\
9053\n\
9054ARGUMENTS:\n\
9055\n\
9056 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9057 which will contain the output. The structure is not allocated by\n\
9058 the routine and must exist before the function is called.\n\
9059";
9060static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9061Set number of colors in cmap0\n\
9062\n\
9063DESCRIPTION:\n\
9064\n\
9065 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9066 (or reallocate) cmap0, and fill with default values for those colors\n\
9067 not previously allocated. The first 16 default colors are given in\n\
9068 the plcol0 documentation. For larger indices the default color is\n\
9069 red.\n\
9070\n\
9071 The drivers are not guaranteed to support more than 16 colors.\n\
9072\n\
9073 Redacted form: plscmap0n(ncol0)\n\
9074\n\
9075 This function is used in examples 15, 16, and 24.\n\
9076\n\
9077\n\
9078\n\
9079SYNOPSIS:\n\
9080\n\
9081plscmap0n(ncol0)\n\
9082\n\
9083ARGUMENTS:\n\
9084\n\
9085 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9086 the cmap0 palette. If this number is zero or less, then the value\n\
9087 from the previous call to plscmap0n is used and if there is no\n\
9088 previous call, then a default value is used.\n\
9089";
9090static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9091Set z axis parameters\n\
9092\n\
9093DESCRIPTION:\n\
9094\n\
9095 Identical to plsxax, except that arguments are flags for z axis. See\n\
9096 the description of plsxax for more detail.\n\
9097\n\
9098 Redacted form: plszax(digmax, digits)\n\
9099\n\
9100 This function is used in example 31.\n\
9101\n\
9102\n\
9103\n\
9104SYNOPSIS:\n\
9105\n\
9106plszax(digmax, digits)\n\
9107\n\
9108ARGUMENTS:\n\
9109\n\
9110 digmax (PLINT, input) : Variable to set the maximum number of\n\
9111 digits for the z axis. If nonzero, the printed label will be\n\
9112 switched to a floating-point representation when the number of\n\
9113 digits exceeds digmax.\n\
9114\n\
9115 digits (PLINT, input) : Field digits value. Currently, changing\n\
9116 its value here has no effect since it is set only by plbox or\n\
9117 plbox3. However, the user may obtain its value after a call to\n\
9118 either of these functions by calling plgzax.\n\
9119";
9120static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9121Get FCI (font characterization integer)\n\
9122\n\
9123DESCRIPTION:\n\
9124\n\
9125 Gets information about the current font using the FCI approach. See\n\
9126 the PLplot documentation for more information.\n\
9127\n\
9128 Redacted form: plgfci(p_fci)\n\
9129\n\
9130 This function is used in example 23.\n\
9131\n\
9132\n\
9133\n\
9134SYNOPSIS:\n\
9135\n\
9136plgfci(p_fci)\n\
9137\n\
9138ARGUMENTS:\n\
9139\n\
9140 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9141 FCI value.\n\
9142";
9143static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9144Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9145\n\
9146DESCRIPTION:\n\
9147\n\
9148 Sets up plotter environment for simple graphs by calling pladv and\n\
9149 setting up viewport and window to sensible default values. plenv0\n\
9150 leaves a standard margin (left-hand margin of eight character heights,\n\
9151 and a margin around the other three sides of five character heights)\n\
9152 around most graphs for axis labels and a title. When these defaults\n\
9153 are not suitable, use the individual routines plvpas, plvpor, or\n\
9154 plvasp for setting up the viewport, plwind for defining the window,\n\
9155 and plbox for drawing the box.\n\
9156\n\
9157 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9158\n\
9159 This function is used in example 21.\n\
9160\n\
9161\n\
9162\n\
9163SYNOPSIS:\n\
9164\n\
9165plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9166\n\
9167ARGUMENTS:\n\
9168\n\
9169 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9170 world coordinates).\n\
9171\n\
9172 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9173 world coordinates).\n\
9174\n\
9175 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9176 coordinates).\n\
9177\n\
9178 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9179 coordinates).\n\
9180\n\
9181 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9182 scales will not be set, the user must set up the scale before\n\
9183 calling plenv0 using plsvpa, plvasp or other.\n\
9184 0: the x and y axes are scaled independently to use as much of\n\
9185 the screen as possible.\n\
9186 1: the scales of the x and y axes are made equal.\n\
9187 2: the axis of the x and y axes are made equal, and the plot\n\
9188 box will be square.\n\
9189\n\
9190\n\
9191 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9192 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9193 -1: draw box only.\n\
9194 0: draw box, ticks, and numeric tick labels.\n\
9195 1: also draw coordinate axes at x=0 and y=0.\n\
9196 2: also draw a grid at major tick positions in both\n\
9197 coordinates.\n\
9198 3: also draw a grid at minor tick positions in both\n\
9199 coordinates.\n\
9200 10: same as 0 except logarithmic x tick marks. (The x data\n\
9201 have to be converted to logarithms separately.)\n\
9202 11: same as 1 except logarithmic x tick marks. (The x data\n\
9203 have to be converted to logarithms separately.)\n\
9204 12: same as 2 except logarithmic x tick marks. (The x data\n\
9205 have to be converted to logarithms separately.)\n\
9206 13: same as 3 except logarithmic x tick marks. (The x data\n\
9207 have to be converted to logarithms separately.)\n\
9208 20: same as 0 except logarithmic y tick marks. (The y data\n\
9209 have to be converted to logarithms separately.)\n\
9210 21: same as 1 except logarithmic y tick marks. (The y data\n\
9211 have to be converted to logarithms separately.)\n\
9212 22: same as 2 except logarithmic y tick marks. (The y data\n\
9213 have to be converted to logarithms separately.)\n\
9214 23: same as 3 except logarithmic y tick marks. (The y data\n\
9215 have to be converted to logarithms separately.)\n\
9216 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9217 and y data have to be converted to logarithms separately.)\n\
9218 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9219 and y data have to be converted to logarithms separately.)\n\
9220 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9221 and y data have to be converted to logarithms separately.)\n\
9222 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9223 and y data have to be converted to logarithms separately.)\n\
9224 40: same as 0 except date / time x labels.\n\
9225 41: same as 1 except date / time x labels.\n\
9226 42: same as 2 except date / time x labels.\n\
9227 43: same as 3 except date / time x labels.\n\
9228 50: same as 0 except date / time y labels.\n\
9229 51: same as 1 except date / time y labels.\n\
9230 52: same as 2 except date / time y labels.\n\
9231 53: same as 3 except date / time y labels.\n\
9232 60: same as 0 except date / time x and y labels.\n\
9233 61: same as 1 except date / time x and y labels.\n\
9234 62: same as 2 except date / time x and y labels.\n\
9235 63: same as 3 except date / time x and y labels.\n\
9236 70: same as 0 except custom x and y labels.\n\
9237 71: same as 1 except custom x and y labels.\n\
9238 72: same as 2 except custom x and y labels.\n\
9239 73: same as 3 except custom x and y labels.\n\
9240";
9241static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9242Set symbol size\n\
9243\n\
9244DESCRIPTION:\n\
9245\n\
9246 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9247 plsym. The actual height of a symbol is the product of the default\n\
9248 symbol size and a scaling factor as for the character height.\n\
9249\n\
9250 Redacted form: plssym(def, scale)\n\
9251\n\
9252 This function is used in example 29.\n\
9253\n\
9254\n\
9255\n\
9256SYNOPSIS:\n\
9257\n\
9258plssym(def, scale)\n\
9259\n\
9260ARGUMENTS:\n\
9261\n\
9262 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9263 should be set to zero if the default height is to remain\n\
9264 unchanged.\n\
9265\n\
9266 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9267 actual symbol height.\n\
9268";
9269static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9270Set plot orientation\n\
9271\n\
9272DESCRIPTION:\n\
9273\n\
9274 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9275 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9276 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9277 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9278 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9279 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9280 not called the default value of rot is 0.\n\
9281\n\
9282 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9283 probably want to change the aspect ratio to a value suitable for the\n\
9284 plot orientation using a call to plsdidev or the command-line options\n\
9285 -a or -freeaspect. For more documentation of those options see the\n\
9286 PLplot documentation. Such command-line options can be set internally\n\
9287 using plsetopt or set directly using the command line and parsed using\n\
9288 a call to plparseopts.\n\
9289\n\
9290 Redacted form: plsdiori(rot)\n\
9291\n\
9292 This function is not used in any examples.\n\
9293\n\
9294\n\
9295\n\
9296SYNOPSIS:\n\
9297\n\
9298plsdiori(rot)\n\
9299\n\
9300ARGUMENTS:\n\
9301\n\
9302 rot (PLFLT, input) : Plot orientation parameter.\n\
9303";
9304static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9305Advance the (sub-)page\n\
9306\n\
9307DESCRIPTION:\n\
9308\n\
9309 Advances to the next subpage if sub=0, performing a page advance if\n\
9310 there are no remaining subpages on the current page. If subpages\n\
9311 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9312 PLplot switches to the specified subpage. Note that this allows you\n\
9313 to overwrite a plot on the specified subpage; if this is not what you\n\
9314 intended, use pleop followed by plbop to first advance the page. This\n\
9315 routine is called automatically (with page=0) by plenv, but if plenv\n\
9316 is not used, pladv must be called after initializing PLplot but before\n\
9317 defining the viewport.\n\
9318\n\
9319 Redacted form: pladv(page)\n\
9320\n\
9321 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9322 29, and 31.\n\
9323\n\
9324\n\
9325\n\
9326SYNOPSIS:\n\
9327\n\
9328pladv(page)\n\
9329\n\
9330ARGUMENTS:\n\
9331\n\
9332 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9333 in the top left corner and increasing along the rows) to which to\n\
9334 advance. Set to zero to advance to the next subpage (or to the\n\
9335 next page if subpages are not being used).\n\
9336";
9337static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9338Set cmap0 colors by 8-bit RGB values\n\
9339\n\
9340DESCRIPTION:\n\
9341\n\
9342 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9343 documentation). This sets the entire color map -- only as many colors\n\
9344 as specified will be allocated.\n\
9345\n\
9346 Redacted form: plscmap0(r, g, b)\n\
9347\n\
9348 This function is used in examples 2 and 24.\n\
9349\n\
9350\n\
9351\n\
9352SYNOPSIS:\n\
9353\n\
9354plscmap0(r, g, b, ncol0)\n\
9355\n\
9356ARGUMENTS:\n\
9357\n\
9358 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9359 integers (0-255) representing the degree of red in the color.\n\
9360\n\
9361 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9362 integers (0-255) representing the degree of green in the color.\n\
9363\n\
9364 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9365 integers (0-255) representing the degree of blue in the color.\n\
9366\n\
9367 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9368";
9369static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9370Get character default height and current (scaled) height\n\
9371\n\
9372DESCRIPTION:\n\
9373\n\
9374 Get character default height and current (scaled) height.\n\
9375\n\
9376 Redacted form: plgchr(p_def, p_ht)\n\
9377\n\
9378 This function is used in example 23.\n\
9379\n\
9380\n\
9381\n\
9382SYNOPSIS:\n\
9383\n\
9384plgchr(p_def, p_ht)\n\
9385\n\
9386ARGUMENTS:\n\
9387\n\
9388 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9389 character height (mm).\n\
9390\n\
9391 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9392 character height (mm).\n\
9393";
9394static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9395Set opaque RGB cmap1 colors values\n\
9396\n\
9397DESCRIPTION:\n\
9398\n\
9399 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9400 vector values. This function also sets the number of cmap1 colors.\n\
9401 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9402 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9403 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9404 to\n\
9405 ncol1-1. So in order for this continuous color model to work\n\
9406 properly, it is the responsibility of the user of plscmap1 to insure\n\
9407 that these RGB vectors are continuous functions of their integer\n\
9408 indices.\n\
9409\n\
9410 Redacted form: plscmap1(r, g, b)\n\
9411\n\
9412 This function is used in example 31.\n\
9413\n\
9414\n\
9415\n\
9416SYNOPSIS:\n\
9417\n\
9418plscmap1(r, g, b, ncol1)\n\
9419\n\
9420ARGUMENTS:\n\
9421\n\
9422 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9423 8-bit integers in the range from 0-255) the degree of red in the\n\
9424 color as a continuous function of the integer index of the vector.\n\
9425\n\
9426 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9427 8-bit integers in the range from 0-255) the degree of green in the\n\
9428 color as a continuous function of the integer index of the vector.\n\
9429\n\
9430 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9431 8-bit integers in the range from 0-255) the degree of blue in the\n\
9432 color as a continuous function of the integer index of the vector.\n\
9433\n\
9434 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9435";
9436static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9437Set any command-line option\n\
9438\n\
9439DESCRIPTION:\n\
9440\n\
9441 Set any command-line option internally from a program before it\n\
9442 invokes plinit. opt is the name of the command-line option and optarg\n\
9443 is the corresponding command-line option argument.\n\
9444\n\
9445 This function returns 0 on success.\n\
9446\n\
9447 Redacted form: plsetopt(opt, optarg)\n\
9448\n\
9449 This function is used in example 14.\n\
9450\n\
9451\n\
9452\n\
9453SYNOPSIS:\n\
9454\n\
9455PLINT plsetopt(opt, optarg)\n\
9456\n\
9457ARGUMENTS:\n\
9458\n\
9459 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9460 the command-line option.\n\
9461\n\
9462 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9463 containing the argument of the command-line option.\n\
9464";
9465static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9466Draw linear gradient inside polygon\n\
9467\n\
9468DESCRIPTION:\n\
9469\n\
9470 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9471 points (\n\
9472 x[i],\n\
9473 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9474 polygon coordinates and the gradient angle are all expressed in world\n\
9475 coordinates. The angle from the x axis for both the rotated\n\
9476 coordinate system and the gradient vector is specified by angle. The\n\
9477 magnitude of the gradient vector is the difference between the maximum\n\
9478 and minimum values of x for the vertices in the rotated coordinate\n\
9479 system. The origin of the gradient vector can be interpreted as being\n\
9480 anywhere on the line corresponding to the minimum x value for the\n\
9481 vertices in the rotated coordinate system. The distance along the\n\
9482 gradient vector is linearly transformed to the independent variable of\n\
9483 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9484 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9485 color corresponding to the independent variable of cmap1. For more\n\
9486 information about cmap1 (see the PLplot documentation).\n\
9487\n\
9488 Redacted form: plgradient(x,y,angle)\n\
9489\n\
9490 This function is used in examples 25 and 30.\n\
9491\n\
9492\n\
9493\n\
9494SYNOPSIS:\n\
9495\n\
9496plgradient(n, x, y, angle)\n\
9497\n\
9498ARGUMENTS:\n\
9499\n\
9500 n (PLINT, input) : Number of vertices in polygon.\n\
9501\n\
9502 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9503 vertices.\n\
9504\n\
9505 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9506 vertices.\n\
9507\n\
9508 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9509 axis.\n\
9510";
9511static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9512Set length of major ticks\n\
9513\n\
9514DESCRIPTION:\n\
9515\n\
9516 This sets up the length of the major ticks. The actual length is the\n\
9517 product of the default length and a scaling factor as for character\n\
9518 height.\n\
9519\n\
9520 Redacted form: plsmaj(def, scale)\n\
9521\n\
9522 This function is used in example 29.\n\
9523\n\
9524\n\
9525\n\
9526SYNOPSIS:\n\
9527\n\
9528plsmaj(def, scale)\n\
9529\n\
9530ARGUMENTS:\n\
9531\n\
9532 def (PLFLT, input) : The default length of a major tick in\n\
9533 millimeters, should be set to zero if the default length is to\n\
9534 remain unchanged.\n\
9535\n\
9536 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9537 actual tick length.\n\
9538";
9539static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9540Set a global coordinate transform function\n\
9541\n\
9542DESCRIPTION:\n\
9543\n\
9544 This function can be used to define a coordinate transformation which\n\
9545 affects all elements drawn within the current plot window. The\n\
9546 coordinate_transform callback function is similar to that provided for\n\
9547 the plmap and plmeridians functions. The coordinate_transform_data\n\
9548 parameter may be used to pass extra data to coordinate_transform.\n\
9549\n\
9550 Redacted form: General: plstransform(coordinate_transform,\n\
9551 coordinate_transform_data)\n\
9552\n\
9553\n\
9554 This function is used in examples 19 and 22.\n\
9555\n\
9556\n\
9557\n\
9558SYNOPSIS:\n\
9559\n\
9560plstransform(coordinate_transform, coordinate_transform_data)\n\
9561\n\
9562ARGUMENTS:\n\
9563\n\
9564 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9565 function that defines the transformation from the input (x, y)\n\
9566 world coordinates to new PLplot world coordinates. If\n\
9567 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9568 case), then no transform is applied.\n\
9569\n\
9570 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9571 for\n\
9572 coordinate_transform.\n\
9573";
9574static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9575Configure the transformation between continuous and broken-down time for the current stream\n\
9576\n\
9577DESCRIPTION:\n\
9578\n\
9579 Configure the transformation between continuous and broken-down time\n\
9580 for the current stream. This transformation is used by both plbtime\n\
9581 and plctime.\n\
9582\n\
9583 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9584 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9585\n\
9586\n\
9587 This function is used in example 29.\n\
9588\n\
9589\n\
9590\n\
9591SYNOPSIS:\n\
9592\n\
9593plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9594\n\
9595ARGUMENTS:\n\
9596\n\
9597 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9598 As a special case, if\n\
9599 scale is 0., then all other arguments are ignored, and the result (the\n\
9600 default used by PLplot) is the equivalent of a call to\n\
9601 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9602 That is, for this special case broken-down time is calculated with\n\
9603 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9604 and the continuous time is defined as the number of seconds since\n\
9605 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9606\n\
9607 offset1 (PLFLT, input) : If\n\
9608 ifbtime_offset is true, the parameters\n\
9609 offset1 and\n\
9610 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9611 (with units in days) specify the epoch of the continuous time\n\
9612 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9613 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9614 are used to specify the origin to allow users (by specifying\n\
9615 offset1 as an integer that can be exactly represented by a\n\
9616 floating-point variable and specifying\n\
9617 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9618 the numerical errors of the continuous time representation.\n\
9619\n\
9620 offset2 (PLFLT, input) : See documentation of\n\
9621 offset1.\n\
9622\n\
9623 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9624 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9625 calendar is used for broken-down time rather than the proleptic\n\
9626 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9627 have been historically used to define UTC are inserted into the\n\
9628 broken-down time. Other possibilities for additional control bits\n\
9629 for ccontrol exist such as making the historical time corrections\n\
9630 in the broken-down time corresponding to ET (ephemeris time) or\n\
9631 making the (slightly non-constant) corrections from international\n\
9632 atomic time (TAI) to what astronomers define as terrestrial time\n\
9633 (TT). But those additional possibilities have not been\n\
9634 implemented yet in the qsastime library (one of the PLplot utility\n\
9635 libraries).\n\
9636\n\
9637 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9638 epoch of the continuous time scale is specified by the user. If\n\
9639 ifbtime_offset is false, then\n\
9640 offset1 and\n\
9641 offset2 are used to specify the epoch, and the following broken-down\n\
9642 time parameters are completely ignored. If\n\
9643 ifbtime_offset is true, then\n\
9644 offset1 and\n\
9645 offset2 are completely ignored, and the following broken-down time\n\
9646 parameters are used to specify the epoch.\n\
9647\n\
9648 year (PLINT, input) : Year of epoch.\n\
9649\n\
9650 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9651 11 (December).\n\
9652\n\
9653 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9654\n\
9655 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9656\n\
9657 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9658\n\
9659 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9660";
9661static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9662Flushes the output stream\n\
9663\n\
9664DESCRIPTION:\n\
9665\n\
9666 Flushes the output stream. Use sparingly, if at all.\n\
9667\n\
9668 Redacted form: plflush()\n\
9669\n\
9670 This function is used in examples 1 and 14.\n\
9671\n\
9672\n\
9673\n\
9674SYNOPSIS:\n\
9675\n\
9676plflush()\n\
9677";
9678static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9679Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9680\n\
9681DESCRIPTION:\n\
9682\n\
9683 This variant of plsurf3d (see that function\'s documentation for more\n\
9684 details) should be suitable for the case where the area of the x, y\n\
9685 coordinate grid where z is defined can be non-rectangular. The limits\n\
9686 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9687 indexymin, and indexymax.\n\
9688\n\
9689 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9690 indexymax)\n\
9691\n\
9692 This function is used in example 8.\n\
9693\n\
9694\n\
9695\n\
9696SYNOPSIS:\n\
9697\n\
9698plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9699\n\
9700ARGUMENTS:\n\
9701\n\
9702 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9703 which the function is evaluated.\n\
9704\n\
9705 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9706 which the function is evaluated.\n\
9707\n\
9708 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9709 plot. Should have dimensions of\n\
9710 nx by\n\
9711 ny.\n\
9712\n\
9713 nx (PLINT, input) : Number of x values at which function is\n\
9714 evaluated.\n\
9715\n\
9716 ny (PLINT, input) : Number of y values at which function is\n\
9717 evaluated.\n\
9718\n\
9719 opt (PLINT, input) : Determines the way in which the surface is\n\
9720 represented. To specify more than one option just add the options,\n\
9721 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9722 connecting points at which function is defined.\n\
9723 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9724 using parameters\n\
9725 nlevel and\n\
9726 clevel.\n\
9727 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9728 using parameters\n\
9729 nlevel and\n\
9730 clevel.\n\
9731 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9732 the borders of the plotted function.\n\
9733 opt=MAG_COLOR : the surface is colored according to the value\n\
9734 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9735 according to the intensity of the reflected light in the\n\
9736 surface from a light source whose position is set using\n\
9737 pllightsource.\n\
9738\n\
9739\n\
9740 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9741 levels.\n\
9742\n\
9743 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9744\n\
9745 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9746 corresponds to the first x index where z is defined.\n\
9747\n\
9748 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9749 which corresponds (by convention) to one more than the last x\n\
9750 index value where z is defined.\n\
9751\n\
9752 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9753 values which all must be ≥ 0. These values are the first y index\n\
9754 where z is defined for a particular x index in the range from\n\
9755 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9756 indexxmax.\n\
9757\n\
9758 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9759 values which all must be ≤ ny. These values correspond (by\n\
9760 convention) to one more than the last y index where z is defined\n\
9761 for a particular x index in the range from indexxmin to indexxmax\n\
9762 - 1. The dimension of indexymax is indexxmax.\n\
9763";
9764static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9765Set semitransparent cmap1 RGBA colors.\n\
9766\n\
9767DESCRIPTION:\n\
9768\n\
9769 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9770 RGBA vector values. This function also sets the number of cmap1\n\
9771 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9772 floating-point index in the range from 0.0-1.0 which is linearly\n\
9773 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9774 vectors in the range from 0 to\n\
9775 ncol1-1. So in order for this continuous color model to work\n\
9776 properly, it is the responsibility of the user of plscmap1 to insure\n\
9777 that these RGBA vectors are continuous functions of their integer\n\
9778 indices.\n\
9779\n\
9780 Redacted form: plscmap1a(r, g, b, alpha)\n\
9781\n\
9782 This function is used in example 31.\n\
9783\n\
9784\n\
9785\n\
9786SYNOPSIS:\n\
9787\n\
9788plscmap1a(r, g, b, alpha, ncol1)\n\
9789\n\
9790ARGUMENTS:\n\
9791\n\
9792 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9793 8-bit integers in the range from 0-255) the degree of red in the\n\
9794 color as a continuous function of the integer index of the vector.\n\
9795\n\
9796 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9797 8-bit integers in the range from 0-255) the degree of green in the\n\
9798 color as a continuous function of the integer index of the vector.\n\
9799\n\
9800 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9801 8-bit integers in the range from 0-255) the degree of blue in the\n\
9802 color as a continuous function of the integer index of the vector.\n\
9803\n\
9804 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9805 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9806 completely transparent and 1.0 corresponds to completely opaque)\n\
9807 the alpha transparency of the color as a continuous function of\n\
9808 the integer index of the vector.\n\
9809\n\
9810 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9811 vectors.\n\
9812";
9813static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9814Calculate broken-down time from continuous time for the current stream\n\
9815\n\
9816DESCRIPTION:\n\
9817\n\
9818 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9819 continuous time, ctime for the current stream. This function is the\n\
9820 inverse of plctime.\n\
9821\n\
9822 The PLplot definition of broken-down time is a calendar time that\n\
9823 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9824 responsibility to apply those offsets (if so desired) before using the\n\
9825 PLplot time API. By default broken-down time is defined using the\n\
9826 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9827 continuous time is defined as the number of seconds since the Unix\n\
9828 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9829 broken-down and continuous time are possible, see plconfigtime.\n\
9830\n\
9831 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9832 ctime)\n\
9833\n\
9834\n\
9835 This function is used in example 29.\n\
9836\n\
9837\n\
9838\n\
9839SYNOPSIS:\n\
9840\n\
9841plbtime(year, month, day, hour, min, sec, ctime)\n\
9842\n\
9843ARGUMENTS:\n\
9844\n\
9845 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9846 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9847 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9848 BCE, etc.)\n\
9849\n\
9850 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9851 the year in the range from 0 (January) to 11 (December).\n\
9852\n\
9853 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9854 month in the range from 1 to 31.\n\
9855\n\
9856 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9857 day in the range from 0 to 23.\n\
9858\n\
9859 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9860 hour in the range from 0 to 59\n\
9861\n\
9862 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9863 minute in range from 0. to 60.\n\
9864\n\
9865 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9866 time is calculated.\n\
9867";
9868static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9869Convert RGB color to HLS\n\
9870\n\
9871DESCRIPTION:\n\
9872\n\
9873 Convert RGB color coordinates to HLS\n\
9874\n\
9875 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9876\n\
9877\n\
9878 This function is used in example 2.\n\
9879\n\
9880\n\
9881\n\
9882SYNOPSIS:\n\
9883\n\
9884plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9885\n\
9886ARGUMENTS:\n\
9887\n\
9888 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9889\n\
9890 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9891\n\
9892 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9893\n\
9894 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9895 degrees (0.0-360.0) on the color cylinder.\n\
9896\n\
9897 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9898 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9899 cylinder.\n\
9900\n\
9901 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9902 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9903 cylinder.\n\
9904";
9905static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9906Get the current device (keyword) name\n\
9907\n\
9908DESCRIPTION:\n\
9909\n\
9910 Get the current device (keyword) name. Note: you must have allocated\n\
9911 space for this (80 characters is safe).\n\
9912\n\
9913 Redacted form: plgdev(p_dev)\n\
9914\n\
9915 This function is used in example 14.\n\
9916\n\
9917\n\
9918\n\
9919SYNOPSIS:\n\
9920\n\
9921plgdev(p_dev)\n\
9922\n\
9923ARGUMENTS:\n\
9924\n\
9925 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9926 (with preallocated length of 80 characters or more) containing the\n\
9927 device (keyword) name.\n\
9928";
9929static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
9930Set the number of subpages in x and y\n\
9931\n\
9932DESCRIPTION:\n\
9933\n\
9934 Set the number of subpages in x and y.\n\
9935\n\
9936 Redacted form: plssub(nx, ny)\n\
9937\n\
9938 This function is examples 1,2,14,21,25,27.\n\
9939\n\
9940\n\
9941\n\
9942SYNOPSIS:\n\
9943\n\
9944plssub(nx, ny)\n\
9945\n\
9946ARGUMENTS:\n\
9947\n\
9948 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
9949 of window columns).\n\
9950\n\
9951 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
9952 of window rows).\n\
9953";
9954static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
9955Get current stream number\n\
9956\n\
9957DESCRIPTION:\n\
9958\n\
9959 Gets the number of the current output stream. See also plsstrm.\n\
9960\n\
9961 Redacted form: plgstrm(p_strm)\n\
9962\n\
9963 This function is used in example 1,20.\n\
9964\n\
9965\n\
9966\n\
9967SYNOPSIS:\n\
9968\n\
9969plgstrm(p_strm)\n\
9970\n\
9971ARGUMENTS:\n\
9972\n\
9973 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9974 stream value.\n\
9975";
9976static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
9977Random number generator returning a real random number in the range [0,1]\n\
9978\n\
9979DESCRIPTION:\n\
9980\n\
9981 Random number generator returning a real random number in the range\n\
9982 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
9983 / compilers provide their own random number generator, and so this is\n\
9984 provided purely for convenience and to give a consistent random number\n\
9985 generator across all languages supported by PLplot. This is\n\
9986 particularly useful for comparing results from the test suite of\n\
9987 examples.\n\
9988\n\
9989 Redacted form: plrandd()\n\
9990\n\
9991 This function is used in examples 17 and 21.\n\
9992\n\
9993\n\
9994\n\
9995SYNOPSIS:\n\
9996\n\
9997plrandd()\n\
9998";
9999static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10000Add a point to a strip chart\n\
10001\n\
10002DESCRIPTION:\n\
10003\n\
10004 Add a point to a given pen of a given strip chart. There is no need\n\
10005 for all pens to have the same number of points or to be equally\n\
10006 sampled in the x coordinate. Allocates memory and rescales as\n\
10007 necessary.\n\
10008\n\
10009 Redacted form: plstripa(id, pen, x, y)\n\
10010\n\
10011 This function is used in example 17.\n\
10012\n\
10013\n\
10014\n\
10015SYNOPSIS:\n\
10016\n\
10017plstripa(id, pen, x, y)\n\
10018\n\
10019ARGUMENTS:\n\
10020\n\
10021 id (PLINT, input) : Identification number of the strip chart (set\n\
10022 up in plstripc).\n\
10023\n\
10024 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10025\n\
10026 x (PLFLT, input) : X coordinate of point to plot.\n\
10027\n\
10028 y (PLFLT, input) : Y coordinate of point to plot.\n\
10029";
10030static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10031Set device-compression level\n\
10032\n\
10033DESCRIPTION:\n\
10034\n\
10035 Set device-compression level. Only used for drivers that provide\n\
10036 compression. This function, if used, should be invoked before a call\n\
10037 to plinit.\n\
10038\n\
10039 Redacted form: plscompression(compression)\n\
10040\n\
10041 This function is used in example 31.\n\
10042\n\
10043\n\
10044\n\
10045SYNOPSIS:\n\
10046\n\
10047plscompression(compression)\n\
10048\n\
10049ARGUMENTS:\n\
10050\n\
10051 compression (PLINT, input) : The desired compression level. This is\n\
10052 a device-dependent value. Currently only the jpeg and png devices\n\
10053 use these values. For jpeg value is the jpeg quality which should\n\
10054 normally be in the range 0-95. Higher values denote higher quality\n\
10055 and hence larger image sizes. For png values are in the range -1\n\
10056 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10057 A value of -1 denotes the default zlib compression level. Values\n\
10058 in the range 10-99 are divided by 10 and then used as the zlib\n\
10059 compression level. Higher compression levels correspond to greater\n\
10060 compression and small file sizes at the expense of more\n\
10061 computation.\n\
10062";
10063static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10064Specify viewport in absolute coordinates\n\
10065\n\
10066DESCRIPTION:\n\
10067\n\
10068 Alternate routine to plvpor for setting up the viewport. This routine\n\
10069 should be used only if the viewport is required to have a definite\n\
10070 size in millimeters. The routine plgspa is useful for finding out the\n\
10071 size of the current subpage.\n\
10072\n\
10073 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10074\n\
10075 This function is used in example 10.\n\
10076\n\
10077\n\
10078\n\
10079SYNOPSIS:\n\
10080\n\
10081plsvpa(xmin, xmax, ymin, ymax)\n\
10082\n\
10083ARGUMENTS:\n\
10084\n\
10085 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10086 viewport from the left-hand edge of the subpage in millimeters.\n\
10087\n\
10088 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10089 viewport from the left-hand edge of the subpage in millimeters.\n\
10090\n\
10091 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10092 viewport from the bottom edge of the subpage in millimeters.\n\
10093\n\
10094 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10095 from the bottom edge of the subpage in millimeters.\n\
10096";
10097static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10098Draw a polygon in 3 space\n\
10099\n\
10100DESCRIPTION:\n\
10101\n\
10102 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10103 like plline3, but differs from that function in that plpoly3 attempts\n\
10104 to determine if the polygon is viewable depending on the order of the\n\
10105 points within the vector and the value of ifcc. If the back of\n\
10106 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10107 you want, then use plline3 instead.\n\
10108\n\
10109 The points are assumed to be in a plane, and the directionality of the\n\
10110 plane is determined from the first three points. Additional points do\n\
10111 not have to lie on the plane defined by the first three, but if they\n\
10112 do not, then the determination of visibility obviously can\'t be 100%\n\
10113 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10114 consider breaking them into smaller polygons. 3 points define a plane\n\
10115 :-).\n\
10116\n\
10117 Bugs: If one of the first two segments is of zero length, or if they\n\
10118 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10119 being correct. Avoid such situations :-). See x18c.c for an example\n\
10120 of this problem. (Search for 20.1).\n\
10121\n\
10122 Redacted form: plpoly3(x, y, z, code)\n\
10123\n\
10124 This function is used in example 18.\n\
10125\n\
10126\n\
10127\n\
10128SYNOPSIS:\n\
10129\n\
10130plpoly3(n, x, y, z, draw, ifcc)\n\
10131\n\
10132ARGUMENTS:\n\
10133\n\
10134 n (PLINT, input) : Number of points defining line.\n\
10135\n\
10136 x (PLFLT_VECTOR, input) : A vector containing\n\
10137 n x coordinates of points.\n\
10138\n\
10139 y (PLFLT_VECTOR, input) : A vector containing\n\
10140 n y coordinates of points.\n\
10141\n\
10142 z (PLFLT_VECTOR, input) : A vector containing\n\
10143 n z coordinates of points.\n\
10144\n\
10145 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10146 n-1 Boolean values which control drawing the segments of the polygon.\n\
10147 If draw[i] is true, then the polygon segment from index [i] to\n\
10148 [i+1] is drawn, otherwise, not.\n\
10149\n\
10150 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10151 polygon is determined by assuming the points are laid out in a\n\
10152 counter-clockwise order. Otherwise, the directionality of the\n\
10153 polygon is determined by assuming the points are laid out in a\n\
10154 clockwise order.\n\
10155";
10156static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10157Magnitude colored plot surface with contour\n\
10158\n\
10159DESCRIPTION:\n\
10160\n\
10161 Aside from dropping the\n\
10162 side functionality this is a more powerful form of plot3d: the surface\n\
10163 mesh can be colored accordingly to the current z value being plotted,\n\
10164 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10165 drawn between the plotted function border and the base XY plane. The\n\
10166 arguments are identical to those of plmeshc. The only difference\n\
10167 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10168 the surface, while plot3dc only draws the surface as viewed from the\n\
10169 top.\n\
10170\n\
10171 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10172\n\
10173\n\
10174 This function is used in example 21.\n\
10175\n\
10176\n\
10177\n\
10178SYNOPSIS:\n\
10179\n\
10180plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10181\n\
10182ARGUMENTS:\n\
10183\n\
10184 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10185 which the function is evaluated.\n\
10186\n\
10187 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10188 which the function is evaluated.\n\
10189\n\
10190 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10191 plot. Should have dimensions of\n\
10192 nx by\n\
10193 ny.\n\
10194\n\
10195 nx (PLINT, input) : Number of x values at which function is\n\
10196 evaluated.\n\
10197\n\
10198 ny (PLINT, input) : Number of y values at which function is\n\
10199 evaluated.\n\
10200\n\
10201 opt (PLINT, input) : Determines the way in which the surface is\n\
10202 represented. To specify more than one option just add the options,\n\
10203 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10204 showing z as a function of x for each value of y[j] .\n\
10205 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10206 for each value of x[i] .\n\
10207 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10208 at which function is defined.\n\
10209 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10210 the z value being plotted. The color is used from the current\n\
10211 cmap1.\n\
10212 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10213 using parameters\n\
10214 nlevel and\n\
10215 clevel.\n\
10216 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10217 the borders of the plotted function.\n\
10218\n\
10219\n\
10220 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10221 levels.\n\
10222\n\
10223 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10224";
10225static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10226Create a 4-pen strip chart\n\
10227\n\
10228DESCRIPTION:\n\
10229\n\
10230 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10231\n\
10232 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10233 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10234 styline, legline, labx, laby, labz)\n\
10235\n\
10236\n\
10237 This function is used in example 17.\n\
10238\n\
10239\n\
10240\n\
10241SYNOPSIS:\n\
10242\n\
10243plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10244\n\
10245ARGUMENTS:\n\
10246\n\
10247 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10248 number of the strip chart to use on plstripa and plstripd.\n\
10249\n\
10250 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10251 the x-axis specification as in plbox.\n\
10252\n\
10253 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10254 the y-axis specification as in plbox.\n\
10255\n\
10256 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10257 change as data are added.\n\
10258\n\
10259 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10260 change as data are added.\n\
10261\n\
10262 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10263 is multiplied by the factor (1 +\n\
10264 xjump) .\n\
10265\n\
10266 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10267 change as data are added.\n\
10268\n\
10269 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10270 change as data are added.\n\
10271\n\
10272 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10273\n\
10274 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10275\n\
10276 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10277 true, otherwise not.\n\
10278\n\
10279 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10280 otherwise slide display.\n\
10281\n\
10282 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10283\n\
10284 collab (PLINT, input) : Legend color index (cmap0).\n\
10285\n\
10286 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10287 indices for the 4 pens.\n\
10288\n\
10289 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10290 indices for the 4 pens.\n\
10291\n\
10292 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10293 strings containing legends for the 4 pens.\n\
10294\n\
10295 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10296 the label for the x axis.\n\
10297\n\
10298 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10299 the label for the y axis.\n\
10300\n\
10301 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10302 the plot title.\n\
10303";
10304static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10305Deletes and releases memory used by a strip chart\n\
10306\n\
10307DESCRIPTION:\n\
10308\n\
10309 Deletes and releases memory used by a strip chart.\n\
10310\n\
10311 Redacted form: plstripd(id)\n\
10312\n\
10313 This function is used in example 17.\n\
10314\n\
10315\n\
10316\n\
10317SYNOPSIS:\n\
10318\n\
10319plstripd(id)\n\
10320\n\
10321ARGUMENTS:\n\
10322\n\
10323 id (PLINT, input) : Identification number of strip chart to delete.\n\
10324";
10325static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10326Set cmap1 colors using a piece-wise linear relationship\n\
10327\n\
10328DESCRIPTION:\n\
10329\n\
10330 Set cmap1 colors using a piece-wise linear relationship between the\n\
10331 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10332 (see the PLplot documentation). May be called at any time.\n\
10333\n\
10334 The idea here is to specify a number of control points that define the\n\
10335 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10336 these points, linear interpolation is used which gives a smooth\n\
10337 variation of color with intensity index. Any number of control points\n\
10338 may be specified, located at arbitrary positions, although typically 2\n\
10339 - 4 are enough. Another way of stating this is that we are traversing\n\
10340 a given number of lines through HLS or RGB space as we move through\n\
10341 cmap1 intensity indices. The control points at the minimum and\n\
10342 maximum position (0 and 1) must always be specified. By adding more\n\
10343 control points you can get more variation. One good technique for\n\
10344 plotting functions that vary about some expected average is to use an\n\
10345 additional 2 control points in the center (position ~= 0.5) that are\n\
10346 the same lightness as the background (typically white for paper\n\
10347 output, black for crt), and same hue as the boundary control points.\n\
10348 This allows the highs and lows to be very easily distinguished.\n\
10349\n\
10350 Each control point must specify the cmap1 intensity index and the\n\
10351 associated three coordinates in HLS or RGB space. The first point\n\
10352 must correspond to position = 0, and the last to position = 1.\n\
10353\n\
10354 If RGB colors are provided then the interpolation takes place in RGB\n\
10355 space and is trivial. However if HLS colors are provided then, because\n\
10356 of the circular nature of the color wheel for the hue coordinate, the\n\
10357 interpolation could be performed in either direction around the color\n\
10358 wheel. The default behaviour is for the hue to be linearly\n\
10359 interpolated ignoring this circular property of hue. So for example,\n\
10360 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10361 green and cyan. If instead you wish to interpolate the other way\n\
10362 around the color wheel you have two options. You may provide hues\n\
10363 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10364 for red the interpolation will proceed via magenta. Alternatively you\n\
10365 can utilise the alt_hue_path variable to reverse the direction of\n\
10366 interpolation if you need to provide hues within the [0-360) range.\n\
10367\n\
10368 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10369 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10370 -120]falsegreen-yellow-red-magenta-blue[240\n\
10371 480]falseblue-magenta-red-yellow-green[120\n\
10372 240]truegreen-yellow-red-magenta-blue[240\n\
10373 120]trueblue-magenta-red-yellow-green\n\
10374\n\
10375 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10376 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10377 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10378\n\
10379 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10380 alt_hue_path)\n\
10381\n\
10382 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10383\n\
10384\n\
10385\n\
10386SYNOPSIS:\n\
10387\n\
10388plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10389\n\
10390ARGUMENTS:\n\
10391\n\
10392 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10393\n\
10394 npts (PLINT, input) : number of control points\n\
10395\n\
10396 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10397 intensity index (0.0-1.0) in ascending order for each control\n\
10398 point.\n\
10399\n\
10400 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10401 coordinate (H or R) for each control point.\n\
10402\n\
10403 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10404 coordinate (L or G) for each control point.\n\
10405\n\
10406 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10407 coordinate (S or B) for each control point.\n\
10408\n\
10409 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10410 npts - 1 elements), each containing either true to use the reversed\n\
10411 HLS interpolation or false to use the regular HLS interpolation.\n\
10412 (alt_hue_path[i] refers to the interpolation interval between the\n\
10413 i and i + 1 control points). This parameter is not used for RGB\n\
10414 colors (\n\
10415 itype = true).\n\
10416";
10417static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10418Shade individual region on the basis of value\n\
10419\n\
10420DESCRIPTION:\n\
10421\n\
10422 Shade individual region on the basis of value. Use plshades if you\n\
10423 want to shade a number of contiguous regions using continuous colors.\n\
10424 In particular the edge contours are treated properly in plshades. If\n\
10425 you attempt to do contiguous regions with plshade the contours at the\n\
10426 edge of the shade are partially obliterated by subsequent plots of\n\
10427 contiguous shaded regions.\n\
10428\n\
10429 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10430 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10431 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10432\n\
10433\n\
10434 This function is used in example 15.\n\
10435\n\
10436\n\
10437\n\
10438SYNOPSIS:\n\
10439\n\
10440plshade(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\
10441\n\
10442ARGUMENTS:\n\
10443\n\
10444 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10445 plot. Should have dimensions of\n\
10446 nx by\n\
10447 ny.\n\
10448\n\
10449 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10450\n\
10451 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10452\n\
10453 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10454 the region that should be plotted in the shade plot. This\n\
10455 function accepts x and y coordinates as input arguments and must\n\
10456 return 1 if the point is to be included in the shade plot and 0\n\
10457 otherwise. If you want to plot the entire shade plot (the usual\n\
10458 case), this argument should be set to NULL.\n\
10459\n\
10460 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10461 pltr below for how these arguments are used (only for the special case\n\
10462 when the callback function\n\
10463 pltr is not supplied).\n\
10464\n\
10465 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10466 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10467\n\
10468 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10469 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10470\n\
10471 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10472 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10473 then sh_color is interpreted as a cmap1 argument in the range\n\
10474 (0.0-1.0).\n\
10475\n\
10476 sh_color (PLFLT, input) : Defines color map index with integer\n\
10477 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10478\n\
10479 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10480\n\
10481 min_color (PLINT, input) : Defines pen color, width used by the\n\
10482 boundary of shaded region. The min values are used for the\n\
10483 shade_min boundary, and the max values are used on the shade_max\n\
10484 boundary. Set color and width to zero for no plotted boundaries.\n\
10485\n\
10486 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10487 boundary of shaded region. The min values are used for the\n\
10488 shade_min boundary, and the max values are used on the shade_max\n\
10489 boundary. Set color and width to zero for no plotted boundaries.\n\
10490\n\
10491 max_color (PLINT, input) : Defines pen color, width used by the\n\
10492 boundary of shaded region. The min values are used for the\n\
10493 shade_min boundary, and the max values are used on the shade_max\n\
10494 boundary. Set color and width to zero for no plotted boundaries.\n\
10495\n\
10496 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10497 boundary of shaded region. The min values are used for the\n\
10498 shade_min boundary, and the max values are used on the shade_max\n\
10499 boundary. Set color and width to zero for no plotted boundaries.\n\
10500\n\
10501 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10502 Use plfill. Future version of PLplot may have other fill\n\
10503 routines.\n\
10504\n\
10505 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10506 map to rectangles after coordinate transformation with pltrl.\n\
10507 Otherwise, set rectangular to false. If rectangular is set to\n\
10508 true, plshade tries to save time by filling large rectangles.\n\
10509 This optimization fails if the coordinate transformation distorts\n\
10510 the shape of rectangles. For example a plot in polar coordinates\n\
10511 has to have rectangular set to false.\n\
10512\n\
10513 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10514 defines the transformation between the zero-based indices of the\n\
10515 matrix a and world coordinates. If\n\
10516 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10517 indices of a are mapped to the range\n\
10518 xmin through\n\
10519 xmax and the y indices of a are mapped to the range\n\
10520 ymin through\n\
10521 ymax.For the C case, transformation functions are provided in the\n\
10522 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10523 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10524 matrices. In addition, C callback routines for the transformation\n\
10525 can be supplied by the user such as the mypltr function in\n\
10526 examples/c/x09c.c which provides a general linear transformation\n\
10527 between index coordinates and world coordinates.For languages\n\
10528 other than C you should consult the PLplot documentation for the\n\
10529 details concerning how PLTRANSFORM_callback arguments are\n\
10530 interfaced. However, in general, a particular pattern of\n\
10531 callback-associated arguments such as a tr vector with 6 elements;\n\
10532 xg and yg vectors; or xg and yg matrices are respectively\n\
10533 interfaced to a linear-transformation routine similar to the above\n\
10534 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10535 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10536 support native language callbacks for handling index to\n\
10537 world-coordinate transformations. Examples of these various\n\
10538 approaches are given in examples/<language>x09*,\n\
10539 examples/<language>x16*, examples/<language>x20*,\n\
10540 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10541 supported languages.\n\
10542\n\
10543 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10544 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10545 externally supplied.\n\
10546";
10547static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10548Set number of colors in cmap1\n\
10549\n\
10550DESCRIPTION:\n\
10551\n\
10552 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10553 values if this is the first allocation (see the PLplot documentation).\n\
10554\n\
10555 Redacted form: plscmap1n(ncol1)\n\
10556\n\
10557 This function is used in examples 8, 11, 20, and 21.\n\
10558\n\
10559\n\
10560\n\
10561SYNOPSIS:\n\
10562\n\
10563plscmap1n(ncol1)\n\
10564\n\
10565ARGUMENTS:\n\
10566\n\
10567 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10568 the cmap1 palette. If this number is zero or less, then the value\n\
10569 from the previous call to plscmap1n is used and if there is no\n\
10570 previous call, then a default value is used.\n\
10571";
10572static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10573Advance to the next family file on the next new page\n\
10574\n\
10575DESCRIPTION:\n\
10576\n\
10577 Advance to the next family file on the next new page.\n\
10578\n\
10579 Redacted form: plfamadv()\n\
10580\n\
10581 This function is not used in any examples.\n\
10582\n\
10583\n\
10584\n\
10585SYNOPSIS:\n\
10586\n\
10587plfamadv()\n\
10588";
10589static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10590Set the escape character for text strings\n\
10591\n\
10592DESCRIPTION:\n\
10593\n\
10594 Set the escape character for text strings. From C (in contrast to\n\
10595 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10596 characters are allowed to prevent the user from shooting himself in\n\
10597 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10598 use of backslash as a character escape). Here are the allowed escape\n\
10599 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10600 #, ASCII 35\n\
10601 $, ASCII 36\n\
10602 %, ASCII 37\n\
10603 &, ASCII 38\n\
10604 *, ASCII 42\n\
10605 @, ASCII 64\n\
10606 ^, ASCII 94\n\
10607 ~, ASCII 126\n\
10608\n\
10609\n\
10610 Redacted form: General: plsesc(esc)\n\
10611\n\
10612\n\
10613 This function is used in example 29.\n\
10614\n\
10615\n\
10616\n\
10617SYNOPSIS:\n\
10618\n\
10619plsesc(esc)\n\
10620\n\
10621ARGUMENTS:\n\
10622\n\
10623 esc (char, input) : Escape character.\n\
10624";
10625static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10626Plot color bar for image, shade or gradient plots\n\
10627\n\
10628DESCRIPTION:\n\
10629\n\
10630 Routine for creating a continuous color bar for image, shade, or\n\
10631 gradient plots. (See pllegend for similar functionality for creating\n\
10632 legends with discrete elements). The arguments of plcolorbar provide\n\
10633 control over the location and size of the color bar as well as the\n\
10634 location and characteristics of the elements (most of which are\n\
10635 optional) within that color bar. The resulting color bar is clipped\n\
10636 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10637 system used for some of the parameters is defined in the documentation\n\
10638 of the position parameter.)\n\
10639\n\
10640 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10641 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10642 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10643 labels, axis_opts, ticks, sub_ticks, values)\n\
10644\n\
10645 This function is used in examples 16 and 33.\n\
10646\n\
10647\n\
10648\n\
10649SYNOPSIS:\n\
10650\n\
10651plcolorbar(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\
10652\n\
10653ARGUMENTS:\n\
10654\n\
10655 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10656 labelled and decorated color bar width in adopted coordinates.\n\
10657\n\
10658 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10659 labelled and decorated color bar height in adopted coordinates.\n\
10660\n\
10661 opt (PLINT, input) : opt contains bits controlling the overall\n\
10662 color bar. The orientation (direction of the maximum value) of\n\
10663 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10664 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10665 specified, the default orientation is toward the top if the\n\
10666 colorbar is placed on the left or right of the viewport or toward\n\
10667 the right if the colorbar is placed on the top or bottom of the\n\
10668 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10669 (semitransparent) background for the color bar. If the\n\
10670 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10671 color bar. The type of color bar must be specified with one of\n\
10672 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10673 more than one of those bits is set only the first one in the above\n\
10674 list is honored. The position of the (optional) label/title can be\n\
10675 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10676 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10677 will be drawn. If more than one of this list of bits is specified,\n\
10678 only the first one on the list is honored. End-caps for the color\n\
10679 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10680 If a particular color bar cap option is not specified then no cap\n\
10681 will be drawn for that end. As a special case for\n\
10682 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10683 specified. If this option is provided then any tick marks and tick\n\
10684 labels will be placed at the breaks between shaded segments. TODO:\n\
10685 This should be expanded to support custom placement of tick marks\n\
10686 and tick labels at custom value locations for any color bar type.\n\
10687\n\
10688 position (PLINT, input) : position contains bits which control the\n\
10689 overall position of the color bar and the definition of the\n\
10690 adopted coordinates used for positions just like what is done for\n\
10691 the position argument for pllegend. However, note that the\n\
10692 defaults for the position bits (see below) are different than the\n\
10693 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10694 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10695 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10696 the 16 possible standard positions (the 4 corners and centers of\n\
10697 the 4 sides for both the inside and outside cases) of the color\n\
10698 bar relative to the adopted coordinate system. The corner\n\
10699 positions are specified by the appropriate combination of two of\n\
10700 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10701 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10702 value of one of those bits. The adopted coordinates are\n\
10703 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10704 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10705 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10706 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10707 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10708 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10709 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10710 PL_POSITION_VIEWPORT.\n\
10711\n\
10712 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10713 coordinates from the specified standard position of the color bar.\n\
10714 For positive x, the direction of motion away from the standard\n\
10715 position is inward/outward from the standard corner positions or\n\
10716 standard left or right positions if the\n\
10717 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10718 For the standard top or bottom positions, the direction of motion\n\
10719 is toward positive X.\n\
10720\n\
10721 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10722 coordinates from the specified standard position of the color bar.\n\
10723 For positive y, the direction of motion away from the standard\n\
10724 position is inward/outward from the standard corner positions or\n\
10725 standard top or bottom positions if the\n\
10726 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10727 For the standard left or right positions, the direction of motion\n\
10728 is toward positive Y.\n\
10729\n\
10730 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10731 the X direction in adopted coordinates.\n\
10732\n\
10733 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10734 the Y direction in adopted coordinates.\n\
10735\n\
10736 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10737 color bar (PL_COLORBAR_BACKGROUND).\n\
10738\n\
10739 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10740 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10741\n\
10742 bb_style (PLINT, input) : The pllsty style number for the\n\
10743 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10744\n\
10745 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10746 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10747\n\
10748 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10749 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10750\n\
10751 cont_color (PLINT, input) : The cmap0 contour color for\n\
10752 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10753 it will be interpreted according to the design of plshades.\n\
10754\n\
10755 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10756 plots. This is passed directly to plshades, so it will be\n\
10757 interpreted according to the design of plshades.\n\
10758\n\
10759 n_labels (PLINT, input) : Number of labels to place around the\n\
10760 color bar.\n\
10761\n\
10762 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10763 n_labels labels.\n\
10764\n\
10765 labels (PLCHAR_MATRIX, input) : A vector of\n\
10766 n_labels UTF-8 character strings containing the labels for the color\n\
10767 bar. Ignored if no label position is specified with one of the\n\
10768 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10769 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10770 corresponding label_opts field.\n\
10771\n\
10772 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10773 value must be greater than 0. It is typically 1 (numerical axis\n\
10774 labels are provided for one of the long edges of the color bar),\n\
10775 but it can be larger if multiple numerical axis labels for the\n\
10776 long edges of the color bar are desired.\n\
10777\n\
10778 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10779 n_axes ascii character strings containing options (interpreted as for\n\
10780 plbox) for the color bar\'s axis definitions.\n\
10781\n\
10782 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10783 spacing of the major tick marks (interpreted as for plbox) for the\n\
10784 color bar\'s axis definitions.\n\
10785\n\
10786 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10787 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10788 axis definitions.\n\
10789\n\
10790 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10791 elements in each of the n_axes rows of the values matrix.\n\
10792\n\
10793 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10794 values for the data range represented by the color bar. For a row\n\
10795 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10796 elements in the row is specified by n_values[i_axis]. For\n\
10797 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10798 is 2, and the corresponding row elements of the values matrix are\n\
10799 the minimum and maximum value represented by the colorbar. For\n\
10800 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10801 of the values matrix is interpreted the same as the nlevel and\n\
10802 clevel arguments of plshades.\n\
10803";
10804static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10805Set current output stream\n\
10806\n\
10807DESCRIPTION:\n\
10808\n\
10809 Sets the number of the current output stream. The stream number\n\
10810 defaults to 0 unless changed by this routine. The first use of this\n\
10811 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10812\n\
10813 Redacted form: plsstrm(strm)\n\
10814\n\
10815 This function is examples 1,14,20.\n\
10816\n\
10817\n\
10818\n\
10819SYNOPSIS:\n\
10820\n\
10821plsstrm(strm)\n\
10822\n\
10823ARGUMENTS:\n\
10824\n\
10825 strm (PLINT, input) : The current stream number.\n\
10826";
10827static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10828Get the current device-compression setting\n\
10829\n\
10830DESCRIPTION:\n\
10831\n\
10832 Get the current device-compression setting. This parameter is only\n\
10833 used for drivers that provide compression.\n\
10834\n\
10835 Redacted form: plgcompression(compression)\n\
10836\n\
10837 This function is used in example 31.\n\
10838\n\
10839\n\
10840\n\
10841SYNOPSIS:\n\
10842\n\
10843plgcompression(compression)\n\
10844\n\
10845ARGUMENTS:\n\
10846\n\
10847 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10848 compression setting for the current device.\n\
10849";
10850static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10851Grid data from irregularly sampled data\n\
10852\n\
10853DESCRIPTION:\n\
10854\n\
10855 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10856 require data organized as a grid, i.e., with x sample point values\n\
10857 independent of y coordinate and vice versa. This function takes\n\
10858 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10859 vectors; reads the desired grid location from the input vectors\n\
10860 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10861 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10862 interpolate the data to the grid is specified with the argument type\n\
10863 which can have one parameter specified in argument data.\n\
10864\n\
10865 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10866 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10867\n\
10868\n\
10869 This function is used in example 21.\n\
10870\n\
10871\n\
10872\n\
10873SYNOPSIS:\n\
10874\n\
10875plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10876\n\
10877ARGUMENTS:\n\
10878\n\
10879 x (PLFLT_VECTOR, input) : The input x vector.\n\
10880\n\
10881 y (PLFLT_VECTOR, input) : The input y vector.\n\
10882\n\
10883 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10884 y[i], z[i] represents one data sample coordinate.\n\
10885\n\
10886 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10887 vectors.\n\
10888\n\
10889 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10890 in the x direction. Usually xg has nptsx equally spaced values\n\
10891 from the minimum to the maximum values of the x input vector.\n\
10892\n\
10893 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10894\n\
10895 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10896 in the y direction. Similar to the xg parameter.\n\
10897\n\
10898 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10899\n\
10900 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10901 where data lies in the grid specified by xg and yg. Therefore the\n\
10902 zg matrix must be dimensioned\n\
10903 nptsx by\n\
10904 nptsy.\n\
10905\n\
10906 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10907 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10908 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10909 GRID_NNI: Natural Neighbors Interpolation\n\
10910 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10911 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10912 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10913 Weighted\n\
10914 For details of the algorithms read the source file plgridd.c.\n\
10915\n\
10916 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10917 which can be specified through this argument. Currently, for\n\
10918 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10919 use, the lower the value, the noisier (more local) the\n\
10920 approximation is.\n\
10921 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10922 range [1. .. 2.]. High values enable the usage of very thin\n\
10923 triangles for interpolation, possibly resulting in error in\n\
10924 the approximation.\n\
10925 GRID_NNI, only weights greater than data will be accepted. If\n\
10926 0, all weights will be accepted.\n\
10927";
10928
10929SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10930 PLINT arg1 ;
10931 PLINT *arg2 = (PLINT *) 0 ;
10932 char **arg3 = (char **) 0 ;
10933 Matrix temp1 ;
10934 octave_value_list _out;
10935 octave_value_list *_outp=&_out;
10936 octave_value _outv;
10937
10938 try {
10939 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10940 SWIG_fail;
10941 }
10942 {
10943 if ( _n_dims( args(0) ) > 1 )
10944 {
10945 error( "argument must be a scalar or vector" ); SWIG_fail;
10946 }
10947 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10948 arg2 = new PLINT[Alen];
10949 temp1 = args(0).matrix_value();
10950 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10951 }
10952 {
10953 charMatrix temp_matrix;
10954 Cell temp_cell;
10955 char *tmp_cstring;
10956 std::string str;
10957 size_t max_length = 0, non_blank_length;
10958 int i, ifcell;
10959 if ( _n_dims( args(1) ) > 2 )
10960 {
10961 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10962 }
10963#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10964 if ( !args(1).isempty() )
10965#else
10966 if ( !args(1).is_empty() )
10967#endif
10968 {
10969 if ( _dim( args(1), 0 ) != Alen )
10970 {
10971 error( "first dimension must be same length as previous vector" ); SWIG_fail;
10972 }
10973 arg3 = new char*[Alen];
10974#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10975 ifcell = args(1).iscell();
10976#else
10977 ifcell = args(1).is_cell();
10978#endif
10979 if ( ifcell )
10980 {
10981 temp_cell = args(1).cell_value();
10982 }
10983 else
10984 {
10985 temp_matrix = args(1).char_matrix_value();
10986 // Allow one extra space for null termination.
10987 max_length = _dim( args(1), 1 ) + 1;
10988 }
10989
10990 for ( i = 0; i < Alen; i++ )
10991 {
10992 // Must copy string to "permanent" location because the string
10993 // location corresponding to tmp_cstring gets
10994 // overwritten for each iteration of loop.
10995 if ( ifcell )
10996 {
10997 if ( temp_cell.elem( i ).is_string() )
10998 {
10999 str = temp_cell.elem( i ).string_value();
11000 // leave room for null termination.
11001 max_length = str.size() + 1;
11002 tmp_cstring = (char *) str.c_str();
11003 }
11004 else
11005 {
11006 // Use null string if user attempts to pass a cell array
11007 // with a non-string element (likely an empty element
11008 // since that should be allowed by the PLplot interface
11009 // if that element is going to be unused).
11010 // leave room for null termination.
11011 max_length = 1;
11012 tmp_cstring = (char *) "";
11013 }
11014 }
11015 else
11016 {
11017 str = temp_matrix.row_as_string( i );
11018 tmp_cstring = (char *) str.c_str();
11019 }
11020 arg3[i] = new char[max_length];
11021 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11022 arg3[i][max_length - 1] = '\0';
11023 // All the trailing blank crapola should not be needed for
11024 // string cell arrays.
11025 if ( !ifcell )
11026 {
11027 // remove trailing-blank padding that is used by the
11028 // charMatrix class to insure all strings in a given
11029 // charMatrix instance have the same length.
11030 // This transformation also removes legitimate trailing
11031 // blanks but there is nothing we can do about that
11032 // for the charMatrix class.
11033
11034 // Look for trailing nulls first (just in case, although that
11035 // shouldn't happen if charMatrix implemented as documented)
11036 // before looking for trailing blanks.
11037 non_blank_length = max_length - 2;
11038 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11039 {
11040 non_blank_length--;
11041 }
11042 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11043 {
11044 non_blank_length--;
11045 }
11046 arg3[i][non_blank_length + 1] = '\0';
11047 }
11048 }
11049 }
11050 else
11051 {
11052 arg3 = NULL;
11053 }
11054 }
11055 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11056 _outv = octave_value();
11057 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11058 {
11059 delete [] arg2;
11060 }
11061 {
11062 int i;
11063 if ( arg3 != NULL )
11064 {
11065 for ( i = 0; i < Alen; i++ )
11066 {
11067 delete[] arg3[i];
11068 }
11069 delete[] arg3;
11070 }
11071 }
11072 return _out;
11073 fail:
11074 {
11075 delete [] arg2;
11076 }
11077 {
11078 int i;
11079 if ( arg3 != NULL )
11080 {
11081 for ( i = 0; i < Alen; i++ )
11082 {
11083 delete[] arg3[i];
11084 }
11085 delete[] arg3;
11086 }
11087 }
11088 return octave_value_list();
11089 }
11090 catch(...) {
11091 {
11092 delete [] arg2;
11093 }
11094 {
11095 int i;
11096 if ( arg3 != NULL )
11097 {
11098 for ( i = 0; i < Alen; i++ )
11099 {
11100 delete[] arg3[i];
11101 }
11102 delete[] arg3;
11103 }
11104 }
11105 throw;
11106 }
11107}
11108
11109
11111 int *arg1 = (int *) 0 ;
11112 int *arg2 = (int *) 0 ;
11113 int *arg3 = (int *) 0 ;
11114 char *arg4 = (char *) 0 ;
11115 int *arg5 = (int *) 0 ;
11116 int *arg6 = (int *) 0 ;
11117 PLFLT *arg7 = (PLFLT *) 0 ;
11118 PLFLT *arg8 = (PLFLT *) 0 ;
11119 PLFLT *arg9 = (PLFLT *) 0 ;
11120 PLFLT *arg10 = (PLFLT *) 0 ;
11121 int *arg11 = (int *) 0 ;
11122 int temp1 ;
11123 int res1 = SWIG_TMPOBJ ;
11124 int temp2 ;
11125 int res2 = SWIG_TMPOBJ ;
11126 int temp3 ;
11127 int res3 = SWIG_TMPOBJ ;
11128 char local_string4[80] ;
11129 int temp5 ;
11130 int res5 = SWIG_TMPOBJ ;
11131 int temp6 ;
11132 int res6 = SWIG_TMPOBJ ;
11133 PLFLT temp7 ;
11134 int res7 = SWIG_TMPOBJ ;
11135 PLFLT temp8 ;
11136 int res8 = SWIG_TMPOBJ ;
11137 PLFLT temp9 ;
11138 int res9 = SWIG_TMPOBJ ;
11139 PLFLT temp10 ;
11140 int res10 = SWIG_TMPOBJ ;
11141 int temp11 ;
11142 int res11 = SWIG_TMPOBJ ;
11143 size_t local_string_length4 ;
11144 charMatrix local_charMatrix4 ;
11145 octave_value_list retval4 ;
11146 octave_value_list _out;
11147 octave_value_list *_outp=&_out;
11148 octave_value _outv;
11149 int result;
11150
11151 try {
11152 arg1 = &temp1;
11153 arg2 = &temp2;
11154 arg3 = &temp3;
11155 {
11156 arg4 = local_string4;
11157 }
11158 arg5 = &temp5;
11159 arg6 = &temp6;
11160 arg7 = &temp7;
11161 arg8 = &temp8;
11162 arg9 = &temp9;
11163 arg10 = &temp10;
11164 arg11 = &temp11;
11165 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11166 SWIG_fail;
11167 }
11168 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11169 _outv = SWIG_From_int(static_cast< int >(result));
11170 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11171 if (SWIG_IsTmpObj(res1)) {
11172 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11173 } else {
11174 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11175 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11176 }
11177 if (SWIG_IsTmpObj(res2)) {
11178 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11179 } else {
11180 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11181 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11182 }
11183 if (SWIG_IsTmpObj(res3)) {
11184 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11185 } else {
11186 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11187 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11188 }
11189 {
11190 local_string_length4 = strlen( local_string4 );
11191 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11192 local_charMatrix4.insert( local_string4, 0, 0 );
11193 retval4( 0 ) = octave_value( local_charMatrix4 );
11194 _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11195 }
11196 if (SWIG_IsTmpObj(res5)) {
11197 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11198 } else {
11199 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11200 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11201 }
11202 if (SWIG_IsTmpObj(res6)) {
11203 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11204 } else {
11205 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11206 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11207 }
11208 if (SWIG_IsTmpObj(res7)) {
11209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11210 } else {
11211 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11213 }
11214 if (SWIG_IsTmpObj(res8)) {
11215 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11216 } else {
11217 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11218 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11219 }
11220 if (SWIG_IsTmpObj(res9)) {
11221 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11222 } else {
11223 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11224 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11225 }
11226 if (SWIG_IsTmpObj(res10)) {
11227 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11228 } else {
11229 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11230 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11231 }
11232 if (SWIG_IsTmpObj(res11)) {
11233 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11234 } else {
11235 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11236 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11237 }
11238 return _out;
11239 fail:
11240 return octave_value_list();
11241 }
11242 catch(...) {
11243 throw;
11244 }
11245}
11246
11247
11248SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11249 PLFLT *arg1 = (PLFLT *) 0 ;
11250 PLFLT *arg2 = (PLFLT *) 0 ;
11251 PLFLT arg3 ;
11252 PLFLT arg4 ;
11253 PLFLT temp1 ;
11254 int res1 = SWIG_TMPOBJ ;
11255 PLFLT temp2 ;
11256 int res2 = SWIG_TMPOBJ ;
11257 double val3 ;
11258 int ecode3 = 0 ;
11259 double val4 ;
11260 int ecode4 = 0 ;
11261 octave_value_list _out;
11262 octave_value_list *_outp=&_out;
11263 octave_value _outv;
11264 int result;
11265
11266 try {
11267 arg1 = &temp1;
11268 arg2 = &temp2;
11269 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11270 SWIG_fail;
11271 }
11272 ecode3 = SWIG_AsVal_double(args(0), &val3);
11273 if (!SWIG_IsOK(ecode3)) {
11274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11275 }
11276 arg3 = static_cast< PLFLT >(val3);
11277 ecode4 = SWIG_AsVal_double(args(1), &val4);
11278 if (!SWIG_IsOK(ecode4)) {
11279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11280 }
11281 arg4 = static_cast< PLFLT >(val4);
11282 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11283 _outv = SWIG_From_int(static_cast< int >(result));
11284 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11285 if (SWIG_IsTmpObj(res1)) {
11286 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11287 } else {
11288 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11289 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11290 }
11291 if (SWIG_IsTmpObj(res2)) {
11292 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11293 } else {
11294 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11295 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11296 }
11297 return _out;
11298 fail:
11299 return octave_value_list();
11300 }
11301 catch(...) {
11302 throw;
11303 }
11304}
11305
11306
11308 PLINT *arg1 = (PLINT *) 0 ;
11309 char *arg2 = (char *) 0 ;
11310 char *arg3 = (char *) 0 ;
11311 PLFLT arg4 ;
11312 PLFLT arg5 ;
11313 PLFLT arg6 ;
11314 PLFLT arg7 ;
11315 PLFLT arg8 ;
11316 PLFLT arg9 ;
11317 PLFLT arg10 ;
11318 PLBOOL arg11 ;
11319 PLBOOL arg12 ;
11320 PLINT arg13 ;
11321 PLINT arg14 ;
11322 PLINT *arg15 = (PLINT *) 0 ;
11323 PLINT *arg16 = (PLINT *) 0 ;
11324 char *arg17 = (char *) 0 ;
11325 char *arg18 = (char *) 0 ;
11326 char *arg19 = (char *) 0 ;
11327 char *arg20 = (char *) 0 ;
11328 char *arg21 = (char *) 0 ;
11329 char *arg22 = (char *) 0 ;
11330 char *arg23 = (char *) 0 ;
11331 PLINT temp1 ;
11332 int res1 = SWIG_TMPOBJ ;
11333 int res2 ;
11334 char *buf2 = 0 ;
11335 int alloc2 = 0 ;
11336 int res3 ;
11337 char *buf3 = 0 ;
11338 int alloc3 = 0 ;
11339 double val4 ;
11340 int ecode4 = 0 ;
11341 double val5 ;
11342 int ecode5 = 0 ;
11343 double val6 ;
11344 int ecode6 = 0 ;
11345 double val7 ;
11346 int ecode7 = 0 ;
11347 double val8 ;
11348 int ecode8 = 0 ;
11349 double val9 ;
11350 int ecode9 = 0 ;
11351 double val10 ;
11352 int ecode10 = 0 ;
11353 int val11 ;
11354 int ecode11 = 0 ;
11355 int val12 ;
11356 int ecode12 = 0 ;
11357 int val13 ;
11358 int ecode13 = 0 ;
11359 int val14 ;
11360 int ecode14 = 0 ;
11361 Matrix temp15 ;
11362 Matrix temp16 ;
11363 int res17 ;
11364 char *buf17 = 0 ;
11365 int alloc17 = 0 ;
11366 int res18 ;
11367 char *buf18 = 0 ;
11368 int alloc18 = 0 ;
11369 int res19 ;
11370 char *buf19 = 0 ;
11371 int alloc19 = 0 ;
11372 int res20 ;
11373 char *buf20 = 0 ;
11374 int alloc20 = 0 ;
11375 int res21 ;
11376 char *buf21 = 0 ;
11377 int alloc21 = 0 ;
11378 int res22 ;
11379 char *buf22 = 0 ;
11380 int alloc22 = 0 ;
11381 int res23 ;
11382 char *buf23 = 0 ;
11383 int alloc23 = 0 ;
11384 octave_value_list _out;
11385 octave_value_list *_outp=&_out;
11386 octave_value _outv;
11387
11388 try {
11389 arg1 = &temp1;
11390 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11391 SWIG_fail;
11392 }
11393 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11394 if (!SWIG_IsOK(res2)) {
11395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11396 }
11397 arg2 = reinterpret_cast< char * >(buf2);
11398 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11399 if (!SWIG_IsOK(res3)) {
11400 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11401 }
11402 arg3 = reinterpret_cast< char * >(buf3);
11403 ecode4 = SWIG_AsVal_double(args(2), &val4);
11404 if (!SWIG_IsOK(ecode4)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11406 }
11407 arg4 = static_cast< PLFLT >(val4);
11408 ecode5 = SWIG_AsVal_double(args(3), &val5);
11409 if (!SWIG_IsOK(ecode5)) {
11410 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11411 }
11412 arg5 = static_cast< PLFLT >(val5);
11413 ecode6 = SWIG_AsVal_double(args(4), &val6);
11414 if (!SWIG_IsOK(ecode6)) {
11415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11416 }
11417 arg6 = static_cast< PLFLT >(val6);
11418 ecode7 = SWIG_AsVal_double(args(5), &val7);
11419 if (!SWIG_IsOK(ecode7)) {
11420 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11421 }
11422 arg7 = static_cast< PLFLT >(val7);
11423 ecode8 = SWIG_AsVal_double(args(6), &val8);
11424 if (!SWIG_IsOK(ecode8)) {
11425 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11426 }
11427 arg8 = static_cast< PLFLT >(val8);
11428 ecode9 = SWIG_AsVal_double(args(7), &val9);
11429 if (!SWIG_IsOK(ecode9)) {
11430 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11431 }
11432 arg9 = static_cast< PLFLT >(val9);
11433 ecode10 = SWIG_AsVal_double(args(8), &val10);
11434 if (!SWIG_IsOK(ecode10)) {
11435 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11436 }
11437 arg10 = static_cast< PLFLT >(val10);
11438 ecode11 = SWIG_AsVal_int(args(9), &val11);
11439 if (!SWIG_IsOK(ecode11)) {
11440 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11441 }
11442 arg11 = static_cast< PLBOOL >(val11);
11443 ecode12 = SWIG_AsVal_int(args(10), &val12);
11444 if (!SWIG_IsOK(ecode12)) {
11445 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11446 }
11447 arg12 = static_cast< PLBOOL >(val12);
11448 ecode13 = SWIG_AsVal_int(args(11), &val13);
11449 if (!SWIG_IsOK(ecode13)) {
11450 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11451 }
11452 arg13 = static_cast< PLINT >(val13);
11453 ecode14 = SWIG_AsVal_int(args(12), &val14);
11454 if (!SWIG_IsOK(ecode14)) {
11455 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11456 }
11457 arg14 = static_cast< PLINT >(val14);
11458 {
11459 if ( _n_dims( args(13) ) > 1 )
11460 {
11461 error( "argument must be a scalar or vector" ); SWIG_fail;
11462 }
11463 Alen = (PLINT) ( _dim( args(13), 0 ) );
11464 temp15 = args(13).matrix_value();
11465 arg15 = new PLINT[Alen];
11466 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11467 }
11468 {
11469 if ( _n_dims( args(14) ) > 1 )
11470 {
11471 error( "argument must be a scalar or vector" ); SWIG_fail;
11472 }
11473 if ( _dim( args(14), 0 ) != Alen )
11474 {
11475 error( "argument vectors must be same length" ); SWIG_fail;
11476 }
11477 temp16 = args(14).matrix_value();
11478 arg16 = new PLINT[Alen];
11479 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11480 }
11481 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11482 if (!SWIG_IsOK(res17)) {
11483 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11484 }
11485 arg17 = reinterpret_cast< char * >(buf17);
11486 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11487 if (!SWIG_IsOK(res18)) {
11488 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11489 }
11490 arg18 = reinterpret_cast< char * >(buf18);
11491 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11492 if (!SWIG_IsOK(res19)) {
11493 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11494 }
11495 arg19 = reinterpret_cast< char * >(buf19);
11496 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11497 if (!SWIG_IsOK(res20)) {
11498 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11499 }
11500 arg20 = reinterpret_cast< char * >(buf20);
11501 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11502 if (!SWIG_IsOK(res21)) {
11503 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11504 }
11505 arg21 = reinterpret_cast< char * >(buf21);
11506 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11507 if (!SWIG_IsOK(res22)) {
11508 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11509 }
11510 arg22 = reinterpret_cast< char * >(buf22);
11511 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11512 if (!SWIG_IsOK(res23)) {
11513 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11514 }
11515 arg23 = reinterpret_cast< char * >(buf23);
11516 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);
11517 _outv = octave_value();
11518 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11519 if (SWIG_IsTmpObj(res1)) {
11520 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11521 } else {
11522 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11523 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11524 }
11525 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11526 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11527 {
11528 delete [] arg15;
11529 }
11530 {
11531 delete [] arg16;
11532 }
11533 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11534 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11535 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11536 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11537 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11538 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11539 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11540 return _out;
11541 fail:
11542 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11543 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11544 {
11545 delete [] arg15;
11546 }
11547 {
11548 delete [] arg16;
11549 }
11550 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11551 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11552 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11553 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11554 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11555 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11556 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11557 return octave_value_list();
11558 }
11559 catch(...) {
11560 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11561 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11562 {
11563 delete [] arg15;
11564 }
11565 {
11566 delete [] arg16;
11567 }
11568 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11569 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11570 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11571 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11572 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11573 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11574 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11575 throw;
11576 }
11577}
11578
11579
11581 PLFLT *arg1 = (PLFLT *) 0 ;
11582 PLINT arg2 ;
11583 PLINT arg3 ;
11584 PLINT arg4 ;
11585 PLINT arg5 ;
11586 PLINT arg6 ;
11587 PLINT arg7 ;
11588 PLFLT *arg8 = (PLFLT *) 0 ;
11589 PLINT arg9 ;
11590 PLFLT *arg10 = (PLFLT *) 0 ;
11591 Matrix temp1 ;
11592 int val4 ;
11593 int ecode4 = 0 ;
11594 int val5 ;
11595 int ecode5 = 0 ;
11596 int val6 ;
11597 int ecode6 = 0 ;
11598 int val7 ;
11599 int ecode7 = 0 ;
11600 Matrix temp8 ;
11601 Matrix temp10 ;
11602 octave_value_list _out;
11603 octave_value_list *_outp=&_out;
11604 octave_value _outv;
11605
11606 try {
11607 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11608 SWIG_fail;
11609 }
11610 {
11611 if ( _n_dims( args(0) ) > 2 )
11612 {
11613 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11614 }
11615 temp1 = args(0).matrix_value();
11616 arg1 = &temp1( 0, 0 );
11617 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11618 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11619 }
11620 ecode4 = SWIG_AsVal_int(args(1), &val4);
11621 if (!SWIG_IsOK(ecode4)) {
11622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11623 }
11624 arg4 = static_cast< PLINT >(val4);
11625 ecode5 = SWIG_AsVal_int(args(2), &val5);
11626 if (!SWIG_IsOK(ecode5)) {
11627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11628 }
11629 arg5 = static_cast< PLINT >(val5);
11630 ecode6 = SWIG_AsVal_int(args(3), &val6);
11631 if (!SWIG_IsOK(ecode6)) {
11632 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11633 }
11634 arg6 = static_cast< PLINT >(val6);
11635 ecode7 = SWIG_AsVal_int(args(4), &val7);
11636 if (!SWIG_IsOK(ecode7)) {
11637 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11638 }
11639 arg7 = static_cast< PLINT >(val7);
11640 {
11641 if ( _n_dims( args(5) ) > 1 )
11642 {
11643 error( "argument must be a scalar or vector" ); SWIG_fail;
11644 }
11645 temp8 = args(5).matrix_value();
11646 arg8 = &temp8( 0, 0 );
11647 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11648 }
11649 {
11650 if ( _n_dims( args(6) ) > 1 )
11651 {
11652 error( "argument must be a scalar or vector" ); SWIG_fail;
11653 }
11654 if ( _dim( args(6), 0 ) != 6 )
11655 {
11656 error( "argument vectors must have length of 6" ); SWIG_fail;
11657 }
11658 temp10 = args(6).matrix_value();
11659 arg10 = &temp10( 0, 0 );
11660 }
11661 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11662 _outv = octave_value();
11663 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11664 {
11665
11666 }
11667 {
11668
11669 }
11670 {
11671
11672 }
11673 return _out;
11674 fail:
11675 {
11676
11677 }
11678 {
11679
11680 }
11681 {
11682
11683 }
11684 return octave_value_list();
11685 }
11686 catch(...) {
11687 {
11688
11689 }
11690 {
11691
11692 }
11693 {
11694
11695 }
11696 throw;
11697 }
11698}
11699
11700
11701SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11702 PLFLT *arg1 = (PLFLT *) 0 ;
11703 PLINT arg2 ;
11704 PLINT arg3 ;
11705 PLINT arg4 ;
11706 PLINT arg5 ;
11707 PLINT arg6 ;
11708 PLINT arg7 ;
11709 PLFLT *arg8 = (PLFLT *) 0 ;
11710 PLINT arg9 ;
11711 Matrix temp1 ;
11712 int val4 ;
11713 int ecode4 = 0 ;
11714 int val5 ;
11715 int ecode5 = 0 ;
11716 int val6 ;
11717 int ecode6 = 0 ;
11718 int val7 ;
11719 int ecode7 = 0 ;
11720 Matrix temp8 ;
11721 octave_value_list _out;
11722 octave_value_list *_outp=&_out;
11723 octave_value _outv;
11724
11725 try {
11726 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11727 SWIG_fail;
11728 }
11729 {
11730 if ( _n_dims( args(0) ) > 2 )
11731 {
11732 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11733 }
11734 temp1 = args(0).matrix_value();
11735 arg1 = &temp1( 0, 0 );
11736 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11737 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11738 }
11739 ecode4 = SWIG_AsVal_int(args(1), &val4);
11740 if (!SWIG_IsOK(ecode4)) {
11741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11742 }
11743 arg4 = static_cast< PLINT >(val4);
11744 ecode5 = SWIG_AsVal_int(args(2), &val5);
11745 if (!SWIG_IsOK(ecode5)) {
11746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11747 }
11748 arg5 = static_cast< PLINT >(val5);
11749 ecode6 = SWIG_AsVal_int(args(3), &val6);
11750 if (!SWIG_IsOK(ecode6)) {
11751 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11752 }
11753 arg6 = static_cast< PLINT >(val6);
11754 ecode7 = SWIG_AsVal_int(args(4), &val7);
11755 if (!SWIG_IsOK(ecode7)) {
11756 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11757 }
11758 arg7 = static_cast< PLINT >(val7);
11759 {
11760 if ( _n_dims( args(5) ) > 1 )
11761 {
11762 error( "argument must be a scalar or vector" ); SWIG_fail;
11763 }
11764 temp8 = args(5).matrix_value();
11765 arg8 = &temp8( 0, 0 );
11766 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11767 }
11768 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11769 _outv = octave_value();
11770 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11771 {
11772
11773 }
11774 {
11775
11776 }
11777 return _out;
11778 fail:
11779 {
11780
11781 }
11782 {
11783
11784 }
11785 return octave_value_list();
11786 }
11787 catch(...) {
11788 {
11789
11790 }
11791 {
11792
11793 }
11794 throw;
11795 }
11796}
11797
11798
11799SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11800 PLFLT *arg1 = (PLFLT *) 0 ;
11801 PLINT arg2 ;
11802 PLINT arg3 ;
11803 PLINT arg4 ;
11804 PLINT arg5 ;
11805 PLINT arg6 ;
11806 PLINT arg7 ;
11807 PLFLT *arg8 = (PLFLT *) 0 ;
11808 PLINT arg9 ;
11809 PLFLT *arg10 = (PLFLT *) 0 ;
11810 PLFLT *arg11 = (PLFLT *) 0 ;
11811 Matrix temp1 ;
11812 int val4 ;
11813 int ecode4 = 0 ;
11814 int val5 ;
11815 int ecode5 = 0 ;
11816 int val6 ;
11817 int ecode6 = 0 ;
11818 int val7 ;
11819 int ecode7 = 0 ;
11820 Matrix temp8 ;
11821 Matrix temp10 ;
11822 Matrix temp11 ;
11823 octave_value_list _out;
11824 octave_value_list *_outp=&_out;
11825 octave_value _outv;
11826
11827 try {
11828 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11829 SWIG_fail;
11830 }
11831 {
11832 if ( _n_dims( args(0) ) > 2 )
11833 {
11834 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11835 }
11836 temp1 = args(0).matrix_value();
11837 arg1 = &temp1( 0, 0 );
11838 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11839 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11840 }
11841 ecode4 = SWIG_AsVal_int(args(1), &val4);
11842 if (!SWIG_IsOK(ecode4)) {
11843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11844 }
11845 arg4 = static_cast< PLINT >(val4);
11846 ecode5 = SWIG_AsVal_int(args(2), &val5);
11847 if (!SWIG_IsOK(ecode5)) {
11848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11849 }
11850 arg5 = static_cast< PLINT >(val5);
11851 ecode6 = SWIG_AsVal_int(args(3), &val6);
11852 if (!SWIG_IsOK(ecode6)) {
11853 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11854 }
11855 arg6 = static_cast< PLINT >(val6);
11856 ecode7 = SWIG_AsVal_int(args(4), &val7);
11857 if (!SWIG_IsOK(ecode7)) {
11858 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11859 }
11860 arg7 = static_cast< PLINT >(val7);
11861 {
11862 if ( _n_dims( args(5) ) > 1 )
11863 {
11864 error( "argument must be a scalar or vector" ); SWIG_fail;
11865 }
11866 temp8 = args(5).matrix_value();
11867 arg8 = &temp8( 0, 0 );
11868 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11869 }
11870 {
11871 if ( _n_dims( args(6) ) > 1 )
11872 {
11873 error( "argument must be a scalar or vector" ); SWIG_fail;
11874 }
11875 if ( _dim( args(6), 0 ) != Xlen )
11876 {
11877 error( "argument vectors must be same length" ); SWIG_fail;
11878 }
11879 temp10 = args(6).matrix_value();
11880 arg10 = &temp10( 0, 0 );
11881 }
11882 {
11883 if ( _n_dims( args(7) ) > 1 )
11884 {
11885 error( "argument must be a scalar or vector" ); SWIG_fail;
11886 }
11887 if ( _dim( args(7), 0 ) != Ylen )
11888 {
11889 error( "argument vectors must be same length" ); SWIG_fail;
11890 }
11891 temp11 = args(7).matrix_value();
11892 arg11 = &temp11( 0, 0 );
11893 }
11894 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11895 _outv = octave_value();
11896 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11897 {
11898
11899 }
11900 {
11901
11902 }
11903 {
11904
11905 }
11906 {
11907
11908 }
11909 return _out;
11910 fail:
11911 {
11912
11913 }
11914 {
11915
11916 }
11917 {
11918
11919 }
11920 {
11921
11922 }
11923 return octave_value_list();
11924 }
11925 catch(...) {
11926 {
11927
11928 }
11929 {
11930
11931 }
11932 {
11933
11934 }
11935 {
11936
11937 }
11938 throw;
11939 }
11940}
11941
11942
11943SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11944 PLFLT *arg1 = (PLFLT *) 0 ;
11945 PLINT arg2 ;
11946 PLINT arg3 ;
11947 PLINT arg4 ;
11948 PLINT arg5 ;
11949 PLINT arg6 ;
11950 PLINT arg7 ;
11951 PLFLT *arg8 = (PLFLT *) 0 ;
11952 PLINT arg9 ;
11953 PLFLT *arg10 = (PLFLT *) 0 ;
11954 PLFLT *arg11 = (PLFLT *) 0 ;
11955 Matrix temp1 ;
11956 int val4 ;
11957 int ecode4 = 0 ;
11958 int val5 ;
11959 int ecode5 = 0 ;
11960 int val6 ;
11961 int ecode6 = 0 ;
11962 int val7 ;
11963 int ecode7 = 0 ;
11964 Matrix temp8 ;
11965 Matrix temp10 ;
11966 Matrix temp11 ;
11967 octave_value_list _out;
11968 octave_value_list *_outp=&_out;
11969 octave_value _outv;
11970
11971 try {
11972 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11973 SWIG_fail;
11974 }
11975 {
11976 if ( _n_dims( args(0) ) > 2 )
11977 {
11978 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11979 }
11980 temp1 = args(0).matrix_value();
11981 arg1 = &temp1( 0, 0 );
11982 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11983 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11984 }
11985 ecode4 = SWIG_AsVal_int(args(1), &val4);
11986 if (!SWIG_IsOK(ecode4)) {
11987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11988 }
11989 arg4 = static_cast< PLINT >(val4);
11990 ecode5 = SWIG_AsVal_int(args(2), &val5);
11991 if (!SWIG_IsOK(ecode5)) {
11992 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11993 }
11994 arg5 = static_cast< PLINT >(val5);
11995 ecode6 = SWIG_AsVal_int(args(3), &val6);
11996 if (!SWIG_IsOK(ecode6)) {
11997 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11998 }
11999 arg6 = static_cast< PLINT >(val6);
12000 ecode7 = SWIG_AsVal_int(args(4), &val7);
12001 if (!SWIG_IsOK(ecode7)) {
12002 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12003 }
12004 arg7 = static_cast< PLINT >(val7);
12005 {
12006 if ( _n_dims( args(5) ) > 1 )
12007 {
12008 error( "argument must be a scalar or vector" ); SWIG_fail;
12009 }
12010 temp8 = args(5).matrix_value();
12011 arg8 = &temp8( 0, 0 );
12012 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12013 }
12014 {
12015 if ( _n_dims( args(6) ) > 2 )
12016 {
12017 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12018 }
12019 if ( _dim( args(6), 0 ) != Xlen )
12020 {
12021 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12022 }
12023 if ( _dim( args(6), 1 ) != Ylen )
12024 {
12025 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12026 }
12027 temp10 = args(6).matrix_value();
12028 arg10 = &temp10( 0, 0 );
12029 }
12030 {
12031 if ( _n_dims( args(7) ) > 2 )
12032 {
12033 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12034 }
12035 if ( _dim( args(7), 0 ) != Xlen )
12036 {
12037 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12038 }
12039 if ( _dim( args(7), 1 ) != Ylen )
12040 {
12041 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12042 }
12043 temp11 = args(7).matrix_value();
12044 arg11 = &temp11( 0, 0 );
12045 }
12046 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12047 _outv = octave_value();
12048 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12049 {
12050
12051 }
12052 {
12053
12054 }
12055 {
12056
12057 }
12058 {
12059
12060 }
12061 return _out;
12062 fail:
12063 {
12064
12065 }
12066 {
12067
12068 }
12069 {
12070
12071 }
12072 {
12073
12074 }
12075 return octave_value_list();
12076 }
12077 catch(...) {
12078 {
12079
12080 }
12081 {
12082
12083 }
12084 {
12085
12086 }
12087 {
12088
12089 }
12090 throw;
12091 }
12092}
12093
12094
12095SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12096 PLFLT *arg1 = (PLFLT *) 0 ;
12097 PLINT arg2 ;
12098 PLINT arg3 ;
12099 PLINT arg4 ;
12100 PLINT arg5 ;
12101 PLINT arg6 ;
12102 PLINT arg7 ;
12103 PLFLT *arg8 = (PLFLT *) 0 ;
12104 PLINT arg9 ;
12105 PLFLT *arg10 = (PLFLT *) 0 ;
12106 PLFLT *arg11 = (PLFLT *) 0 ;
12107 Matrix temp1 ;
12108 int val4 ;
12109 int ecode4 = 0 ;
12110 int val5 ;
12111 int ecode5 = 0 ;
12112 int val6 ;
12113 int ecode6 = 0 ;
12114 int val7 ;
12115 int ecode7 = 0 ;
12116 Matrix temp8 ;
12117 Matrix temp10 ;
12118 Matrix temp11 ;
12119 octave_value_list _out;
12120 octave_value_list *_outp=&_out;
12121 octave_value _outv;
12122
12123 try {
12124 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12125 SWIG_fail;
12126 }
12127 {
12128 if ( _n_dims( args(0) ) > 2 )
12129 {
12130 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12131 }
12132 temp1 = args(0).matrix_value();
12133 arg1 = &temp1( 0, 0 );
12134 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12135 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12136 }
12137 ecode4 = SWIG_AsVal_int(args(1), &val4);
12138 if (!SWIG_IsOK(ecode4)) {
12139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12140 }
12141 arg4 = static_cast< PLINT >(val4);
12142 ecode5 = SWIG_AsVal_int(args(2), &val5);
12143 if (!SWIG_IsOK(ecode5)) {
12144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12145 }
12146 arg5 = static_cast< PLINT >(val5);
12147 ecode6 = SWIG_AsVal_int(args(3), &val6);
12148 if (!SWIG_IsOK(ecode6)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12150 }
12151 arg6 = static_cast< PLINT >(val6);
12152 ecode7 = SWIG_AsVal_int(args(4), &val7);
12153 if (!SWIG_IsOK(ecode7)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12155 }
12156 arg7 = static_cast< PLINT >(val7);
12157 {
12158 if ( _n_dims( args(5) ) > 1 )
12159 {
12160 error( "argument must be a scalar or vector" ); SWIG_fail;
12161 }
12162 temp8 = args(5).matrix_value();
12163 arg8 = &temp8( 0, 0 );
12164 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12165 }
12166 {
12167 if ( _n_dims( args(6) ) > 2 )
12168 {
12169 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12170 }
12171 if ( _dim( args(6), 0 ) != Xlen )
12172 {
12173 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12174 }
12175 if ( _dim( args(6), 1 ) != Ylen )
12176 {
12177 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12178 }
12179 temp10 = args(6).matrix_value();
12180 arg10 = &temp10( 0, 0 );
12181 }
12182 {
12183 if ( _n_dims( args(7) ) > 2 )
12184 {
12185 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12186 }
12187 if ( _dim( args(7), 0 ) != Xlen )
12188 {
12189 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12190 }
12191 if ( _dim( args(7), 1 ) != Ylen )
12192 {
12193 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12194 }
12195 temp11 = args(7).matrix_value();
12196 arg11 = &temp11( 0, 0 );
12197 }
12198 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12199 _outv = octave_value();
12200 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12201 {
12202
12203 }
12204 {
12205
12206 }
12207 {
12208
12209 }
12210 {
12211
12212 }
12213 return _out;
12214 fail:
12215 {
12216
12217 }
12218 {
12219
12220 }
12221 {
12222
12223 }
12224 {
12225
12226 }
12227 return octave_value_list();
12228 }
12229 catch(...) {
12230 {
12231
12232 }
12233 {
12234
12235 }
12236 {
12237
12238 }
12239 {
12240
12241 }
12242 throw;
12243 }
12244}
12245
12246
12247SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12248 PLFLT *arg1 = (PLFLT *) 0 ;
12249 PLFLT *arg2 = (PLFLT *) 0 ;
12250 PLFLT *arg3 = (PLFLT *) 0 ;
12251 PLINT arg4 ;
12252 PLFLT *arg5 = (PLFLT *) 0 ;
12253 PLINT arg6 ;
12254 PLFLT *arg7 = (PLFLT *) 0 ;
12255 PLINT arg8 ;
12256 PLFLT *arg9 = (PLFLT *) 0 ;
12257 PLINT arg10 ;
12258 PLFLT arg11 ;
12259 Matrix temp1 ;
12260 Matrix temp2 ;
12261 Matrix temp3 ;
12262 Matrix temp5 ;
12263 Matrix temp7 ;
12264 octave_value_list retval7 ;
12265 int val10 ;
12266 int ecode10 = 0 ;
12267 double val11 ;
12268 int ecode11 = 0 ;
12269 octave_value_list _out;
12270 octave_value_list *_outp=&_out;
12271 octave_value _outv;
12272
12273 try {
12274 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12275 SWIG_fail;
12276 }
12277 {
12278 if ( _n_dims( args(0) ) > 1 )
12279 {
12280 error( "argument must be a scalar or vector" ); SWIG_fail;
12281 }
12282 Alen = (PLINT) ( _dim( args(0), 0 ) );
12283 temp1 = args(0).matrix_value();
12284 arg1 = &temp1( 0, 0 );
12285 }
12286 {
12287 if ( _n_dims( args(1) ) > 1 )
12288 {
12289 error( "argument must be a scalar or vector" ); SWIG_fail;
12290 }
12291 if ( _dim( args(1), 0 ) != Alen )
12292 {
12293 error( "argument vectors must be same length" ); SWIG_fail;
12294 }
12295 temp2 = args(1).matrix_value();
12296 arg2 = &temp2( 0, 0 );
12297 }
12298 {
12299 if ( _n_dims( args(2) ) > 1 )
12300 {
12301 error( "argument must be a scalar or vector" ); SWIG_fail;
12302 }
12303 if ( _dim( args(2), 0 ) != Alen )
12304 {
12305 error( "argument vectors must be same length" ); SWIG_fail;
12306 }
12307 temp3 = args(2).matrix_value();
12308 arg3 = &temp3( 0, 0 );
12309 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12310 }
12311 {
12312 if ( _n_dims( args(3) ) > 1 )
12313 {
12314 error( "argument must be a scalar or vector" ); SWIG_fail;
12315 }
12316 temp5 = args(3).matrix_value();
12317 arg5 = &temp5( 0, 0 );
12318 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12319 }
12320 {
12321 if ( _n_dims( args(4) ) > 1 )
12322 {
12323 error( "argument must be a scalar or vector" ); SWIG_fail;
12324 }
12325 temp7 = args(4).matrix_value();
12326 arg7 = &temp7( 0, 0 );
12327 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12328 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12329 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12330 }
12331 ecode10 = SWIG_AsVal_int(args(5), &val10);
12332 if (!SWIG_IsOK(ecode10)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12334 }
12335 arg10 = static_cast< PLINT >(val10);
12336 ecode11 = SWIG_AsVal_double(args(6), &val11);
12337 if (!SWIG_IsOK(ecode11)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12339 }
12340 arg11 = static_cast< PLFLT >(val11);
12341 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12342 _outv = octave_value();
12343 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12344 {
12345 _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12346 }
12347 {
12348
12349 }
12350 {
12351
12352 }
12353 {
12354
12355 }
12356 {
12357
12358 }
12359 {
12360
12361 }
12362 return _out;
12363 fail:
12364 {
12365
12366 }
12367 {
12368
12369 }
12370 {
12371
12372 }
12373 {
12374
12375 }
12376 {
12377
12378 }
12379 return octave_value_list();
12380 }
12381 catch(...) {
12382 {
12383
12384 }
12385 {
12386
12387 }
12388 {
12389
12390 }
12391 {
12392
12393 }
12394 {
12395
12396 }
12397 throw;
12398 }
12399}
12400
12401
12403 PLFLT *arg1 = (PLFLT *) 0 ;
12404 PLFLT *arg2 = (PLFLT *) 0 ;
12405 PLFLT *arg3 = (PLFLT *) 0 ;
12406 PLINT arg4 ;
12407 PLINT arg5 ;
12408 PLINT arg6 ;
12409 Matrix temp1 ;
12410 Matrix temp2 ;
12411 Matrix temp3 ;
12412 int val6 ;
12413 int ecode6 = 0 ;
12414 octave_value_list _out;
12415 octave_value_list *_outp=&_out;
12416 octave_value _outv;
12417
12418 try {
12419 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12420 SWIG_fail;
12421 }
12422 {
12423 if ( _n_dims( args(0) ) > 1 )
12424 {
12425 error( "argument must be a scalar or vector" ); SWIG_fail;
12426 }
12427 temp1 = args(0).matrix_value();
12428 arg1 = &temp1( 0, 0 );
12429 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12430 }
12431 {
12432 if ( _n_dims( args(1) ) > 1 )
12433 {
12434 error( "argument must be a scalar or vector" ); SWIG_fail;
12435 }
12436 temp2 = args(1).matrix_value();
12437 arg2 = &temp2( 0, 0 );
12438 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12439 }
12440 {
12441 if ( _n_dims( args(2) ) > 2 )
12442 {
12443 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12444 }
12445 if ( _dim( args(2), 0 ) != Xlen )
12446 {
12447 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12448 }
12449 if ( _dim( args(2), 1 ) != Ylen )
12450 {
12451 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12452 }
12453 temp3 = args(2).matrix_value();
12454 arg3 = &temp3( 0, 0 );
12455 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12456 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12457 }
12458 ecode6 = SWIG_AsVal_int(args(3), &val6);
12459 if (!SWIG_IsOK(ecode6)) {
12460 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12461 }
12462 arg6 = static_cast< PLINT >(val6);
12463 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12464 _outv = octave_value();
12465 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12466 {
12467
12468 }
12469 {
12470
12471 }
12472 {
12473
12474 }
12475 return _out;
12476 fail:
12477 {
12478
12479 }
12480 {
12481
12482 }
12483 {
12484
12485 }
12486 return octave_value_list();
12487 }
12488 catch(...) {
12489 {
12490
12491 }
12492 {
12493
12494 }
12495 {
12496
12497 }
12498 throw;
12499 }
12500}
12501
12502
12504 PLFLT *arg1 = (PLFLT *) 0 ;
12505 PLFLT *arg2 = (PLFLT *) 0 ;
12506 PLFLT *arg3 = (PLFLT *) 0 ;
12507 PLINT arg4 ;
12508 PLINT arg5 ;
12509 PLINT arg6 ;
12510 PLFLT *arg7 = (PLFLT *) 0 ;
12511 PLINT arg8 ;
12512 Matrix temp1 ;
12513 Matrix temp2 ;
12514 Matrix temp3 ;
12515 int val6 ;
12516 int ecode6 = 0 ;
12517 Matrix temp7 ;
12518 octave_value_list _out;
12519 octave_value_list *_outp=&_out;
12520 octave_value _outv;
12521
12522 try {
12523 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12524 SWIG_fail;
12525 }
12526 {
12527 if ( _n_dims( args(0) ) > 1 )
12528 {
12529 error( "argument must be a scalar or vector" ); SWIG_fail;
12530 }
12531 temp1 = args(0).matrix_value();
12532 arg1 = &temp1( 0, 0 );
12533 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12534 }
12535 {
12536 if ( _n_dims( args(1) ) > 1 )
12537 {
12538 error( "argument must be a scalar or vector" ); SWIG_fail;
12539 }
12540 temp2 = args(1).matrix_value();
12541 arg2 = &temp2( 0, 0 );
12542 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12543 }
12544 {
12545 if ( _n_dims( args(2) ) > 2 )
12546 {
12547 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12548 }
12549 if ( _dim( args(2), 0 ) != Xlen )
12550 {
12551 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12552 }
12553 if ( _dim( args(2), 1 ) != Ylen )
12554 {
12555 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12556 }
12557 temp3 = args(2).matrix_value();
12558 arg3 = &temp3( 0, 0 );
12559 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12560 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12561 }
12562 ecode6 = SWIG_AsVal_int(args(3), &val6);
12563 if (!SWIG_IsOK(ecode6)) {
12564 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12565 }
12566 arg6 = static_cast< PLINT >(val6);
12567 {
12568 if ( _n_dims( args(4) ) > 1 )
12569 {
12570 error( "argument must be a scalar or vector" ); SWIG_fail;
12571 }
12572 temp7 = args(4).matrix_value();
12573 arg7 = &temp7( 0, 0 );
12574 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12575 }
12576 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12577 _outv = octave_value();
12578 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12579 {
12580
12581 }
12582 {
12583
12584 }
12585 {
12586
12587 }
12588 {
12589
12590 }
12591 return _out;
12592 fail:
12593 {
12594
12595 }
12596 {
12597
12598 }
12599 {
12600
12601 }
12602 {
12603
12604 }
12605 return octave_value_list();
12606 }
12607 catch(...) {
12608 {
12609
12610 }
12611 {
12612
12613 }
12614 {
12615
12616 }
12617 {
12618
12619 }
12620 throw;
12621 }
12622}
12623
12624
12626 PLFLT *arg1 = (PLFLT *) 0 ;
12627 PLFLT *arg2 = (PLFLT *) 0 ;
12628 PLFLT *arg3 = (PLFLT *) 0 ;
12629 PLINT arg4 ;
12630 PLINT arg5 ;
12631 PLINT arg6 ;
12632 PLBOOL arg7 ;
12633 Matrix temp1 ;
12634 Matrix temp2 ;
12635 Matrix temp3 ;
12636 int val6 ;
12637 int ecode6 = 0 ;
12638 int val7 ;
12639 int ecode7 = 0 ;
12640 octave_value_list _out;
12641 octave_value_list *_outp=&_out;
12642 octave_value _outv;
12643
12644 try {
12645 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12646 SWIG_fail;
12647 }
12648 {
12649 if ( _n_dims( args(0) ) > 1 )
12650 {
12651 error( "argument must be a scalar or vector" ); SWIG_fail;
12652 }
12653 temp1 = args(0).matrix_value();
12654 arg1 = &temp1( 0, 0 );
12655 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12656 }
12657 {
12658 if ( _n_dims( args(1) ) > 1 )
12659 {
12660 error( "argument must be a scalar or vector" ); SWIG_fail;
12661 }
12662 temp2 = args(1).matrix_value();
12663 arg2 = &temp2( 0, 0 );
12664 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12665 }
12666 {
12667 if ( _n_dims( args(2) ) > 2 )
12668 {
12669 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12670 }
12671 if ( _dim( args(2), 0 ) != Xlen )
12672 {
12673 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12674 }
12675 if ( _dim( args(2), 1 ) != Ylen )
12676 {
12677 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12678 }
12679 temp3 = args(2).matrix_value();
12680 arg3 = &temp3( 0, 0 );
12681 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12682 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12683 }
12684 ecode6 = SWIG_AsVal_int(args(3), &val6);
12685 if (!SWIG_IsOK(ecode6)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12687 }
12688 arg6 = static_cast< PLINT >(val6);
12689 ecode7 = SWIG_AsVal_int(args(4), &val7);
12690 if (!SWIG_IsOK(ecode7)) {
12691 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12692 }
12693 arg7 = static_cast< PLBOOL >(val7);
12694 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12695 _outv = octave_value();
12696 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12697 {
12698
12699 }
12700 {
12701
12702 }
12703 {
12704
12705 }
12706 return _out;
12707 fail:
12708 {
12709
12710 }
12711 {
12712
12713 }
12714 {
12715
12716 }
12717 return octave_value_list();
12718 }
12719 catch(...) {
12720 {
12721
12722 }
12723 {
12724
12725 }
12726 {
12727
12728 }
12729 throw;
12730 }
12731}
12732
12733
12735 PLFLT *arg1 = (PLFLT *) 0 ;
12736 PLFLT *arg2 = (PLFLT *) 0 ;
12737 PLFLT *arg3 = (PLFLT *) 0 ;
12738 PLINT arg4 ;
12739 PLINT arg5 ;
12740 PLINT arg6 ;
12741 PLFLT *arg7 = (PLFLT *) 0 ;
12742 PLINT arg8 ;
12743 Matrix temp1 ;
12744 Matrix temp2 ;
12745 Matrix temp3 ;
12746 int val6 ;
12747 int ecode6 = 0 ;
12748 Matrix temp7 ;
12749 octave_value_list _out;
12750 octave_value_list *_outp=&_out;
12751 octave_value _outv;
12752
12753 try {
12754 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12755 SWIG_fail;
12756 }
12757 {
12758 if ( _n_dims( args(0) ) > 1 )
12759 {
12760 error( "argument must be a scalar or vector" ); SWIG_fail;
12761 }
12762 temp1 = args(0).matrix_value();
12763 arg1 = &temp1( 0, 0 );
12764 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12765 }
12766 {
12767 if ( _n_dims( args(1) ) > 1 )
12768 {
12769 error( "argument must be a scalar or vector" ); SWIG_fail;
12770 }
12771 temp2 = args(1).matrix_value();
12772 arg2 = &temp2( 0, 0 );
12773 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12774 }
12775 {
12776 if ( _n_dims( args(2) ) > 2 )
12777 {
12778 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12779 }
12780 if ( _dim( args(2), 0 ) != Xlen )
12781 {
12782 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12783 }
12784 if ( _dim( args(2), 1 ) != Ylen )
12785 {
12786 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12787 }
12788 temp3 = args(2).matrix_value();
12789 arg3 = &temp3( 0, 0 );
12790 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12791 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12792 }
12793 ecode6 = SWIG_AsVal_int(args(3), &val6);
12794 if (!SWIG_IsOK(ecode6)) {
12795 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12796 }
12797 arg6 = static_cast< PLINT >(val6);
12798 {
12799 if ( _n_dims( args(4) ) > 1 )
12800 {
12801 error( "argument must be a scalar or vector" ); SWIG_fail;
12802 }
12803 temp7 = args(4).matrix_value();
12804 arg7 = &temp7( 0, 0 );
12805 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12806 }
12807 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12808 _outv = octave_value();
12809 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12810 {
12811
12812 }
12813 {
12814
12815 }
12816 {
12817
12818 }
12819 {
12820
12821 }
12822 return _out;
12823 fail:
12824 {
12825
12826 }
12827 {
12828
12829 }
12830 {
12831
12832 }
12833 {
12834
12835 }
12836 return octave_value_list();
12837 }
12838 catch(...) {
12839 {
12840
12841 }
12842 {
12843
12844 }
12845 {
12846
12847 }
12848 {
12849
12850 }
12851 throw;
12852 }
12853}
12854
12855
12857 PLFLT *arg1 = (PLFLT *) 0 ;
12858 PLFLT *arg2 = (PLFLT *) 0 ;
12859 PLFLT *arg3 = (PLFLT *) 0 ;
12860 PLINT arg4 ;
12861 PLINT arg5 ;
12862 PLINT arg6 ;
12863 PLFLT *arg7 = (PLFLT *) 0 ;
12864 PLINT arg8 ;
12865 PLINT arg9 ;
12866 PLINT arg10 ;
12867 PLINT *arg11 = (PLINT *) 0 ;
12868 PLINT *arg12 = (PLINT *) 0 ;
12869 Matrix temp1 ;
12870 Matrix temp2 ;
12871 Matrix temp3 ;
12872 int val6 ;
12873 int ecode6 = 0 ;
12874 Matrix temp7 ;
12875 int val9 ;
12876 int ecode9 = 0 ;
12877 Matrix temp10 ;
12878 Matrix temp12 ;
12879 octave_value_list _out;
12880 octave_value_list *_outp=&_out;
12881 octave_value _outv;
12882
12883 try {
12884 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12885 SWIG_fail;
12886 }
12887 {
12888 if ( _n_dims( args(0) ) > 1 )
12889 {
12890 error( "argument must be a scalar or vector" ); SWIG_fail;
12891 }
12892 temp1 = args(0).matrix_value();
12893 arg1 = &temp1( 0, 0 );
12894 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12895 }
12896 {
12897 if ( _n_dims( args(1) ) > 1 )
12898 {
12899 error( "argument must be a scalar or vector" ); SWIG_fail;
12900 }
12901 temp2 = args(1).matrix_value();
12902 arg2 = &temp2( 0, 0 );
12903 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12904 }
12905 {
12906 if ( _n_dims( args(2) ) > 2 )
12907 {
12908 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12909 }
12910 if ( _dim( args(2), 0 ) != Xlen )
12911 {
12912 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12913 }
12914 if ( _dim( args(2), 1 ) != Ylen )
12915 {
12916 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12917 }
12918 temp3 = args(2).matrix_value();
12919 arg3 = &temp3( 0, 0 );
12920 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12921 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12922 }
12923 ecode6 = SWIG_AsVal_int(args(3), &val6);
12924 if (!SWIG_IsOK(ecode6)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12926 }
12927 arg6 = static_cast< PLINT >(val6);
12928 {
12929 if ( _n_dims( args(4) ) > 1 )
12930 {
12931 error( "argument must be a scalar or vector" ); SWIG_fail;
12932 }
12933 temp7 = args(4).matrix_value();
12934 arg7 = &temp7( 0, 0 );
12935 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12936 }
12937 ecode9 = SWIG_AsVal_int(args(5), &val9);
12938 if (!SWIG_IsOK(ecode9)) {
12939 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12940 }
12941 arg9 = static_cast< PLINT >(val9);
12942 {
12943 if ( _n_dims( args(6) ) > 1 )
12944 {
12945 error( "argument must be a scalar or vector" ); SWIG_fail;
12946 }
12947 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12948 arg11 = new PLINT[Alen];
12949 temp10 = args(6).matrix_value();
12950 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12951 }
12952 {
12953 if ( _n_dims( args(7) ) > 1 )
12954 {
12955 error( "argument must be a scalar or vector" ); SWIG_fail;
12956 }
12957 if ( _dim( args(7), 0 ) != Alen )
12958 {
12959 error( "argument vectors must be same length" ); SWIG_fail;
12960 }
12961 temp12 = args(7).matrix_value();
12962 arg12 = new PLINT[Alen];
12963 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12964 }
12965 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);
12966 _outv = octave_value();
12967 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12968 {
12969
12970 }
12971 {
12972
12973 }
12974 {
12975
12976 }
12977 {
12978
12979 }
12980 {
12981 delete [] arg11;
12982 }
12983 {
12984 delete [] arg12;
12985 }
12986 return _out;
12987 fail:
12988 {
12989
12990 }
12991 {
12992
12993 }
12994 {
12995
12996 }
12997 {
12998
12999 }
13000 {
13001 delete [] arg11;
13002 }
13003 {
13004 delete [] arg12;
13005 }
13006 return octave_value_list();
13007 }
13008 catch(...) {
13009 {
13010
13011 }
13012 {
13013
13014 }
13015 {
13016
13017 }
13018 {
13019
13020 }
13021 {
13022 delete [] arg11;
13023 }
13024 {
13025 delete [] arg12;
13026 }
13027 throw;
13028 }
13029}
13030
13031
13033 PLFLT *arg1 = (PLFLT *) 0 ;
13034 PLFLT *arg2 = (PLFLT *) 0 ;
13035 PLFLT *arg3 = (PLFLT *) 0 ;
13036 PLINT arg4 ;
13037 PLINT arg5 ;
13038 PLINT arg6 ;
13039 PLFLT *arg7 = (PLFLT *) 0 ;
13040 PLINT arg8 ;
13041 Matrix temp1 ;
13042 Matrix temp2 ;
13043 Matrix temp3 ;
13044 int val6 ;
13045 int ecode6 = 0 ;
13046 Matrix temp7 ;
13047 octave_value_list _out;
13048 octave_value_list *_outp=&_out;
13049 octave_value _outv;
13050
13051 try {
13052 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13053 SWIG_fail;
13054 }
13055 {
13056 if ( _n_dims( args(0) ) > 1 )
13057 {
13058 error( "argument must be a scalar or vector" ); SWIG_fail;
13059 }
13060 temp1 = args(0).matrix_value();
13061 arg1 = &temp1( 0, 0 );
13062 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13063 }
13064 {
13065 if ( _n_dims( args(1) ) > 1 )
13066 {
13067 error( "argument must be a scalar or vector" ); SWIG_fail;
13068 }
13069 temp2 = args(1).matrix_value();
13070 arg2 = &temp2( 0, 0 );
13071 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13072 }
13073 {
13074 if ( _n_dims( args(2) ) > 2 )
13075 {
13076 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13077 }
13078 if ( _dim( args(2), 0 ) != Xlen )
13079 {
13080 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13081 }
13082 if ( _dim( args(2), 1 ) != Ylen )
13083 {
13084 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13085 }
13086 temp3 = args(2).matrix_value();
13087 arg3 = &temp3( 0, 0 );
13088 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13089 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13090 }
13091 ecode6 = SWIG_AsVal_int(args(3), &val6);
13092 if (!SWIG_IsOK(ecode6)) {
13093 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13094 }
13095 arg6 = static_cast< PLINT >(val6);
13096 {
13097 if ( _n_dims( args(4) ) > 1 )
13098 {
13099 error( "argument must be a scalar or vector" ); SWIG_fail;
13100 }
13101 temp7 = args(4).matrix_value();
13102 arg7 = &temp7( 0, 0 );
13103 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13104 }
13105 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13106 _outv = octave_value();
13107 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13108 {
13109
13110 }
13111 {
13112
13113 }
13114 {
13115
13116 }
13117 {
13118
13119 }
13120 return _out;
13121 fail:
13122 {
13123
13124 }
13125 {
13126
13127 }
13128 {
13129
13130 }
13131 {
13132
13133 }
13134 return octave_value_list();
13135 }
13136 catch(...) {
13137 {
13138
13139 }
13140 {
13141
13142 }
13143 {
13144
13145 }
13146 {
13147
13148 }
13149 throw;
13150 }
13151}
13152
13153
13155 PLFLT *arg1 = (PLFLT *) 0 ;
13156 PLFLT *arg2 = (PLFLT *) 0 ;
13157 PLFLT *arg3 = (PLFLT *) 0 ;
13158 PLINT arg4 ;
13159 PLINT arg5 ;
13160 PLINT arg6 ;
13161 PLFLT *arg7 = (PLFLT *) 0 ;
13162 PLINT arg8 ;
13163 PLINT arg9 ;
13164 PLINT arg10 ;
13165 PLINT *arg11 = (PLINT *) 0 ;
13166 PLINT *arg12 = (PLINT *) 0 ;
13167 Matrix temp1 ;
13168 Matrix temp2 ;
13169 Matrix temp3 ;
13170 int val6 ;
13171 int ecode6 = 0 ;
13172 Matrix temp7 ;
13173 int val9 ;
13174 int ecode9 = 0 ;
13175 Matrix temp10 ;
13176 Matrix temp12 ;
13177 octave_value_list _out;
13178 octave_value_list *_outp=&_out;
13179 octave_value _outv;
13180
13181 try {
13182 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13183 SWIG_fail;
13184 }
13185 {
13186 if ( _n_dims( args(0) ) > 1 )
13187 {
13188 error( "argument must be a scalar or vector" ); SWIG_fail;
13189 }
13190 temp1 = args(0).matrix_value();
13191 arg1 = &temp1( 0, 0 );
13192 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13193 }
13194 {
13195 if ( _n_dims( args(1) ) > 1 )
13196 {
13197 error( "argument must be a scalar or vector" ); SWIG_fail;
13198 }
13199 temp2 = args(1).matrix_value();
13200 arg2 = &temp2( 0, 0 );
13201 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13202 }
13203 {
13204 if ( _n_dims( args(2) ) > 2 )
13205 {
13206 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13207 }
13208 if ( _dim( args(2), 0 ) != Xlen )
13209 {
13210 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13211 }
13212 if ( _dim( args(2), 1 ) != Ylen )
13213 {
13214 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13215 }
13216 temp3 = args(2).matrix_value();
13217 arg3 = &temp3( 0, 0 );
13218 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13219 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13220 }
13221 ecode6 = SWIG_AsVal_int(args(3), &val6);
13222 if (!SWIG_IsOK(ecode6)) {
13223 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13224 }
13225 arg6 = static_cast< PLINT >(val6);
13226 {
13227 if ( _n_dims( args(4) ) > 1 )
13228 {
13229 error( "argument must be a scalar or vector" ); SWIG_fail;
13230 }
13231 temp7 = args(4).matrix_value();
13232 arg7 = &temp7( 0, 0 );
13233 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13234 }
13235 ecode9 = SWIG_AsVal_int(args(5), &val9);
13236 if (!SWIG_IsOK(ecode9)) {
13237 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13238 }
13239 arg9 = static_cast< PLINT >(val9);
13240 {
13241 if ( _n_dims( args(6) ) > 1 )
13242 {
13243 error( "argument must be a scalar or vector" ); SWIG_fail;
13244 }
13245 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13246 arg11 = new PLINT[Alen];
13247 temp10 = args(6).matrix_value();
13248 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13249 }
13250 {
13251 if ( _n_dims( args(7) ) > 1 )
13252 {
13253 error( "argument must be a scalar or vector" ); SWIG_fail;
13254 }
13255 if ( _dim( args(7), 0 ) != Alen )
13256 {
13257 error( "argument vectors must be same length" ); SWIG_fail;
13258 }
13259 temp12 = args(7).matrix_value();
13260 arg12 = new PLINT[Alen];
13261 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13262 }
13263 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);
13264 _outv = octave_value();
13265 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13266 {
13267
13268 }
13269 {
13270
13271 }
13272 {
13273
13274 }
13275 {
13276
13277 }
13278 {
13279 delete [] arg11;
13280 }
13281 {
13282 delete [] arg12;
13283 }
13284 return _out;
13285 fail:
13286 {
13287
13288 }
13289 {
13290
13291 }
13292 {
13293
13294 }
13295 {
13296
13297 }
13298 {
13299 delete [] arg11;
13300 }
13301 {
13302 delete [] arg12;
13303 }
13304 return octave_value_list();
13305 }
13306 catch(...) {
13307 {
13308
13309 }
13310 {
13311
13312 }
13313 {
13314
13315 }
13316 {
13317
13318 }
13319 {
13320 delete [] arg11;
13321 }
13322 {
13323 delete [] arg12;
13324 }
13325 throw;
13326 }
13327}
13328
13329
13331 PLFLT *arg1 = (PLFLT *) 0 ;
13332 PLINT arg2 ;
13333 PLINT arg3 ;
13334 PLFLT *arg4 = (PLFLT *) 0 ;
13335 PLFLT arg5 ;
13336 PLFLT arg6 ;
13337 PLFLT arg7 ;
13338 PLFLT arg8 ;
13339 PLFLT arg9 ;
13340 PLFLT arg10 ;
13341 PLINT arg11 ;
13342 PLFLT arg12 ;
13343 PLINT arg13 ;
13344 PLINT arg14 ;
13345 PLINT arg15 ;
13346 PLINT arg16 ;
13347 PLINT arg17 ;
13348 PLBOOL arg18 ;
13349 PLFLT *arg19 = (PLFLT *) 0 ;
13350 Matrix temp1 ;
13351 Matrix temp4 ;
13352 double val5 ;
13353 int ecode5 = 0 ;
13354 double val6 ;
13355 int ecode6 = 0 ;
13356 double val7 ;
13357 int ecode7 = 0 ;
13358 double val8 ;
13359 int ecode8 = 0 ;
13360 double val9 ;
13361 int ecode9 = 0 ;
13362 double val10 ;
13363 int ecode10 = 0 ;
13364 int val11 ;
13365 int ecode11 = 0 ;
13366 double val12 ;
13367 int ecode12 = 0 ;
13368 int val13 ;
13369 int ecode13 = 0 ;
13370 int val14 ;
13371 int ecode14 = 0 ;
13372 int val15 ;
13373 int ecode15 = 0 ;
13374 int val16 ;
13375 int ecode16 = 0 ;
13376 int val17 ;
13377 int ecode17 = 0 ;
13378 int val18 ;
13379 int ecode18 = 0 ;
13380 Matrix temp19 ;
13381 octave_value_list _out;
13382 octave_value_list *_outp=&_out;
13383 octave_value _outv;
13384
13385 try {
13386 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13387 SWIG_fail;
13388 }
13389 {
13390 if ( _n_dims( args(0) ) > 2 )
13391 {
13392 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13393 }
13394 temp1 = args(0).matrix_value();
13395 arg1 = &temp1( 0, 0 );
13396 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13397 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13398 }
13399 {
13400 if ( _n_dims( args(1) ) > 1 )
13401 {
13402 error( "argument must be a scalar or vector" ); SWIG_fail;
13403 }
13404 Alen = (PLINT) ( _dim( args(1), 0 ) );
13405 temp4 = args(1).matrix_value();
13406 arg4 = &temp4( 0, 0 );
13407 }
13408 ecode5 = SWIG_AsVal_double(args(2), &val5);
13409 if (!SWIG_IsOK(ecode5)) {
13410 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13411 }
13412 arg5 = static_cast< PLFLT >(val5);
13413 ecode6 = SWIG_AsVal_double(args(3), &val6);
13414 if (!SWIG_IsOK(ecode6)) {
13415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13416 }
13417 arg6 = static_cast< PLFLT >(val6);
13418 ecode7 = SWIG_AsVal_double(args(4), &val7);
13419 if (!SWIG_IsOK(ecode7)) {
13420 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13421 }
13422 arg7 = static_cast< PLFLT >(val7);
13423 ecode8 = SWIG_AsVal_double(args(5), &val8);
13424 if (!SWIG_IsOK(ecode8)) {
13425 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13426 }
13427 arg8 = static_cast< PLFLT >(val8);
13428 ecode9 = SWIG_AsVal_double(args(6), &val9);
13429 if (!SWIG_IsOK(ecode9)) {
13430 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13431 }
13432 arg9 = static_cast< PLFLT >(val9);
13433 ecode10 = SWIG_AsVal_double(args(7), &val10);
13434 if (!SWIG_IsOK(ecode10)) {
13435 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13436 }
13437 arg10 = static_cast< PLFLT >(val10);
13438 ecode11 = SWIG_AsVal_int(args(8), &val11);
13439 if (!SWIG_IsOK(ecode11)) {
13440 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13441 }
13442 arg11 = static_cast< PLINT >(val11);
13443 ecode12 = SWIG_AsVal_double(args(9), &val12);
13444 if (!SWIG_IsOK(ecode12)) {
13445 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13446 }
13447 arg12 = static_cast< PLFLT >(val12);
13448 ecode13 = SWIG_AsVal_int(args(10), &val13);
13449 if (!SWIG_IsOK(ecode13)) {
13450 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13451 }
13452 arg13 = static_cast< PLINT >(val13);
13453 ecode14 = SWIG_AsVal_int(args(11), &val14);
13454 if (!SWIG_IsOK(ecode14)) {
13455 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13456 }
13457 arg14 = static_cast< PLINT >(val14);
13458 ecode15 = SWIG_AsVal_int(args(12), &val15);
13459 if (!SWIG_IsOK(ecode15)) {
13460 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13461 }
13462 arg15 = static_cast< PLINT >(val15);
13463 ecode16 = SWIG_AsVal_int(args(13), &val16);
13464 if (!SWIG_IsOK(ecode16)) {
13465 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13466 }
13467 arg16 = static_cast< PLINT >(val16);
13468 ecode17 = SWIG_AsVal_int(args(14), &val17);
13469 if (!SWIG_IsOK(ecode17)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13471 }
13472 arg17 = static_cast< PLINT >(val17);
13473 ecode18 = SWIG_AsVal_int(args(15), &val18);
13474 if (!SWIG_IsOK(ecode18)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13476 }
13477 arg18 = static_cast< PLBOOL >(val18);
13478 {
13479 if ( _n_dims( args(16) ) > 1 )
13480 {
13481 error( "argument must be a scalar or vector" ); SWIG_fail;
13482 }
13483 if ( _dim( args(16), 0 ) != 6 )
13484 {
13485 error( "argument vectors must have length of 6" ); SWIG_fail;
13486 }
13487 temp19 = args(16).matrix_value();
13488 arg19 = &temp19( 0, 0 );
13489 }
13490 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);
13491 _outv = octave_value();
13492 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13493 {
13494
13495 }
13496 {
13497
13498 }
13499 {
13500
13501 }
13502 return _out;
13503 fail:
13504 {
13505
13506 }
13507 {
13508
13509 }
13510 {
13511
13512 }
13513 return octave_value_list();
13514 }
13515 catch(...) {
13516 {
13517
13518 }
13519 {
13520
13521 }
13522 {
13523
13524 }
13525 throw;
13526 }
13527}
13528
13529
13530SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13531 PLFLT *arg1 = (PLFLT *) 0 ;
13532 PLINT arg2 ;
13533 PLINT arg3 ;
13534 char *arg4 = (char *) 0 ;
13535 PLFLT arg5 ;
13536 PLFLT arg6 ;
13537 PLFLT arg7 ;
13538 PLFLT arg8 ;
13539 PLFLT arg9 ;
13540 PLFLT arg10 ;
13541 PLINT arg11 ;
13542 PLFLT arg12 ;
13543 PLINT arg13 ;
13544 PLINT arg14 ;
13545 PLINT arg15 ;
13546 PLINT arg16 ;
13547 PLINT arg17 ;
13548 PLBOOL arg18 ;
13549 PLFLT *arg19 = (PLFLT *) 0 ;
13550 PLFLT *arg20 = (PLFLT *) 0 ;
13551 Matrix temp1 ;
13552 int res4 ;
13553 char *buf4 = 0 ;
13554 int alloc4 = 0 ;
13555 double val5 ;
13556 int ecode5 = 0 ;
13557 double val6 ;
13558 int ecode6 = 0 ;
13559 double val7 ;
13560 int ecode7 = 0 ;
13561 double val8 ;
13562 int ecode8 = 0 ;
13563 double val9 ;
13564 int ecode9 = 0 ;
13565 double val10 ;
13566 int ecode10 = 0 ;
13567 int val11 ;
13568 int ecode11 = 0 ;
13569 double val12 ;
13570 int ecode12 = 0 ;
13571 int val13 ;
13572 int ecode13 = 0 ;
13573 int val14 ;
13574 int ecode14 = 0 ;
13575 int val15 ;
13576 int ecode15 = 0 ;
13577 int val16 ;
13578 int ecode16 = 0 ;
13579 int val17 ;
13580 int ecode17 = 0 ;
13581 int val18 ;
13582 int ecode18 = 0 ;
13583 Matrix temp19 ;
13584 Matrix temp20 ;
13585 octave_value_list _out;
13586 octave_value_list *_outp=&_out;
13587 octave_value _outv;
13588
13589 try {
13590 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13591 SWIG_fail;
13592 }
13593 {
13594 if ( _n_dims( args(0) ) > 2 )
13595 {
13596 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13597 }
13598 temp1 = args(0).matrix_value();
13599 arg1 = &temp1( 0, 0 );
13600 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13601 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13602 }
13603 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13604 if (!SWIG_IsOK(res4)) {
13605 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13606 }
13607 arg4 = reinterpret_cast< char * >(buf4);
13608 ecode5 = SWIG_AsVal_double(args(2), &val5);
13609 if (!SWIG_IsOK(ecode5)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13611 }
13612 arg5 = static_cast< PLFLT >(val5);
13613 ecode6 = SWIG_AsVal_double(args(3), &val6);
13614 if (!SWIG_IsOK(ecode6)) {
13615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13616 }
13617 arg6 = static_cast< PLFLT >(val6);
13618 ecode7 = SWIG_AsVal_double(args(4), &val7);
13619 if (!SWIG_IsOK(ecode7)) {
13620 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13621 }
13622 arg7 = static_cast< PLFLT >(val7);
13623 ecode8 = SWIG_AsVal_double(args(5), &val8);
13624 if (!SWIG_IsOK(ecode8)) {
13625 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13626 }
13627 arg8 = static_cast< PLFLT >(val8);
13628 ecode9 = SWIG_AsVal_double(args(6), &val9);
13629 if (!SWIG_IsOK(ecode9)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13631 }
13632 arg9 = static_cast< PLFLT >(val9);
13633 ecode10 = SWIG_AsVal_double(args(7), &val10);
13634 if (!SWIG_IsOK(ecode10)) {
13635 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13636 }
13637 arg10 = static_cast< PLFLT >(val10);
13638 ecode11 = SWIG_AsVal_int(args(8), &val11);
13639 if (!SWIG_IsOK(ecode11)) {
13640 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13641 }
13642 arg11 = static_cast< PLINT >(val11);
13643 ecode12 = SWIG_AsVal_double(args(9), &val12);
13644 if (!SWIG_IsOK(ecode12)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13646 }
13647 arg12 = static_cast< PLFLT >(val12);
13648 ecode13 = SWIG_AsVal_int(args(10), &val13);
13649 if (!SWIG_IsOK(ecode13)) {
13650 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13651 }
13652 arg13 = static_cast< PLINT >(val13);
13653 ecode14 = SWIG_AsVal_int(args(11), &val14);
13654 if (!SWIG_IsOK(ecode14)) {
13655 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13656 }
13657 arg14 = static_cast< PLINT >(val14);
13658 ecode15 = SWIG_AsVal_int(args(12), &val15);
13659 if (!SWIG_IsOK(ecode15)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13661 }
13662 arg15 = static_cast< PLINT >(val15);
13663 ecode16 = SWIG_AsVal_int(args(13), &val16);
13664 if (!SWIG_IsOK(ecode16)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13666 }
13667 arg16 = static_cast< PLINT >(val16);
13668 ecode17 = SWIG_AsVal_int(args(14), &val17);
13669 if (!SWIG_IsOK(ecode17)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13671 }
13672 arg17 = static_cast< PLINT >(val17);
13673 ecode18 = SWIG_AsVal_int(args(15), &val18);
13674 if (!SWIG_IsOK(ecode18)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13676 }
13677 arg18 = static_cast< PLBOOL >(val18);
13678 {
13679 if ( _n_dims( args(16) ) > 1 )
13680 {
13681 error( "argument must be a scalar or vector" ); SWIG_fail;
13682 }
13683 if ( _dim( args(16), 0 ) != Xlen )
13684 {
13685 error( "argument vectors must be same length" ); SWIG_fail;
13686 }
13687 temp19 = args(16).matrix_value();
13688 arg19 = &temp19( 0, 0 );
13689 }
13690 {
13691 if ( _n_dims( args(17) ) > 1 )
13692 {
13693 error( "argument must be a scalar or vector" ); SWIG_fail;
13694 }
13695 if ( _dim( args(17), 0 ) != Ylen )
13696 {
13697 error( "argument vectors must be same length" ); SWIG_fail;
13698 }
13699 temp20 = args(17).matrix_value();
13700 arg20 = &temp20( 0, 0 );
13701 }
13702 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);
13703 _outv = octave_value();
13704 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13705 {
13706
13707 }
13708 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13709 {
13710
13711 }
13712 {
13713
13714 }
13715 return _out;
13716 fail:
13717 {
13718
13719 }
13720 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13721 {
13722
13723 }
13724 {
13725
13726 }
13727 return octave_value_list();
13728 }
13729 catch(...) {
13730 {
13731
13732 }
13733 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13734 {
13735
13736 }
13737 {
13738
13739 }
13740 throw;
13741 }
13742}
13743
13744
13745SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13746 PLFLT *arg1 = (PLFLT *) 0 ;
13747 PLINT arg2 ;
13748 PLINT arg3 ;
13749 char *arg4 = (char *) 0 ;
13750 PLFLT arg5 ;
13751 PLFLT arg6 ;
13752 PLFLT arg7 ;
13753 PLFLT arg8 ;
13754 PLFLT arg9 ;
13755 PLFLT arg10 ;
13756 PLINT arg11 ;
13757 PLFLT arg12 ;
13758 PLINT arg13 ;
13759 PLINT arg14 ;
13760 PLINT arg15 ;
13761 PLINT arg16 ;
13762 PLINT arg17 ;
13763 PLBOOL arg18 ;
13764 PLFLT *arg19 = (PLFLT *) 0 ;
13765 PLFLT *arg20 = (PLFLT *) 0 ;
13766 Matrix temp1 ;
13767 int res4 ;
13768 char *buf4 = 0 ;
13769 int alloc4 = 0 ;
13770 double val5 ;
13771 int ecode5 = 0 ;
13772 double val6 ;
13773 int ecode6 = 0 ;
13774 double val7 ;
13775 int ecode7 = 0 ;
13776 double val8 ;
13777 int ecode8 = 0 ;
13778 double val9 ;
13779 int ecode9 = 0 ;
13780 double val10 ;
13781 int ecode10 = 0 ;
13782 int val11 ;
13783 int ecode11 = 0 ;
13784 double val12 ;
13785 int ecode12 = 0 ;
13786 int val13 ;
13787 int ecode13 = 0 ;
13788 int val14 ;
13789 int ecode14 = 0 ;
13790 int val15 ;
13791 int ecode15 = 0 ;
13792 int val16 ;
13793 int ecode16 = 0 ;
13794 int val17 ;
13795 int ecode17 = 0 ;
13796 int val18 ;
13797 int ecode18 = 0 ;
13798 Matrix temp19 ;
13799 Matrix temp20 ;
13800 octave_value_list _out;
13801 octave_value_list *_outp=&_out;
13802 octave_value _outv;
13803
13804 try {
13805 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13806 SWIG_fail;
13807 }
13808 {
13809 if ( _n_dims( args(0) ) > 2 )
13810 {
13811 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13812 }
13813 temp1 = args(0).matrix_value();
13814 arg1 = &temp1( 0, 0 );
13815 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13816 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13817 }
13818 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13819 if (!SWIG_IsOK(res4)) {
13820 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13821 }
13822 arg4 = reinterpret_cast< char * >(buf4);
13823 ecode5 = SWIG_AsVal_double(args(2), &val5);
13824 if (!SWIG_IsOK(ecode5)) {
13825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13826 }
13827 arg5 = static_cast< PLFLT >(val5);
13828 ecode6 = SWIG_AsVal_double(args(3), &val6);
13829 if (!SWIG_IsOK(ecode6)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13831 }
13832 arg6 = static_cast< PLFLT >(val6);
13833 ecode7 = SWIG_AsVal_double(args(4), &val7);
13834 if (!SWIG_IsOK(ecode7)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13836 }
13837 arg7 = static_cast< PLFLT >(val7);
13838 ecode8 = SWIG_AsVal_double(args(5), &val8);
13839 if (!SWIG_IsOK(ecode8)) {
13840 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13841 }
13842 arg8 = static_cast< PLFLT >(val8);
13843 ecode9 = SWIG_AsVal_double(args(6), &val9);
13844 if (!SWIG_IsOK(ecode9)) {
13845 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13846 }
13847 arg9 = static_cast< PLFLT >(val9);
13848 ecode10 = SWIG_AsVal_double(args(7), &val10);
13849 if (!SWIG_IsOK(ecode10)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13851 }
13852 arg10 = static_cast< PLFLT >(val10);
13853 ecode11 = SWIG_AsVal_int(args(8), &val11);
13854 if (!SWIG_IsOK(ecode11)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13856 }
13857 arg11 = static_cast< PLINT >(val11);
13858 ecode12 = SWIG_AsVal_double(args(9), &val12);
13859 if (!SWIG_IsOK(ecode12)) {
13860 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13861 }
13862 arg12 = static_cast< PLFLT >(val12);
13863 ecode13 = SWIG_AsVal_int(args(10), &val13);
13864 if (!SWIG_IsOK(ecode13)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13866 }
13867 arg13 = static_cast< PLINT >(val13);
13868 ecode14 = SWIG_AsVal_int(args(11), &val14);
13869 if (!SWIG_IsOK(ecode14)) {
13870 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13871 }
13872 arg14 = static_cast< PLINT >(val14);
13873 ecode15 = SWIG_AsVal_int(args(12), &val15);
13874 if (!SWIG_IsOK(ecode15)) {
13875 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13876 }
13877 arg15 = static_cast< PLINT >(val15);
13878 ecode16 = SWIG_AsVal_int(args(13), &val16);
13879 if (!SWIG_IsOK(ecode16)) {
13880 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13881 }
13882 arg16 = static_cast< PLINT >(val16);
13883 ecode17 = SWIG_AsVal_int(args(14), &val17);
13884 if (!SWIG_IsOK(ecode17)) {
13885 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13886 }
13887 arg17 = static_cast< PLINT >(val17);
13888 ecode18 = SWIG_AsVal_int(args(15), &val18);
13889 if (!SWIG_IsOK(ecode18)) {
13890 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13891 }
13892 arg18 = static_cast< PLBOOL >(val18);
13893 {
13894 if ( _n_dims( args(16) ) > 2 )
13895 {
13896 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13897 }
13898 temp19 = args(16).matrix_value();
13899 arg19 = &temp19( 0, 0 );
13900 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13901 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13902 }
13903 {
13904 if ( _n_dims( args(17) ) > 2 )
13905 {
13906 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13907 }
13908 temp20 = args(17).matrix_value();
13909 arg20 = &temp20( 0, 0 );
13910 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13911 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13912 }
13913 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);
13914 _outv = octave_value();
13915 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13916 {
13917
13918 }
13919 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13920 {
13921
13922 }
13923 {
13924
13925 }
13926 return _out;
13927 fail:
13928 {
13929
13930 }
13931 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13932 {
13933
13934 }
13935 {
13936
13937 }
13938 return octave_value_list();
13939 }
13940 catch(...) {
13941 {
13942
13943 }
13944 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13945 {
13946
13947 }
13948 {
13949
13950 }
13951 throw;
13952 }
13953}
13954
13955
13957 PLFLT *arg1 = (PLFLT *) 0 ;
13958 PLINT arg2 ;
13959 PLINT arg3 ;
13960 PLFLT arg4 ;
13961 PLFLT arg5 ;
13962 PLFLT arg6 ;
13963 PLFLT arg7 ;
13964 PLFLT *arg8 = (PLFLT *) 0 ;
13965 PLINT arg9 ;
13966 PLINT arg10 ;
13967 PLINT arg11 ;
13968 PLINT arg12 ;
13969 PLBOOL arg13 ;
13970 Matrix temp1 ;
13971 double val4 ;
13972 int ecode4 = 0 ;
13973 double val5 ;
13974 int ecode5 = 0 ;
13975 double val6 ;
13976 int ecode6 = 0 ;
13977 double val7 ;
13978 int ecode7 = 0 ;
13979 Matrix temp8 ;
13980 int val10 ;
13981 int ecode10 = 0 ;
13982 int val11 ;
13983 int ecode11 = 0 ;
13984 int val12 ;
13985 int ecode12 = 0 ;
13986 int val13 ;
13987 int ecode13 = 0 ;
13988 octave_value_list _out;
13989 octave_value_list *_outp=&_out;
13990 octave_value _outv;
13991
13992 try {
13993 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13994 SWIG_fail;
13995 }
13996 {
13997 if ( _n_dims( args(0) ) > 2 )
13998 {
13999 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14000 }
14001 temp1 = args(0).matrix_value();
14002 arg1 = &temp1( 0, 0 );
14003 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14004 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14005 }
14006 ecode4 = SWIG_AsVal_double(args(1), &val4);
14007 if (!SWIG_IsOK(ecode4)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14009 }
14010 arg4 = static_cast< PLFLT >(val4);
14011 ecode5 = SWIG_AsVal_double(args(2), &val5);
14012 if (!SWIG_IsOK(ecode5)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14014 }
14015 arg5 = static_cast< PLFLT >(val5);
14016 ecode6 = SWIG_AsVal_double(args(3), &val6);
14017 if (!SWIG_IsOK(ecode6)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14019 }
14020 arg6 = static_cast< PLFLT >(val6);
14021 ecode7 = SWIG_AsVal_double(args(4), &val7);
14022 if (!SWIG_IsOK(ecode7)) {
14023 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14024 }
14025 arg7 = static_cast< PLFLT >(val7);
14026 {
14027 if ( _n_dims( args(5) ) > 1 )
14028 {
14029 error( "argument must be a scalar or vector" ); SWIG_fail;
14030 }
14031 temp8 = args(5).matrix_value();
14032 arg8 = &temp8( 0, 0 );
14033 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14034 }
14035 ecode10 = SWIG_AsVal_int(args(6), &val10);
14036 if (!SWIG_IsOK(ecode10)) {
14037 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14038 }
14039 arg10 = static_cast< PLINT >(val10);
14040 ecode11 = SWIG_AsVal_int(args(7), &val11);
14041 if (!SWIG_IsOK(ecode11)) {
14042 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14043 }
14044 arg11 = static_cast< PLINT >(val11);
14045 ecode12 = SWIG_AsVal_int(args(8), &val12);
14046 if (!SWIG_IsOK(ecode12)) {
14047 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14048 }
14049 arg12 = static_cast< PLINT >(val12);
14050 ecode13 = SWIG_AsVal_int(args(9), &val13);
14051 if (!SWIG_IsOK(ecode13)) {
14052 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14053 }
14054 arg13 = static_cast< PLBOOL >(val13);
14055 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14056 _outv = octave_value();
14057 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14058 {
14059
14060 }
14061 {
14062
14063 }
14064 return _out;
14065 fail:
14066 {
14067
14068 }
14069 {
14070
14071 }
14072 return octave_value_list();
14073 }
14074 catch(...) {
14075 {
14076
14077 }
14078 {
14079
14080 }
14081 throw;
14082 }
14083}
14084
14085
14086SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14087 PLFLT *arg1 = (PLFLT *) 0 ;
14088 PLINT arg2 ;
14089 PLINT arg3 ;
14090 PLFLT arg4 ;
14091 PLFLT arg5 ;
14092 PLFLT arg6 ;
14093 PLFLT arg7 ;
14094 PLFLT *arg8 = (PLFLT *) 0 ;
14095 PLINT arg9 ;
14096 PLINT arg10 ;
14097 PLINT arg11 ;
14098 PLINT arg12 ;
14099 PLBOOL arg13 ;
14100 PLFLT *arg14 = (PLFLT *) 0 ;
14101 Matrix temp1 ;
14102 double val4 ;
14103 int ecode4 = 0 ;
14104 double val5 ;
14105 int ecode5 = 0 ;
14106 double val6 ;
14107 int ecode6 = 0 ;
14108 double val7 ;
14109 int ecode7 = 0 ;
14110 Matrix temp8 ;
14111 int val10 ;
14112 int ecode10 = 0 ;
14113 int val11 ;
14114 int ecode11 = 0 ;
14115 int val12 ;
14116 int ecode12 = 0 ;
14117 int val13 ;
14118 int ecode13 = 0 ;
14119 Matrix temp14 ;
14120 octave_value_list _out;
14121 octave_value_list *_outp=&_out;
14122 octave_value _outv;
14123
14124 try {
14125 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14126 SWIG_fail;
14127 }
14128 {
14129 if ( _n_dims( args(0) ) > 2 )
14130 {
14131 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14132 }
14133 temp1 = args(0).matrix_value();
14134 arg1 = &temp1( 0, 0 );
14135 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14136 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14137 }
14138 ecode4 = SWIG_AsVal_double(args(1), &val4);
14139 if (!SWIG_IsOK(ecode4)) {
14140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14141 }
14142 arg4 = static_cast< PLFLT >(val4);
14143 ecode5 = SWIG_AsVal_double(args(2), &val5);
14144 if (!SWIG_IsOK(ecode5)) {
14145 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14146 }
14147 arg5 = static_cast< PLFLT >(val5);
14148 ecode6 = SWIG_AsVal_double(args(3), &val6);
14149 if (!SWIG_IsOK(ecode6)) {
14150 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14151 }
14152 arg6 = static_cast< PLFLT >(val6);
14153 ecode7 = SWIG_AsVal_double(args(4), &val7);
14154 if (!SWIG_IsOK(ecode7)) {
14155 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14156 }
14157 arg7 = static_cast< PLFLT >(val7);
14158 {
14159 if ( _n_dims( args(5) ) > 1 )
14160 {
14161 error( "argument must be a scalar or vector" ); SWIG_fail;
14162 }
14163 temp8 = args(5).matrix_value();
14164 arg8 = &temp8( 0, 0 );
14165 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14166 }
14167 ecode10 = SWIG_AsVal_int(args(6), &val10);
14168 if (!SWIG_IsOK(ecode10)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14170 }
14171 arg10 = static_cast< PLINT >(val10);
14172 ecode11 = SWIG_AsVal_int(args(7), &val11);
14173 if (!SWIG_IsOK(ecode11)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14175 }
14176 arg11 = static_cast< PLINT >(val11);
14177 ecode12 = SWIG_AsVal_int(args(8), &val12);
14178 if (!SWIG_IsOK(ecode12)) {
14179 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14180 }
14181 arg12 = static_cast< PLINT >(val12);
14182 ecode13 = SWIG_AsVal_int(args(9), &val13);
14183 if (!SWIG_IsOK(ecode13)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14185 }
14186 arg13 = static_cast< PLBOOL >(val13);
14187 {
14188 if ( _n_dims( args(10) ) > 1 )
14189 {
14190 error( "argument must be a scalar or vector" ); SWIG_fail;
14191 }
14192 if ( _dim( args(10), 0 ) != 6 )
14193 {
14194 error( "argument vectors must have length of 6" ); SWIG_fail;
14195 }
14196 temp14 = args(10).matrix_value();
14197 arg14 = &temp14( 0, 0 );
14198 }
14199 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14200 _outv = octave_value();
14201 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14202 {
14203
14204 }
14205 {
14206
14207 }
14208 {
14209
14210 }
14211 return _out;
14212 fail:
14213 {
14214
14215 }
14216 {
14217
14218 }
14219 {
14220
14221 }
14222 return octave_value_list();
14223 }
14224 catch(...) {
14225 {
14226
14227 }
14228 {
14229
14230 }
14231 {
14232
14233 }
14234 throw;
14235 }
14236}
14237
14238
14239SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14240 PLFLT *arg1 = (PLFLT *) 0 ;
14241 PLINT arg2 ;
14242 PLINT arg3 ;
14243 PLFLT arg4 ;
14244 PLFLT arg5 ;
14245 PLFLT arg6 ;
14246 PLFLT arg7 ;
14247 PLFLT *arg8 = (PLFLT *) 0 ;
14248 PLINT arg9 ;
14249 PLINT arg10 ;
14250 PLINT arg11 ;
14251 PLINT arg12 ;
14252 PLBOOL arg13 ;
14253 PLFLT *arg14 = (PLFLT *) 0 ;
14254 PLFLT *arg15 = (PLFLT *) 0 ;
14255 Matrix temp1 ;
14256 double val4 ;
14257 int ecode4 = 0 ;
14258 double val5 ;
14259 int ecode5 = 0 ;
14260 double val6 ;
14261 int ecode6 = 0 ;
14262 double val7 ;
14263 int ecode7 = 0 ;
14264 Matrix temp8 ;
14265 int val10 ;
14266 int ecode10 = 0 ;
14267 int val11 ;
14268 int ecode11 = 0 ;
14269 int val12 ;
14270 int ecode12 = 0 ;
14271 int val13 ;
14272 int ecode13 = 0 ;
14273 Matrix temp14 ;
14274 Matrix temp15 ;
14275 octave_value_list _out;
14276 octave_value_list *_outp=&_out;
14277 octave_value _outv;
14278
14279 try {
14280 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14281 SWIG_fail;
14282 }
14283 {
14284 if ( _n_dims( args(0) ) > 2 )
14285 {
14286 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14287 }
14288 temp1 = args(0).matrix_value();
14289 arg1 = &temp1( 0, 0 );
14290 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14291 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14292 }
14293 ecode4 = SWIG_AsVal_double(args(1), &val4);
14294 if (!SWIG_IsOK(ecode4)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14296 }
14297 arg4 = static_cast< PLFLT >(val4);
14298 ecode5 = SWIG_AsVal_double(args(2), &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14301 }
14302 arg5 = static_cast< PLFLT >(val5);
14303 ecode6 = SWIG_AsVal_double(args(3), &val6);
14304 if (!SWIG_IsOK(ecode6)) {
14305 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14306 }
14307 arg6 = static_cast< PLFLT >(val6);
14308 ecode7 = SWIG_AsVal_double(args(4), &val7);
14309 if (!SWIG_IsOK(ecode7)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14311 }
14312 arg7 = static_cast< PLFLT >(val7);
14313 {
14314 if ( _n_dims( args(5) ) > 1 )
14315 {
14316 error( "argument must be a scalar or vector" ); SWIG_fail;
14317 }
14318 temp8 = args(5).matrix_value();
14319 arg8 = &temp8( 0, 0 );
14320 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14321 }
14322 ecode10 = SWIG_AsVal_int(args(6), &val10);
14323 if (!SWIG_IsOK(ecode10)) {
14324 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14325 }
14326 arg10 = static_cast< PLINT >(val10);
14327 ecode11 = SWIG_AsVal_int(args(7), &val11);
14328 if (!SWIG_IsOK(ecode11)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14330 }
14331 arg11 = static_cast< PLINT >(val11);
14332 ecode12 = SWIG_AsVal_int(args(8), &val12);
14333 if (!SWIG_IsOK(ecode12)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14335 }
14336 arg12 = static_cast< PLINT >(val12);
14337 ecode13 = SWIG_AsVal_int(args(9), &val13);
14338 if (!SWIG_IsOK(ecode13)) {
14339 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14340 }
14341 arg13 = static_cast< PLBOOL >(val13);
14342 {
14343 if ( _n_dims( args(10) ) > 1 )
14344 {
14345 error( "argument must be a scalar or vector" ); SWIG_fail;
14346 }
14347 if ( _dim( args(10), 0 ) != Xlen )
14348 {
14349 error( "argument vectors must be same length" ); SWIG_fail;
14350 }
14351 temp14 = args(10).matrix_value();
14352 arg14 = &temp14( 0, 0 );
14353 }
14354 {
14355 if ( _n_dims( args(11) ) > 1 )
14356 {
14357 error( "argument must be a scalar or vector" ); SWIG_fail;
14358 }
14359 if ( _dim( args(11), 0 ) != Ylen )
14360 {
14361 error( "argument vectors must be same length" ); SWIG_fail;
14362 }
14363 temp15 = args(11).matrix_value();
14364 arg15 = &temp15( 0, 0 );
14365 }
14366 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);
14367 _outv = octave_value();
14368 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14369 {
14370
14371 }
14372 {
14373
14374 }
14375 {
14376
14377 }
14378 {
14379
14380 }
14381 return _out;
14382 fail:
14383 {
14384
14385 }
14386 {
14387
14388 }
14389 {
14390
14391 }
14392 {
14393
14394 }
14395 return octave_value_list();
14396 }
14397 catch(...) {
14398 {
14399
14400 }
14401 {
14402
14403 }
14404 {
14405
14406 }
14407 {
14408
14409 }
14410 throw;
14411 }
14412}
14413
14414
14415SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14416 PLFLT *arg1 = (PLFLT *) 0 ;
14417 PLINT arg2 ;
14418 PLINT arg3 ;
14419 PLFLT arg4 ;
14420 PLFLT arg5 ;
14421 PLFLT arg6 ;
14422 PLFLT arg7 ;
14423 PLFLT *arg8 = (PLFLT *) 0 ;
14424 PLINT arg9 ;
14425 PLINT arg10 ;
14426 PLINT arg11 ;
14427 PLINT arg12 ;
14428 PLBOOL arg13 ;
14429 PLFLT *arg14 = (PLFLT *) 0 ;
14430 PLFLT *arg15 = (PLFLT *) 0 ;
14431 Matrix temp1 ;
14432 double val4 ;
14433 int ecode4 = 0 ;
14434 double val5 ;
14435 int ecode5 = 0 ;
14436 double val6 ;
14437 int ecode6 = 0 ;
14438 double val7 ;
14439 int ecode7 = 0 ;
14440 Matrix temp8 ;
14441 int val10 ;
14442 int ecode10 = 0 ;
14443 int val11 ;
14444 int ecode11 = 0 ;
14445 int val12 ;
14446 int ecode12 = 0 ;
14447 int val13 ;
14448 int ecode13 = 0 ;
14449 Matrix temp14 ;
14450 Matrix temp15 ;
14451 octave_value_list _out;
14452 octave_value_list *_outp=&_out;
14453 octave_value _outv;
14454
14455 try {
14456 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14457 SWIG_fail;
14458 }
14459 {
14460 if ( _n_dims( args(0) ) > 2 )
14461 {
14462 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14463 }
14464 temp1 = args(0).matrix_value();
14465 arg1 = &temp1( 0, 0 );
14466 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14467 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14468 }
14469 ecode4 = SWIG_AsVal_double(args(1), &val4);
14470 if (!SWIG_IsOK(ecode4)) {
14471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14472 }
14473 arg4 = static_cast< PLFLT >(val4);
14474 ecode5 = SWIG_AsVal_double(args(2), &val5);
14475 if (!SWIG_IsOK(ecode5)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14477 }
14478 arg5 = static_cast< PLFLT >(val5);
14479 ecode6 = SWIG_AsVal_double(args(3), &val6);
14480 if (!SWIG_IsOK(ecode6)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14482 }
14483 arg6 = static_cast< PLFLT >(val6);
14484 ecode7 = SWIG_AsVal_double(args(4), &val7);
14485 if (!SWIG_IsOK(ecode7)) {
14486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14487 }
14488 arg7 = static_cast< PLFLT >(val7);
14489 {
14490 if ( _n_dims( args(5) ) > 1 )
14491 {
14492 error( "argument must be a scalar or vector" ); SWIG_fail;
14493 }
14494 temp8 = args(5).matrix_value();
14495 arg8 = &temp8( 0, 0 );
14496 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14497 }
14498 ecode10 = SWIG_AsVal_int(args(6), &val10);
14499 if (!SWIG_IsOK(ecode10)) {
14500 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14501 }
14502 arg10 = static_cast< PLINT >(val10);
14503 ecode11 = SWIG_AsVal_int(args(7), &val11);
14504 if (!SWIG_IsOK(ecode11)) {
14505 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14506 }
14507 arg11 = static_cast< PLINT >(val11);
14508 ecode12 = SWIG_AsVal_int(args(8), &val12);
14509 if (!SWIG_IsOK(ecode12)) {
14510 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14511 }
14512 arg12 = static_cast< PLINT >(val12);
14513 ecode13 = SWIG_AsVal_int(args(9), &val13);
14514 if (!SWIG_IsOK(ecode13)) {
14515 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14516 }
14517 arg13 = static_cast< PLBOOL >(val13);
14518 {
14519 if ( _n_dims( args(10) ) > 2 )
14520 {
14521 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14522 }
14523 temp14 = args(10).matrix_value();
14524 arg14 = &temp14( 0, 0 );
14525 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14526 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14527 }
14528 {
14529 if ( _n_dims( args(11) ) > 2 )
14530 {
14531 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14532 }
14533 temp15 = args(11).matrix_value();
14534 arg15 = &temp15( 0, 0 );
14535 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14536 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14537 }
14538 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);
14539 _outv = octave_value();
14540 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14541 {
14542
14543 }
14544 {
14545
14546 }
14547 {
14548
14549 }
14550 {
14551
14552 }
14553 return _out;
14554 fail:
14555 {
14556
14557 }
14558 {
14559
14560 }
14561 {
14562
14563 }
14564 {
14565
14566 }
14567 return octave_value_list();
14568 }
14569 catch(...) {
14570 {
14571
14572 }
14573 {
14574
14575 }
14576 {
14577
14578 }
14579 {
14580
14581 }
14582 throw;
14583 }
14584}
14585
14586
14588 PLFLT *arg1 = (PLFLT *) 0 ;
14589 PLFLT *arg2 = (PLFLT *) 0 ;
14590 PLINT arg3 ;
14591 PLINT arg4 ;
14592 PLFLT arg5 ;
14593 PLFLT *arg6 = (PLFLT *) 0 ;
14594 Matrix temp1 ;
14595 Matrix temp2 ;
14596 double val5 ;
14597 int ecode5 = 0 ;
14598 Matrix temp6 ;
14599 octave_value_list _out;
14600 octave_value_list *_outp=&_out;
14601 octave_value _outv;
14602
14603 try {
14604 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14605 SWIG_fail;
14606 }
14607 {
14608 if ( _n_dims( args(0) ) > 2 )
14609 {
14610 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14611 }
14612 temp1 = args(0).matrix_value();
14613 arg1 = &temp1( 0, 0 );
14614 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14615 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14616 }
14617 {
14618 if ( _n_dims( args(1) ) > 2 )
14619 {
14620 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14621 }
14622 if ( _dim( args(1), 0 ) != Xlen )
14623 {
14624 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14625 }
14626 if ( _dim( args(1), 1 ) != Ylen )
14627 {
14628 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14629 }
14630 temp2 = args(1).matrix_value();
14631 arg2 = &temp2( 0, 0 );
14632 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14633 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14634 }
14635 ecode5 = SWIG_AsVal_double(args(2), &val5);
14636 if (!SWIG_IsOK(ecode5)) {
14637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14638 }
14639 arg5 = static_cast< PLFLT >(val5);
14640 {
14641 if ( _n_dims( args(3) ) > 1 )
14642 {
14643 error( "argument must be a scalar or vector" ); SWIG_fail;
14644 }
14645 if ( _dim( args(3), 0 ) != 6 )
14646 {
14647 error( "argument vectors must have length of 6" ); SWIG_fail;
14648 }
14649 temp6 = args(3).matrix_value();
14650 arg6 = &temp6( 0, 0 );
14651 }
14652 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14653 _outv = octave_value();
14654 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14655 {
14656
14657 }
14658 {
14659
14660 }
14661 {
14662
14663 }
14664 return _out;
14665 fail:
14666 {
14667
14668 }
14669 {
14670
14671 }
14672 {
14673
14674 }
14675 return octave_value_list();
14676 }
14677 catch(...) {
14678 {
14679
14680 }
14681 {
14682
14683 }
14684 {
14685
14686 }
14687 throw;
14688 }
14689}
14690
14691
14692SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14693 PLFLT *arg1 = (PLFLT *) 0 ;
14694 PLFLT *arg2 = (PLFLT *) 0 ;
14695 PLINT arg3 ;
14696 PLINT arg4 ;
14697 PLFLT arg5 ;
14698 PLFLT *arg6 = (PLFLT *) 0 ;
14699 PLFLT *arg7 = (PLFLT *) 0 ;
14700 Matrix temp1 ;
14701 Matrix temp2 ;
14702 double val5 ;
14703 int ecode5 = 0 ;
14704 Matrix temp6 ;
14705 Matrix temp7 ;
14706 octave_value_list _out;
14707 octave_value_list *_outp=&_out;
14708 octave_value _outv;
14709
14710 try {
14711 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14712 SWIG_fail;
14713 }
14714 {
14715 if ( _n_dims( args(0) ) > 2 )
14716 {
14717 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14718 }
14719 temp1 = args(0).matrix_value();
14720 arg1 = &temp1( 0, 0 );
14721 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14722 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14723 }
14724 {
14725 if ( _n_dims( args(1) ) > 2 )
14726 {
14727 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14728 }
14729 if ( _dim( args(1), 0 ) != Xlen )
14730 {
14731 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14732 }
14733 if ( _dim( args(1), 1 ) != Ylen )
14734 {
14735 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14736 }
14737 temp2 = args(1).matrix_value();
14738 arg2 = &temp2( 0, 0 );
14739 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14740 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14741 }
14742 ecode5 = SWIG_AsVal_double(args(2), &val5);
14743 if (!SWIG_IsOK(ecode5)) {
14744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14745 }
14746 arg5 = static_cast< PLFLT >(val5);
14747 {
14748 if ( _n_dims( args(3) ) > 1 )
14749 {
14750 error( "argument must be a scalar or vector" ); SWIG_fail;
14751 }
14752 if ( _dim( args(3), 0 ) != Xlen )
14753 {
14754 error( "argument vectors must be same length" ); SWIG_fail;
14755 }
14756 temp6 = args(3).matrix_value();
14757 arg6 = &temp6( 0, 0 );
14758 }
14759 {
14760 if ( _n_dims( args(4) ) > 1 )
14761 {
14762 error( "argument must be a scalar or vector" ); SWIG_fail;
14763 }
14764 if ( _dim( args(4), 0 ) != Ylen )
14765 {
14766 error( "argument vectors must be same length" ); SWIG_fail;
14767 }
14768 temp7 = args(4).matrix_value();
14769 arg7 = &temp7( 0, 0 );
14770 }
14771 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14772 _outv = octave_value();
14773 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14774 {
14775
14776 }
14777 {
14778
14779 }
14780 {
14781
14782 }
14783 {
14784
14785 }
14786 return _out;
14787 fail:
14788 {
14789
14790 }
14791 {
14792
14793 }
14794 {
14795
14796 }
14797 {
14798
14799 }
14800 return octave_value_list();
14801 }
14802 catch(...) {
14803 {
14804
14805 }
14806 {
14807
14808 }
14809 {
14810
14811 }
14812 {
14813
14814 }
14815 throw;
14816 }
14817}
14818
14819
14820SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14821 PLFLT *arg1 = (PLFLT *) 0 ;
14822 PLFLT *arg2 = (PLFLT *) 0 ;
14823 PLINT arg3 ;
14824 PLINT arg4 ;
14825 PLFLT arg5 ;
14826 PLFLT *arg6 = (PLFLT *) 0 ;
14827 PLFLT *arg7 = (PLFLT *) 0 ;
14828 Matrix temp1 ;
14829 Matrix temp2 ;
14830 double val5 ;
14831 int ecode5 = 0 ;
14832 Matrix temp6 ;
14833 Matrix temp7 ;
14834 octave_value_list _out;
14835 octave_value_list *_outp=&_out;
14836 octave_value _outv;
14837
14838 try {
14839 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14840 SWIG_fail;
14841 }
14842 {
14843 if ( _n_dims( args(0) ) > 2 )
14844 {
14845 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14846 }
14847 temp1 = args(0).matrix_value();
14848 arg1 = &temp1( 0, 0 );
14849 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14850 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14851 }
14852 {
14853 if ( _n_dims( args(1) ) > 2 )
14854 {
14855 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14856 }
14857 if ( _dim( args(1), 0 ) != Xlen )
14858 {
14859 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14860 }
14861 if ( _dim( args(1), 1 ) != Ylen )
14862 {
14863 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14864 }
14865 temp2 = args(1).matrix_value();
14866 arg2 = &temp2( 0, 0 );
14867 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14868 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14869 }
14870 ecode5 = SWIG_AsVal_double(args(2), &val5);
14871 if (!SWIG_IsOK(ecode5)) {
14872 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14873 }
14874 arg5 = static_cast< PLFLT >(val5);
14875 {
14876 if ( _n_dims( args(3) ) > 2 )
14877 {
14878 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14879 }
14880 temp6 = args(3).matrix_value();
14881 arg6 = &temp6( 0, 0 );
14882 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14883 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14884 }
14885 {
14886 if ( _n_dims( args(4) ) > 2 )
14887 {
14888 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14889 }
14890 temp7 = args(4).matrix_value();
14891 arg7 = &temp7( 0, 0 );
14892 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14893 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14894 }
14895 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14896 _outv = octave_value();
14897 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14898 {
14899
14900 }
14901 {
14902
14903 }
14904 {
14905
14906 }
14907 {
14908
14909 }
14910 return _out;
14911 fail:
14912 {
14913
14914 }
14915 {
14916
14917 }
14918 {
14919
14920 }
14921 {
14922
14923 }
14924 return octave_value_list();
14925 }
14926 catch(...) {
14927 {
14928
14929 }
14930 {
14931
14932 }
14933 {
14934
14935 }
14936 {
14937
14938 }
14939 throw;
14940 }
14941}
14942
14943
14944SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14945 PLFLT *arg1 = (PLFLT *) 0 ;
14946 PLINT arg2 ;
14947 PLINT arg3 ;
14948 PLFLT arg4 ;
14949 PLFLT arg5 ;
14950 PLFLT arg6 ;
14951 PLFLT arg7 ;
14952 PLFLT arg8 ;
14953 PLFLT arg9 ;
14954 PLFLT arg10 ;
14955 PLFLT arg11 ;
14956 PLFLT arg12 ;
14957 PLFLT arg13 ;
14958 Matrix temp1 ;
14959 double val4 ;
14960 int ecode4 = 0 ;
14961 double val5 ;
14962 int ecode5 = 0 ;
14963 double val6 ;
14964 int ecode6 = 0 ;
14965 double val7 ;
14966 int ecode7 = 0 ;
14967 double val8 ;
14968 int ecode8 = 0 ;
14969 double val9 ;
14970 int ecode9 = 0 ;
14971 double val10 ;
14972 int ecode10 = 0 ;
14973 double val11 ;
14974 int ecode11 = 0 ;
14975 double val12 ;
14976 int ecode12 = 0 ;
14977 double val13 ;
14978 int ecode13 = 0 ;
14979 octave_value_list _out;
14980 octave_value_list *_outp=&_out;
14981 octave_value _outv;
14982
14983 try {
14984 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14985 SWIG_fail;
14986 }
14987 {
14988 if ( _n_dims( args(0) ) > 2 )
14989 {
14990 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14991 }
14992 temp1 = args(0).matrix_value();
14993 arg1 = &temp1( 0, 0 );
14994 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14995 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14996 }
14997 ecode4 = SWIG_AsVal_double(args(1), &val4);
14998 if (!SWIG_IsOK(ecode4)) {
14999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15000 }
15001 arg4 = static_cast< PLFLT >(val4);
15002 ecode5 = SWIG_AsVal_double(args(2), &val5);
15003 if (!SWIG_IsOK(ecode5)) {
15004 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15005 }
15006 arg5 = static_cast< PLFLT >(val5);
15007 ecode6 = SWIG_AsVal_double(args(3), &val6);
15008 if (!SWIG_IsOK(ecode6)) {
15009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15010 }
15011 arg6 = static_cast< PLFLT >(val6);
15012 ecode7 = SWIG_AsVal_double(args(4), &val7);
15013 if (!SWIG_IsOK(ecode7)) {
15014 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15015 }
15016 arg7 = static_cast< PLFLT >(val7);
15017 ecode8 = SWIG_AsVal_double(args(5), &val8);
15018 if (!SWIG_IsOK(ecode8)) {
15019 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15020 }
15021 arg8 = static_cast< PLFLT >(val8);
15022 ecode9 = SWIG_AsVal_double(args(6), &val9);
15023 if (!SWIG_IsOK(ecode9)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15025 }
15026 arg9 = static_cast< PLFLT >(val9);
15027 ecode10 = SWIG_AsVal_double(args(7), &val10);
15028 if (!SWIG_IsOK(ecode10)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15030 }
15031 arg10 = static_cast< PLFLT >(val10);
15032 ecode11 = SWIG_AsVal_double(args(8), &val11);
15033 if (!SWIG_IsOK(ecode11)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15035 }
15036 arg11 = static_cast< PLFLT >(val11);
15037 ecode12 = SWIG_AsVal_double(args(9), &val12);
15038 if (!SWIG_IsOK(ecode12)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15040 }
15041 arg12 = static_cast< PLFLT >(val12);
15042 ecode13 = SWIG_AsVal_double(args(10), &val13);
15043 if (!SWIG_IsOK(ecode13)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15045 }
15046 arg13 = static_cast< PLFLT >(val13);
15047 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15048 _outv = octave_value();
15049 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15050 {
15051
15052 }
15053 return _out;
15054 fail:
15055 {
15056
15057 }
15058 return octave_value_list();
15059 }
15060 catch(...) {
15061 {
15062
15063 }
15064 throw;
15065 }
15066}
15067
15068
15070 PLFLT *arg1 = (PLFLT *) 0 ;
15071 PLINT arg2 ;
15072 PLINT arg3 ;
15073 PLFLT arg4 ;
15074 PLFLT arg5 ;
15075 PLFLT arg6 ;
15076 PLFLT arg7 ;
15077 PLFLT arg8 ;
15078 PLFLT arg9 ;
15079 PLFLT arg10 ;
15080 PLFLT arg11 ;
15081 Matrix temp1 ;
15082 double val4 ;
15083 int ecode4 = 0 ;
15084 double val5 ;
15085 int ecode5 = 0 ;
15086 double val6 ;
15087 int ecode6 = 0 ;
15088 double val7 ;
15089 int ecode7 = 0 ;
15090 double val8 ;
15091 int ecode8 = 0 ;
15092 double val9 ;
15093 int ecode9 = 0 ;
15094 double val10 ;
15095 int ecode10 = 0 ;
15096 double val11 ;
15097 int ecode11 = 0 ;
15098 octave_value_list _out;
15099 octave_value_list *_outp=&_out;
15100 octave_value _outv;
15101
15102 try {
15103 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15104 SWIG_fail;
15105 }
15106 {
15107 if ( _n_dims( args(0) ) > 2 )
15108 {
15109 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15110 }
15111 temp1 = args(0).matrix_value();
15112 arg1 = &temp1( 0, 0 );
15113 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15114 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15115 }
15116 ecode4 = SWIG_AsVal_double(args(1), &val4);
15117 if (!SWIG_IsOK(ecode4)) {
15118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15119 }
15120 arg4 = static_cast< PLFLT >(val4);
15121 ecode5 = SWIG_AsVal_double(args(2), &val5);
15122 if (!SWIG_IsOK(ecode5)) {
15123 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15124 }
15125 arg5 = static_cast< PLFLT >(val5);
15126 ecode6 = SWIG_AsVal_double(args(3), &val6);
15127 if (!SWIG_IsOK(ecode6)) {
15128 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15129 }
15130 arg6 = static_cast< PLFLT >(val6);
15131 ecode7 = SWIG_AsVal_double(args(4), &val7);
15132 if (!SWIG_IsOK(ecode7)) {
15133 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15134 }
15135 arg7 = static_cast< PLFLT >(val7);
15136 ecode8 = SWIG_AsVal_double(args(5), &val8);
15137 if (!SWIG_IsOK(ecode8)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15139 }
15140 arg8 = static_cast< PLFLT >(val8);
15141 ecode9 = SWIG_AsVal_double(args(6), &val9);
15142 if (!SWIG_IsOK(ecode9)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15144 }
15145 arg9 = static_cast< PLFLT >(val9);
15146 ecode10 = SWIG_AsVal_double(args(7), &val10);
15147 if (!SWIG_IsOK(ecode10)) {
15148 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15149 }
15150 arg10 = static_cast< PLFLT >(val10);
15151 ecode11 = SWIG_AsVal_double(args(8), &val11);
15152 if (!SWIG_IsOK(ecode11)) {
15153 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15154 }
15155 arg11 = static_cast< PLFLT >(val11);
15156 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15157 _outv = octave_value();
15158 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15159 {
15160
15161 }
15162 return _out;
15163 fail:
15164 {
15165
15166 }
15167 return octave_value_list();
15168 }
15169 catch(...) {
15170 {
15171
15172 }
15173 throw;
15174 }
15175}
15176
15177
15178SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15179 PLFLT *arg1 = (PLFLT *) 0 ;
15180 PLINT arg2 ;
15181 PLINT arg3 ;
15182 PLFLT arg4 ;
15183 PLFLT arg5 ;
15184 PLFLT arg6 ;
15185 PLFLT arg7 ;
15186 PLFLT arg8 ;
15187 PLFLT arg9 ;
15188 PLFLT arg10 ;
15189 PLFLT arg11 ;
15190 PLFLT *arg12 = (PLFLT *) 0 ;
15191 Matrix temp1 ;
15192 double val4 ;
15193 int ecode4 = 0 ;
15194 double val5 ;
15195 int ecode5 = 0 ;
15196 double val6 ;
15197 int ecode6 = 0 ;
15198 double val7 ;
15199 int ecode7 = 0 ;
15200 double val8 ;
15201 int ecode8 = 0 ;
15202 double val9 ;
15203 int ecode9 = 0 ;
15204 double val10 ;
15205 int ecode10 = 0 ;
15206 double val11 ;
15207 int ecode11 = 0 ;
15208 Matrix temp12 ;
15209 octave_value_list _out;
15210 octave_value_list *_outp=&_out;
15211 octave_value _outv;
15212
15213 try {
15214 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15215 SWIG_fail;
15216 }
15217 {
15218 if ( _n_dims( args(0) ) > 2 )
15219 {
15220 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15221 }
15222 temp1 = args(0).matrix_value();
15223 arg1 = &temp1( 0, 0 );
15224 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15225 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15226 }
15227 ecode4 = SWIG_AsVal_double(args(1), &val4);
15228 if (!SWIG_IsOK(ecode4)) {
15229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15230 }
15231 arg4 = static_cast< PLFLT >(val4);
15232 ecode5 = SWIG_AsVal_double(args(2), &val5);
15233 if (!SWIG_IsOK(ecode5)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15235 }
15236 arg5 = static_cast< PLFLT >(val5);
15237 ecode6 = SWIG_AsVal_double(args(3), &val6);
15238 if (!SWIG_IsOK(ecode6)) {
15239 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15240 }
15241 arg6 = static_cast< PLFLT >(val6);
15242 ecode7 = SWIG_AsVal_double(args(4), &val7);
15243 if (!SWIG_IsOK(ecode7)) {
15244 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15245 }
15246 arg7 = static_cast< PLFLT >(val7);
15247 ecode8 = SWIG_AsVal_double(args(5), &val8);
15248 if (!SWIG_IsOK(ecode8)) {
15249 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15250 }
15251 arg8 = static_cast< PLFLT >(val8);
15252 ecode9 = SWIG_AsVal_double(args(6), &val9);
15253 if (!SWIG_IsOK(ecode9)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15255 }
15256 arg9 = static_cast< PLFLT >(val9);
15257 ecode10 = SWIG_AsVal_double(args(7), &val10);
15258 if (!SWIG_IsOK(ecode10)) {
15259 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15260 }
15261 arg10 = static_cast< PLFLT >(val10);
15262 ecode11 = SWIG_AsVal_double(args(8), &val11);
15263 if (!SWIG_IsOK(ecode11)) {
15264 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15265 }
15266 arg11 = static_cast< PLFLT >(val11);
15267 {
15268 if ( _n_dims( args(9) ) > 1 )
15269 {
15270 error( "argument must be a scalar or vector" ); SWIG_fail;
15271 }
15272 if ( _dim( args(9), 0 ) != 6 )
15273 {
15274 error( "argument vectors must have length of 6" ); SWIG_fail;
15275 }
15276 temp12 = args(9).matrix_value();
15277 arg12 = &temp12( 0, 0 );
15278 }
15279 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15280 _outv = octave_value();
15281 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15282 {
15283
15284 }
15285 {
15286
15287 }
15288 return _out;
15289 fail:
15290 {
15291
15292 }
15293 {
15294
15295 }
15296 return octave_value_list();
15297 }
15298 catch(...) {
15299 {
15300
15301 }
15302 {
15303
15304 }
15305 throw;
15306 }
15307}
15308
15309
15310SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15311 PLFLT *arg1 = (PLFLT *) 0 ;
15312 PLINT arg2 ;
15313 PLINT arg3 ;
15314 PLFLT arg4 ;
15315 PLFLT arg5 ;
15316 PLFLT arg6 ;
15317 PLFLT arg7 ;
15318 PLFLT arg8 ;
15319 PLFLT arg9 ;
15320 PLFLT arg10 ;
15321 PLFLT arg11 ;
15322 PLFLT *arg12 = (PLFLT *) 0 ;
15323 PLFLT *arg13 = (PLFLT *) 0 ;
15324 Matrix temp1 ;
15325 double val4 ;
15326 int ecode4 = 0 ;
15327 double val5 ;
15328 int ecode5 = 0 ;
15329 double val6 ;
15330 int ecode6 = 0 ;
15331 double val7 ;
15332 int ecode7 = 0 ;
15333 double val8 ;
15334 int ecode8 = 0 ;
15335 double val9 ;
15336 int ecode9 = 0 ;
15337 double val10 ;
15338 int ecode10 = 0 ;
15339 double val11 ;
15340 int ecode11 = 0 ;
15341 Matrix temp12 ;
15342 Matrix temp13 ;
15343 octave_value_list _out;
15344 octave_value_list *_outp=&_out;
15345 octave_value _outv;
15346
15347 try {
15348 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15349 SWIG_fail;
15350 }
15351 {
15352 if ( _n_dims( args(0) ) > 2 )
15353 {
15354 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15355 }
15356 temp1 = args(0).matrix_value();
15357 arg1 = &temp1( 0, 0 );
15358 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15359 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15360 }
15361 ecode4 = SWIG_AsVal_double(args(1), &val4);
15362 if (!SWIG_IsOK(ecode4)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15364 }
15365 arg4 = static_cast< PLFLT >(val4);
15366 ecode5 = SWIG_AsVal_double(args(2), &val5);
15367 if (!SWIG_IsOK(ecode5)) {
15368 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15369 }
15370 arg5 = static_cast< PLFLT >(val5);
15371 ecode6 = SWIG_AsVal_double(args(3), &val6);
15372 if (!SWIG_IsOK(ecode6)) {
15373 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15374 }
15375 arg6 = static_cast< PLFLT >(val6);
15376 ecode7 = SWIG_AsVal_double(args(4), &val7);
15377 if (!SWIG_IsOK(ecode7)) {
15378 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15379 }
15380 arg7 = static_cast< PLFLT >(val7);
15381 ecode8 = SWIG_AsVal_double(args(5), &val8);
15382 if (!SWIG_IsOK(ecode8)) {
15383 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15384 }
15385 arg8 = static_cast< PLFLT >(val8);
15386 ecode9 = SWIG_AsVal_double(args(6), &val9);
15387 if (!SWIG_IsOK(ecode9)) {
15388 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15389 }
15390 arg9 = static_cast< PLFLT >(val9);
15391 ecode10 = SWIG_AsVal_double(args(7), &val10);
15392 if (!SWIG_IsOK(ecode10)) {
15393 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15394 }
15395 arg10 = static_cast< PLFLT >(val10);
15396 ecode11 = SWIG_AsVal_double(args(8), &val11);
15397 if (!SWIG_IsOK(ecode11)) {
15398 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15399 }
15400 arg11 = static_cast< PLFLT >(val11);
15401 {
15402 if ( _n_dims( args(9) ) > 1 )
15403 {
15404 error( "argument must be a scalar or vector" ); SWIG_fail;
15405 }
15406 if ( _dim( args(9), 0 ) != Xlen )
15407 {
15408 error( "argument vectors must be same length" ); SWIG_fail;
15409 }
15410 temp12 = args(9).matrix_value();
15411 arg12 = &temp12( 0, 0 );
15412 }
15413 {
15414 if ( _n_dims( args(10) ) > 1 )
15415 {
15416 error( "argument must be a scalar or vector" ); SWIG_fail;
15417 }
15418 if ( _dim( args(10), 0 ) != Ylen )
15419 {
15420 error( "argument vectors must be same length" ); SWIG_fail;
15421 }
15422 temp13 = args(10).matrix_value();
15423 arg13 = &temp13( 0, 0 );
15424 }
15425 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15426 _outv = octave_value();
15427 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15428 {
15429
15430 }
15431 {
15432
15433 }
15434 {
15435
15436 }
15437 return _out;
15438 fail:
15439 {
15440
15441 }
15442 {
15443
15444 }
15445 {
15446
15447 }
15448 return octave_value_list();
15449 }
15450 catch(...) {
15451 {
15452
15453 }
15454 {
15455
15456 }
15457 {
15458
15459 }
15460 throw;
15461 }
15462}
15463
15464
15465SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15466 PLFLT *arg1 = (PLFLT *) 0 ;
15467 PLINT arg2 ;
15468 PLINT arg3 ;
15469 PLFLT arg4 ;
15470 PLFLT arg5 ;
15471 PLFLT arg6 ;
15472 PLFLT arg7 ;
15473 PLFLT arg8 ;
15474 PLFLT arg9 ;
15475 PLFLT arg10 ;
15476 PLFLT arg11 ;
15477 PLFLT *arg12 = (PLFLT *) 0 ;
15478 PLFLT *arg13 = (PLFLT *) 0 ;
15479 Matrix temp1 ;
15480 double val4 ;
15481 int ecode4 = 0 ;
15482 double val5 ;
15483 int ecode5 = 0 ;
15484 double val6 ;
15485 int ecode6 = 0 ;
15486 double val7 ;
15487 int ecode7 = 0 ;
15488 double val8 ;
15489 int ecode8 = 0 ;
15490 double val9 ;
15491 int ecode9 = 0 ;
15492 double val10 ;
15493 int ecode10 = 0 ;
15494 double val11 ;
15495 int ecode11 = 0 ;
15496 Matrix temp12 ;
15497 Matrix temp13 ;
15498 octave_value_list _out;
15499 octave_value_list *_outp=&_out;
15500 octave_value _outv;
15501
15502 try {
15503 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15504 SWIG_fail;
15505 }
15506 {
15507 if ( _n_dims( args(0) ) > 2 )
15508 {
15509 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15510 }
15511 temp1 = args(0).matrix_value();
15512 arg1 = &temp1( 0, 0 );
15513 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15514 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15515 }
15516 ecode4 = SWIG_AsVal_double(args(1), &val4);
15517 if (!SWIG_IsOK(ecode4)) {
15518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15519 }
15520 arg4 = static_cast< PLFLT >(val4);
15521 ecode5 = SWIG_AsVal_double(args(2), &val5);
15522 if (!SWIG_IsOK(ecode5)) {
15523 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15524 }
15525 arg5 = static_cast< PLFLT >(val5);
15526 ecode6 = SWIG_AsVal_double(args(3), &val6);
15527 if (!SWIG_IsOK(ecode6)) {
15528 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15529 }
15530 arg6 = static_cast< PLFLT >(val6);
15531 ecode7 = SWIG_AsVal_double(args(4), &val7);
15532 if (!SWIG_IsOK(ecode7)) {
15533 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15534 }
15535 arg7 = static_cast< PLFLT >(val7);
15536 ecode8 = SWIG_AsVal_double(args(5), &val8);
15537 if (!SWIG_IsOK(ecode8)) {
15538 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15539 }
15540 arg8 = static_cast< PLFLT >(val8);
15541 ecode9 = SWIG_AsVal_double(args(6), &val9);
15542 if (!SWIG_IsOK(ecode9)) {
15543 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15544 }
15545 arg9 = static_cast< PLFLT >(val9);
15546 ecode10 = SWIG_AsVal_double(args(7), &val10);
15547 if (!SWIG_IsOK(ecode10)) {
15548 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15549 }
15550 arg10 = static_cast< PLFLT >(val10);
15551 ecode11 = SWIG_AsVal_double(args(8), &val11);
15552 if (!SWIG_IsOK(ecode11)) {
15553 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15554 }
15555 arg11 = static_cast< PLFLT >(val11);
15556 {
15557 if ( _n_dims( args(9) ) > 2 )
15558 {
15559 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15560 }
15561 temp12 = args(9).matrix_value();
15562 arg12 = &temp12( 0, 0 );
15563 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15564 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15565 }
15566 {
15567 if ( _n_dims( args(10) ) > 2 )
15568 {
15569 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15570 }
15571 temp13 = args(10).matrix_value();
15572 arg13 = &temp13( 0, 0 );
15573 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15574 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15575 }
15576 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15577 _outv = octave_value();
15578 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15579 {
15580
15581 }
15582 {
15583
15584 }
15585 {
15586
15587 }
15588 return _out;
15589 fail:
15590 {
15591
15592 }
15593 {
15594
15595 }
15596 {
15597
15598 }
15599 return octave_value_list();
15600 }
15601 catch(...) {
15602 {
15603
15604 }
15605 {
15606
15607 }
15608 {
15609
15610 }
15611 throw;
15612 }
15613}
15614
15615
15616SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15617 PLFLT *arg1 = (PLFLT *) 0 ;
15618 PLFLT *arg2 = (PLFLT *) 0 ;
15619 PLINT arg3 ;
15620 PLINT arg4 ;
15621 PLFLT arg5 ;
15622 PLFLT arg6 ;
15623 PLFLT arg7 ;
15624 PLFLT arg8 ;
15625 PLINT arg9 ;
15626 PLINT arg10 ;
15627 PLINT arg11 ;
15628 PLFLT arg12 ;
15629 PLFLT arg13 ;
15630 PLINT arg14 ;
15631 PLFLT arg15 ;
15632 PLINT arg16 ;
15633 PLINT *arg17 = (PLINT *) 0 ;
15634 char **arg18 = (char **) 0 ;
15635 PLINT arg19 ;
15636 char **arg20 = (char **) 0 ;
15637 PLFLT *arg21 = (PLFLT *) 0 ;
15638 PLINT *arg22 = (PLINT *) 0 ;
15639 PLINT *arg23 = (PLINT *) 0 ;
15640 PLFLT *arg24 = (PLFLT *) 0 ;
15641 PLFLT temp1 ;
15642 int res1 = SWIG_TMPOBJ ;
15643 PLFLT temp2 ;
15644 int res2 = SWIG_TMPOBJ ;
15645 int val3 ;
15646 int ecode3 = 0 ;
15647 int val4 ;
15648 int ecode4 = 0 ;
15649 double val5 ;
15650 int ecode5 = 0 ;
15651 double val6 ;
15652 int ecode6 = 0 ;
15653 double val7 ;
15654 int ecode7 = 0 ;
15655 double val8 ;
15656 int ecode8 = 0 ;
15657 int val9 ;
15658 int ecode9 = 0 ;
15659 int val10 ;
15660 int ecode10 = 0 ;
15661 int val11 ;
15662 int ecode11 = 0 ;
15663 double val12 ;
15664 int ecode12 = 0 ;
15665 double val13 ;
15666 int ecode13 = 0 ;
15667 int val14 ;
15668 int ecode14 = 0 ;
15669 double val15 ;
15670 int ecode15 = 0 ;
15671 Matrix temp16 ;
15672 Matrix temp21 ;
15673 Matrix temp22 ;
15674 Matrix temp23 ;
15675 Matrix temp24 ;
15676 octave_value_list _out;
15677 octave_value_list *_outp=&_out;
15678 octave_value _outv;
15679
15680 try {
15681 arg1 = &temp1;
15682 arg2 = &temp2;
15683 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15684 SWIG_fail;
15685 }
15686 ecode3 = SWIG_AsVal_int(args(0), &val3);
15687 if (!SWIG_IsOK(ecode3)) {
15688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15689 }
15690 arg3 = static_cast< PLINT >(val3);
15691 ecode4 = SWIG_AsVal_int(args(1), &val4);
15692 if (!SWIG_IsOK(ecode4)) {
15693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15694 }
15695 arg4 = static_cast< PLINT >(val4);
15696 ecode5 = SWIG_AsVal_double(args(2), &val5);
15697 if (!SWIG_IsOK(ecode5)) {
15698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15699 }
15700 arg5 = static_cast< PLFLT >(val5);
15701 ecode6 = SWIG_AsVal_double(args(3), &val6);
15702 if (!SWIG_IsOK(ecode6)) {
15703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15704 }
15705 arg6 = static_cast< PLFLT >(val6);
15706 ecode7 = SWIG_AsVal_double(args(4), &val7);
15707 if (!SWIG_IsOK(ecode7)) {
15708 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15709 }
15710 arg7 = static_cast< PLFLT >(val7);
15711 ecode8 = SWIG_AsVal_double(args(5), &val8);
15712 if (!SWIG_IsOK(ecode8)) {
15713 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15714 }
15715 arg8 = static_cast< PLFLT >(val8);
15716 ecode9 = SWIG_AsVal_int(args(6), &val9);
15717 if (!SWIG_IsOK(ecode9)) {
15718 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15719 }
15720 arg9 = static_cast< PLINT >(val9);
15721 ecode10 = SWIG_AsVal_int(args(7), &val10);
15722 if (!SWIG_IsOK(ecode10)) {
15723 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15724 }
15725 arg10 = static_cast< PLINT >(val10);
15726 ecode11 = SWIG_AsVal_int(args(8), &val11);
15727 if (!SWIG_IsOK(ecode11)) {
15728 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15729 }
15730 arg11 = static_cast< PLINT >(val11);
15731 ecode12 = SWIG_AsVal_double(args(9), &val12);
15732 if (!SWIG_IsOK(ecode12)) {
15733 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15734 }
15735 arg12 = static_cast< PLFLT >(val12);
15736 ecode13 = SWIG_AsVal_double(args(10), &val13);
15737 if (!SWIG_IsOK(ecode13)) {
15738 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15739 }
15740 arg13 = static_cast< PLFLT >(val13);
15741 ecode14 = SWIG_AsVal_int(args(11), &val14);
15742 if (!SWIG_IsOK(ecode14)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15744 }
15745 arg14 = static_cast< PLINT >(val14);
15746 ecode15 = SWIG_AsVal_double(args(12), &val15);
15747 if (!SWIG_IsOK(ecode15)) {
15748 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15749 }
15750 arg15 = static_cast< PLFLT >(val15);
15751 {
15752 if ( _n_dims( args(13) ) > 1 )
15753 {
15754 error( "argument must be a scalar or vector" ); SWIG_fail;
15755 }
15756 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15757 arg17 = new PLINT[Alen];
15758 temp16 = args(13).matrix_value();
15759 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15760 }
15761 {
15762 charMatrix temp_matrix;
15763 Cell temp_cell;
15764 char *tmp_cstring;
15765 std::string str;
15766 size_t max_length = 0, non_blank_length;
15767 int i, ifcell;
15768 if ( _n_dims( args(14) ) > 2 )
15769 {
15770 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15771 }
15772#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15773 if ( !args(14).isempty() )
15774#else
15775 if ( !args(14).is_empty() )
15776#endif
15777 {
15778 if ( _dim( args(14), 0 ) != Alen )
15779 {
15780 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15781 }
15782 arg18 = new char*[Alen];
15783#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15784 ifcell = args(14).iscell();
15785#else
15786 ifcell = args(14).is_cell();
15787#endif
15788 if ( ifcell )
15789 {
15790 temp_cell = args(14).cell_value();
15791 }
15792 else
15793 {
15794 temp_matrix = args(14).char_matrix_value();
15795 // Allow one extra space for null termination.
15796 max_length = _dim( args(14), 1 ) + 1;
15797 }
15798
15799 for ( i = 0; i < Alen; i++ )
15800 {
15801 // Must copy string to "permanent" location because the string
15802 // location corresponding to tmp_cstring gets
15803 // overwritten for each iteration of loop.
15804 if ( ifcell )
15805 {
15806 if ( temp_cell.elem( i ).is_string() )
15807 {
15808 str = temp_cell.elem( i ).string_value();
15809 // leave room for null termination.
15810 max_length = str.size() + 1;
15811 tmp_cstring = (char *) str.c_str();
15812 }
15813 else
15814 {
15815 // Use null string if user attempts to pass a cell array
15816 // with a non-string element (likely an empty element
15817 // since that should be allowed by the PLplot interface
15818 // if that element is going to be unused).
15819 // leave room for null termination.
15820 max_length = 1;
15821 tmp_cstring = (char *) "";
15822 }
15823 }
15824 else
15825 {
15826 str = temp_matrix.row_as_string( i );
15827 tmp_cstring = (char *) str.c_str();
15828 }
15829 arg18[i] = new char[max_length];
15830 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15831 arg18[i][max_length - 1] = '\0';
15832 // All the trailing blank crapola should not be needed for
15833 // string cell arrays.
15834 if ( !ifcell )
15835 {
15836 // remove trailing-blank padding that is used by the
15837 // charMatrix class to insure all strings in a given
15838 // charMatrix instance have the same length.
15839 // This transformation also removes legitimate trailing
15840 // blanks but there is nothing we can do about that
15841 // for the charMatrix class.
15842
15843 // Look for trailing nulls first (just in case, although that
15844 // shouldn't happen if charMatrix implemented as documented)
15845 // before looking for trailing blanks.
15846 non_blank_length = max_length - 2;
15847 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15848 {
15849 non_blank_length--;
15850 }
15851 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15852 {
15853 non_blank_length--;
15854 }
15855 arg18[i][non_blank_length + 1] = '\0';
15856 }
15857 }
15858 }
15859 else
15860 {
15861 arg18 = NULL;
15862 }
15863 }
15864 {
15865 charMatrix temp_matrix;
15866 Cell temp_cell;
15867 char *tmp_cstring;
15868 std::string str;
15869 size_t max_length = 0, non_blank_length;
15870 int i, ifcell;
15871 if ( _n_dims( args(15) ) > 2 )
15872 {
15873 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15874 }
15875#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15876 if ( !args(15).isempty() )
15877#else
15878 if ( !args(15).is_empty() )
15879#endif
15880 {
15881 Alen = _dim( args(15), 0 );
15882 arg19 = Alen;
15883 arg20 = new char*[Alen];
15884#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15885 ifcell = args(15).iscell();
15886#else
15887 ifcell = args(15).is_cell();
15888#endif
15889 if ( ifcell )
15890 {
15891 temp_cell = args(15).cell_value();
15892 }
15893 else
15894 {
15895 temp_matrix = args(15).char_matrix_value();
15896 // Allow one extra space for null termination.
15897 max_length = _dim( args(15), 1 ) + 1;
15898 }
15899
15900 for ( i = 0; i < Alen; i++ )
15901 {
15902 // Must copy string to "permanent" location because the string
15903 // location corresponding to tmp_cstring gets
15904 // overwritten for each iteration of loop.
15905 if ( ifcell )
15906 {
15907 if ( temp_cell.elem( i ).is_string() )
15908 {
15909 str = temp_cell.elem( i ).string_value();
15910 // leave room for null termination.
15911 max_length = str.size() + 1;
15912 tmp_cstring = (char *) str.c_str();
15913 }
15914 else
15915 {
15916 // Use null string if user attempts to pass a cell array
15917 // with a non-string element (likely an empty element
15918 // since that should be allowed by the PLplot interface
15919 // if that element is going to be unused).
15920 // leave room for null termination.
15921 max_length = 1;
15922 tmp_cstring = (char *) "";
15923 }
15924 }
15925 else
15926 {
15927 str = temp_matrix.row_as_string( i );
15928 tmp_cstring = (char *) str.c_str();
15929 }
15930 arg20[i] = new char[max_length];
15931 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15932 arg20[i][max_length - 1] = '\0';
15933 // All the trailing blank crapola should not be needed for
15934 // string cell arrays.
15935 if ( !ifcell )
15936 {
15937 // remove trailing-blank padding that is used by the
15938 // charMatrix class to insure all strings in a given
15939 // charMatrix instance have the same length.
15940 // This transformation also removes legitimate trailing
15941 // blanks but there is nothing we can do about that
15942 // for the charMatrix class.
15943
15944 // Look for trailing nulls first (just in case, although that
15945 // shouldn't happen if charMatrix implemented as documented)
15946 // before looking for trailing blanks.
15947 non_blank_length = max_length - 2;
15948 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15949 {
15950 non_blank_length--;
15951 }
15952 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15953 {
15954 non_blank_length--;
15955 }
15956 arg20[i][non_blank_length + 1] = '\0';
15957 }
15958 }
15959 }
15960 else
15961 {
15962 arg19 = 0;
15963 arg20 = NULL;
15964 }
15965 }
15966 {
15967 if ( _n_dims( args(16) ) > 1 )
15968 {
15969 error( "argument must be a scalar or vector" ); SWIG_fail;
15970 }
15971 if ( _dim( args(16), 0 ) != Alen )
15972 {
15973 error( "argument vectors must be same length" ); SWIG_fail;
15974 }
15975 temp21 = args(16).matrix_value();
15976 arg21 = &temp21( 0, 0 );
15977 }
15978 {
15979 if ( _n_dims( args(17) ) > 1 )
15980 {
15981 error( "argument must be a scalar or vector" ); SWIG_fail;
15982 }
15983 if ( _dim( args(17), 0 ) != Alen )
15984 {
15985 error( "argument vectors must be same length" ); SWIG_fail;
15986 }
15987 temp22 = args(17).matrix_value();
15988 arg22 = new PLINT[Alen];
15989 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15990 }
15991 {
15992 int i;
15993 if ( _n_dims( args(18) ) > 1 )
15994 {
15995 error( "argument must be a scalar or vector" ); SWIG_fail;
15996 }
15997 if ( _dim( args(18), 0 ) != Alen )
15998 {
15999 error( "argument vectors must be same length" ); SWIG_fail;
16000 }
16001 Xlen = Alen;
16002 temp23 = args(18).matrix_value();
16003 arg23 = new PLINT[Alen];
16004 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16005 Ylen = -1;
16006 for ( i = 0; i < Xlen; i++ )
16007 if ( arg23[i] > Ylen )
16008 Ylen = arg23[i];
16009 }
16010 {
16011 if ( _n_dims( args(19) ) > 2 )
16012 {
16013 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16014 }
16015 if ( _dim( args(19), 0 ) != Xlen )
16016 {
16017 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16018 }
16019 if ( _dim( args(19), 1 ) != Ylen )
16020 {
16021 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16022 }
16023 temp24 = args(19).matrix_value();
16024 arg24 = &temp24( 0, 0 );
16025 }
16026 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);
16027 _outv = octave_value();
16028 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16029 if (SWIG_IsTmpObj(res1)) {
16030 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16031 } else {
16032 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16033 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16034 }
16035 if (SWIG_IsTmpObj(res2)) {
16036 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16037 } else {
16038 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16039 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16040 }
16041 {
16042 delete [] arg17;
16043 }
16044 {
16045 int i;
16046 if ( arg18 != NULL )
16047 {
16048 for ( i = 0; i < Alen; i++ )
16049 {
16050 delete[] arg18[i];
16051 }
16052 delete[] arg18;
16053 }
16054 }
16055 {
16056 int i;
16057 if ( arg20 != NULL )
16058 {
16059 for ( i = 0; i < Alen; i++ )
16060 {
16061 delete[] arg20[i];
16062 }
16063 delete[] arg20;
16064 }
16065 }
16066 {
16067
16068 }
16069 {
16070 delete [] arg22;
16071 }
16072 {
16073 delete [] arg23;
16074 }
16075 {
16076
16077 }
16078 return _out;
16079 fail:
16080 {
16081 delete [] arg17;
16082 }
16083 {
16084 int i;
16085 if ( arg18 != NULL )
16086 {
16087 for ( i = 0; i < Alen; i++ )
16088 {
16089 delete[] arg18[i];
16090 }
16091 delete[] arg18;
16092 }
16093 }
16094 {
16095 int i;
16096 if ( arg20 != NULL )
16097 {
16098 for ( i = 0; i < Alen; i++ )
16099 {
16100 delete[] arg20[i];
16101 }
16102 delete[] arg20;
16103 }
16104 }
16105 {
16106
16107 }
16108 {
16109 delete [] arg22;
16110 }
16111 {
16112 delete [] arg23;
16113 }
16114 {
16115
16116 }
16117 return octave_value_list();
16118 }
16119 catch(...) {
16120 {
16121 delete [] arg17;
16122 }
16123 {
16124 int i;
16125 if ( arg18 != NULL )
16126 {
16127 for ( i = 0; i < Alen; i++ )
16128 {
16129 delete[] arg18[i];
16130 }
16131 delete[] arg18;
16132 }
16133 }
16134 {
16135 int i;
16136 if ( arg20 != NULL )
16137 {
16138 for ( i = 0; i < Alen; i++ )
16139 {
16140 delete[] arg20[i];
16141 }
16142 delete[] arg20;
16143 }
16144 }
16145 {
16146
16147 }
16148 {
16149 delete [] arg22;
16150 }
16151 {
16152 delete [] arg23;
16153 }
16154 {
16155
16156 }
16157 throw;
16158 }
16159}
16160
16161
16162SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16163 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16164 int arg2 ;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 int val2 ;
16168 int ecode2 = 0 ;
16169 octave_value_list _out;
16170 octave_value_list *_outp=&_out;
16171 octave_value _outv;
16172
16173 try {
16174 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16175 SWIG_fail;
16176 }
16177 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16178 if (!SWIG_IsOK(res1)) {
16179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16180 }
16181 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16182 ecode2 = SWIG_AsVal_int(args(1), &val2);
16183 if (!SWIG_IsOK(ecode2)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16185 }
16186 arg2 = static_cast< int >(val2);
16187 if (arg1) (arg1)->type = arg2;
16188 _outv = octave_value();
16189 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16190 return _out;
16191 fail:
16192 return octave_value_list();
16193 }
16194 catch(...) {
16195 throw;
16196 }
16197}
16198
16199
16200SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16201 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16202 void *argp1 = 0 ;
16203 int res1 = 0 ;
16204 octave_value_list _out;
16205 octave_value_list *_outp=&_out;
16206 octave_value _outv;
16207 int result;
16208
16209 try {
16210 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16211 SWIG_fail;
16212 }
16213 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16214 if (!SWIG_IsOK(res1)) {
16215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16216 }
16217 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16218 result = (int) ((arg1)->type);
16219 _outv = SWIG_From_int(static_cast< int >(result));
16220 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16221 return _out;
16222 fail:
16223 return octave_value_list();
16224 }
16225 catch(...) {
16226 throw;
16227 }
16228}
16229
16230
16231SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16232 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16233 unsigned int arg2 ;
16234 void *argp1 = 0 ;
16235 int res1 = 0 ;
16236 unsigned int val2 ;
16237 int ecode2 = 0 ;
16238 octave_value_list _out;
16239 octave_value_list *_outp=&_out;
16240 octave_value _outv;
16241
16242 try {
16243 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16244 SWIG_fail;
16245 }
16246 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16247 if (!SWIG_IsOK(res1)) {
16248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16249 }
16250 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16251 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16252 if (!SWIG_IsOK(ecode2)) {
16253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16254 }
16255 arg2 = static_cast< unsigned int >(val2);
16256 if (arg1) (arg1)->state = arg2;
16257 _outv = octave_value();
16258 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16259 return _out;
16260 fail:
16261 return octave_value_list();
16262 }
16263 catch(...) {
16264 throw;
16265 }
16266}
16267
16268
16269SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16270 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16271 void *argp1 = 0 ;
16272 int res1 = 0 ;
16273 octave_value_list _out;
16274 octave_value_list *_outp=&_out;
16275 octave_value _outv;
16276 unsigned int result;
16277
16278 try {
16279 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16280 SWIG_fail;
16281 }
16282 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16283 if (!SWIG_IsOK(res1)) {
16284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16285 }
16286 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16287 result = (unsigned int) ((arg1)->state);
16288 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16289 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16290 return _out;
16291 fail:
16292 return octave_value_list();
16293 }
16294 catch(...) {
16295 throw;
16296 }
16297}
16298
16299
16300SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16301 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16302 unsigned int arg2 ;
16303 void *argp1 = 0 ;
16304 int res1 = 0 ;
16305 unsigned int val2 ;
16306 int ecode2 = 0 ;
16307 octave_value_list _out;
16308 octave_value_list *_outp=&_out;
16309 octave_value _outv;
16310
16311 try {
16312 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16313 SWIG_fail;
16314 }
16315 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16316 if (!SWIG_IsOK(res1)) {
16317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16318 }
16319 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16320 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16321 if (!SWIG_IsOK(ecode2)) {
16322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16323 }
16324 arg2 = static_cast< unsigned int >(val2);
16325 if (arg1) (arg1)->keysym = arg2;
16326 _outv = octave_value();
16327 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16328 return _out;
16329 fail:
16330 return octave_value_list();
16331 }
16332 catch(...) {
16333 throw;
16334 }
16335}
16336
16337
16338SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16339 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16340 void *argp1 = 0 ;
16341 int res1 = 0 ;
16342 octave_value_list _out;
16343 octave_value_list *_outp=&_out;
16344 octave_value _outv;
16345 unsigned int result;
16346
16347 try {
16348 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16349 SWIG_fail;
16350 }
16351 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16354 }
16355 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16356 result = (unsigned int) ((arg1)->keysym);
16357 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16358 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16359 return _out;
16360 fail:
16361 return octave_value_list();
16362 }
16363 catch(...) {
16364 throw;
16365 }
16366}
16367
16368
16369SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16370 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16371 unsigned int arg2 ;
16372 void *argp1 = 0 ;
16373 int res1 = 0 ;
16374 unsigned int val2 ;
16375 int ecode2 = 0 ;
16376 octave_value_list _out;
16377 octave_value_list *_outp=&_out;
16378 octave_value _outv;
16379
16380 try {
16381 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16382 SWIG_fail;
16383 }
16384 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16387 }
16388 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16389 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16390 if (!SWIG_IsOK(ecode2)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16392 }
16393 arg2 = static_cast< unsigned int >(val2);
16394 if (arg1) (arg1)->button = arg2;
16395 _outv = octave_value();
16396 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16397 return _out;
16398 fail:
16399 return octave_value_list();
16400 }
16401 catch(...) {
16402 throw;
16403 }
16404}
16405
16406
16407SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16408 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16409 void *argp1 = 0 ;
16410 int res1 = 0 ;
16411 octave_value_list _out;
16412 octave_value_list *_outp=&_out;
16413 octave_value _outv;
16414 unsigned int result;
16415
16416 try {
16417 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16418 SWIG_fail;
16419 }
16420 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16421 if (!SWIG_IsOK(res1)) {
16422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16423 }
16424 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16425 result = (unsigned int) ((arg1)->button);
16426 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16427 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16428 return _out;
16429 fail:
16430 return octave_value_list();
16431 }
16432 catch(...) {
16433 throw;
16434 }
16435}
16436
16437
16438SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16439 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16440 PLINT arg2 ;
16441 void *argp1 = 0 ;
16442 int res1 = 0 ;
16443 int val2 ;
16444 int ecode2 = 0 ;
16445 octave_value_list _out;
16446 octave_value_list *_outp=&_out;
16447 octave_value _outv;
16448
16449 try {
16450 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16451 SWIG_fail;
16452 }
16453 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16456 }
16457 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16458 ecode2 = SWIG_AsVal_int(args(1), &val2);
16459 if (!SWIG_IsOK(ecode2)) {
16460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16461 }
16462 arg2 = static_cast< PLINT >(val2);
16463 if (arg1) (arg1)->subwindow = arg2;
16464 _outv = octave_value();
16465 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16466 return _out;
16467 fail:
16468 return octave_value_list();
16469 }
16470 catch(...) {
16471 throw;
16472 }
16473}
16474
16475
16476SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16477 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16478 void *argp1 = 0 ;
16479 int res1 = 0 ;
16480 octave_value_list _out;
16481 octave_value_list *_outp=&_out;
16482 octave_value _outv;
16483 PLINT result;
16484
16485 try {
16486 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16487 SWIG_fail;
16488 }
16489 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16490 if (!SWIG_IsOK(res1)) {
16491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16492 }
16493 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16494 result = (PLINT) ((arg1)->subwindow);
16495 _outv = SWIG_From_int(static_cast< int >(result));
16496 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16497 return _out;
16498 fail:
16499 return octave_value_list();
16500 }
16501 catch(...) {
16502 throw;
16503 }
16504}
16505
16506
16507SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16508 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16509 char *arg2 ;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 char temp2[16] ;
16513 int res2 ;
16514 octave_value_list _out;
16515 octave_value_list *_outp=&_out;
16516 octave_value _outv;
16517
16518 try {
16519 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16520 SWIG_fail;
16521 }
16522 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16525 }
16526 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16527 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16528 if (!SWIG_IsOK(res2)) {
16529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16530 }
16531 arg2 = reinterpret_cast< char * >(temp2);
16532 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16533 else memset(arg1->string,0,16*sizeof(char));
16534 _outv = octave_value();
16535 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16536 return _out;
16537 fail:
16538 return octave_value_list();
16539 }
16540 catch(...) {
16541 throw;
16542 }
16543}
16544
16545
16546SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16547 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16548 void *argp1 = 0 ;
16549 int res1 = 0 ;
16550 octave_value_list _out;
16551 octave_value_list *_outp=&_out;
16552 octave_value _outv;
16553 char *result = 0 ;
16554
16555 try {
16556 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16557 SWIG_fail;
16558 }
16559 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16560 if (!SWIG_IsOK(res1)) {
16561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16562 }
16563 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16564 result = (char *)(char *) ((arg1)->string);
16565 {
16566 size_t size = SWIG_strnlen(result, 16);
16567
16568
16569
16570 _outv = SWIG_FromCharPtrAndSize(result, size);
16571 }
16572 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16573 return _out;
16574 fail:
16575 return octave_value_list();
16576 }
16577 catch(...) {
16578 throw;
16579 }
16580}
16581
16582
16583SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16584 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16585 int arg2 ;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 int val2 ;
16589 int ecode2 = 0 ;
16590 octave_value_list _out;
16591 octave_value_list *_outp=&_out;
16592 octave_value _outv;
16593
16594 try {
16595 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16596 SWIG_fail;
16597 }
16598 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16601 }
16602 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16603 ecode2 = SWIG_AsVal_int(args(1), &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16606 }
16607 arg2 = static_cast< int >(val2);
16608 if (arg1) (arg1)->pX = arg2;
16609 _outv = octave_value();
16610 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16611 return _out;
16612 fail:
16613 return octave_value_list();
16614 }
16615 catch(...) {
16616 throw;
16617 }
16618}
16619
16620
16621SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16622 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16623 void *argp1 = 0 ;
16624 int res1 = 0 ;
16625 octave_value_list _out;
16626 octave_value_list *_outp=&_out;
16627 octave_value _outv;
16628 int result;
16629
16630 try {
16631 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16632 SWIG_fail;
16633 }
16634 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16635 if (!SWIG_IsOK(res1)) {
16636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16637 }
16638 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16639 result = (int) ((arg1)->pX);
16640 _outv = SWIG_From_int(static_cast< int >(result));
16641 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16642 return _out;
16643 fail:
16644 return octave_value_list();
16645 }
16646 catch(...) {
16647 throw;
16648 }
16649}
16650
16651
16652SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16653 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16654 int arg2 ;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 int val2 ;
16658 int ecode2 = 0 ;
16659 octave_value_list _out;
16660 octave_value_list *_outp=&_out;
16661 octave_value _outv;
16662
16663 try {
16664 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16665 SWIG_fail;
16666 }
16667 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16670 }
16671 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16672 ecode2 = SWIG_AsVal_int(args(1), &val2);
16673 if (!SWIG_IsOK(ecode2)) {
16674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16675 }
16676 arg2 = static_cast< int >(val2);
16677 if (arg1) (arg1)->pY = arg2;
16678 _outv = octave_value();
16679 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16680 return _out;
16681 fail:
16682 return octave_value_list();
16683 }
16684 catch(...) {
16685 throw;
16686 }
16687}
16688
16689
16690SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16691 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16692 void *argp1 = 0 ;
16693 int res1 = 0 ;
16694 octave_value_list _out;
16695 octave_value_list *_outp=&_out;
16696 octave_value _outv;
16697 int result;
16698
16699 try {
16700 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16701 SWIG_fail;
16702 }
16703 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16706 }
16707 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16708 result = (int) ((arg1)->pY);
16709 _outv = SWIG_From_int(static_cast< int >(result));
16710 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16711 return _out;
16712 fail:
16713 return octave_value_list();
16714 }
16715 catch(...) {
16716 throw;
16717 }
16718}
16719
16720
16721SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16722 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16723 PLFLT arg2 ;
16724 void *argp1 = 0 ;
16725 int res1 = 0 ;
16726 double val2 ;
16727 int ecode2 = 0 ;
16728 octave_value_list _out;
16729 octave_value_list *_outp=&_out;
16730 octave_value _outv;
16731
16732 try {
16733 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16734 SWIG_fail;
16735 }
16736 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16739 }
16740 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16741 ecode2 = SWIG_AsVal_double(args(1), &val2);
16742 if (!SWIG_IsOK(ecode2)) {
16743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16744 }
16745 arg2 = static_cast< PLFLT >(val2);
16746 if (arg1) (arg1)->dX = arg2;
16747 _outv = octave_value();
16748 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16749 return _out;
16750 fail:
16751 return octave_value_list();
16752 }
16753 catch(...) {
16754 throw;
16755 }
16756}
16757
16758
16759SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16760 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16761 void *argp1 = 0 ;
16762 int res1 = 0 ;
16763 octave_value_list _out;
16764 octave_value_list *_outp=&_out;
16765 octave_value _outv;
16766 PLFLT result;
16767
16768 try {
16769 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16770 SWIG_fail;
16771 }
16772 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16775 }
16776 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16777 result = (PLFLT) ((arg1)->dX);
16778 _outv = SWIG_From_double(static_cast< double >(result));
16779 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16780 return _out;
16781 fail:
16782 return octave_value_list();
16783 }
16784 catch(...) {
16785 throw;
16786 }
16787}
16788
16789
16790SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16791 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16792 PLFLT arg2 ;
16793 void *argp1 = 0 ;
16794 int res1 = 0 ;
16795 double val2 ;
16796 int ecode2 = 0 ;
16797 octave_value_list _out;
16798 octave_value_list *_outp=&_out;
16799 octave_value _outv;
16800
16801 try {
16802 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16803 SWIG_fail;
16804 }
16805 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16806 if (!SWIG_IsOK(res1)) {
16807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16808 }
16809 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16810 ecode2 = SWIG_AsVal_double(args(1), &val2);
16811 if (!SWIG_IsOK(ecode2)) {
16812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16813 }
16814 arg2 = static_cast< PLFLT >(val2);
16815 if (arg1) (arg1)->dY = arg2;
16816 _outv = octave_value();
16817 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16818 return _out;
16819 fail:
16820 return octave_value_list();
16821 }
16822 catch(...) {
16823 throw;
16824 }
16825}
16826
16827
16828SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16829 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16830 void *argp1 = 0 ;
16831 int res1 = 0 ;
16832 octave_value_list _out;
16833 octave_value_list *_outp=&_out;
16834 octave_value _outv;
16835 PLFLT result;
16836
16837 try {
16838 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16839 SWIG_fail;
16840 }
16841 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16842 if (!SWIG_IsOK(res1)) {
16843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16844 }
16845 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16846 result = (PLFLT) ((arg1)->dY);
16847 _outv = SWIG_From_double(static_cast< double >(result));
16848 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16849 return _out;
16850 fail:
16851 return octave_value_list();
16852 }
16853 catch(...) {
16854 throw;
16855 }
16856}
16857
16858
16859SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16860 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16861 PLFLT arg2 ;
16862 void *argp1 = 0 ;
16863 int res1 = 0 ;
16864 double val2 ;
16865 int ecode2 = 0 ;
16866 octave_value_list _out;
16867 octave_value_list *_outp=&_out;
16868 octave_value _outv;
16869
16870 try {
16871 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16872 SWIG_fail;
16873 }
16874 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16875 if (!SWIG_IsOK(res1)) {
16876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16877 }
16878 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16879 ecode2 = SWIG_AsVal_double(args(1), &val2);
16880 if (!SWIG_IsOK(ecode2)) {
16881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16882 }
16883 arg2 = static_cast< PLFLT >(val2);
16884 if (arg1) (arg1)->wX = arg2;
16885 _outv = octave_value();
16886 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16887 return _out;
16888 fail:
16889 return octave_value_list();
16890 }
16891 catch(...) {
16892 throw;
16893 }
16894}
16895
16896
16897SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16898 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 octave_value_list _out;
16902 octave_value_list *_outp=&_out;
16903 octave_value _outv;
16904 PLFLT result;
16905
16906 try {
16907 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16908 SWIG_fail;
16909 }
16910 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16913 }
16914 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16915 result = (PLFLT) ((arg1)->wX);
16916 _outv = SWIG_From_double(static_cast< double >(result));
16917 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16918 return _out;
16919 fail:
16920 return octave_value_list();
16921 }
16922 catch(...) {
16923 throw;
16924 }
16925}
16926
16927
16928SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16929 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16930 PLFLT arg2 ;
16931 void *argp1 = 0 ;
16932 int res1 = 0 ;
16933 double val2 ;
16934 int ecode2 = 0 ;
16935 octave_value_list _out;
16936 octave_value_list *_outp=&_out;
16937 octave_value _outv;
16938
16939 try {
16940 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16941 SWIG_fail;
16942 }
16943 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16946 }
16947 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16948 ecode2 = SWIG_AsVal_double(args(1), &val2);
16949 if (!SWIG_IsOK(ecode2)) {
16950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16951 }
16952 arg2 = static_cast< PLFLT >(val2);
16953 if (arg1) (arg1)->wY = arg2;
16954 _outv = octave_value();
16955 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16956 return _out;
16957 fail:
16958 return octave_value_list();
16959 }
16960 catch(...) {
16961 throw;
16962 }
16963}
16964
16965
16966SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16967 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16968 void *argp1 = 0 ;
16969 int res1 = 0 ;
16970 octave_value_list _out;
16971 octave_value_list *_outp=&_out;
16972 octave_value _outv;
16973 PLFLT result;
16974
16975 try {
16976 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16977 SWIG_fail;
16978 }
16979 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16982 }
16983 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16984 result = (PLFLT) ((arg1)->wY);
16985 _outv = SWIG_From_double(static_cast< double >(result));
16986 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16987 return _out;
16988 fail:
16989 return octave_value_list();
16990 }
16991 catch(...) {
16992 throw;
16993 }
16994}
16995
16996
16997SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16998 octave_value_list _out;
16999 octave_value_list *_outp=&_out;
17000 octave_value _outv;
17001 PLGraphicsIn *result = 0 ;
17002
17003 try {
17004 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17005 SWIG_fail;
17006 }
17007 result = (PLGraphicsIn *)new PLGraphicsIn();
17009 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17010 return _out;
17011 fail:
17012 return octave_value_list();
17013 }
17014 catch(...) {
17015 throw;
17016 }
17017}
17018
17019
17020SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17021 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17022 void *argp1 = 0 ;
17023 int res1 = 0 ;
17024 octave_value_list _out;
17025 octave_value_list *_outp=&_out;
17026 octave_value _outv;
17027
17028 try {
17029 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17030 SWIG_fail;
17031 }
17032 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17033 if (!SWIG_IsOK(res1)) {
17034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17035 }
17036 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17037 delete arg1;
17038 _outv = octave_value();
17039 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17040 return _out;
17041 fail:
17042 return octave_value_list();
17043 }
17044 catch(...) {
17045 throw;
17046 }
17047}
17048
17049
17063{0,0,0,0,0,0}
17064};
17065static const char *swig_PLGraphicsIn_base_names[] = {0};
17068
17070 PLINT arg1 ;
17071 PLINT arg2 ;
17072 int val1 ;
17073 int ecode1 = 0 ;
17074 int val2 ;
17075 int ecode2 = 0 ;
17076 octave_value_list _out;
17077 octave_value_list *_outp=&_out;
17078 octave_value _outv;
17079
17080 try {
17081 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17082 SWIG_fail;
17083 }
17084 ecode1 = SWIG_AsVal_int(args(0), &val1);
17085 if (!SWIG_IsOK(ecode1)) {
17086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17087 }
17088 arg1 = static_cast< PLINT >(val1);
17089 ecode2 = SWIG_AsVal_int(args(1), &val2);
17090 if (!SWIG_IsOK(ecode2)) {
17091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17092 }
17093 arg2 = static_cast< PLINT >(val2);
17094 pl_setcontlabelformat(arg1,arg2);
17095 _outv = octave_value();
17096 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17097 return _out;
17098 fail:
17099 return octave_value_list();
17100 }
17101 catch(...) {
17102 throw;
17103 }
17104}
17105
17106
17108 PLFLT arg1 ;
17109 PLFLT arg2 ;
17110 PLFLT arg3 ;
17111 PLINT arg4 ;
17112 double val1 ;
17113 int ecode1 = 0 ;
17114 double val2 ;
17115 int ecode2 = 0 ;
17116 double val3 ;
17117 int ecode3 = 0 ;
17118 int val4 ;
17119 int ecode4 = 0 ;
17120 octave_value_list _out;
17121 octave_value_list *_outp=&_out;
17122 octave_value _outv;
17123
17124 try {
17125 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17126 SWIG_fail;
17127 }
17128 ecode1 = SWIG_AsVal_double(args(0), &val1);
17129 if (!SWIG_IsOK(ecode1)) {
17130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17131 }
17132 arg1 = static_cast< PLFLT >(val1);
17133 ecode2 = SWIG_AsVal_double(args(1), &val2);
17134 if (!SWIG_IsOK(ecode2)) {
17135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17136 }
17137 arg2 = static_cast< PLFLT >(val2);
17138 ecode3 = SWIG_AsVal_double(args(2), &val3);
17139 if (!SWIG_IsOK(ecode3)) {
17140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17141 }
17142 arg3 = static_cast< PLFLT >(val3);
17143 ecode4 = SWIG_AsVal_int(args(3), &val4);
17144 if (!SWIG_IsOK(ecode4)) {
17145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17146 }
17147 arg4 = static_cast< PLINT >(val4);
17148 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17149 _outv = octave_value();
17150 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17151 return _out;
17152 fail:
17153 return octave_value_list();
17154 }
17155 catch(...) {
17156 throw;
17157 }
17158}
17159
17160
17162 PLINT arg1 ;
17163 int val1 ;
17164 int ecode1 = 0 ;
17165 octave_value_list _out;
17166 octave_value_list *_outp=&_out;
17167 octave_value _outv;
17168
17169 try {
17170 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17171 SWIG_fail;
17172 }
17173 ecode1 = SWIG_AsVal_int(args(0), &val1);
17174 if (!SWIG_IsOK(ecode1)) {
17175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17176 }
17177 arg1 = static_cast< PLINT >(val1);
17178 pladv(arg1);
17179 _outv = octave_value();
17180 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17181 return _out;
17182 fail:
17183 return octave_value_list();
17184 }
17185 catch(...) {
17186 throw;
17187 }
17188}
17189
17190
17192 PLFLT arg1 ;
17193 PLFLT arg2 ;
17194 PLFLT arg3 ;
17195 PLFLT arg4 ;
17196 PLFLT arg5 ;
17197 PLFLT arg6 ;
17198 PLFLT arg7 ;
17199 PLBOOL arg8 ;
17200 double val1 ;
17201 int ecode1 = 0 ;
17202 double val2 ;
17203 int ecode2 = 0 ;
17204 double val3 ;
17205 int ecode3 = 0 ;
17206 double val4 ;
17207 int ecode4 = 0 ;
17208 double val5 ;
17209 int ecode5 = 0 ;
17210 double val6 ;
17211 int ecode6 = 0 ;
17212 double val7 ;
17213 int ecode7 = 0 ;
17214 int val8 ;
17215 int ecode8 = 0 ;
17216 octave_value_list _out;
17217 octave_value_list *_outp=&_out;
17218 octave_value _outv;
17219
17220 try {
17221 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17222 SWIG_fail;
17223 }
17224 ecode1 = SWIG_AsVal_double(args(0), &val1);
17225 if (!SWIG_IsOK(ecode1)) {
17226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17227 }
17228 arg1 = static_cast< PLFLT >(val1);
17229 ecode2 = SWIG_AsVal_double(args(1), &val2);
17230 if (!SWIG_IsOK(ecode2)) {
17231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17232 }
17233 arg2 = static_cast< PLFLT >(val2);
17234 ecode3 = SWIG_AsVal_double(args(2), &val3);
17235 if (!SWIG_IsOK(ecode3)) {
17236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17237 }
17238 arg3 = static_cast< PLFLT >(val3);
17239 ecode4 = SWIG_AsVal_double(args(3), &val4);
17240 if (!SWIG_IsOK(ecode4)) {
17241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17242 }
17243 arg4 = static_cast< PLFLT >(val4);
17244 ecode5 = SWIG_AsVal_double(args(4), &val5);
17245 if (!SWIG_IsOK(ecode5)) {
17246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17247 }
17248 arg5 = static_cast< PLFLT >(val5);
17249 ecode6 = SWIG_AsVal_double(args(5), &val6);
17250 if (!SWIG_IsOK(ecode6)) {
17251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17252 }
17253 arg6 = static_cast< PLFLT >(val6);
17254 ecode7 = SWIG_AsVal_double(args(6), &val7);
17255 if (!SWIG_IsOK(ecode7)) {
17256 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17257 }
17258 arg7 = static_cast< PLFLT >(val7);
17259 ecode8 = SWIG_AsVal_int(args(7), &val8);
17260 if (!SWIG_IsOK(ecode8)) {
17261 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17262 }
17263 arg8 = static_cast< PLBOOL >(val8);
17264 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17265 _outv = octave_value();
17266 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17267 return _out;
17268 fail:
17269 return octave_value_list();
17270 }
17271 catch(...) {
17272 throw;
17273 }
17274}
17275
17276
17278 PLFLT arg1 ;
17279 PLFLT arg2 ;
17280 char *arg3 = (char *) 0 ;
17281 PLFLT arg4 ;
17282 PLINT arg5 ;
17283 char *arg6 = (char *) 0 ;
17284 PLFLT arg7 ;
17285 PLINT arg8 ;
17286 double val1 ;
17287 int ecode1 = 0 ;
17288 double val2 ;
17289 int ecode2 = 0 ;
17290 int res3 ;
17291 char *buf3 = 0 ;
17292 int alloc3 = 0 ;
17293 double val4 ;
17294 int ecode4 = 0 ;
17295 int val5 ;
17296 int ecode5 = 0 ;
17297 int res6 ;
17298 char *buf6 = 0 ;
17299 int alloc6 = 0 ;
17300 double val7 ;
17301 int ecode7 = 0 ;
17302 int val8 ;
17303 int ecode8 = 0 ;
17304 octave_value_list _out;
17305 octave_value_list *_outp=&_out;
17306 octave_value _outv;
17307
17308 try {
17309 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17310 SWIG_fail;
17311 }
17312 ecode1 = SWIG_AsVal_double(args(0), &val1);
17313 if (!SWIG_IsOK(ecode1)) {
17314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17315 }
17316 arg1 = static_cast< PLFLT >(val1);
17317 ecode2 = SWIG_AsVal_double(args(1), &val2);
17318 if (!SWIG_IsOK(ecode2)) {
17319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17320 }
17321 arg2 = static_cast< PLFLT >(val2);
17322 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17323 if (!SWIG_IsOK(res3)) {
17324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17325 }
17326 arg3 = reinterpret_cast< char * >(buf3);
17327 ecode4 = SWIG_AsVal_double(args(3), &val4);
17328 if (!SWIG_IsOK(ecode4)) {
17329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17330 }
17331 arg4 = static_cast< PLFLT >(val4);
17332 ecode5 = SWIG_AsVal_int(args(4), &val5);
17333 if (!SWIG_IsOK(ecode5)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17335 }
17336 arg5 = static_cast< PLINT >(val5);
17337 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17338 if (!SWIG_IsOK(res6)) {
17339 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17340 }
17341 arg6 = reinterpret_cast< char * >(buf6);
17342 ecode7 = SWIG_AsVal_double(args(6), &val7);
17343 if (!SWIG_IsOK(ecode7)) {
17344 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17345 }
17346 arg7 = static_cast< PLFLT >(val7);
17347 ecode8 = SWIG_AsVal_int(args(7), &val8);
17348 if (!SWIG_IsOK(ecode8)) {
17349 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17350 }
17351 arg8 = static_cast< PLINT >(val8);
17352 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17353 _outv = octave_value();
17354 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17355 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17356 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17357 return _out;
17358 fail:
17359 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17360 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17361 return octave_value_list();
17362 }
17363 catch(...) {
17364 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17365 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17366 throw;
17367 }
17368}
17369
17370
17372 PLINT arg1 ;
17373 PLFLT *arg2 = (PLFLT *) 0 ;
17374 PLFLT *arg3 = (PLFLT *) 0 ;
17375 PLINT arg4 ;
17376 Matrix temp1 ;
17377 Matrix temp3 ;
17378 int val4 ;
17379 int ecode4 = 0 ;
17380 octave_value_list _out;
17381 octave_value_list *_outp=&_out;
17382 octave_value _outv;
17383
17384 try {
17385 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17386 SWIG_fail;
17387 }
17388 {
17389 if ( _n_dims( args(0) ) > 1 )
17390 {
17391 error( "argument must be a scalar or vector" ); SWIG_fail;
17392 }
17393 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17394 temp1 = args(0).matrix_value();
17395 arg2 = &temp1( 0, 0 );
17396 }
17397 {
17398 if ( _n_dims( args(1) ) > 1 )
17399 {
17400 error( "argument must be a scalar or vector" ); SWIG_fail;
17401 }
17402 if ( _dim( args(1), 0 ) != Alen )
17403 {
17404 error( "argument vectors must be same length" ); SWIG_fail;
17405 }
17406 temp3 = args(1).matrix_value();
17407 arg3 = &temp3( 0, 0 );
17408 }
17409 ecode4 = SWIG_AsVal_int(args(2), &val4);
17410 if (!SWIG_IsOK(ecode4)) {
17411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17412 }
17413 arg4 = static_cast< PLINT >(val4);
17414 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17415 _outv = octave_value();
17416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17417 {
17418
17419 }
17420 {
17421
17422 }
17423 return _out;
17424 fail:
17425 {
17426
17427 }
17428 {
17429
17430 }
17431 return octave_value_list();
17432 }
17433 catch(...) {
17434 {
17435
17436 }
17437 {
17438
17439 }
17440 throw;
17441 }
17442}
17443
17444
17446 PLINT *arg1 = (PLINT *) 0 ;
17447 PLINT *arg2 = (PLINT *) 0 ;
17448 PLINT *arg3 = (PLINT *) 0 ;
17449 PLINT *arg4 = (PLINT *) 0 ;
17450 PLINT *arg5 = (PLINT *) 0 ;
17451 PLFLT *arg6 = (PLFLT *) 0 ;
17452 PLFLT arg7 ;
17453 PLINT temp1 ;
17454 int res1 = SWIG_TMPOBJ ;
17455 PLINT temp2 ;
17456 int res2 = SWIG_TMPOBJ ;
17457 PLINT temp3 ;
17458 int res3 = SWIG_TMPOBJ ;
17459 PLINT temp4 ;
17460 int res4 = SWIG_TMPOBJ ;
17461 PLINT temp5 ;
17462 int res5 = SWIG_TMPOBJ ;
17463 PLFLT temp6 ;
17464 int res6 = SWIG_TMPOBJ ;
17465 double val7 ;
17466 int ecode7 = 0 ;
17467 octave_value_list _out;
17468 octave_value_list *_outp=&_out;
17469 octave_value _outv;
17470
17471 try {
17472 arg1 = &temp1;
17473 arg2 = &temp2;
17474 arg3 = &temp3;
17475 arg4 = &temp4;
17476 arg5 = &temp5;
17477 arg6 = &temp6;
17478 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17479 SWIG_fail;
17480 }
17481 ecode7 = SWIG_AsVal_double(args(0), &val7);
17482 if (!SWIG_IsOK(ecode7)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17484 }
17485 arg7 = static_cast< PLFLT >(val7);
17486 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17487 _outv = octave_value();
17488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17489 if (SWIG_IsTmpObj(res1)) {
17490 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17491 } else {
17492 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17493 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17494 }
17495 if (SWIG_IsTmpObj(res2)) {
17496 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17497 } else {
17498 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17499 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17500 }
17501 if (SWIG_IsTmpObj(res3)) {
17502 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17503 } else {
17504 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17505 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17506 }
17507 if (SWIG_IsTmpObj(res4)) {
17508 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17509 } else {
17510 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17511 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17512 }
17513 if (SWIG_IsTmpObj(res5)) {
17514 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17515 } else {
17516 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17517 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17518 }
17519 if (SWIG_IsTmpObj(res6)) {
17520 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17521 } else {
17522 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17523 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17524 }
17525 return _out;
17526 fail:
17527 return octave_value_list();
17528 }
17529 catch(...) {
17530 throw;
17531 }
17532}
17533
17534
17536 octave_value_list _out;
17537 octave_value_list *_outp=&_out;
17538 octave_value _outv;
17539
17540 try {
17541 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17542 SWIG_fail;
17543 }
17544 plbop();
17545 _outv = octave_value();
17546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17547 return _out;
17548 fail:
17549 return octave_value_list();
17550 }
17551 catch(...) {
17552 throw;
17553 }
17554}
17555
17556
17558 char *arg1 = (char *) 0 ;
17559 PLFLT arg2 ;
17560 PLINT arg3 ;
17561 char *arg4 = (char *) 0 ;
17562 PLFLT arg5 ;
17563 PLINT arg6 ;
17564 int res1 ;
17565 char *buf1 = 0 ;
17566 int alloc1 = 0 ;
17567 double val2 ;
17568 int ecode2 = 0 ;
17569 int val3 ;
17570 int ecode3 = 0 ;
17571 int res4 ;
17572 char *buf4 = 0 ;
17573 int alloc4 = 0 ;
17574 double val5 ;
17575 int ecode5 = 0 ;
17576 int val6 ;
17577 int ecode6 = 0 ;
17578 octave_value_list _out;
17579 octave_value_list *_outp=&_out;
17580 octave_value _outv;
17581
17582 try {
17583 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17584 SWIG_fail;
17585 }
17586 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17587 if (!SWIG_IsOK(res1)) {
17588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17589 }
17590 arg1 = reinterpret_cast< char * >(buf1);
17591 ecode2 = SWIG_AsVal_double(args(1), &val2);
17592 if (!SWIG_IsOK(ecode2)) {
17593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17594 }
17595 arg2 = static_cast< PLFLT >(val2);
17596 ecode3 = SWIG_AsVal_int(args(2), &val3);
17597 if (!SWIG_IsOK(ecode3)) {
17598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17599 }
17600 arg3 = static_cast< PLINT >(val3);
17601 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17602 if (!SWIG_IsOK(res4)) {
17603 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17604 }
17605 arg4 = reinterpret_cast< char * >(buf4);
17606 ecode5 = SWIG_AsVal_double(args(4), &val5);
17607 if (!SWIG_IsOK(ecode5)) {
17608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17609 }
17610 arg5 = static_cast< PLFLT >(val5);
17611 ecode6 = SWIG_AsVal_int(args(5), &val6);
17612 if (!SWIG_IsOK(ecode6)) {
17613 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17614 }
17615 arg6 = static_cast< PLINT >(val6);
17616 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17617 _outv = octave_value();
17618 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17619 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17620 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17621 return _out;
17622 fail:
17623 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17624 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17625 return octave_value_list();
17626 }
17627 catch(...) {
17628 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17629 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17630 throw;
17631 }
17632}
17633
17634
17636 char *arg1 = (char *) 0 ;
17637 char *arg2 = (char *) 0 ;
17638 PLFLT arg3 ;
17639 PLINT arg4 ;
17640 char *arg5 = (char *) 0 ;
17641 char *arg6 = (char *) 0 ;
17642 PLFLT arg7 ;
17643 PLINT arg8 ;
17644 char *arg9 = (char *) 0 ;
17645 char *arg10 = (char *) 0 ;
17646 PLFLT arg11 ;
17647 PLINT arg12 ;
17648 int res1 ;
17649 char *buf1 = 0 ;
17650 int alloc1 = 0 ;
17651 int res2 ;
17652 char *buf2 = 0 ;
17653 int alloc2 = 0 ;
17654 double val3 ;
17655 int ecode3 = 0 ;
17656 int val4 ;
17657 int ecode4 = 0 ;
17658 int res5 ;
17659 char *buf5 = 0 ;
17660 int alloc5 = 0 ;
17661 int res6 ;
17662 char *buf6 = 0 ;
17663 int alloc6 = 0 ;
17664 double val7 ;
17665 int ecode7 = 0 ;
17666 int val8 ;
17667 int ecode8 = 0 ;
17668 int res9 ;
17669 char *buf9 = 0 ;
17670 int alloc9 = 0 ;
17671 int res10 ;
17672 char *buf10 = 0 ;
17673 int alloc10 = 0 ;
17674 double val11 ;
17675 int ecode11 = 0 ;
17676 int val12 ;
17677 int ecode12 = 0 ;
17678 octave_value_list _out;
17679 octave_value_list *_outp=&_out;
17680 octave_value _outv;
17681
17682 try {
17683 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17684 SWIG_fail;
17685 }
17686 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17687 if (!SWIG_IsOK(res1)) {
17688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17689 }
17690 arg1 = reinterpret_cast< char * >(buf1);
17691 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17692 if (!SWIG_IsOK(res2)) {
17693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17694 }
17695 arg2 = reinterpret_cast< char * >(buf2);
17696 ecode3 = SWIG_AsVal_double(args(2), &val3);
17697 if (!SWIG_IsOK(ecode3)) {
17698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17699 }
17700 arg3 = static_cast< PLFLT >(val3);
17701 ecode4 = SWIG_AsVal_int(args(3), &val4);
17702 if (!SWIG_IsOK(ecode4)) {
17703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17704 }
17705 arg4 = static_cast< PLINT >(val4);
17706 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17707 if (!SWIG_IsOK(res5)) {
17708 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17709 }
17710 arg5 = reinterpret_cast< char * >(buf5);
17711 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17712 if (!SWIG_IsOK(res6)) {
17713 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17714 }
17715 arg6 = reinterpret_cast< char * >(buf6);
17716 ecode7 = SWIG_AsVal_double(args(6), &val7);
17717 if (!SWIG_IsOK(ecode7)) {
17718 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17719 }
17720 arg7 = static_cast< PLFLT >(val7);
17721 ecode8 = SWIG_AsVal_int(args(7), &val8);
17722 if (!SWIG_IsOK(ecode8)) {
17723 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17724 }
17725 arg8 = static_cast< PLINT >(val8);
17726 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17727 if (!SWIG_IsOK(res9)) {
17728 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17729 }
17730 arg9 = reinterpret_cast< char * >(buf9);
17731 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17732 if (!SWIG_IsOK(res10)) {
17733 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17734 }
17735 arg10 = reinterpret_cast< char * >(buf10);
17736 ecode11 = SWIG_AsVal_double(args(10), &val11);
17737 if (!SWIG_IsOK(ecode11)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17739 }
17740 arg11 = static_cast< PLFLT >(val11);
17741 ecode12 = SWIG_AsVal_int(args(11), &val12);
17742 if (!SWIG_IsOK(ecode12)) {
17743 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17744 }
17745 arg12 = static_cast< PLINT >(val12);
17746 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);
17747 _outv = octave_value();
17748 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17749 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17750 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17751 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17752 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17753 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17754 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17755 return _out;
17756 fail:
17757 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17758 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17759 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17760 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17761 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17762 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17763 return octave_value_list();
17764 }
17765 catch(...) {
17766 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17767 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17768 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17769 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17770 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17771 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17772 throw;
17773 }
17774}
17775
17776
17778 PLFLT arg1 ;
17779 PLFLT arg2 ;
17780 PLFLT *arg3 = (PLFLT *) 0 ;
17781 PLFLT *arg4 = (PLFLT *) 0 ;
17782 PLINT *arg5 = (PLINT *) 0 ;
17783 double val1 ;
17784 int ecode1 = 0 ;
17785 double val2 ;
17786 int ecode2 = 0 ;
17787 PLFLT temp3 ;
17788 int res3 = SWIG_TMPOBJ ;
17789 PLFLT temp4 ;
17790 int res4 = SWIG_TMPOBJ ;
17791 PLINT temp5 ;
17792 int res5 = SWIG_TMPOBJ ;
17793 octave_value_list _out;
17794 octave_value_list *_outp=&_out;
17795 octave_value _outv;
17796
17797 try {
17798 arg3 = &temp3;
17799 arg4 = &temp4;
17800 arg5 = &temp5;
17801 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17802 SWIG_fail;
17803 }
17804 ecode1 = SWIG_AsVal_double(args(0), &val1);
17805 if (!SWIG_IsOK(ecode1)) {
17806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17807 }
17808 arg1 = static_cast< PLFLT >(val1);
17809 ecode2 = SWIG_AsVal_double(args(1), &val2);
17810 if (!SWIG_IsOK(ecode2)) {
17811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17812 }
17813 arg2 = static_cast< PLFLT >(val2);
17814 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17815 _outv = octave_value();
17816 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17817 if (SWIG_IsTmpObj(res3)) {
17818 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17819 } else {
17820 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17821 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17822 }
17823 if (SWIG_IsTmpObj(res4)) {
17824 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17825 } else {
17826 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17827 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17828 }
17829 if (SWIG_IsTmpObj(res5)) {
17830 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17831 } else {
17832 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17833 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17834 }
17835 return _out;
17836 fail:
17837 return octave_value_list();
17838 }
17839 catch(...) {
17840 throw;
17841 }
17842}
17843
17844
17846 octave_value_list _out;
17847 octave_value_list *_outp=&_out;
17848 octave_value _outv;
17849
17850 try {
17851 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17852 SWIG_fail;
17853 }
17854 plclear();
17855 _outv = octave_value();
17856 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17857 return _out;
17858 fail:
17859 return octave_value_list();
17860 }
17861 catch(...) {
17862 throw;
17863 }
17864}
17865
17866
17868 PLINT arg1 ;
17869 int val1 ;
17870 int ecode1 = 0 ;
17871 octave_value_list _out;
17872 octave_value_list *_outp=&_out;
17873 octave_value _outv;
17874
17875 try {
17876 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17877 SWIG_fail;
17878 }
17879 ecode1 = SWIG_AsVal_int(args(0), &val1);
17880 if (!SWIG_IsOK(ecode1)) {
17881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17882 }
17883 arg1 = static_cast< PLINT >(val1);
17884 plcol0(arg1);
17885 _outv = octave_value();
17886 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17887 return _out;
17888 fail:
17889 return octave_value_list();
17890 }
17891 catch(...) {
17892 throw;
17893 }
17894}
17895
17896
17898 PLFLT arg1 ;
17899 double val1 ;
17900 int ecode1 = 0 ;
17901 octave_value_list _out;
17902 octave_value_list *_outp=&_out;
17903 octave_value _outv;
17904
17905 try {
17906 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17907 SWIG_fail;
17908 }
17909 ecode1 = SWIG_AsVal_double(args(0), &val1);
17910 if (!SWIG_IsOK(ecode1)) {
17911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17912 }
17913 arg1 = static_cast< PLFLT >(val1);
17914 plcol1(arg1);
17915 _outv = octave_value();
17916 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17917 return _out;
17918 fail:
17919 return octave_value_list();
17920 }
17921 catch(...) {
17922 throw;
17923 }
17924}
17925
17926
17928 PLFLT arg1 ;
17929 PLFLT arg2 ;
17930 PLFLT arg3 ;
17931 PLINT arg4 ;
17932 PLBOOL arg5 ;
17933 PLINT arg6 ;
17934 PLINT arg7 ;
17935 PLINT arg8 ;
17936 PLINT arg9 ;
17937 PLINT arg10 ;
17938 PLFLT arg11 ;
17939 double val1 ;
17940 int ecode1 = 0 ;
17941 double val2 ;
17942 int ecode2 = 0 ;
17943 double val3 ;
17944 int ecode3 = 0 ;
17945 int val4 ;
17946 int ecode4 = 0 ;
17947 int val5 ;
17948 int ecode5 = 0 ;
17949 int val6 ;
17950 int ecode6 = 0 ;
17951 int val7 ;
17952 int ecode7 = 0 ;
17953 int val8 ;
17954 int ecode8 = 0 ;
17955 int val9 ;
17956 int ecode9 = 0 ;
17957 int val10 ;
17958 int ecode10 = 0 ;
17959 double val11 ;
17960 int ecode11 = 0 ;
17961 octave_value_list _out;
17962 octave_value_list *_outp=&_out;
17963 octave_value _outv;
17964
17965 try {
17966 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17967 SWIG_fail;
17968 }
17969 ecode1 = SWIG_AsVal_double(args(0), &val1);
17970 if (!SWIG_IsOK(ecode1)) {
17971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17972 }
17973 arg1 = static_cast< PLFLT >(val1);
17974 ecode2 = SWIG_AsVal_double(args(1), &val2);
17975 if (!SWIG_IsOK(ecode2)) {
17976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17977 }
17978 arg2 = static_cast< PLFLT >(val2);
17979 ecode3 = SWIG_AsVal_double(args(2), &val3);
17980 if (!SWIG_IsOK(ecode3)) {
17981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17982 }
17983 arg3 = static_cast< PLFLT >(val3);
17984 ecode4 = SWIG_AsVal_int(args(3), &val4);
17985 if (!SWIG_IsOK(ecode4)) {
17986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17987 }
17988 arg4 = static_cast< PLINT >(val4);
17989 ecode5 = SWIG_AsVal_int(args(4), &val5);
17990 if (!SWIG_IsOK(ecode5)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17992 }
17993 arg5 = static_cast< PLBOOL >(val5);
17994 ecode6 = SWIG_AsVal_int(args(5), &val6);
17995 if (!SWIG_IsOK(ecode6)) {
17996 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17997 }
17998 arg6 = static_cast< PLINT >(val6);
17999 ecode7 = SWIG_AsVal_int(args(6), &val7);
18000 if (!SWIG_IsOK(ecode7)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18002 }
18003 arg7 = static_cast< PLINT >(val7);
18004 ecode8 = SWIG_AsVal_int(args(7), &val8);
18005 if (!SWIG_IsOK(ecode8)) {
18006 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18007 }
18008 arg8 = static_cast< PLINT >(val8);
18009 ecode9 = SWIG_AsVal_int(args(8), &val9);
18010 if (!SWIG_IsOK(ecode9)) {
18011 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18012 }
18013 arg9 = static_cast< PLINT >(val9);
18014 ecode10 = SWIG_AsVal_int(args(9), &val10);
18015 if (!SWIG_IsOK(ecode10)) {
18016 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18017 }
18018 arg10 = static_cast< PLINT >(val10);
18019 ecode11 = SWIG_AsVal_double(args(10), &val11);
18020 if (!SWIG_IsOK(ecode11)) {
18021 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18022 }
18023 arg11 = static_cast< PLFLT >(val11);
18024 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18025 _outv = octave_value();
18026 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18027 return _out;
18028 fail:
18029 return octave_value_list();
18030 }
18031 catch(...) {
18032 throw;
18033 }
18034}
18035
18036
18038 PLINT arg1 ;
18039 PLINT arg2 ;
18040 PLINT arg3 ;
18041 PLINT arg4 ;
18042 PLINT arg5 ;
18043 PLFLT arg6 ;
18044 PLFLT *arg7 = (PLFLT *) 0 ;
18045 int val1 ;
18046 int ecode1 = 0 ;
18047 int val2 ;
18048 int ecode2 = 0 ;
18049 int val3 ;
18050 int ecode3 = 0 ;
18051 int val4 ;
18052 int ecode4 = 0 ;
18053 int val5 ;
18054 int ecode5 = 0 ;
18055 double val6 ;
18056 int ecode6 = 0 ;
18057 PLFLT temp7 ;
18058 int res7 = SWIG_TMPOBJ ;
18059 octave_value_list _out;
18060 octave_value_list *_outp=&_out;
18061 octave_value _outv;
18062
18063 try {
18064 arg7 = &temp7;
18065 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18066 SWIG_fail;
18067 }
18068 ecode1 = SWIG_AsVal_int(args(0), &val1);
18069 if (!SWIG_IsOK(ecode1)) {
18070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18071 }
18072 arg1 = static_cast< PLINT >(val1);
18073 ecode2 = SWIG_AsVal_int(args(1), &val2);
18074 if (!SWIG_IsOK(ecode2)) {
18075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18076 }
18077 arg2 = static_cast< PLINT >(val2);
18078 ecode3 = SWIG_AsVal_int(args(2), &val3);
18079 if (!SWIG_IsOK(ecode3)) {
18080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18081 }
18082 arg3 = static_cast< PLINT >(val3);
18083 ecode4 = SWIG_AsVal_int(args(3), &val4);
18084 if (!SWIG_IsOK(ecode4)) {
18085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18086 }
18087 arg4 = static_cast< PLINT >(val4);
18088 ecode5 = SWIG_AsVal_int(args(4), &val5);
18089 if (!SWIG_IsOK(ecode5)) {
18090 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18091 }
18092 arg5 = static_cast< PLINT >(val5);
18093 ecode6 = SWIG_AsVal_double(args(5), &val6);
18094 if (!SWIG_IsOK(ecode6)) {
18095 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18096 }
18097 arg6 = static_cast< PLFLT >(val6);
18098 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18099 _outv = octave_value();
18100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18101 if (SWIG_IsTmpObj(res7)) {
18102 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18103 } else {
18104 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18105 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18106 }
18107 return _out;
18108 fail:
18109 return octave_value_list();
18110 }
18111 catch(...) {
18112 throw;
18113 }
18114}
18115
18116
18118 PLINT arg1 ;
18119 PLBOOL arg2 ;
18120 int val1 ;
18121 int ecode1 = 0 ;
18122 int val2 ;
18123 int ecode2 = 0 ;
18124 octave_value_list _out;
18125 octave_value_list *_outp=&_out;
18126 octave_value _outv;
18127
18128 try {
18129 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18130 SWIG_fail;
18131 }
18132 ecode1 = SWIG_AsVal_int(args(0), &val1);
18133 if (!SWIG_IsOK(ecode1)) {
18134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18135 }
18136 arg1 = static_cast< PLINT >(val1);
18137 ecode2 = SWIG_AsVal_int(args(1), &val2);
18138 if (!SWIG_IsOK(ecode2)) {
18139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18140 }
18141 arg2 = static_cast< PLBOOL >(val2);
18142 plcpstrm(arg1,arg2);
18143 _outv = octave_value();
18144 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18145 return _out;
18146 fail:
18147 return octave_value_list();
18148 }
18149 catch(...) {
18150 throw;
18151 }
18152}
18153
18154
18156 octave_value_list _out;
18157 octave_value_list *_outp=&_out;
18158 octave_value _outv;
18159
18160 try {
18161 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18162 SWIG_fail;
18163 }
18164 plend();
18165 _outv = octave_value();
18166 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18167 return _out;
18168 fail:
18169 return octave_value_list();
18170 }
18171 catch(...) {
18172 throw;
18173 }
18174}
18175
18176
18178 octave_value_list _out;
18179 octave_value_list *_outp=&_out;
18180 octave_value _outv;
18181
18182 try {
18183 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18184 SWIG_fail;
18185 }
18186 plend1();
18187 _outv = octave_value();
18188 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18189 return _out;
18190 fail:
18191 return octave_value_list();
18192 }
18193 catch(...) {
18194 throw;
18195 }
18196}
18197
18198
18200 PLFLT arg1 ;
18201 PLFLT arg2 ;
18202 PLFLT arg3 ;
18203 PLFLT arg4 ;
18204 PLINT arg5 ;
18205 PLINT arg6 ;
18206 double val1 ;
18207 int ecode1 = 0 ;
18208 double val2 ;
18209 int ecode2 = 0 ;
18210 double val3 ;
18211 int ecode3 = 0 ;
18212 double val4 ;
18213 int ecode4 = 0 ;
18214 int val5 ;
18215 int ecode5 = 0 ;
18216 int val6 ;
18217 int ecode6 = 0 ;
18218 octave_value_list _out;
18219 octave_value_list *_outp=&_out;
18220 octave_value _outv;
18221
18222 try {
18223 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18224 SWIG_fail;
18225 }
18226 ecode1 = SWIG_AsVal_double(args(0), &val1);
18227 if (!SWIG_IsOK(ecode1)) {
18228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18229 }
18230 arg1 = static_cast< PLFLT >(val1);
18231 ecode2 = SWIG_AsVal_double(args(1), &val2);
18232 if (!SWIG_IsOK(ecode2)) {
18233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18234 }
18235 arg2 = static_cast< PLFLT >(val2);
18236 ecode3 = SWIG_AsVal_double(args(2), &val3);
18237 if (!SWIG_IsOK(ecode3)) {
18238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18239 }
18240 arg3 = static_cast< PLFLT >(val3);
18241 ecode4 = SWIG_AsVal_double(args(3), &val4);
18242 if (!SWIG_IsOK(ecode4)) {
18243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18244 }
18245 arg4 = static_cast< PLFLT >(val4);
18246 ecode5 = SWIG_AsVal_int(args(4), &val5);
18247 if (!SWIG_IsOK(ecode5)) {
18248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18249 }
18250 arg5 = static_cast< PLINT >(val5);
18251 ecode6 = SWIG_AsVal_int(args(5), &val6);
18252 if (!SWIG_IsOK(ecode6)) {
18253 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18254 }
18255 arg6 = static_cast< PLINT >(val6);
18256 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18257 _outv = octave_value();
18258 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18259 return _out;
18260 fail:
18261 return octave_value_list();
18262 }
18263 catch(...) {
18264 throw;
18265 }
18266}
18267
18268
18270 PLFLT arg1 ;
18271 PLFLT arg2 ;
18272 PLFLT arg3 ;
18273 PLFLT arg4 ;
18274 PLINT arg5 ;
18275 PLINT arg6 ;
18276 double val1 ;
18277 int ecode1 = 0 ;
18278 double val2 ;
18279 int ecode2 = 0 ;
18280 double val3 ;
18281 int ecode3 = 0 ;
18282 double val4 ;
18283 int ecode4 = 0 ;
18284 int val5 ;
18285 int ecode5 = 0 ;
18286 int val6 ;
18287 int ecode6 = 0 ;
18288 octave_value_list _out;
18289 octave_value_list *_outp=&_out;
18290 octave_value _outv;
18291
18292 try {
18293 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18294 SWIG_fail;
18295 }
18296 ecode1 = SWIG_AsVal_double(args(0), &val1);
18297 if (!SWIG_IsOK(ecode1)) {
18298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18299 }
18300 arg1 = static_cast< PLFLT >(val1);
18301 ecode2 = SWIG_AsVal_double(args(1), &val2);
18302 if (!SWIG_IsOK(ecode2)) {
18303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18304 }
18305 arg2 = static_cast< PLFLT >(val2);
18306 ecode3 = SWIG_AsVal_double(args(2), &val3);
18307 if (!SWIG_IsOK(ecode3)) {
18308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18309 }
18310 arg3 = static_cast< PLFLT >(val3);
18311 ecode4 = SWIG_AsVal_double(args(3), &val4);
18312 if (!SWIG_IsOK(ecode4)) {
18313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18314 }
18315 arg4 = static_cast< PLFLT >(val4);
18316 ecode5 = SWIG_AsVal_int(args(4), &val5);
18317 if (!SWIG_IsOK(ecode5)) {
18318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18319 }
18320 arg5 = static_cast< PLINT >(val5);
18321 ecode6 = SWIG_AsVal_int(args(5), &val6);
18322 if (!SWIG_IsOK(ecode6)) {
18323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18324 }
18325 arg6 = static_cast< PLINT >(val6);
18326 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18327 _outv = octave_value();
18328 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18329 return _out;
18330 fail:
18331 return octave_value_list();
18332 }
18333 catch(...) {
18334 throw;
18335 }
18336}
18337
18338
18340 octave_value_list _out;
18341 octave_value_list *_outp=&_out;
18342 octave_value _outv;
18343
18344 try {
18345 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18346 SWIG_fail;
18347 }
18348 pleop();
18349 _outv = octave_value();
18350 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18351 return _out;
18352 fail:
18353 return octave_value_list();
18354 }
18355 catch(...) {
18356 throw;
18357 }
18358}
18359
18360
18362 PLINT arg1 ;
18363 PLFLT *arg2 = (PLFLT *) 0 ;
18364 PLFLT *arg3 = (PLFLT *) 0 ;
18365 PLFLT *arg4 = (PLFLT *) 0 ;
18366 Matrix temp1 ;
18367 Matrix temp3 ;
18368 Matrix temp4 ;
18369 octave_value_list _out;
18370 octave_value_list *_outp=&_out;
18371 octave_value _outv;
18372
18373 try {
18374 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18375 SWIG_fail;
18376 }
18377 {
18378 if ( _n_dims( args(0) ) > 1 )
18379 {
18380 error( "argument must be a scalar or vector" ); SWIG_fail;
18381 }
18382 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18383 temp1 = args(0).matrix_value();
18384 arg2 = &temp1( 0, 0 );
18385 }
18386 {
18387 if ( _n_dims( args(1) ) > 1 )
18388 {
18389 error( "argument must be a scalar or vector" ); SWIG_fail;
18390 }
18391 if ( _dim( args(1), 0 ) != Alen )
18392 {
18393 error( "argument vectors must be same length" ); SWIG_fail;
18394 }
18395 temp3 = args(1).matrix_value();
18396 arg3 = &temp3( 0, 0 );
18397 }
18398 {
18399 if ( _n_dims( args(2) ) > 1 )
18400 {
18401 error( "argument must be a scalar or vector" ); SWIG_fail;
18402 }
18403 if ( _dim( args(2), 0 ) != Alen )
18404 {
18405 error( "argument vectors must be same length" ); SWIG_fail;
18406 }
18407 temp4 = args(2).matrix_value();
18408 arg4 = &temp4( 0, 0 );
18409 }
18410 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18411 _outv = octave_value();
18412 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18413 {
18414
18415 }
18416 {
18417
18418 }
18419 {
18420
18421 }
18422 return _out;
18423 fail:
18424 {
18425
18426 }
18427 {
18428
18429 }
18430 {
18431
18432 }
18433 return octave_value_list();
18434 }
18435 catch(...) {
18436 {
18437
18438 }
18439 {
18440
18441 }
18442 {
18443
18444 }
18445 throw;
18446 }
18447}
18448
18449
18451 PLINT arg1 ;
18452 PLFLT *arg2 = (PLFLT *) 0 ;
18453 PLFLT *arg3 = (PLFLT *) 0 ;
18454 PLFLT *arg4 = (PLFLT *) 0 ;
18455 Matrix temp1 ;
18456 Matrix temp3 ;
18457 Matrix temp4 ;
18458 octave_value_list _out;
18459 octave_value_list *_outp=&_out;
18460 octave_value _outv;
18461
18462 try {
18463 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18464 SWIG_fail;
18465 }
18466 {
18467 if ( _n_dims( args(0) ) > 1 )
18468 {
18469 error( "argument must be a scalar or vector" ); SWIG_fail;
18470 }
18471 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18472 temp1 = args(0).matrix_value();
18473 arg2 = &temp1( 0, 0 );
18474 }
18475 {
18476 if ( _n_dims( args(1) ) > 1 )
18477 {
18478 error( "argument must be a scalar or vector" ); SWIG_fail;
18479 }
18480 if ( _dim( args(1), 0 ) != Alen )
18481 {
18482 error( "argument vectors must be same length" ); SWIG_fail;
18483 }
18484 temp3 = args(1).matrix_value();
18485 arg3 = &temp3( 0, 0 );
18486 }
18487 {
18488 if ( _n_dims( args(2) ) > 1 )
18489 {
18490 error( "argument must be a scalar or vector" ); SWIG_fail;
18491 }
18492 if ( _dim( args(2), 0 ) != Alen )
18493 {
18494 error( "argument vectors must be same length" ); SWIG_fail;
18495 }
18496 temp4 = args(2).matrix_value();
18497 arg4 = &temp4( 0, 0 );
18498 }
18499 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18500 _outv = octave_value();
18501 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18502 {
18503
18504 }
18505 {
18506
18507 }
18508 {
18509
18510 }
18511 return _out;
18512 fail:
18513 {
18514
18515 }
18516 {
18517
18518 }
18519 {
18520
18521 }
18522 return octave_value_list();
18523 }
18524 catch(...) {
18525 {
18526
18527 }
18528 {
18529
18530 }
18531 {
18532
18533 }
18534 throw;
18535 }
18536}
18537
18538
18540 octave_value_list _out;
18541 octave_value_list *_outp=&_out;
18542 octave_value _outv;
18543
18544 try {
18545 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18546 SWIG_fail;
18547 }
18548 plfamadv();
18549 _outv = octave_value();
18550 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18551 return _out;
18552 fail:
18553 return octave_value_list();
18554 }
18555 catch(...) {
18556 throw;
18557 }
18558}
18559
18560
18562 PLINT arg1 ;
18563 PLFLT *arg2 = (PLFLT *) 0 ;
18564 PLFLT *arg3 = (PLFLT *) 0 ;
18565 Matrix temp1 ;
18566 Matrix temp3 ;
18567 octave_value_list _out;
18568 octave_value_list *_outp=&_out;
18569 octave_value _outv;
18570
18571 try {
18572 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18573 SWIG_fail;
18574 }
18575 {
18576 if ( _n_dims( args(0) ) > 1 )
18577 {
18578 error( "argument must be a scalar or vector" ); SWIG_fail;
18579 }
18580 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18581 temp1 = args(0).matrix_value();
18582 arg2 = &temp1( 0, 0 );
18583 }
18584 {
18585 if ( _n_dims( args(1) ) > 1 )
18586 {
18587 error( "argument must be a scalar or vector" ); SWIG_fail;
18588 }
18589 if ( _dim( args(1), 0 ) != Alen )
18590 {
18591 error( "argument vectors must be same length" ); SWIG_fail;
18592 }
18593 temp3 = args(1).matrix_value();
18594 arg3 = &temp3( 0, 0 );
18595 }
18596 plfill(arg1,(double const *)arg2,(double const *)arg3);
18597 _outv = octave_value();
18598 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18599 {
18600
18601 }
18602 {
18603
18604 }
18605 return _out;
18606 fail:
18607 {
18608
18609 }
18610 {
18611
18612 }
18613 return octave_value_list();
18614 }
18615 catch(...) {
18616 {
18617
18618 }
18619 {
18620
18621 }
18622 throw;
18623 }
18624}
18625
18626
18628 PLINT arg1 ;
18629 PLFLT *arg2 = (PLFLT *) 0 ;
18630 PLFLT *arg3 = (PLFLT *) 0 ;
18631 PLFLT *arg4 = (PLFLT *) 0 ;
18632 Matrix temp1 ;
18633 Matrix temp3 ;
18634 Matrix temp4 ;
18635 octave_value_list _out;
18636 octave_value_list *_outp=&_out;
18637 octave_value _outv;
18638
18639 try {
18640 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18641 SWIG_fail;
18642 }
18643 {
18644 if ( _n_dims( args(0) ) > 1 )
18645 {
18646 error( "argument must be a scalar or vector" ); SWIG_fail;
18647 }
18648 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18649 temp1 = args(0).matrix_value();
18650 arg2 = &temp1( 0, 0 );
18651 }
18652 {
18653 if ( _n_dims( args(1) ) > 1 )
18654 {
18655 error( "argument must be a scalar or vector" ); SWIG_fail;
18656 }
18657 if ( _dim( args(1), 0 ) != Alen )
18658 {
18659 error( "argument vectors must be same length" ); SWIG_fail;
18660 }
18661 temp3 = args(1).matrix_value();
18662 arg3 = &temp3( 0, 0 );
18663 }
18664 {
18665 if ( _n_dims( args(2) ) > 1 )
18666 {
18667 error( "argument must be a scalar or vector" ); SWIG_fail;
18668 }
18669 if ( _dim( args(2), 0 ) != Alen )
18670 {
18671 error( "argument vectors must be same length" ); SWIG_fail;
18672 }
18673 temp4 = args(2).matrix_value();
18674 arg4 = &temp4( 0, 0 );
18675 }
18676 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18677 _outv = octave_value();
18678 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18679 {
18680
18681 }
18682 {
18683
18684 }
18685 {
18686
18687 }
18688 return _out;
18689 fail:
18690 {
18691
18692 }
18693 {
18694
18695 }
18696 {
18697
18698 }
18699 return octave_value_list();
18700 }
18701 catch(...) {
18702 {
18703
18704 }
18705 {
18706
18707 }
18708 {
18709
18710 }
18711 throw;
18712 }
18713}
18714
18715
18717 PLINT arg1 ;
18718 PLFLT *arg2 = (PLFLT *) 0 ;
18719 PLFLT *arg3 = (PLFLT *) 0 ;
18720 PLFLT arg4 ;
18721 Matrix temp1 ;
18722 Matrix temp3 ;
18723 double val4 ;
18724 int ecode4 = 0 ;
18725 octave_value_list _out;
18726 octave_value_list *_outp=&_out;
18727 octave_value _outv;
18728
18729 try {
18730 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18731 SWIG_fail;
18732 }
18733 {
18734 if ( _n_dims( args(0) ) > 1 )
18735 {
18736 error( "argument must be a scalar or vector" ); SWIG_fail;
18737 }
18738 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18739 temp1 = args(0).matrix_value();
18740 arg2 = &temp1( 0, 0 );
18741 }
18742 {
18743 if ( _n_dims( args(1) ) > 1 )
18744 {
18745 error( "argument must be a scalar or vector" ); SWIG_fail;
18746 }
18747 if ( _dim( args(1), 0 ) != Alen )
18748 {
18749 error( "argument vectors must be same length" ); SWIG_fail;
18750 }
18751 temp3 = args(1).matrix_value();
18752 arg3 = &temp3( 0, 0 );
18753 }
18754 ecode4 = SWIG_AsVal_double(args(2), &val4);
18755 if (!SWIG_IsOK(ecode4)) {
18756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18757 }
18758 arg4 = static_cast< PLFLT >(val4);
18759 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18760 _outv = octave_value();
18761 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18762 {
18763
18764 }
18765 {
18766
18767 }
18768 return _out;
18769 fail:
18770 {
18771
18772 }
18773 {
18774
18775 }
18776 return octave_value_list();
18777 }
18778 catch(...) {
18779 {
18780
18781 }
18782 {
18783
18784 }
18785 throw;
18786 }
18787}
18788
18789
18791 octave_value_list _out;
18792 octave_value_list *_outp=&_out;
18793 octave_value _outv;
18794
18795 try {
18796 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18797 SWIG_fail;
18798 }
18799 plflush();
18800 _outv = octave_value();
18801 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18802 return _out;
18803 fail:
18804 return octave_value_list();
18805 }
18806 catch(...) {
18807 throw;
18808 }
18809}
18810
18811
18813 PLINT arg1 ;
18814 int val1 ;
18815 int ecode1 = 0 ;
18816 octave_value_list _out;
18817 octave_value_list *_outp=&_out;
18818 octave_value _outv;
18819
18820 try {
18821 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18822 SWIG_fail;
18823 }
18824 ecode1 = SWIG_AsVal_int(args(0), &val1);
18825 if (!SWIG_IsOK(ecode1)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18827 }
18828 arg1 = static_cast< PLINT >(val1);
18829 plfont(arg1);
18830 _outv = octave_value();
18831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18832 return _out;
18833 fail:
18834 return octave_value_list();
18835 }
18836 catch(...) {
18837 throw;
18838 }
18839}
18840
18841
18843 PLINT arg1 ;
18844 int val1 ;
18845 int ecode1 = 0 ;
18846 octave_value_list _out;
18847 octave_value_list *_outp=&_out;
18848 octave_value _outv;
18849
18850 try {
18851 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18852 SWIG_fail;
18853 }
18854 ecode1 = SWIG_AsVal_int(args(0), &val1);
18855 if (!SWIG_IsOK(ecode1)) {
18856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18857 }
18858 arg1 = static_cast< PLINT >(val1);
18859 plfontld(arg1);
18860 _outv = octave_value();
18861 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18862 return _out;
18863 fail:
18864 return octave_value_list();
18865 }
18866 catch(...) {
18867 throw;
18868 }
18869}
18870
18871
18873 PLFLT *arg1 = (PLFLT *) 0 ;
18874 PLFLT *arg2 = (PLFLT *) 0 ;
18875 PLFLT temp1 ;
18876 int res1 = SWIG_TMPOBJ ;
18877 PLFLT temp2 ;
18878 int res2 = SWIG_TMPOBJ ;
18879 octave_value_list _out;
18880 octave_value_list *_outp=&_out;
18881 octave_value _outv;
18882
18883 try {
18884 arg1 = &temp1;
18885 arg2 = &temp2;
18886 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18887 SWIG_fail;
18888 }
18889 plgchr(arg1,arg2);
18890 _outv = octave_value();
18891 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18892 if (SWIG_IsTmpObj(res1)) {
18893 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18894 } else {
18895 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18896 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18897 }
18898 if (SWIG_IsTmpObj(res2)) {
18899 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18900 } else {
18901 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18902 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18903 }
18904 return _out;
18905 fail:
18906 return octave_value_list();
18907 }
18908 catch(...) {
18909 throw;
18910 }
18911}
18912
18913
18915 PLINT arg1 ;
18916 PLINT *arg2 = (PLINT *) 0 ;
18917 PLINT *arg3 = (PLINT *) 0 ;
18918 PLINT *arg4 = (PLINT *) 0 ;
18919 int val1 ;
18920 int ecode1 = 0 ;
18921 PLINT temp2 ;
18922 int res2 = SWIG_TMPOBJ ;
18923 PLINT temp3 ;
18924 int res3 = SWIG_TMPOBJ ;
18925 PLINT temp4 ;
18926 int res4 = SWIG_TMPOBJ ;
18927 octave_value_list _out;
18928 octave_value_list *_outp=&_out;
18929 octave_value _outv;
18930
18931 try {
18932 arg2 = &temp2;
18933 arg3 = &temp3;
18934 arg4 = &temp4;
18935 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
18936 SWIG_fail;
18937 }
18938 ecode1 = SWIG_AsVal_int(args(0), &val1);
18939 if (!SWIG_IsOK(ecode1)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
18941 }
18942 arg1 = static_cast< PLINT >(val1);
18943 plgcol0(arg1,arg2,arg3,arg4);
18944 _outv = octave_value();
18945 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18946 if (SWIG_IsTmpObj(res2)) {
18947 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18948 } else {
18949 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18950 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18951 }
18952 if (SWIG_IsTmpObj(res3)) {
18953 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18954 } else {
18955 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18956 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18957 }
18958 if (SWIG_IsTmpObj(res4)) {
18959 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18960 } else {
18961 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18962 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18963 }
18964 return _out;
18965 fail:
18966 return octave_value_list();
18967 }
18968 catch(...) {
18969 throw;
18970 }
18971}
18972
18973
18975 PLINT arg1 ;
18976 PLINT *arg2 = (PLINT *) 0 ;
18977 PLINT *arg3 = (PLINT *) 0 ;
18978 PLINT *arg4 = (PLINT *) 0 ;
18979 PLFLT *arg5 = (PLFLT *) 0 ;
18980 int val1 ;
18981 int ecode1 = 0 ;
18982 PLINT temp2 ;
18983 int res2 = SWIG_TMPOBJ ;
18984 PLINT temp3 ;
18985 int res3 = SWIG_TMPOBJ ;
18986 PLINT temp4 ;
18987 int res4 = SWIG_TMPOBJ ;
18988 PLFLT temp5 ;
18989 int res5 = SWIG_TMPOBJ ;
18990 octave_value_list _out;
18991 octave_value_list *_outp=&_out;
18992 octave_value _outv;
18993
18994 try {
18995 arg2 = &temp2;
18996 arg3 = &temp3;
18997 arg4 = &temp4;
18998 arg5 = &temp5;
18999 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19000 SWIG_fail;
19001 }
19002 ecode1 = SWIG_AsVal_int(args(0), &val1);
19003 if (!SWIG_IsOK(ecode1)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19005 }
19006 arg1 = static_cast< PLINT >(val1);
19007 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19008 _outv = octave_value();
19009 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19010 if (SWIG_IsTmpObj(res2)) {
19011 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19012 } else {
19013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19014 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19015 }
19016 if (SWIG_IsTmpObj(res3)) {
19017 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19018 } else {
19019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19020 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19021 }
19022 if (SWIG_IsTmpObj(res4)) {
19023 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19024 } else {
19025 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19026 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19027 }
19028 if (SWIG_IsTmpObj(res5)) {
19029 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19030 } else {
19031 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19032 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19033 }
19034 return _out;
19035 fail:
19036 return octave_value_list();
19037 }
19038 catch(...) {
19039 throw;
19040 }
19041}
19042
19043
19045 PLINT *arg1 = (PLINT *) 0 ;
19046 PLINT *arg2 = (PLINT *) 0 ;
19047 PLINT *arg3 = (PLINT *) 0 ;
19048 PLINT temp1 ;
19049 int res1 = SWIG_TMPOBJ ;
19050 PLINT temp2 ;
19051 int res2 = SWIG_TMPOBJ ;
19052 PLINT temp3 ;
19053 int res3 = SWIG_TMPOBJ ;
19054 octave_value_list _out;
19055 octave_value_list *_outp=&_out;
19056 octave_value _outv;
19057
19058 try {
19059 arg1 = &temp1;
19060 arg2 = &temp2;
19061 arg3 = &temp3;
19062 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19063 SWIG_fail;
19064 }
19065 plgcolbg(arg1,arg2,arg3);
19066 _outv = octave_value();
19067 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19068 if (SWIG_IsTmpObj(res1)) {
19069 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19070 } else {
19071 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19072 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19073 }
19074 if (SWIG_IsTmpObj(res2)) {
19075 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19076 } else {
19077 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19078 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19079 }
19080 if (SWIG_IsTmpObj(res3)) {
19081 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19082 } else {
19083 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19084 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19085 }
19086 return _out;
19087 fail:
19088 return octave_value_list();
19089 }
19090 catch(...) {
19091 throw;
19092 }
19093}
19094
19095
19097 PLINT *arg1 = (PLINT *) 0 ;
19098 PLINT *arg2 = (PLINT *) 0 ;
19099 PLINT *arg3 = (PLINT *) 0 ;
19100 PLFLT *arg4 = (PLFLT *) 0 ;
19101 PLINT temp1 ;
19102 int res1 = SWIG_TMPOBJ ;
19103 PLINT temp2 ;
19104 int res2 = SWIG_TMPOBJ ;
19105 PLINT temp3 ;
19106 int res3 = SWIG_TMPOBJ ;
19107 PLFLT temp4 ;
19108 int res4 = SWIG_TMPOBJ ;
19109 octave_value_list _out;
19110 octave_value_list *_outp=&_out;
19111 octave_value _outv;
19112
19113 try {
19114 arg1 = &temp1;
19115 arg2 = &temp2;
19116 arg3 = &temp3;
19117 arg4 = &temp4;
19118 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19119 SWIG_fail;
19120 }
19121 plgcolbga(arg1,arg2,arg3,arg4);
19122 _outv = octave_value();
19123 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19124 if (SWIG_IsTmpObj(res1)) {
19125 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19126 } else {
19127 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19128 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19129 }
19130 if (SWIG_IsTmpObj(res2)) {
19131 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19132 } else {
19133 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19134 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19135 }
19136 if (SWIG_IsTmpObj(res3)) {
19137 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19138 } else {
19139 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19140 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19141 }
19142 if (SWIG_IsTmpObj(res4)) {
19143 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19144 } else {
19145 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19146 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19147 }
19148 return _out;
19149 fail:
19150 return octave_value_list();
19151 }
19152 catch(...) {
19153 throw;
19154 }
19155}
19156
19157
19158SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19159 PLINT *arg1 = (PLINT *) 0 ;
19160 PLINT temp1 ;
19161 int res1 = SWIG_TMPOBJ ;
19162 octave_value_list _out;
19163 octave_value_list *_outp=&_out;
19164 octave_value _outv;
19165
19166 try {
19167 arg1 = &temp1;
19168 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19169 SWIG_fail;
19170 }
19171 plgcompression(arg1);
19172 _outv = octave_value();
19173 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19174 if (SWIG_IsTmpObj(res1)) {
19175 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19176 } else {
19177 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19178 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19179 }
19180 return _out;
19181 fail:
19182 return octave_value_list();
19183 }
19184 catch(...) {
19185 throw;
19186 }
19187}
19188
19189
19191 char *arg1 = (char *) 0 ;
19192 char local_string1[80] ;
19193 size_t local_string_length1 ;
19194 charMatrix local_charMatrix1 ;
19195 octave_value_list retval1 ;
19196 octave_value_list _out;
19197 octave_value_list *_outp=&_out;
19198 octave_value _outv;
19199
19200 try {
19201 {
19202 arg1 = local_string1;
19203 }
19204 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19205 SWIG_fail;
19206 }
19207 plgdev(arg1);
19208 _outv = octave_value();
19209 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19210 {
19211 local_string_length1 = strlen( local_string1 );
19212 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19213 local_charMatrix1.insert( local_string1, 0, 0 );
19214 retval1( 0 ) = octave_value( local_charMatrix1 );
19215 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19216 }
19217 return _out;
19218 fail:
19219 return octave_value_list();
19220 }
19221 catch(...) {
19222 throw;
19223 }
19224}
19225
19226
19228 PLFLT *arg1 = (PLFLT *) 0 ;
19229 PLFLT *arg2 = (PLFLT *) 0 ;
19230 PLFLT *arg3 = (PLFLT *) 0 ;
19231 PLFLT *arg4 = (PLFLT *) 0 ;
19232 PLFLT temp1 ;
19233 int res1 = SWIG_TMPOBJ ;
19234 PLFLT temp2 ;
19235 int res2 = SWIG_TMPOBJ ;
19236 PLFLT temp3 ;
19237 int res3 = SWIG_TMPOBJ ;
19238 PLFLT temp4 ;
19239 int res4 = SWIG_TMPOBJ ;
19240 octave_value_list _out;
19241 octave_value_list *_outp=&_out;
19242 octave_value _outv;
19243
19244 try {
19245 arg1 = &temp1;
19246 arg2 = &temp2;
19247 arg3 = &temp3;
19248 arg4 = &temp4;
19249 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19250 SWIG_fail;
19251 }
19252 plgdidev(arg1,arg2,arg3,arg4);
19253 _outv = octave_value();
19254 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19255 if (SWIG_IsTmpObj(res1)) {
19256 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19257 } else {
19258 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19259 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19260 }
19261 if (SWIG_IsTmpObj(res2)) {
19262 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19263 } else {
19264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19265 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19266 }
19267 if (SWIG_IsTmpObj(res3)) {
19268 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19269 } else {
19270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19271 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19272 }
19273 if (SWIG_IsTmpObj(res4)) {
19274 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19275 } else {
19276 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19277 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19278 }
19279 return _out;
19280 fail:
19281 return octave_value_list();
19282 }
19283 catch(...) {
19284 throw;
19285 }
19286}
19287
19288
19290 PLFLT *arg1 = (PLFLT *) 0 ;
19291 PLFLT temp1 ;
19292 int res1 = SWIG_TMPOBJ ;
19293 octave_value_list _out;
19294 octave_value_list *_outp=&_out;
19295 octave_value _outv;
19296
19297 try {
19298 arg1 = &temp1;
19299 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19300 SWIG_fail;
19301 }
19302 plgdiori(arg1);
19303 _outv = octave_value();
19304 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19305 if (SWIG_IsTmpObj(res1)) {
19306 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19307 } else {
19308 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19309 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19310 }
19311 return _out;
19312 fail:
19313 return octave_value_list();
19314 }
19315 catch(...) {
19316 throw;
19317 }
19318}
19319
19320
19322 PLFLT *arg1 = (PLFLT *) 0 ;
19323 PLFLT *arg2 = (PLFLT *) 0 ;
19324 PLFLT *arg3 = (PLFLT *) 0 ;
19325 PLFLT *arg4 = (PLFLT *) 0 ;
19326 PLFLT temp1 ;
19327 int res1 = SWIG_TMPOBJ ;
19328 PLFLT temp2 ;
19329 int res2 = SWIG_TMPOBJ ;
19330 PLFLT temp3 ;
19331 int res3 = SWIG_TMPOBJ ;
19332 PLFLT temp4 ;
19333 int res4 = SWIG_TMPOBJ ;
19334 octave_value_list _out;
19335 octave_value_list *_outp=&_out;
19336 octave_value _outv;
19337
19338 try {
19339 arg1 = &temp1;
19340 arg2 = &temp2;
19341 arg3 = &temp3;
19342 arg4 = &temp4;
19343 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19344 SWIG_fail;
19345 }
19346 plgdiplt(arg1,arg2,arg3,arg4);
19347 _outv = octave_value();
19348 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19349 if (SWIG_IsTmpObj(res1)) {
19350 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19351 } else {
19352 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19353 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19354 }
19355 if (SWIG_IsTmpObj(res2)) {
19356 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19357 } else {
19358 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19359 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19360 }
19361 if (SWIG_IsTmpObj(res3)) {
19362 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19363 } else {
19364 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19365 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19366 }
19367 if (SWIG_IsTmpObj(res4)) {
19368 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19369 } else {
19370 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19371 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19372 }
19373 return _out;
19374 fail:
19375 return octave_value_list();
19376 }
19377 catch(...) {
19378 throw;
19379 }
19380}
19381
19382
19384 PLINT *arg1 = (PLINT *) 0 ;
19385 PLINT *arg2 = (PLINT *) 0 ;
19386 PLINT *arg3 = (PLINT *) 0 ;
19387 PLINT temp1 ;
19388 int res1 = SWIG_TMPOBJ ;
19389 PLINT temp2 ;
19390 int res2 = SWIG_TMPOBJ ;
19391 PLINT temp3 ;
19392 int res3 = SWIG_TMPOBJ ;
19393 octave_value_list _out;
19394 octave_value_list *_outp=&_out;
19395 octave_value _outv;
19396
19397 try {
19398 arg1 = &temp1;
19399 arg2 = &temp2;
19400 arg3 = &temp3;
19401 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19402 SWIG_fail;
19403 }
19404 plgfam(arg1,arg2,arg3);
19405 _outv = octave_value();
19406 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19407 if (SWIG_IsTmpObj(res1)) {
19408 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19409 } else {
19410 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19411 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19412 }
19413 if (SWIG_IsTmpObj(res2)) {
19414 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19415 } else {
19416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19417 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19418 }
19419 if (SWIG_IsTmpObj(res3)) {
19420 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19421 } else {
19422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19423 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19424 }
19425 return _out;
19426 fail:
19427 return octave_value_list();
19428 }
19429 catch(...) {
19430 throw;
19431 }
19432}
19433
19434
19436 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19437 PLUNICODE temp1 ;
19438 int res1 = SWIG_TMPOBJ ;
19439 octave_value_list _out;
19440 octave_value_list *_outp=&_out;
19441 octave_value _outv;
19442
19443 try {
19444 arg1 = &temp1;
19445 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19446 SWIG_fail;
19447 }
19448 plgfci(arg1);
19449 _outv = octave_value();
19450 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19451 if (SWIG_IsTmpObj(res1)) {
19452 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19453 } else {
19454 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19455 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19456 }
19457 return _out;
19458 fail:
19459 return octave_value_list();
19460 }
19461 catch(...) {
19462 throw;
19463 }
19464}
19465
19466
19468 char *arg1 = (char *) 0 ;
19469 char local_string1[80] ;
19470 size_t local_string_length1 ;
19471 charMatrix local_charMatrix1 ;
19472 octave_value_list retval1 ;
19473 octave_value_list _out;
19474 octave_value_list *_outp=&_out;
19475 octave_value _outv;
19476
19477 try {
19478 {
19479 arg1 = local_string1;
19480 }
19481 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19482 SWIG_fail;
19483 }
19484 plgfnam(arg1);
19485 _outv = octave_value();
19486 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19487 {
19488 local_string_length1 = strlen( local_string1 );
19489 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19490 local_charMatrix1.insert( local_string1, 0, 0 );
19491 retval1( 0 ) = octave_value( local_charMatrix1 );
19492 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19493 }
19494 return _out;
19495 fail:
19496 return octave_value_list();
19497 }
19498 catch(...) {
19499 throw;
19500 }
19501}
19502
19503
19505 PLINT *arg1 = (PLINT *) 0 ;
19506 PLINT *arg2 = (PLINT *) 0 ;
19507 PLINT *arg3 = (PLINT *) 0 ;
19508 PLINT temp1 ;
19509 int res1 = SWIG_TMPOBJ ;
19510 PLINT temp2 ;
19511 int res2 = SWIG_TMPOBJ ;
19512 PLINT temp3 ;
19513 int res3 = SWIG_TMPOBJ ;
19514 octave_value_list _out;
19515 octave_value_list *_outp=&_out;
19516 octave_value _outv;
19517
19518 try {
19519 arg1 = &temp1;
19520 arg2 = &temp2;
19521 arg3 = &temp3;
19522 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19523 SWIG_fail;
19524 }
19525 plgfont(arg1,arg2,arg3);
19526 _outv = octave_value();
19527 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19528 if (SWIG_IsTmpObj(res1)) {
19529 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19530 } else {
19531 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19532 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19533 }
19534 if (SWIG_IsTmpObj(res2)) {
19535 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19536 } else {
19537 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19538 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19539 }
19540 if (SWIG_IsTmpObj(res3)) {
19541 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19542 } else {
19543 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19544 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19545 }
19546 return _out;
19547 fail:
19548 return octave_value_list();
19549 }
19550 catch(...) {
19551 throw;
19552 }
19553}
19554
19555
19557 PLINT *arg1 = (PLINT *) 0 ;
19558 PLINT temp1 ;
19559 int res1 = SWIG_TMPOBJ ;
19560 octave_value_list _out;
19561 octave_value_list *_outp=&_out;
19562 octave_value _outv;
19563
19564 try {
19565 arg1 = &temp1;
19566 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19567 SWIG_fail;
19568 }
19569 plglevel(arg1);
19570 _outv = octave_value();
19571 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19572 if (SWIG_IsTmpObj(res1)) {
19573 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19574 } else {
19575 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19576 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19577 }
19578 return _out;
19579 fail:
19580 return octave_value_list();
19581 }
19582 catch(...) {
19583 throw;
19584 }
19585}
19586
19587
19589 PLFLT *arg1 = (PLFLT *) 0 ;
19590 PLFLT *arg2 = (PLFLT *) 0 ;
19591 PLINT *arg3 = (PLINT *) 0 ;
19592 PLINT *arg4 = (PLINT *) 0 ;
19593 PLINT *arg5 = (PLINT *) 0 ;
19594 PLINT *arg6 = (PLINT *) 0 ;
19595 PLFLT temp1 ;
19596 int res1 = SWIG_TMPOBJ ;
19597 PLFLT temp2 ;
19598 int res2 = SWIG_TMPOBJ ;
19599 PLINT temp3 ;
19600 int res3 = SWIG_TMPOBJ ;
19601 PLINT temp4 ;
19602 int res4 = SWIG_TMPOBJ ;
19603 PLINT temp5 ;
19604 int res5 = SWIG_TMPOBJ ;
19605 PLINT temp6 ;
19606 int res6 = SWIG_TMPOBJ ;
19607 octave_value_list _out;
19608 octave_value_list *_outp=&_out;
19609 octave_value _outv;
19610
19611 try {
19612 arg1 = &temp1;
19613 arg2 = &temp2;
19614 arg3 = &temp3;
19615 arg4 = &temp4;
19616 arg5 = &temp5;
19617 arg6 = &temp6;
19618 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19619 SWIG_fail;
19620 }
19621 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19622 _outv = octave_value();
19623 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19624 if (SWIG_IsTmpObj(res1)) {
19625 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19626 } else {
19627 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19628 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19629 }
19630 if (SWIG_IsTmpObj(res2)) {
19631 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19632 } else {
19633 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19634 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19635 }
19636 if (SWIG_IsTmpObj(res3)) {
19637 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19638 } else {
19639 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19640 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19641 }
19642 if (SWIG_IsTmpObj(res4)) {
19643 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19644 } else {
19645 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19646 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19647 }
19648 if (SWIG_IsTmpObj(res5)) {
19649 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19650 } else {
19651 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19652 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19653 }
19654 if (SWIG_IsTmpObj(res6)) {
19655 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19656 } else {
19657 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19658 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19659 }
19660 return _out;
19661 fail:
19662 return octave_value_list();
19663 }
19664 catch(...) {
19665 throw;
19666 }
19667}
19668
19669
19671 octave_value_list _out;
19672 octave_value_list *_outp=&_out;
19673 octave_value _outv;
19674
19675 try {
19676 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19677 SWIG_fail;
19678 }
19679 plgra();
19680 _outv = octave_value();
19681 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19682 return _out;
19683 fail:
19684 return octave_value_list();
19685 }
19686 catch(...) {
19687 throw;
19688 }
19689}
19690
19691
19693 PLFLT *arg1 = (PLFLT *) 0 ;
19694 PLFLT *arg2 = (PLFLT *) 0 ;
19695 PLFLT *arg3 = (PLFLT *) 0 ;
19696 PLFLT *arg4 = (PLFLT *) 0 ;
19697 PLFLT temp1 ;
19698 int res1 = SWIG_TMPOBJ ;
19699 PLFLT temp2 ;
19700 int res2 = SWIG_TMPOBJ ;
19701 PLFLT temp3 ;
19702 int res3 = SWIG_TMPOBJ ;
19703 PLFLT temp4 ;
19704 int res4 = SWIG_TMPOBJ ;
19705 octave_value_list _out;
19706 octave_value_list *_outp=&_out;
19707 octave_value _outv;
19708
19709 try {
19710 arg1 = &temp1;
19711 arg2 = &temp2;
19712 arg3 = &temp3;
19713 arg4 = &temp4;
19714 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19715 SWIG_fail;
19716 }
19717 plgspa(arg1,arg2,arg3,arg4);
19718 _outv = octave_value();
19719 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19720 if (SWIG_IsTmpObj(res1)) {
19721 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19722 } else {
19723 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19724 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19725 }
19726 if (SWIG_IsTmpObj(res2)) {
19727 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19728 } else {
19729 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19730 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19731 }
19732 if (SWIG_IsTmpObj(res3)) {
19733 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19734 } else {
19735 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19736 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19737 }
19738 if (SWIG_IsTmpObj(res4)) {
19739 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19740 } else {
19741 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19742 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19743 }
19744 return _out;
19745 fail:
19746 return octave_value_list();
19747 }
19748 catch(...) {
19749 throw;
19750 }
19751}
19752
19753
19755 PLINT *arg1 = (PLINT *) 0 ;
19756 PLINT temp1 ;
19757 int res1 = SWIG_TMPOBJ ;
19758 octave_value_list _out;
19759 octave_value_list *_outp=&_out;
19760 octave_value _outv;
19761
19762 try {
19763 arg1 = &temp1;
19764 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19765 SWIG_fail;
19766 }
19767 plgstrm(arg1);
19768 _outv = octave_value();
19769 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19770 if (SWIG_IsTmpObj(res1)) {
19771 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19772 } else {
19773 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19774 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19775 }
19776 return _out;
19777 fail:
19778 return octave_value_list();
19779 }
19780 catch(...) {
19781 throw;
19782 }
19783}
19784
19785
19787 char *arg1 = (char *) 0 ;
19788 char local_string1[80] ;
19789 size_t local_string_length1 ;
19790 charMatrix local_charMatrix1 ;
19791 octave_value_list retval1 ;
19792 octave_value_list _out;
19793 octave_value_list *_outp=&_out;
19794 octave_value _outv;
19795
19796 try {
19797 {
19798 arg1 = local_string1;
19799 }
19800 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19801 SWIG_fail;
19802 }
19803 plgver(arg1);
19804 _outv = octave_value();
19805 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19806 {
19807 local_string_length1 = strlen( local_string1 );
19808 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19809 local_charMatrix1.insert( local_string1, 0, 0 );
19810 retval1( 0 ) = octave_value( local_charMatrix1 );
19811 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19812 }
19813 return _out;
19814 fail:
19815 return octave_value_list();
19816 }
19817 catch(...) {
19818 throw;
19819 }
19820}
19821
19822
19824 PLFLT *arg1 = (PLFLT *) 0 ;
19825 PLFLT *arg2 = (PLFLT *) 0 ;
19826 PLFLT *arg3 = (PLFLT *) 0 ;
19827 PLFLT *arg4 = (PLFLT *) 0 ;
19828 PLFLT temp1 ;
19829 int res1 = SWIG_TMPOBJ ;
19830 PLFLT temp2 ;
19831 int res2 = SWIG_TMPOBJ ;
19832 PLFLT temp3 ;
19833 int res3 = SWIG_TMPOBJ ;
19834 PLFLT temp4 ;
19835 int res4 = SWIG_TMPOBJ ;
19836 octave_value_list _out;
19837 octave_value_list *_outp=&_out;
19838 octave_value _outv;
19839
19840 try {
19841 arg1 = &temp1;
19842 arg2 = &temp2;
19843 arg3 = &temp3;
19844 arg4 = &temp4;
19845 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19846 SWIG_fail;
19847 }
19848 plgvpd(arg1,arg2,arg3,arg4);
19849 _outv = octave_value();
19850 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19851 if (SWIG_IsTmpObj(res1)) {
19852 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19853 } else {
19854 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19855 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19856 }
19857 if (SWIG_IsTmpObj(res2)) {
19858 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19859 } else {
19860 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19861 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19862 }
19863 if (SWIG_IsTmpObj(res3)) {
19864 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19865 } else {
19866 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19867 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19868 }
19869 if (SWIG_IsTmpObj(res4)) {
19870 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19871 } else {
19872 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19873 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19874 }
19875 return _out;
19876 fail:
19877 return octave_value_list();
19878 }
19879 catch(...) {
19880 throw;
19881 }
19882}
19883
19884
19886 PLFLT *arg1 = (PLFLT *) 0 ;
19887 PLFLT *arg2 = (PLFLT *) 0 ;
19888 PLFLT *arg3 = (PLFLT *) 0 ;
19889 PLFLT *arg4 = (PLFLT *) 0 ;
19890 PLFLT temp1 ;
19891 int res1 = SWIG_TMPOBJ ;
19892 PLFLT temp2 ;
19893 int res2 = SWIG_TMPOBJ ;
19894 PLFLT temp3 ;
19895 int res3 = SWIG_TMPOBJ ;
19896 PLFLT temp4 ;
19897 int res4 = SWIG_TMPOBJ ;
19898 octave_value_list _out;
19899 octave_value_list *_outp=&_out;
19900 octave_value _outv;
19901
19902 try {
19903 arg1 = &temp1;
19904 arg2 = &temp2;
19905 arg3 = &temp3;
19906 arg4 = &temp4;
19907 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19908 SWIG_fail;
19909 }
19910 plgvpw(arg1,arg2,arg3,arg4);
19911 _outv = octave_value();
19912 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19913 if (SWIG_IsTmpObj(res1)) {
19914 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19915 } else {
19916 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19917 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19918 }
19919 if (SWIG_IsTmpObj(res2)) {
19920 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19921 } else {
19922 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19923 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19924 }
19925 if (SWIG_IsTmpObj(res3)) {
19926 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19927 } else {
19928 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19929 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19930 }
19931 if (SWIG_IsTmpObj(res4)) {
19932 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19933 } else {
19934 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19935 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19936 }
19937 return _out;
19938 fail:
19939 return octave_value_list();
19940 }
19941 catch(...) {
19942 throw;
19943 }
19944}
19945
19946
19948 PLINT *arg1 = (PLINT *) 0 ;
19949 PLINT *arg2 = (PLINT *) 0 ;
19950 PLINT temp1 ;
19951 int res1 = SWIG_TMPOBJ ;
19952 PLINT temp2 ;
19953 int res2 = SWIG_TMPOBJ ;
19954 octave_value_list _out;
19955 octave_value_list *_outp=&_out;
19956 octave_value _outv;
19957
19958 try {
19959 arg1 = &temp1;
19960 arg2 = &temp2;
19961 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
19962 SWIG_fail;
19963 }
19964 plgxax(arg1,arg2);
19965 _outv = octave_value();
19966 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19967 if (SWIG_IsTmpObj(res1)) {
19968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19969 } else {
19970 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19971 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19972 }
19973 if (SWIG_IsTmpObj(res2)) {
19974 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19975 } else {
19976 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19977 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19978 }
19979 return _out;
19980 fail:
19981 return octave_value_list();
19982 }
19983 catch(...) {
19984 throw;
19985 }
19986}
19987
19988
19990 PLINT *arg1 = (PLINT *) 0 ;
19991 PLINT *arg2 = (PLINT *) 0 ;
19992 PLINT temp1 ;
19993 int res1 = SWIG_TMPOBJ ;
19994 PLINT temp2 ;
19995 int res2 = SWIG_TMPOBJ ;
19996 octave_value_list _out;
19997 octave_value_list *_outp=&_out;
19998 octave_value _outv;
19999
20000 try {
20001 arg1 = &temp1;
20002 arg2 = &temp2;
20003 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20004 SWIG_fail;
20005 }
20006 plgyax(arg1,arg2);
20007 _outv = octave_value();
20008 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20009 if (SWIG_IsTmpObj(res1)) {
20010 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20011 } else {
20012 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20013 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20014 }
20015 if (SWIG_IsTmpObj(res2)) {
20016 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20017 } else {
20018 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20019 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20020 }
20021 return _out;
20022 fail:
20023 return octave_value_list();
20024 }
20025 catch(...) {
20026 throw;
20027 }
20028}
20029
20030
20032 PLINT *arg1 = (PLINT *) 0 ;
20033 PLINT *arg2 = (PLINT *) 0 ;
20034 PLINT temp1 ;
20035 int res1 = SWIG_TMPOBJ ;
20036 PLINT temp2 ;
20037 int res2 = SWIG_TMPOBJ ;
20038 octave_value_list _out;
20039 octave_value_list *_outp=&_out;
20040 octave_value _outv;
20041
20042 try {
20043 arg1 = &temp1;
20044 arg2 = &temp2;
20045 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20046 SWIG_fail;
20047 }
20048 plgzax(arg1,arg2);
20049 _outv = octave_value();
20050 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20051 if (SWIG_IsTmpObj(res1)) {
20052 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20053 } else {
20054 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20055 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20056 }
20057 if (SWIG_IsTmpObj(res2)) {
20058 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20059 } else {
20060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20061 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20062 }
20063 return _out;
20064 fail:
20065 return octave_value_list();
20066 }
20067 catch(...) {
20068 throw;
20069 }
20070}
20071
20072
20074 PLINT arg1 ;
20075 PLFLT *arg2 = (PLFLT *) 0 ;
20076 PLFLT arg3 ;
20077 PLFLT arg4 ;
20078 PLINT arg5 ;
20079 PLINT arg6 ;
20080 Matrix temp1 ;
20081 double val3 ;
20082 int ecode3 = 0 ;
20083 double val4 ;
20084 int ecode4 = 0 ;
20085 int val5 ;
20086 int ecode5 = 0 ;
20087 int val6 ;
20088 int ecode6 = 0 ;
20089 octave_value_list _out;
20090 octave_value_list *_outp=&_out;
20091 octave_value _outv;
20092
20093 try {
20094 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20095 SWIG_fail;
20096 }
20097 {
20098 if ( _n_dims( args(0) ) > 1 )
20099 {
20100 error( "argument must be a scalar or vector" ); SWIG_fail;
20101 }
20102 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20103 temp1 = args(0).matrix_value();
20104 arg2 = &temp1( 0, 0 );
20105 }
20106 ecode3 = SWIG_AsVal_double(args(1), &val3);
20107 if (!SWIG_IsOK(ecode3)) {
20108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20109 }
20110 arg3 = static_cast< PLFLT >(val3);
20111 ecode4 = SWIG_AsVal_double(args(2), &val4);
20112 if (!SWIG_IsOK(ecode4)) {
20113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20114 }
20115 arg4 = static_cast< PLFLT >(val4);
20116 ecode5 = SWIG_AsVal_int(args(3), &val5);
20117 if (!SWIG_IsOK(ecode5)) {
20118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20119 }
20120 arg5 = static_cast< PLINT >(val5);
20121 ecode6 = SWIG_AsVal_int(args(4), &val6);
20122 if (!SWIG_IsOK(ecode6)) {
20123 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20124 }
20125 arg6 = static_cast< PLINT >(val6);
20126 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20127 _outv = octave_value();
20128 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20129 {
20130
20131 }
20132 return _out;
20133 fail:
20134 {
20135
20136 }
20137 return octave_value_list();
20138 }
20139 catch(...) {
20140 {
20141
20142 }
20143 throw;
20144 }
20145}
20146
20147
20149 PLFLT arg1 ;
20150 PLFLT arg2 ;
20151 PLFLT arg3 ;
20152 PLFLT *arg4 = (PLFLT *) 0 ;
20153 PLFLT *arg5 = (PLFLT *) 0 ;
20154 PLFLT *arg6 = (PLFLT *) 0 ;
20155 double val1 ;
20156 int ecode1 = 0 ;
20157 double val2 ;
20158 int ecode2 = 0 ;
20159 double val3 ;
20160 int ecode3 = 0 ;
20161 PLFLT temp4 ;
20162 int res4 = SWIG_TMPOBJ ;
20163 PLFLT temp5 ;
20164 int res5 = SWIG_TMPOBJ ;
20165 PLFLT temp6 ;
20166 int res6 = SWIG_TMPOBJ ;
20167 octave_value_list _out;
20168 octave_value_list *_outp=&_out;
20169 octave_value _outv;
20170
20171 try {
20172 arg4 = &temp4;
20173 arg5 = &temp5;
20174 arg6 = &temp6;
20175 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20176 SWIG_fail;
20177 }
20178 ecode1 = SWIG_AsVal_double(args(0), &val1);
20179 if (!SWIG_IsOK(ecode1)) {
20180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20181 }
20182 arg1 = static_cast< PLFLT >(val1);
20183 ecode2 = SWIG_AsVal_double(args(1), &val2);
20184 if (!SWIG_IsOK(ecode2)) {
20185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20186 }
20187 arg2 = static_cast< PLFLT >(val2);
20188 ecode3 = SWIG_AsVal_double(args(2), &val3);
20189 if (!SWIG_IsOK(ecode3)) {
20190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20191 }
20192 arg3 = static_cast< PLFLT >(val3);
20193 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20194 _outv = octave_value();
20195 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20196 if (SWIG_IsTmpObj(res4)) {
20197 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20198 } else {
20199 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20200 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20201 }
20202 if (SWIG_IsTmpObj(res5)) {
20203 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20204 } else {
20205 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20206 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20207 }
20208 if (SWIG_IsTmpObj(res6)) {
20209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20210 } else {
20211 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20213 }
20214 return _out;
20215 fail:
20216 return octave_value_list();
20217 }
20218 catch(...) {
20219 throw;
20220 }
20221}
20222
20223
20225 octave_value_list _out;
20226 octave_value_list *_outp=&_out;
20227 octave_value _outv;
20228
20229 try {
20230 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20231 SWIG_fail;
20232 }
20233 plinit();
20234 _outv = octave_value();
20235 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20236 return _out;
20237 fail:
20238 return octave_value_list();
20239 }
20240 catch(...) {
20241 throw;
20242 }
20243}
20244
20245
20247 PLFLT arg1 ;
20248 PLFLT arg2 ;
20249 PLFLT arg3 ;
20250 PLFLT arg4 ;
20251 double val1 ;
20252 int ecode1 = 0 ;
20253 double val2 ;
20254 int ecode2 = 0 ;
20255 double val3 ;
20256 int ecode3 = 0 ;
20257 double val4 ;
20258 int ecode4 = 0 ;
20259 octave_value_list _out;
20260 octave_value_list *_outp=&_out;
20261 octave_value _outv;
20262
20263 try {
20264 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20265 SWIG_fail;
20266 }
20267 ecode1 = SWIG_AsVal_double(args(0), &val1);
20268 if (!SWIG_IsOK(ecode1)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20270 }
20271 arg1 = static_cast< PLFLT >(val1);
20272 ecode2 = SWIG_AsVal_double(args(1), &val2);
20273 if (!SWIG_IsOK(ecode2)) {
20274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20275 }
20276 arg2 = static_cast< PLFLT >(val2);
20277 ecode3 = SWIG_AsVal_double(args(2), &val3);
20278 if (!SWIG_IsOK(ecode3)) {
20279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20280 }
20281 arg3 = static_cast< PLFLT >(val3);
20282 ecode4 = SWIG_AsVal_double(args(3), &val4);
20283 if (!SWIG_IsOK(ecode4)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20285 }
20286 arg4 = static_cast< PLFLT >(val4);
20287 pljoin(arg1,arg2,arg3,arg4);
20288 _outv = octave_value();
20289 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20290 return _out;
20291 fail:
20292 return octave_value_list();
20293 }
20294 catch(...) {
20295 throw;
20296 }
20297}
20298
20299
20301 char *arg1 = (char *) 0 ;
20302 char *arg2 = (char *) 0 ;
20303 char *arg3 = (char *) 0 ;
20304 int res1 ;
20305 char *buf1 = 0 ;
20306 int alloc1 = 0 ;
20307 int res2 ;
20308 char *buf2 = 0 ;
20309 int alloc2 = 0 ;
20310 int res3 ;
20311 char *buf3 = 0 ;
20312 int alloc3 = 0 ;
20313 octave_value_list _out;
20314 octave_value_list *_outp=&_out;
20315 octave_value _outv;
20316
20317 try {
20318 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20319 SWIG_fail;
20320 }
20321 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20322 if (!SWIG_IsOK(res1)) {
20323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20324 }
20325 arg1 = reinterpret_cast< char * >(buf1);
20326 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20327 if (!SWIG_IsOK(res2)) {
20328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20329 }
20330 arg2 = reinterpret_cast< char * >(buf2);
20331 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20332 if (!SWIG_IsOK(res3)) {
20333 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20334 }
20335 arg3 = reinterpret_cast< char * >(buf3);
20336 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20337 _outv = octave_value();
20338 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20339 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20340 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20341 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20342 return _out;
20343 fail:
20344 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20345 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20346 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20347 return octave_value_list();
20348 }
20349 catch(...) {
20350 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20351 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20352 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20353 throw;
20354 }
20355}
20356
20357
20359 PLFLT *arg1 = (PLFLT *) 0 ;
20360 PLFLT *arg2 = (PLFLT *) 0 ;
20361 PLINT arg3 ;
20362 PLINT arg4 ;
20363 PLFLT arg5 ;
20364 PLFLT arg6 ;
20365 PLFLT arg7 ;
20366 PLINT arg8 ;
20367 PLINT arg9 ;
20368 PLINT arg10 ;
20369 PLINT arg11 ;
20370 PLINT arg12 ;
20371 PLINT arg13 ;
20372 PLINT *arg14 = (PLINT *) 0 ;
20373 PLFLT arg15 ;
20374 PLFLT arg16 ;
20375 PLFLT arg17 ;
20376 PLFLT arg18 ;
20377 PLINT *arg19 = (PLINT *) 0 ;
20378 char **arg20 = (char **) 0 ;
20379 PLINT *arg21 = (PLINT *) 0 ;
20380 PLINT *arg22 = (PLINT *) 0 ;
20381 PLFLT *arg23 = (PLFLT *) 0 ;
20382 PLFLT *arg24 = (PLFLT *) 0 ;
20383 PLINT *arg25 = (PLINT *) 0 ;
20384 PLINT *arg26 = (PLINT *) 0 ;
20385 PLFLT *arg27 = (PLFLT *) 0 ;
20386 PLINT *arg28 = (PLINT *) 0 ;
20387 PLFLT *arg29 = (PLFLT *) 0 ;
20388 PLINT *arg30 = (PLINT *) 0 ;
20389 char **arg31 = (char **) 0 ;
20390 PLFLT temp1 ;
20391 int res1 = SWIG_TMPOBJ ;
20392 PLFLT temp2 ;
20393 int res2 = SWIG_TMPOBJ ;
20394 int val3 ;
20395 int ecode3 = 0 ;
20396 int val4 ;
20397 int ecode4 = 0 ;
20398 double val5 ;
20399 int ecode5 = 0 ;
20400 double val6 ;
20401 int ecode6 = 0 ;
20402 double val7 ;
20403 int ecode7 = 0 ;
20404 int val8 ;
20405 int ecode8 = 0 ;
20406 int val9 ;
20407 int ecode9 = 0 ;
20408 int val10 ;
20409 int ecode10 = 0 ;
20410 int val11 ;
20411 int ecode11 = 0 ;
20412 int val12 ;
20413 int ecode12 = 0 ;
20414 Matrix temp13 ;
20415 double val15 ;
20416 int ecode15 = 0 ;
20417 double val16 ;
20418 int ecode16 = 0 ;
20419 double val17 ;
20420 int ecode17 = 0 ;
20421 double val18 ;
20422 int ecode18 = 0 ;
20423 Matrix temp19 ;
20424 Matrix temp21 ;
20425 Matrix temp22 ;
20426 Matrix temp23 ;
20427 Matrix temp24 ;
20428 Matrix temp25 ;
20429 Matrix temp26 ;
20430 Matrix temp27 ;
20431 Matrix temp28 ;
20432 Matrix temp29 ;
20433 Matrix temp30 ;
20434 octave_value_list _out;
20435 octave_value_list *_outp=&_out;
20436 octave_value _outv;
20437
20438 try {
20439 arg1 = &temp1;
20440 arg2 = &temp2;
20441 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20442 SWIG_fail;
20443 }
20444 ecode3 = SWIG_AsVal_int(args(0), &val3);
20445 if (!SWIG_IsOK(ecode3)) {
20446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20447 }
20448 arg3 = static_cast< PLINT >(val3);
20449 ecode4 = SWIG_AsVal_int(args(1), &val4);
20450 if (!SWIG_IsOK(ecode4)) {
20451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20452 }
20453 arg4 = static_cast< PLINT >(val4);
20454 ecode5 = SWIG_AsVal_double(args(2), &val5);
20455 if (!SWIG_IsOK(ecode5)) {
20456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20457 }
20458 arg5 = static_cast< PLFLT >(val5);
20459 ecode6 = SWIG_AsVal_double(args(3), &val6);
20460 if (!SWIG_IsOK(ecode6)) {
20461 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20462 }
20463 arg6 = static_cast< PLFLT >(val6);
20464 ecode7 = SWIG_AsVal_double(args(4), &val7);
20465 if (!SWIG_IsOK(ecode7)) {
20466 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20467 }
20468 arg7 = static_cast< PLFLT >(val7);
20469 ecode8 = SWIG_AsVal_int(args(5), &val8);
20470 if (!SWIG_IsOK(ecode8)) {
20471 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20472 }
20473 arg8 = static_cast< PLINT >(val8);
20474 ecode9 = SWIG_AsVal_int(args(6), &val9);
20475 if (!SWIG_IsOK(ecode9)) {
20476 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20477 }
20478 arg9 = static_cast< PLINT >(val9);
20479 ecode10 = SWIG_AsVal_int(args(7), &val10);
20480 if (!SWIG_IsOK(ecode10)) {
20481 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20482 }
20483 arg10 = static_cast< PLINT >(val10);
20484 ecode11 = SWIG_AsVal_int(args(8), &val11);
20485 if (!SWIG_IsOK(ecode11)) {
20486 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20487 }
20488 arg11 = static_cast< PLINT >(val11);
20489 ecode12 = SWIG_AsVal_int(args(9), &val12);
20490 if (!SWIG_IsOK(ecode12)) {
20491 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20492 }
20493 arg12 = static_cast< PLINT >(val12);
20494 {
20495 if ( _n_dims( args(10) ) > 1 )
20496 {
20497 error( "argument must be a scalar or vector" ); SWIG_fail;
20498 }
20499 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20500 arg14 = new PLINT[Alen];
20501 temp13 = args(10).matrix_value();
20502 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20503 }
20504 ecode15 = SWIG_AsVal_double(args(11), &val15);
20505 if (!SWIG_IsOK(ecode15)) {
20506 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20507 }
20508 arg15 = static_cast< PLFLT >(val15);
20509 ecode16 = SWIG_AsVal_double(args(12), &val16);
20510 if (!SWIG_IsOK(ecode16)) {
20511 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20512 }
20513 arg16 = static_cast< PLFLT >(val16);
20514 ecode17 = SWIG_AsVal_double(args(13), &val17);
20515 if (!SWIG_IsOK(ecode17)) {
20516 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20517 }
20518 arg17 = static_cast< PLFLT >(val17);
20519 ecode18 = SWIG_AsVal_double(args(14), &val18);
20520 if (!SWIG_IsOK(ecode18)) {
20521 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20522 }
20523 arg18 = static_cast< PLFLT >(val18);
20524 {
20525 if ( _n_dims( args(15) ) > 1 )
20526 {
20527 error( "argument must be a scalar or vector" ); SWIG_fail;
20528 }
20529 if ( _dim( args(15), 0 ) != Alen )
20530 {
20531 error( "argument vectors must be same length" ); SWIG_fail;
20532 }
20533 temp19 = args(15).matrix_value();
20534 arg19 = new PLINT[Alen];
20535 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20536 }
20537 {
20538 charMatrix temp_matrix;
20539 Cell temp_cell;
20540 char *tmp_cstring;
20541 std::string str;
20542 size_t max_length = 0, non_blank_length;
20543 int i, ifcell;
20544 if ( _n_dims( args(16) ) > 2 )
20545 {
20546 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20547 }
20548#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20549 if ( !args(16).isempty() )
20550#else
20551 if ( !args(16).is_empty() )
20552#endif
20553 {
20554 if ( _dim( args(16), 0 ) != Alen )
20555 {
20556 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20557 }
20558 arg20 = new char*[Alen];
20559#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20560 ifcell = args(16).iscell();
20561#else
20562 ifcell = args(16).is_cell();
20563#endif
20564 if ( ifcell )
20565 {
20566 temp_cell = args(16).cell_value();
20567 }
20568 else
20569 {
20570 temp_matrix = args(16).char_matrix_value();
20571 // Allow one extra space for null termination.
20572 max_length = _dim( args(16), 1 ) + 1;
20573 }
20574
20575 for ( i = 0; i < Alen; i++ )
20576 {
20577 // Must copy string to "permanent" location because the string
20578 // location corresponding to tmp_cstring gets
20579 // overwritten for each iteration of loop.
20580 if ( ifcell )
20581 {
20582 if ( temp_cell.elem( i ).is_string() )
20583 {
20584 str = temp_cell.elem( i ).string_value();
20585 // leave room for null termination.
20586 max_length = str.size() + 1;
20587 tmp_cstring = (char *) str.c_str();
20588 }
20589 else
20590 {
20591 // Use null string if user attempts to pass a cell array
20592 // with a non-string element (likely an empty element
20593 // since that should be allowed by the PLplot interface
20594 // if that element is going to be unused).
20595 // leave room for null termination.
20596 max_length = 1;
20597 tmp_cstring = (char *) "";
20598 }
20599 }
20600 else
20601 {
20602 str = temp_matrix.row_as_string( i );
20603 tmp_cstring = (char *) str.c_str();
20604 }
20605 arg20[i] = new char[max_length];
20606 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20607 arg20[i][max_length - 1] = '\0';
20608 // All the trailing blank crapola should not be needed for
20609 // string cell arrays.
20610 if ( !ifcell )
20611 {
20612 // remove trailing-blank padding that is used by the
20613 // charMatrix class to insure all strings in a given
20614 // charMatrix instance have the same length.
20615 // This transformation also removes legitimate trailing
20616 // blanks but there is nothing we can do about that
20617 // for the charMatrix class.
20618
20619 // Look for trailing nulls first (just in case, although that
20620 // shouldn't happen if charMatrix implemented as documented)
20621 // before looking for trailing blanks.
20622 non_blank_length = max_length - 2;
20623 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20624 {
20625 non_blank_length--;
20626 }
20627 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20628 {
20629 non_blank_length--;
20630 }
20631 arg20[i][non_blank_length + 1] = '\0';
20632 }
20633 }
20634 }
20635 else
20636 {
20637 arg20 = NULL;
20638 }
20639 }
20640 {
20641 if ( _n_dims( args(17) ) > 1 )
20642 {
20643 error( "argument must be a scalar or vector" ); SWIG_fail;
20644 }
20645#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20646 if ( !args(17).isempty() )
20647#else
20648 if ( !args(17).is_empty() )
20649#endif
20650 {
20651 if ( _dim( args(17), 0 ) != Alen )
20652 {
20653 error( "argument vectors must be same length" ); SWIG_fail;
20654 }
20655 temp21 = args(17).matrix_value();
20656 arg21 = new PLINT[Alen];
20657 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20658 }
20659 else
20660 {
20661 arg21 = NULL;
20662 }
20663 }
20664 {
20665 if ( _n_dims( args(18) ) > 1 )
20666 {
20667 error( "argument must be a scalar or vector" ); SWIG_fail;
20668 }
20669#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20670 if ( !args(18).isempty() )
20671#else
20672 if ( !args(18).is_empty() )
20673#endif
20674 {
20675 if ( _dim( args(18), 0 ) != Alen )
20676 {
20677 error( "argument vectors must be same length" ); SWIG_fail;
20678 }
20679 temp22 = args(18).matrix_value();
20680 arg22 = new PLINT[Alen];
20681 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20682 }
20683 else
20684 {
20685 arg22 = NULL;
20686 }
20687 }
20688 {
20689 if ( _n_dims( args(19) ) > 1 )
20690 {
20691 error( "argument must be a scalar or vector" ); SWIG_fail;
20692 }
20693#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20694 if ( !args(19).isempty() )
20695#else
20696 if ( !args(19).is_empty() )
20697#endif
20698 {
20699 if ( _dim( args(19), 0 ) != Alen )
20700 {
20701 error( "argument vectors must be same length" ); SWIG_fail;
20702 }
20703 temp23 = args(19).matrix_value();
20704 arg23 = &temp23( 0, 0 );
20705 }
20706 else
20707 {
20708 arg23 = NULL;
20709 }
20710 }
20711 {
20712 if ( _n_dims( args(20) ) > 1 )
20713 {
20714 error( "argument must be a scalar or vector" ); SWIG_fail;
20715 }
20716#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20717 if ( !args(20).isempty() )
20718#else
20719 if ( !args(20).is_empty() )
20720#endif
20721 {
20722 if ( _dim( args(20), 0 ) != Alen )
20723 {
20724 error( "argument vectors must be same length" ); SWIG_fail;
20725 }
20726 temp24 = args(20).matrix_value();
20727 arg24 = &temp24( 0, 0 );
20728 }
20729 else
20730 {
20731 arg24 = NULL;
20732 }
20733 }
20734 {
20735 if ( _n_dims( args(21) ) > 1 )
20736 {
20737 error( "argument must be a scalar or vector" ); SWIG_fail;
20738 }
20739#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20740 if ( !args(21).isempty() )
20741#else
20742 if ( !args(21).is_empty() )
20743#endif
20744 {
20745 if ( _dim( args(21), 0 ) != Alen )
20746 {
20747 error( "argument vectors must be same length" ); SWIG_fail;
20748 }
20749 temp25 = args(21).matrix_value();
20750 arg25 = new PLINT[Alen];
20751 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20752 }
20753 else
20754 {
20755 arg25 = NULL;
20756 }
20757 }
20758 {
20759 if ( _n_dims( args(22) ) > 1 )
20760 {
20761 error( "argument must be a scalar or vector" ); SWIG_fail;
20762 }
20763#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20764 if ( !args(22).isempty() )
20765#else
20766 if ( !args(22).is_empty() )
20767#endif
20768 {
20769 if ( _dim( args(22), 0 ) != Alen )
20770 {
20771 error( "argument vectors must be same length" ); SWIG_fail;
20772 }
20773 temp26 = args(22).matrix_value();
20774 arg26 = new PLINT[Alen];
20775 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20776 }
20777 else
20778 {
20779 arg26 = NULL;
20780 }
20781 }
20782 {
20783 if ( _n_dims( args(23) ) > 1 )
20784 {
20785 error( "argument must be a scalar or vector" ); SWIG_fail;
20786 }
20787#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20788 if ( !args(23).isempty() )
20789#else
20790 if ( !args(23).is_empty() )
20791#endif
20792 {
20793 if ( _dim( args(23), 0 ) != Alen )
20794 {
20795 error( "argument vectors must be same length" ); SWIG_fail;
20796 }
20797 temp27 = args(23).matrix_value();
20798 arg27 = &temp27( 0, 0 );
20799 }
20800 else
20801 {
20802 arg27 = NULL;
20803 }
20804 }
20805 {
20806 if ( _n_dims( args(24) ) > 1 )
20807 {
20808 error( "argument must be a scalar or vector" ); SWIG_fail;
20809 }
20810#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20811 if ( !args(24).isempty() )
20812#else
20813 if ( !args(24).is_empty() )
20814#endif
20815 {
20816 if ( _dim( args(24), 0 ) != Alen )
20817 {
20818 error( "argument vectors must be same length" ); SWIG_fail;
20819 }
20820 temp28 = args(24).matrix_value();
20821 arg28 = new PLINT[Alen];
20822 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20823 }
20824 else
20825 {
20826 arg28 = NULL;
20827 }
20828 }
20829 {
20830 if ( _n_dims( args(25) ) > 1 )
20831 {
20832 error( "argument must be a scalar or vector" ); SWIG_fail;
20833 }
20834#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20835 if ( !args(25).isempty() )
20836#else
20837 if ( !args(25).is_empty() )
20838#endif
20839 {
20840 if ( _dim( args(25), 0 ) != Alen )
20841 {
20842 error( "argument vectors must be same length" ); SWIG_fail;
20843 }
20844 temp29 = args(25).matrix_value();
20845 arg29 = &temp29( 0, 0 );
20846 }
20847 else
20848 {
20849 arg29 = NULL;
20850 }
20851 }
20852 {
20853 if ( _n_dims( args(26) ) > 1 )
20854 {
20855 error( "argument must be a scalar or vector" ); SWIG_fail;
20856 }
20857#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20858 if ( !args(26).isempty() )
20859#else
20860 if ( !args(26).is_empty() )
20861#endif
20862 {
20863 if ( _dim( args(26), 0 ) != Alen )
20864 {
20865 error( "argument vectors must be same length" ); SWIG_fail;
20866 }
20867 temp30 = args(26).matrix_value();
20868 arg30 = new PLINT[Alen];
20869 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20870 }
20871 else
20872 {
20873 arg30 = NULL;
20874 }
20875 }
20876 {
20877 charMatrix temp_matrix;
20878 Cell temp_cell;
20879 char *tmp_cstring;
20880 std::string str;
20881 size_t max_length = 0, non_blank_length;
20882 int i, ifcell;
20883 if ( _n_dims( args(27) ) > 2 )
20884 {
20885 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20886 }
20887#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20888 if ( !args(27).isempty() )
20889#else
20890 if ( !args(27).is_empty() )
20891#endif
20892 {
20893 if ( _dim( args(27), 0 ) != Alen )
20894 {
20895 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20896 }
20897 arg31 = new char*[Alen];
20898#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20899 ifcell = args(27).iscell();
20900#else
20901 ifcell = args(27).is_cell();
20902#endif
20903 if ( ifcell )
20904 {
20905 temp_cell = args(27).cell_value();
20906 }
20907 else
20908 {
20909 temp_matrix = args(27).char_matrix_value();
20910 // Allow one extra space for null termination.
20911 max_length = _dim( args(27), 1 ) + 1;
20912 }
20913
20914 for ( i = 0; i < Alen; i++ )
20915 {
20916 // Must copy string to "permanent" location because the string
20917 // location corresponding to tmp_cstring gets
20918 // overwritten for each iteration of loop.
20919 if ( ifcell )
20920 {
20921 if ( temp_cell.elem( i ).is_string() )
20922 {
20923 str = temp_cell.elem( i ).string_value();
20924 // leave room for null termination.
20925 max_length = str.size() + 1;
20926 tmp_cstring = (char *) str.c_str();
20927 }
20928 else
20929 {
20930 // Use null string if user attempts to pass a cell array
20931 // with a non-string element (likely an empty element
20932 // since that should be allowed by the PLplot interface
20933 // if that element is going to be unused).
20934 // leave room for null termination.
20935 max_length = 1;
20936 tmp_cstring = (char *) "";
20937 }
20938 }
20939 else
20940 {
20941 str = temp_matrix.row_as_string( i );
20942 tmp_cstring = (char *) str.c_str();
20943 }
20944 arg31[i] = new char[max_length];
20945 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20946 arg31[i][max_length - 1] = '\0';
20947 // All the trailing blank crapola should not be needed for
20948 // string cell arrays.
20949 if ( !ifcell )
20950 {
20951 // remove trailing-blank padding that is used by the
20952 // charMatrix class to insure all strings in a given
20953 // charMatrix instance have the same length.
20954 // This transformation also removes legitimate trailing
20955 // blanks but there is nothing we can do about that
20956 // for the charMatrix class.
20957
20958 // Look for trailing nulls first (just in case, although that
20959 // shouldn't happen if charMatrix implemented as documented)
20960 // before looking for trailing blanks.
20961 non_blank_length = max_length - 2;
20962 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
20963 {
20964 non_blank_length--;
20965 }
20966 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
20967 {
20968 non_blank_length--;
20969 }
20970 arg31[i][non_blank_length + 1] = '\0';
20971 }
20972 }
20973 }
20974 else
20975 {
20976 arg31 = NULL;
20977 }
20978 }
20979 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);
20980 _outv = octave_value();
20981 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20982 if (SWIG_IsTmpObj(res1)) {
20983 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20984 } else {
20985 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20986 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20987 }
20988 if (SWIG_IsTmpObj(res2)) {
20989 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20990 } else {
20991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20992 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20993 }
20994 {
20995 delete [] arg14;
20996 }
20997 {
20998 delete [] arg19;
20999 }
21000 {
21001 int i;
21002 if ( arg20 != NULL )
21003 {
21004 for ( i = 0; i < Alen; i++ )
21005 {
21006 delete[] arg20[i];
21007 }
21008 delete[] arg20;
21009 }
21010 }
21011 {
21012 if ( arg21 != NULL )
21013 delete [] arg21;
21014 }
21015 {
21016 if ( arg22 != NULL )
21017 delete [] arg22;
21018 }
21019 {
21020
21021 }
21022 {
21023
21024 }
21025 {
21026 if ( arg25 != NULL )
21027 delete [] arg25;
21028 }
21029 {
21030 if ( arg26 != NULL )
21031 delete [] arg26;
21032 }
21033 {
21034
21035 }
21036 {
21037 if ( arg28 != NULL )
21038 delete [] arg28;
21039 }
21040 {
21041
21042 }
21043 {
21044 if ( arg30 != NULL )
21045 delete [] arg30;
21046 }
21047 {
21048 int i;
21049 if ( arg31 != NULL )
21050 {
21051 for ( i = 0; i < Alen; i++ )
21052 {
21053 delete[] arg31[i];
21054 }
21055 delete[] arg31;
21056 }
21057 }
21058 return _out;
21059 fail:
21060 {
21061 delete [] arg14;
21062 }
21063 {
21064 delete [] arg19;
21065 }
21066 {
21067 int i;
21068 if ( arg20 != NULL )
21069 {
21070 for ( i = 0; i < Alen; i++ )
21071 {
21072 delete[] arg20[i];
21073 }
21074 delete[] arg20;
21075 }
21076 }
21077 {
21078 if ( arg21 != NULL )
21079 delete [] arg21;
21080 }
21081 {
21082 if ( arg22 != NULL )
21083 delete [] arg22;
21084 }
21085 {
21086
21087 }
21088 {
21089
21090 }
21091 {
21092 if ( arg25 != NULL )
21093 delete [] arg25;
21094 }
21095 {
21096 if ( arg26 != NULL )
21097 delete [] arg26;
21098 }
21099 {
21100
21101 }
21102 {
21103 if ( arg28 != NULL )
21104 delete [] arg28;
21105 }
21106 {
21107
21108 }
21109 {
21110 if ( arg30 != NULL )
21111 delete [] arg30;
21112 }
21113 {
21114 int i;
21115 if ( arg31 != NULL )
21116 {
21117 for ( i = 0; i < Alen; i++ )
21118 {
21119 delete[] arg31[i];
21120 }
21121 delete[] arg31;
21122 }
21123 }
21124 return octave_value_list();
21125 }
21126 catch(...) {
21127 {
21128 delete [] arg14;
21129 }
21130 {
21131 delete [] arg19;
21132 }
21133 {
21134 int i;
21135 if ( arg20 != NULL )
21136 {
21137 for ( i = 0; i < Alen; i++ )
21138 {
21139 delete[] arg20[i];
21140 }
21141 delete[] arg20;
21142 }
21143 }
21144 {
21145 if ( arg21 != NULL )
21146 delete [] arg21;
21147 }
21148 {
21149 if ( arg22 != NULL )
21150 delete [] arg22;
21151 }
21152 {
21153
21154 }
21155 {
21156
21157 }
21158 {
21159 if ( arg25 != NULL )
21160 delete [] arg25;
21161 }
21162 {
21163 if ( arg26 != NULL )
21164 delete [] arg26;
21165 }
21166 {
21167
21168 }
21169 {
21170 if ( arg28 != NULL )
21171 delete [] arg28;
21172 }
21173 {
21174
21175 }
21176 {
21177 if ( arg30 != NULL )
21178 delete [] arg30;
21179 }
21180 {
21181 int i;
21182 if ( arg31 != NULL )
21183 {
21184 for ( i = 0; i < Alen; i++ )
21185 {
21186 delete[] arg31[i];
21187 }
21188 delete[] arg31;
21189 }
21190 }
21191 throw;
21192 }
21193}
21194
21195
21197 PLFLT arg1 ;
21198 PLFLT arg2 ;
21199 PLFLT arg3 ;
21200 double val1 ;
21201 int ecode1 = 0 ;
21202 double val2 ;
21203 int ecode2 = 0 ;
21204 double val3 ;
21205 int ecode3 = 0 ;
21206 octave_value_list _out;
21207 octave_value_list *_outp=&_out;
21208 octave_value _outv;
21209
21210 try {
21211 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21212 SWIG_fail;
21213 }
21214 ecode1 = SWIG_AsVal_double(args(0), &val1);
21215 if (!SWIG_IsOK(ecode1)) {
21216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21217 }
21218 arg1 = static_cast< PLFLT >(val1);
21219 ecode2 = SWIG_AsVal_double(args(1), &val2);
21220 if (!SWIG_IsOK(ecode2)) {
21221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21222 }
21223 arg2 = static_cast< PLFLT >(val2);
21224 ecode3 = SWIG_AsVal_double(args(2), &val3);
21225 if (!SWIG_IsOK(ecode3)) {
21226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21227 }
21228 arg3 = static_cast< PLFLT >(val3);
21229 pllightsource(arg1,arg2,arg3);
21230 _outv = octave_value();
21231 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21232 return _out;
21233 fail:
21234 return octave_value_list();
21235 }
21236 catch(...) {
21237 throw;
21238 }
21239}
21240
21241
21243 PLINT arg1 ;
21244 PLFLT *arg2 = (PLFLT *) 0 ;
21245 PLFLT *arg3 = (PLFLT *) 0 ;
21246 Matrix temp1 ;
21247 Matrix temp3 ;
21248 octave_value_list _out;
21249 octave_value_list *_outp=&_out;
21250 octave_value _outv;
21251
21252 try {
21253 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21254 SWIG_fail;
21255 }
21256 {
21257 if ( _n_dims( args(0) ) > 1 )
21258 {
21259 error( "argument must be a scalar or vector" ); SWIG_fail;
21260 }
21261 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21262 temp1 = args(0).matrix_value();
21263 arg2 = &temp1( 0, 0 );
21264 }
21265 {
21266 if ( _n_dims( args(1) ) > 1 )
21267 {
21268 error( "argument must be a scalar or vector" ); SWIG_fail;
21269 }
21270 if ( _dim( args(1), 0 ) != Alen )
21271 {
21272 error( "argument vectors must be same length" ); SWIG_fail;
21273 }
21274 temp3 = args(1).matrix_value();
21275 arg3 = &temp3( 0, 0 );
21276 }
21277 plline(arg1,(double const *)arg2,(double const *)arg3);
21278 _outv = octave_value();
21279 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21280 {
21281
21282 }
21283 {
21284
21285 }
21286 return _out;
21287 fail:
21288 {
21289
21290 }
21291 {
21292
21293 }
21294 return octave_value_list();
21295 }
21296 catch(...) {
21297 {
21298
21299 }
21300 {
21301
21302 }
21303 throw;
21304 }
21305}
21306
21307
21309 PLINT arg1 ;
21310 PLFLT *arg2 = (PLFLT *) 0 ;
21311 PLFLT *arg3 = (PLFLT *) 0 ;
21312 PLFLT *arg4 = (PLFLT *) 0 ;
21313 Matrix temp1 ;
21314 Matrix temp3 ;
21315 Matrix temp4 ;
21316 octave_value_list _out;
21317 octave_value_list *_outp=&_out;
21318 octave_value _outv;
21319
21320 try {
21321 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21322 SWIG_fail;
21323 }
21324 {
21325 if ( _n_dims( args(0) ) > 1 )
21326 {
21327 error( "argument must be a scalar or vector" ); SWIG_fail;
21328 }
21329 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21330 temp1 = args(0).matrix_value();
21331 arg2 = &temp1( 0, 0 );
21332 }
21333 {
21334 if ( _n_dims( args(1) ) > 1 )
21335 {
21336 error( "argument must be a scalar or vector" ); SWIG_fail;
21337 }
21338 if ( _dim( args(1), 0 ) != Alen )
21339 {
21340 error( "argument vectors must be same length" ); SWIG_fail;
21341 }
21342 temp3 = args(1).matrix_value();
21343 arg3 = &temp3( 0, 0 );
21344 }
21345 {
21346 if ( _n_dims( args(2) ) > 1 )
21347 {
21348 error( "argument must be a scalar or vector" ); SWIG_fail;
21349 }
21350 if ( _dim( args(2), 0 ) != Alen )
21351 {
21352 error( "argument vectors must be same length" ); SWIG_fail;
21353 }
21354 temp4 = args(2).matrix_value();
21355 arg4 = &temp4( 0, 0 );
21356 }
21357 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21358 _outv = octave_value();
21359 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21360 {
21361
21362 }
21363 {
21364
21365 }
21366 {
21367
21368 }
21369 return _out;
21370 fail:
21371 {
21372
21373 }
21374 {
21375
21376 }
21377 {
21378
21379 }
21380 return octave_value_list();
21381 }
21382 catch(...) {
21383 {
21384
21385 }
21386 {
21387
21388 }
21389 {
21390
21391 }
21392 throw;
21393 }
21394}
21395
21396
21398 PLINT arg1 ;
21399 int val1 ;
21400 int ecode1 = 0 ;
21401 octave_value_list _out;
21402 octave_value_list *_outp=&_out;
21403 octave_value _outv;
21404
21405 try {
21406 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21407 SWIG_fail;
21408 }
21409 ecode1 = SWIG_AsVal_int(args(0), &val1);
21410 if (!SWIG_IsOK(ecode1)) {
21411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21412 }
21413 arg1 = static_cast< PLINT >(val1);
21414 pllsty(arg1);
21415 _outv = octave_value();
21416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21417 return _out;
21418 fail:
21419 return octave_value_list();
21420 }
21421 catch(...) {
21422 throw;
21423 }
21424}
21425
21426
21428 PLINT *arg1 = (PLINT *) 0 ;
21429 PLINT temp1 ;
21430 int res1 = SWIG_TMPOBJ ;
21431 octave_value_list _out;
21432 octave_value_list *_outp=&_out;
21433 octave_value _outv;
21434
21435 try {
21436 arg1 = &temp1;
21437 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21438 SWIG_fail;
21439 }
21440 plmkstrm(arg1);
21441 _outv = octave_value();
21442 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21443 if (SWIG_IsTmpObj(res1)) {
21444 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21445 } else {
21446 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21447 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21448 }
21449 return _out;
21450 fail:
21451 return octave_value_list();
21452 }
21453 catch(...) {
21454 throw;
21455 }
21456}
21457
21458
21460 char *arg1 = (char *) 0 ;
21461 PLFLT arg2 ;
21462 PLFLT arg3 ;
21463 PLFLT arg4 ;
21464 char *arg5 = (char *) 0 ;
21465 int res1 ;
21466 char *buf1 = 0 ;
21467 int alloc1 = 0 ;
21468 double val2 ;
21469 int ecode2 = 0 ;
21470 double val3 ;
21471 int ecode3 = 0 ;
21472 double val4 ;
21473 int ecode4 = 0 ;
21474 int res5 ;
21475 char *buf5 = 0 ;
21476 int alloc5 = 0 ;
21477 octave_value_list _out;
21478 octave_value_list *_outp=&_out;
21479 octave_value _outv;
21480
21481 try {
21482 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21483 SWIG_fail;
21484 }
21485 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21486 if (!SWIG_IsOK(res1)) {
21487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21488 }
21489 arg1 = reinterpret_cast< char * >(buf1);
21490 ecode2 = SWIG_AsVal_double(args(1), &val2);
21491 if (!SWIG_IsOK(ecode2)) {
21492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21493 }
21494 arg2 = static_cast< PLFLT >(val2);
21495 ecode3 = SWIG_AsVal_double(args(2), &val3);
21496 if (!SWIG_IsOK(ecode3)) {
21497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21498 }
21499 arg3 = static_cast< PLFLT >(val3);
21500 ecode4 = SWIG_AsVal_double(args(3), &val4);
21501 if (!SWIG_IsOK(ecode4)) {
21502 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21503 }
21504 arg4 = static_cast< PLFLT >(val4);
21505 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21506 if (!SWIG_IsOK(res5)) {
21507 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21508 }
21509 arg5 = reinterpret_cast< char * >(buf5);
21510 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21511 _outv = octave_value();
21512 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21513 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21514 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21515 return _out;
21516 fail:
21517 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21518 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21519 return octave_value_list();
21520 }
21521 catch(...) {
21522 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21523 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21524 throw;
21525 }
21526}
21527
21528
21530 char *arg1 = (char *) 0 ;
21531 PLFLT arg2 ;
21532 PLFLT arg3 ;
21533 PLFLT arg4 ;
21534 char *arg5 = (char *) 0 ;
21535 int res1 ;
21536 char *buf1 = 0 ;
21537 int alloc1 = 0 ;
21538 double val2 ;
21539 int ecode2 = 0 ;
21540 double val3 ;
21541 int ecode3 = 0 ;
21542 double val4 ;
21543 int ecode4 = 0 ;
21544 int res5 ;
21545 char *buf5 = 0 ;
21546 int alloc5 = 0 ;
21547 octave_value_list _out;
21548 octave_value_list *_outp=&_out;
21549 octave_value _outv;
21550
21551 try {
21552 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21553 SWIG_fail;
21554 }
21555 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21556 if (!SWIG_IsOK(res1)) {
21557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21558 }
21559 arg1 = reinterpret_cast< char * >(buf1);
21560 ecode2 = SWIG_AsVal_double(args(1), &val2);
21561 if (!SWIG_IsOK(ecode2)) {
21562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21563 }
21564 arg2 = static_cast< PLFLT >(val2);
21565 ecode3 = SWIG_AsVal_double(args(2), &val3);
21566 if (!SWIG_IsOK(ecode3)) {
21567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21568 }
21569 arg3 = static_cast< PLFLT >(val3);
21570 ecode4 = SWIG_AsVal_double(args(3), &val4);
21571 if (!SWIG_IsOK(ecode4)) {
21572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21573 }
21574 arg4 = static_cast< PLFLT >(val4);
21575 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21576 if (!SWIG_IsOK(res5)) {
21577 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21578 }
21579 arg5 = reinterpret_cast< char * >(buf5);
21580 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21581 _outv = octave_value();
21582 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21583 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21584 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21585 return _out;
21586 fail:
21587 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21588 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21589 return octave_value_list();
21590 }
21591 catch(...) {
21592 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21593 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21594 throw;
21595 }
21596}
21597
21598
21600 int *arg1 = (int *) 0 ;
21601 char **arg2 = (char **) 0 ;
21602 PLINT arg3 ;
21603 void *argp1 = 0 ;
21604 int res1 = 0 ;
21605 void *argp2 = 0 ;
21606 int res2 = 0 ;
21607 int val3 ;
21608 int ecode3 = 0 ;
21609 octave_value_list _out;
21610 octave_value_list *_outp=&_out;
21611 octave_value _outv;
21612 PLINT result;
21613
21614 try {
21615 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21616 SWIG_fail;
21617 }
21618 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21619 if (!SWIG_IsOK(res1)) {
21620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21621 }
21622 arg1 = reinterpret_cast< int * >(argp1);
21623 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21624 if (!SWIG_IsOK(res2)) {
21625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21626 }
21627 arg2 = reinterpret_cast< char ** >(argp2);
21628 ecode3 = SWIG_AsVal_int(args(2), &val3);
21629 if (!SWIG_IsOK(ecode3)) {
21630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21631 }
21632 arg3 = static_cast< PLINT >(val3);
21633 result = (PLINT)plparseopts(arg1,arg2,arg3);
21634 _outv = SWIG_From_int(static_cast< int >(result));
21635 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21636 return _out;
21637 fail:
21638 return octave_value_list();
21639 }
21640 catch(...) {
21641 throw;
21642 }
21643}
21644
21645
21647 PLINT arg1 ;
21648 PLINT *arg2 = (PLINT *) 0 ;
21649 PLINT *arg3 = (PLINT *) 0 ;
21650 Matrix temp1 ;
21651 Matrix temp3 ;
21652 octave_value_list _out;
21653 octave_value_list *_outp=&_out;
21654 octave_value _outv;
21655
21656 try {
21657 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21658 SWIG_fail;
21659 }
21660 {
21661 if ( _n_dims( args(0) ) > 1 )
21662 {
21663 error( "argument must be a scalar or vector" ); SWIG_fail;
21664 }
21665 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21666 arg2 = new PLINT[Alen];
21667 temp1 = args(0).matrix_value();
21668 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21669 }
21670 {
21671 if ( _n_dims( args(1) ) > 1 )
21672 {
21673 error( "argument must be a scalar or vector" ); SWIG_fail;
21674 }
21675 if ( _dim( args(1), 0 ) != Alen )
21676 {
21677 error( "argument vectors must be same length" ); SWIG_fail;
21678 }
21679 temp3 = args(1).matrix_value();
21680 arg3 = new PLINT[Alen];
21681 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21682 }
21683 plpat(arg1,(int const *)arg2,(int const *)arg3);
21684 _outv = octave_value();
21685 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21686 {
21687 delete [] arg2;
21688 }
21689 {
21690 delete [] arg3;
21691 }
21692 return _out;
21693 fail:
21694 {
21695 delete [] arg2;
21696 }
21697 {
21698 delete [] arg3;
21699 }
21700 return octave_value_list();
21701 }
21702 catch(...) {
21703 {
21704 delete [] arg2;
21705 }
21706 {
21707 delete [] arg3;
21708 }
21709 throw;
21710 }
21711}
21712
21713
21715 PLINT arg1 ;
21716 PLFLT arg2 ;
21717 PLFLT arg3 ;
21718 PLFLT arg4 ;
21719 PLFLT arg5 ;
21720 int val1 ;
21721 int ecode1 = 0 ;
21722 double val2 ;
21723 int ecode2 = 0 ;
21724 double val3 ;
21725 int ecode3 = 0 ;
21726 double val4 ;
21727 int ecode4 = 0 ;
21728 double val5 ;
21729 int ecode5 = 0 ;
21730 octave_value_list _out;
21731 octave_value_list *_outp=&_out;
21732 octave_value _outv;
21733
21734 try {
21735 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21736 SWIG_fail;
21737 }
21738 ecode1 = SWIG_AsVal_int(args(0), &val1);
21739 if (!SWIG_IsOK(ecode1)) {
21740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21741 }
21742 arg1 = static_cast< PLINT >(val1);
21743 ecode2 = SWIG_AsVal_double(args(1), &val2);
21744 if (!SWIG_IsOK(ecode2)) {
21745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21746 }
21747 arg2 = static_cast< PLFLT >(val2);
21748 ecode3 = SWIG_AsVal_double(args(2), &val3);
21749 if (!SWIG_IsOK(ecode3)) {
21750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21751 }
21752 arg3 = static_cast< PLFLT >(val3);
21753 ecode4 = SWIG_AsVal_double(args(3), &val4);
21754 if (!SWIG_IsOK(ecode4)) {
21755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21756 }
21757 arg4 = static_cast< PLFLT >(val4);
21758 ecode5 = SWIG_AsVal_double(args(4), &val5);
21759 if (!SWIG_IsOK(ecode5)) {
21760 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21761 }
21762 arg5 = static_cast< PLFLT >(val5);
21763 plpath(arg1,arg2,arg3,arg4,arg5);
21764 _outv = octave_value();
21765 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21766 return _out;
21767 fail:
21768 return octave_value_list();
21769 }
21770 catch(...) {
21771 throw;
21772 }
21773}
21774
21775
21777 PLINT arg1 ;
21778 PLFLT *arg2 = (PLFLT *) 0 ;
21779 PLFLT *arg3 = (PLFLT *) 0 ;
21780 PLINT arg4 ;
21781 Matrix temp1 ;
21782 Matrix temp3 ;
21783 int val4 ;
21784 int ecode4 = 0 ;
21785 octave_value_list _out;
21786 octave_value_list *_outp=&_out;
21787 octave_value _outv;
21788
21789 try {
21790 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21791 SWIG_fail;
21792 }
21793 {
21794 if ( _n_dims( args(0) ) > 1 )
21795 {
21796 error( "argument must be a scalar or vector" ); SWIG_fail;
21797 }
21798 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21799 temp1 = args(0).matrix_value();
21800 arg2 = &temp1( 0, 0 );
21801 }
21802 {
21803 if ( _n_dims( args(1) ) > 1 )
21804 {
21805 error( "argument must be a scalar or vector" ); SWIG_fail;
21806 }
21807 if ( _dim( args(1), 0 ) != Alen )
21808 {
21809 error( "argument vectors must be same length" ); SWIG_fail;
21810 }
21811 temp3 = args(1).matrix_value();
21812 arg3 = &temp3( 0, 0 );
21813 }
21814 ecode4 = SWIG_AsVal_int(args(2), &val4);
21815 if (!SWIG_IsOK(ecode4)) {
21816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21817 }
21818 arg4 = static_cast< PLINT >(val4);
21819 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21820 _outv = octave_value();
21821 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21822 {
21823
21824 }
21825 {
21826
21827 }
21828 return _out;
21829 fail:
21830 {
21831
21832 }
21833 {
21834
21835 }
21836 return octave_value_list();
21837 }
21838 catch(...) {
21839 {
21840
21841 }
21842 {
21843
21844 }
21845 throw;
21846 }
21847}
21848
21849
21851 PLINT arg1 ;
21852 PLFLT *arg2 = (PLFLT *) 0 ;
21853 PLFLT *arg3 = (PLFLT *) 0 ;
21854 PLFLT *arg4 = (PLFLT *) 0 ;
21855 PLINT arg5 ;
21856 Matrix temp1 ;
21857 Matrix temp3 ;
21858 Matrix temp4 ;
21859 int val5 ;
21860 int ecode5 = 0 ;
21861 octave_value_list _out;
21862 octave_value_list *_outp=&_out;
21863 octave_value _outv;
21864
21865 try {
21866 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21867 SWIG_fail;
21868 }
21869 {
21870 if ( _n_dims( args(0) ) > 1 )
21871 {
21872 error( "argument must be a scalar or vector" ); SWIG_fail;
21873 }
21874 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21875 temp1 = args(0).matrix_value();
21876 arg2 = &temp1( 0, 0 );
21877 }
21878 {
21879 if ( _n_dims( args(1) ) > 1 )
21880 {
21881 error( "argument must be a scalar or vector" ); SWIG_fail;
21882 }
21883 if ( _dim( args(1), 0 ) != Alen )
21884 {
21885 error( "argument vectors must be same length" ); SWIG_fail;
21886 }
21887 temp3 = args(1).matrix_value();
21888 arg3 = &temp3( 0, 0 );
21889 }
21890 {
21891 if ( _n_dims( args(2) ) > 1 )
21892 {
21893 error( "argument must be a scalar or vector" ); SWIG_fail;
21894 }
21895 if ( _dim( args(2), 0 ) != Alen )
21896 {
21897 error( "argument vectors must be same length" ); SWIG_fail;
21898 }
21899 temp4 = args(2).matrix_value();
21900 arg4 = &temp4( 0, 0 );
21901 }
21902 ecode5 = SWIG_AsVal_int(args(3), &val5);
21903 if (!SWIG_IsOK(ecode5)) {
21904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21905 }
21906 arg5 = static_cast< PLINT >(val5);
21907 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21908 _outv = octave_value();
21909 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21910 {
21911
21912 }
21913 {
21914
21915 }
21916 {
21917
21918 }
21919 return _out;
21920 fail:
21921 {
21922
21923 }
21924 {
21925
21926 }
21927 {
21928
21929 }
21930 return octave_value_list();
21931 }
21932 catch(...) {
21933 {
21934
21935 }
21936 {
21937
21938 }
21939 {
21940
21941 }
21942 throw;
21943 }
21944}
21945
21946
21948 PLINT arg1 ;
21949 PLFLT *arg2 = (PLFLT *) 0 ;
21950 PLFLT *arg3 = (PLFLT *) 0 ;
21951 PLFLT *arg4 = (PLFLT *) 0 ;
21952 PLBOOL *arg5 = (PLBOOL *) 0 ;
21953 PLBOOL arg6 ;
21954 Matrix temp1 ;
21955 Matrix temp3 ;
21956 Matrix temp4 ;
21957 Matrix temp5 ;
21958 int val6 ;
21959 int ecode6 = 0 ;
21960 octave_value_list _out;
21961 octave_value_list *_outp=&_out;
21962 octave_value _outv;
21963
21964 try {
21965 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
21966 SWIG_fail;
21967 }
21968 {
21969 if ( _n_dims( args(0) ) > 1 )
21970 {
21971 error( "argument must be a scalar or vector" ); SWIG_fail;
21972 }
21973 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21974 temp1 = args(0).matrix_value();
21975 arg2 = &temp1( 0, 0 );
21976 }
21977 {
21978 if ( _n_dims( args(1) ) > 1 )
21979 {
21980 error( "argument must be a scalar or vector" ); SWIG_fail;
21981 }
21982 if ( _dim( args(1), 0 ) != Alen )
21983 {
21984 error( "argument vectors must be same length" ); SWIG_fail;
21985 }
21986 temp3 = args(1).matrix_value();
21987 arg3 = &temp3( 0, 0 );
21988 }
21989 {
21990 if ( _n_dims( args(2) ) > 1 )
21991 {
21992 error( "argument must be a scalar or vector" ); SWIG_fail;
21993 }
21994 if ( _dim( args(2), 0 ) != Alen )
21995 {
21996 error( "argument vectors must be same length" ); SWIG_fail;
21997 }
21998 temp4 = args(2).matrix_value();
21999 arg4 = &temp4( 0, 0 );
22000 }
22001 {
22002 if ( _n_dims( args(3) ) > 1 )
22003 {
22004 error( "argument must be a scalar or vector" ); SWIG_fail;
22005 }
22006 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22007 {
22008 error( "argument vector must be same length or one less" ); SWIG_fail;
22009 }
22010 temp5 = args(3).matrix_value();
22011 arg5 = new PLINT[Alen];
22012 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22013 }
22014 ecode6 = SWIG_AsVal_int(args(4), &val6);
22015 if (!SWIG_IsOK(ecode6)) {
22016 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22017 }
22018 arg6 = static_cast< PLBOOL >(val6);
22019 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22020 _outv = octave_value();
22021 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22022 {
22023
22024 }
22025 {
22026
22027 }
22028 {
22029
22030 }
22031 {
22032 delete [] arg5;
22033 }
22034 return _out;
22035 fail:
22036 {
22037
22038 }
22039 {
22040
22041 }
22042 {
22043
22044 }
22045 {
22046 delete [] arg5;
22047 }
22048 return octave_value_list();
22049 }
22050 catch(...) {
22051 {
22052
22053 }
22054 {
22055
22056 }
22057 {
22058
22059 }
22060 {
22061 delete [] arg5;
22062 }
22063 throw;
22064 }
22065}
22066
22067
22069 PLINT arg1 ;
22070 PLINT arg2 ;
22071 int val1 ;
22072 int ecode1 = 0 ;
22073 int val2 ;
22074 int ecode2 = 0 ;
22075 octave_value_list _out;
22076 octave_value_list *_outp=&_out;
22077 octave_value _outv;
22078
22079 try {
22080 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22081 SWIG_fail;
22082 }
22083 ecode1 = SWIG_AsVal_int(args(0), &val1);
22084 if (!SWIG_IsOK(ecode1)) {
22085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22086 }
22087 arg1 = static_cast< PLINT >(val1);
22088 ecode2 = SWIG_AsVal_int(args(1), &val2);
22089 if (!SWIG_IsOK(ecode2)) {
22090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22091 }
22092 arg2 = static_cast< PLINT >(val2);
22093 plprec(arg1,arg2);
22094 _outv = octave_value();
22095 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22096 return _out;
22097 fail:
22098 return octave_value_list();
22099 }
22100 catch(...) {
22101 throw;
22102 }
22103}
22104
22105
22107 PLINT arg1 ;
22108 int val1 ;
22109 int ecode1 = 0 ;
22110 octave_value_list _out;
22111 octave_value_list *_outp=&_out;
22112 octave_value _outv;
22113
22114 try {
22115 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22116 SWIG_fail;
22117 }
22118 ecode1 = SWIG_AsVal_int(args(0), &val1);
22119 if (!SWIG_IsOK(ecode1)) {
22120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22121 }
22122 arg1 = static_cast< PLINT >(val1);
22123 plpsty(arg1);
22124 _outv = octave_value();
22125 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22126 return _out;
22127 fail:
22128 return octave_value_list();
22129 }
22130 catch(...) {
22131 throw;
22132 }
22133}
22134
22135
22137 PLFLT arg1 ;
22138 PLFLT arg2 ;
22139 PLFLT arg3 ;
22140 PLFLT arg4 ;
22141 PLFLT arg5 ;
22142 char *arg6 = (char *) 0 ;
22143 double val1 ;
22144 int ecode1 = 0 ;
22145 double val2 ;
22146 int ecode2 = 0 ;
22147 double val3 ;
22148 int ecode3 = 0 ;
22149 double val4 ;
22150 int ecode4 = 0 ;
22151 double val5 ;
22152 int ecode5 = 0 ;
22153 int res6 ;
22154 char *buf6 = 0 ;
22155 int alloc6 = 0 ;
22156 octave_value_list _out;
22157 octave_value_list *_outp=&_out;
22158 octave_value _outv;
22159
22160 try {
22161 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22162 SWIG_fail;
22163 }
22164 ecode1 = SWIG_AsVal_double(args(0), &val1);
22165 if (!SWIG_IsOK(ecode1)) {
22166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22167 }
22168 arg1 = static_cast< PLFLT >(val1);
22169 ecode2 = SWIG_AsVal_double(args(1), &val2);
22170 if (!SWIG_IsOK(ecode2)) {
22171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22172 }
22173 arg2 = static_cast< PLFLT >(val2);
22174 ecode3 = SWIG_AsVal_double(args(2), &val3);
22175 if (!SWIG_IsOK(ecode3)) {
22176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22177 }
22178 arg3 = static_cast< PLFLT >(val3);
22179 ecode4 = SWIG_AsVal_double(args(3), &val4);
22180 if (!SWIG_IsOK(ecode4)) {
22181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22182 }
22183 arg4 = static_cast< PLFLT >(val4);
22184 ecode5 = SWIG_AsVal_double(args(4), &val5);
22185 if (!SWIG_IsOK(ecode5)) {
22186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22187 }
22188 arg5 = static_cast< PLFLT >(val5);
22189 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22190 if (!SWIG_IsOK(res6)) {
22191 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22192 }
22193 arg6 = reinterpret_cast< char * >(buf6);
22194 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22195 _outv = octave_value();
22196 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22197 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22198 return _out;
22199 fail:
22200 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22201 return octave_value_list();
22202 }
22203 catch(...) {
22204 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22205 throw;
22206 }
22207}
22208
22209
22211 PLFLT arg1 ;
22212 PLFLT arg2 ;
22213 PLFLT arg3 ;
22214 PLFLT arg4 ;
22215 PLFLT arg5 ;
22216 PLFLT arg6 ;
22217 PLFLT arg7 ;
22218 PLFLT arg8 ;
22219 PLFLT arg9 ;
22220 PLFLT arg10 ;
22221 char *arg11 = (char *) 0 ;
22222 double val1 ;
22223 int ecode1 = 0 ;
22224 double val2 ;
22225 int ecode2 = 0 ;
22226 double val3 ;
22227 int ecode3 = 0 ;
22228 double val4 ;
22229 int ecode4 = 0 ;
22230 double val5 ;
22231 int ecode5 = 0 ;
22232 double val6 ;
22233 int ecode6 = 0 ;
22234 double val7 ;
22235 int ecode7 = 0 ;
22236 double val8 ;
22237 int ecode8 = 0 ;
22238 double val9 ;
22239 int ecode9 = 0 ;
22240 double val10 ;
22241 int ecode10 = 0 ;
22242 int res11 ;
22243 char *buf11 = 0 ;
22244 int alloc11 = 0 ;
22245 octave_value_list _out;
22246 octave_value_list *_outp=&_out;
22247 octave_value _outv;
22248
22249 try {
22250 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22251 SWIG_fail;
22252 }
22253 ecode1 = SWIG_AsVal_double(args(0), &val1);
22254 if (!SWIG_IsOK(ecode1)) {
22255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22256 }
22257 arg1 = static_cast< PLFLT >(val1);
22258 ecode2 = SWIG_AsVal_double(args(1), &val2);
22259 if (!SWIG_IsOK(ecode2)) {
22260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22261 }
22262 arg2 = static_cast< PLFLT >(val2);
22263 ecode3 = SWIG_AsVal_double(args(2), &val3);
22264 if (!SWIG_IsOK(ecode3)) {
22265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22266 }
22267 arg3 = static_cast< PLFLT >(val3);
22268 ecode4 = SWIG_AsVal_double(args(3), &val4);
22269 if (!SWIG_IsOK(ecode4)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22271 }
22272 arg4 = static_cast< PLFLT >(val4);
22273 ecode5 = SWIG_AsVal_double(args(4), &val5);
22274 if (!SWIG_IsOK(ecode5)) {
22275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22276 }
22277 arg5 = static_cast< PLFLT >(val5);
22278 ecode6 = SWIG_AsVal_double(args(5), &val6);
22279 if (!SWIG_IsOK(ecode6)) {
22280 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22281 }
22282 arg6 = static_cast< PLFLT >(val6);
22283 ecode7 = SWIG_AsVal_double(args(6), &val7);
22284 if (!SWIG_IsOK(ecode7)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22286 }
22287 arg7 = static_cast< PLFLT >(val7);
22288 ecode8 = SWIG_AsVal_double(args(7), &val8);
22289 if (!SWIG_IsOK(ecode8)) {
22290 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22291 }
22292 arg8 = static_cast< PLFLT >(val8);
22293 ecode9 = SWIG_AsVal_double(args(8), &val9);
22294 if (!SWIG_IsOK(ecode9)) {
22295 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22296 }
22297 arg9 = static_cast< PLFLT >(val9);
22298 ecode10 = SWIG_AsVal_double(args(9), &val10);
22299 if (!SWIG_IsOK(ecode10)) {
22300 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22301 }
22302 arg10 = static_cast< PLFLT >(val10);
22303 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22304 if (!SWIG_IsOK(res11)) {
22305 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22306 }
22307 arg11 = reinterpret_cast< char * >(buf11);
22308 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22309 _outv = octave_value();
22310 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22311 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22312 return _out;
22313 fail:
22314 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22315 return octave_value_list();
22316 }
22317 catch(...) {
22318 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22319 throw;
22320 }
22321}
22322
22323
22325 octave_value_list _out;
22326 octave_value_list *_outp=&_out;
22327 octave_value _outv;
22328 PLFLT result;
22329
22330 try {
22331 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22332 SWIG_fail;
22333 }
22334 result = (PLFLT)plrandd();
22335 _outv = SWIG_From_double(static_cast< double >(result));
22336 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22337 return _out;
22338 fail:
22339 return octave_value_list();
22340 }
22341 catch(...) {
22342 throw;
22343 }
22344}
22345
22346
22348 octave_value_list _out;
22349 octave_value_list *_outp=&_out;
22350 octave_value _outv;
22351
22352 try {
22353 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22354 SWIG_fail;
22355 }
22356 plreplot();
22357 _outv = octave_value();
22358 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22359 return _out;
22360 fail:
22361 return octave_value_list();
22362 }
22363 catch(...) {
22364 throw;
22365 }
22366}
22367
22368
22370 PLFLT arg1 ;
22371 PLFLT arg2 ;
22372 PLFLT arg3 ;
22373 PLFLT *arg4 = (PLFLT *) 0 ;
22374 PLFLT *arg5 = (PLFLT *) 0 ;
22375 PLFLT *arg6 = (PLFLT *) 0 ;
22376 double val1 ;
22377 int ecode1 = 0 ;
22378 double val2 ;
22379 int ecode2 = 0 ;
22380 double val3 ;
22381 int ecode3 = 0 ;
22382 PLFLT temp4 ;
22383 int res4 = SWIG_TMPOBJ ;
22384 PLFLT temp5 ;
22385 int res5 = SWIG_TMPOBJ ;
22386 PLFLT temp6 ;
22387 int res6 = SWIG_TMPOBJ ;
22388 octave_value_list _out;
22389 octave_value_list *_outp=&_out;
22390 octave_value _outv;
22391
22392 try {
22393 arg4 = &temp4;
22394 arg5 = &temp5;
22395 arg6 = &temp6;
22396 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22397 SWIG_fail;
22398 }
22399 ecode1 = SWIG_AsVal_double(args(0), &val1);
22400 if (!SWIG_IsOK(ecode1)) {
22401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22402 }
22403 arg1 = static_cast< PLFLT >(val1);
22404 ecode2 = SWIG_AsVal_double(args(1), &val2);
22405 if (!SWIG_IsOK(ecode2)) {
22406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22407 }
22408 arg2 = static_cast< PLFLT >(val2);
22409 ecode3 = SWIG_AsVal_double(args(2), &val3);
22410 if (!SWIG_IsOK(ecode3)) {
22411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22412 }
22413 arg3 = static_cast< PLFLT >(val3);
22414 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22415 _outv = octave_value();
22416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22417 if (SWIG_IsTmpObj(res4)) {
22418 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22419 } else {
22420 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22421 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22422 }
22423 if (SWIG_IsTmpObj(res5)) {
22424 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22425 } else {
22426 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22427 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22428 }
22429 if (SWIG_IsTmpObj(res6)) {
22430 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22431 } else {
22432 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22433 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22434 }
22435 return _out;
22436 fail:
22437 return octave_value_list();
22438 }
22439 catch(...) {
22440 throw;
22441 }
22442}
22443
22444
22446 PLFLT arg1 ;
22447 PLFLT arg2 ;
22448 double val1 ;
22449 int ecode1 = 0 ;
22450 double val2 ;
22451 int ecode2 = 0 ;
22452 octave_value_list _out;
22453 octave_value_list *_outp=&_out;
22454 octave_value _outv;
22455
22456 try {
22457 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22458 SWIG_fail;
22459 }
22460 ecode1 = SWIG_AsVal_double(args(0), &val1);
22461 if (!SWIG_IsOK(ecode1)) {
22462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22463 }
22464 arg1 = static_cast< PLFLT >(val1);
22465 ecode2 = SWIG_AsVal_double(args(1), &val2);
22466 if (!SWIG_IsOK(ecode2)) {
22467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22468 }
22469 arg2 = static_cast< PLFLT >(val2);
22470 plschr(arg1,arg2);
22471 _outv = octave_value();
22472 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22473 return _out;
22474 fail:
22475 return octave_value_list();
22476 }
22477 catch(...) {
22478 throw;
22479 }
22480}
22481
22482
22484 PLINT *arg1 = (PLINT *) 0 ;
22485 PLINT *arg2 = (PLINT *) 0 ;
22486 PLINT *arg3 = (PLINT *) 0 ;
22487 PLINT arg4 ;
22488 Matrix temp1 ;
22489 Matrix temp2 ;
22490 Matrix temp3 ;
22491 octave_value_list _out;
22492 octave_value_list *_outp=&_out;
22493 octave_value _outv;
22494
22495 try {
22496 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22497 SWIG_fail;
22498 }
22499 {
22500 if ( _n_dims( args(0) ) > 1 )
22501 {
22502 error( "argument must be a scalar or vector" ); SWIG_fail;
22503 }
22504 Alen = (PLINT) ( _dim( args(0), 0 ) );
22505 temp1 = args(0).matrix_value();
22506 arg1 = new PLINT[Alen];
22507 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22508 }
22509 {
22510 if ( _n_dims( args(1) ) > 1 )
22511 {
22512 error( "argument must be a scalar or vector" ); SWIG_fail;
22513 }
22514 if ( _dim( args(1), 0 ) != Alen )
22515 {
22516 error( "argument vectors must be same length" ); SWIG_fail;
22517 }
22518 temp2 = args(1).matrix_value();
22519 arg2 = new PLINT[Alen];
22520 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22521 }
22522 {
22523 if ( _n_dims( args(2) ) > 1 )
22524 {
22525 error( "argument must be a scalar or vector" ); SWIG_fail;
22526 }
22527 if ( _dim( args(2), 0 ) != Alen )
22528 {
22529 error( "argument vectors must be same length" ); SWIG_fail;
22530 }
22531 temp3 = args(2).matrix_value();
22532 arg3 = new PLINT[Alen];
22533 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22534 arg4 = Alen;
22535 }
22536 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22537 _outv = octave_value();
22538 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22539 {
22540 delete [] arg1;
22541 }
22542 {
22543 delete [] arg2;
22544 }
22545 {
22546 delete [] arg3;
22547 }
22548 return _out;
22549 fail:
22550 {
22551 delete [] arg1;
22552 }
22553 {
22554 delete [] arg2;
22555 }
22556 {
22557 delete [] arg3;
22558 }
22559 return octave_value_list();
22560 }
22561 catch(...) {
22562 {
22563 delete [] arg1;
22564 }
22565 {
22566 delete [] arg2;
22567 }
22568 {
22569 delete [] arg3;
22570 }
22571 throw;
22572 }
22573}
22574
22575
22577 PLINT *arg1 = (PLINT *) 0 ;
22578 PLINT *arg2 = (PLINT *) 0 ;
22579 PLINT *arg3 = (PLINT *) 0 ;
22580 PLFLT *arg4 = (PLFLT *) 0 ;
22581 PLINT arg5 ;
22582 Matrix temp1 ;
22583 Matrix temp2 ;
22584 Matrix temp3 ;
22585 Matrix temp4 ;
22586 octave_value_list _out;
22587 octave_value_list *_outp=&_out;
22588 octave_value _outv;
22589
22590 try {
22591 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22592 SWIG_fail;
22593 }
22594 {
22595 if ( _n_dims( args(0) ) > 1 )
22596 {
22597 error( "argument must be a scalar or vector" ); SWIG_fail;
22598 }
22599 Alen = (PLINT) ( _dim( args(0), 0 ) );
22600 temp1 = args(0).matrix_value();
22601 arg1 = new PLINT[Alen];
22602 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22603 }
22604 {
22605 if ( _n_dims( args(1) ) > 1 )
22606 {
22607 error( "argument must be a scalar or vector" ); SWIG_fail;
22608 }
22609 if ( _dim( args(1), 0 ) != Alen )
22610 {
22611 error( "argument vectors must be same length" ); SWIG_fail;
22612 }
22613 temp2 = args(1).matrix_value();
22614 arg2 = new PLINT[Alen];
22615 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22616 }
22617 {
22618 if ( _n_dims( args(2) ) > 1 )
22619 {
22620 error( "argument must be a scalar or vector" ); SWIG_fail;
22621 }
22622 if ( _dim( args(2), 0 ) != Alen )
22623 {
22624 error( "argument vectors must be same length" ); SWIG_fail;
22625 }
22626 temp3 = args(2).matrix_value();
22627 arg3 = new PLINT[Alen];
22628 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22629 }
22630 {
22631 if ( _n_dims( args(3) ) > 1 )
22632 {
22633 error( "argument must be a scalar or vector" ); SWIG_fail;
22634 }
22635 if ( _dim( args(3), 0 ) != Alen )
22636 {
22637 error( "argument vectors must be same length" ); SWIG_fail;
22638 }
22639 temp4 = args(3).matrix_value();
22640 arg4 = &temp4( 0, 0 );
22641 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22642 }
22643 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22644 _outv = octave_value();
22645 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22646 {
22647 delete [] arg1;
22648 }
22649 {
22650 delete [] arg2;
22651 }
22652 {
22653 delete [] arg3;
22654 }
22655 {
22656
22657 }
22658 return _out;
22659 fail:
22660 {
22661 delete [] arg1;
22662 }
22663 {
22664 delete [] arg2;
22665 }
22666 {
22667 delete [] arg3;
22668 }
22669 {
22670
22671 }
22672 return octave_value_list();
22673 }
22674 catch(...) {
22675 {
22676 delete [] arg1;
22677 }
22678 {
22679 delete [] arg2;
22680 }
22681 {
22682 delete [] arg3;
22683 }
22684 {
22685
22686 }
22687 throw;
22688 }
22689}
22690
22691
22693 PLINT arg1 ;
22694 int val1 ;
22695 int ecode1 = 0 ;
22696 octave_value_list _out;
22697 octave_value_list *_outp=&_out;
22698 octave_value _outv;
22699
22700 try {
22701 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22702 SWIG_fail;
22703 }
22704 ecode1 = SWIG_AsVal_int(args(0), &val1);
22705 if (!SWIG_IsOK(ecode1)) {
22706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22707 }
22708 arg1 = static_cast< PLINT >(val1);
22709 plscmap0n(arg1);
22710 _outv = octave_value();
22711 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22712 return _out;
22713 fail:
22714 return octave_value_list();
22715 }
22716 catch(...) {
22717 throw;
22718 }
22719}
22720
22721
22723 PLINT *arg1 = (PLINT *) 0 ;
22724 PLINT *arg2 = (PLINT *) 0 ;
22725 PLINT *arg3 = (PLINT *) 0 ;
22726 PLINT arg4 ;
22727 Matrix temp1 ;
22728 Matrix temp2 ;
22729 Matrix temp3 ;
22730 octave_value_list _out;
22731 octave_value_list *_outp=&_out;
22732 octave_value _outv;
22733
22734 try {
22735 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22736 SWIG_fail;
22737 }
22738 {
22739 if ( _n_dims( args(0) ) > 1 )
22740 {
22741 error( "argument must be a scalar or vector" ); SWIG_fail;
22742 }
22743 Alen = (PLINT) ( _dim( args(0), 0 ) );
22744 temp1 = args(0).matrix_value();
22745 arg1 = new PLINT[Alen];
22746 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22747 }
22748 {
22749 if ( _n_dims( args(1) ) > 1 )
22750 {
22751 error( "argument must be a scalar or vector" ); SWIG_fail;
22752 }
22753 if ( _dim( args(1), 0 ) != Alen )
22754 {
22755 error( "argument vectors must be same length" ); SWIG_fail;
22756 }
22757 temp2 = args(1).matrix_value();
22758 arg2 = new PLINT[Alen];
22759 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22760 }
22761 {
22762 if ( _n_dims( args(2) ) > 1 )
22763 {
22764 error( "argument must be a scalar or vector" ); SWIG_fail;
22765 }
22766 if ( _dim( args(2), 0 ) != Alen )
22767 {
22768 error( "argument vectors must be same length" ); SWIG_fail;
22769 }
22770 temp3 = args(2).matrix_value();
22771 arg3 = new PLINT[Alen];
22772 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22773 arg4 = Alen;
22774 }
22775 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22776 _outv = octave_value();
22777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22778 {
22779 delete [] arg1;
22780 }
22781 {
22782 delete [] arg2;
22783 }
22784 {
22785 delete [] arg3;
22786 }
22787 return _out;
22788 fail:
22789 {
22790 delete [] arg1;
22791 }
22792 {
22793 delete [] arg2;
22794 }
22795 {
22796 delete [] arg3;
22797 }
22798 return octave_value_list();
22799 }
22800 catch(...) {
22801 {
22802 delete [] arg1;
22803 }
22804 {
22805 delete [] arg2;
22806 }
22807 {
22808 delete [] arg3;
22809 }
22810 throw;
22811 }
22812}
22813
22814
22816 PLINT *arg1 = (PLINT *) 0 ;
22817 PLINT *arg2 = (PLINT *) 0 ;
22818 PLINT *arg3 = (PLINT *) 0 ;
22819 PLFLT *arg4 = (PLFLT *) 0 ;
22820 PLINT arg5 ;
22821 Matrix temp1 ;
22822 Matrix temp2 ;
22823 Matrix temp3 ;
22824 Matrix temp4 ;
22825 octave_value_list _out;
22826 octave_value_list *_outp=&_out;
22827 octave_value _outv;
22828
22829 try {
22830 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22831 SWIG_fail;
22832 }
22833 {
22834 if ( _n_dims( args(0) ) > 1 )
22835 {
22836 error( "argument must be a scalar or vector" ); SWIG_fail;
22837 }
22838 Alen = (PLINT) ( _dim( args(0), 0 ) );
22839 temp1 = args(0).matrix_value();
22840 arg1 = new PLINT[Alen];
22841 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22842 }
22843 {
22844 if ( _n_dims( args(1) ) > 1 )
22845 {
22846 error( "argument must be a scalar or vector" ); SWIG_fail;
22847 }
22848 if ( _dim( args(1), 0 ) != Alen )
22849 {
22850 error( "argument vectors must be same length" ); SWIG_fail;
22851 }
22852 temp2 = args(1).matrix_value();
22853 arg2 = new PLINT[Alen];
22854 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22855 }
22856 {
22857 if ( _n_dims( args(2) ) > 1 )
22858 {
22859 error( "argument must be a scalar or vector" ); SWIG_fail;
22860 }
22861 if ( _dim( args(2), 0 ) != Alen )
22862 {
22863 error( "argument vectors must be same length" ); SWIG_fail;
22864 }
22865 temp3 = args(2).matrix_value();
22866 arg3 = new PLINT[Alen];
22867 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22868 }
22869 {
22870 if ( _n_dims( args(3) ) > 1 )
22871 {
22872 error( "argument must be a scalar or vector" ); SWIG_fail;
22873 }
22874 if ( _dim( args(3), 0 ) != Alen )
22875 {
22876 error( "argument vectors must be same length" ); SWIG_fail;
22877 }
22878 temp4 = args(3).matrix_value();
22879 arg4 = &temp4( 0, 0 );
22880 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22881 }
22882 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22883 _outv = octave_value();
22884 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22885 {
22886 delete [] arg1;
22887 }
22888 {
22889 delete [] arg2;
22890 }
22891 {
22892 delete [] arg3;
22893 }
22894 {
22895
22896 }
22897 return _out;
22898 fail:
22899 {
22900 delete [] arg1;
22901 }
22902 {
22903 delete [] arg2;
22904 }
22905 {
22906 delete [] arg3;
22907 }
22908 {
22909
22910 }
22911 return octave_value_list();
22912 }
22913 catch(...) {
22914 {
22915 delete [] arg1;
22916 }
22917 {
22918 delete [] arg2;
22919 }
22920 {
22921 delete [] arg3;
22922 }
22923 {
22924
22925 }
22926 throw;
22927 }
22928}
22929
22930
22932 PLBOOL arg1 ;
22933 PLINT arg2 ;
22934 PLFLT *arg3 = (PLFLT *) 0 ;
22935 PLFLT *arg4 = (PLFLT *) 0 ;
22936 PLFLT *arg5 = (PLFLT *) 0 ;
22937 PLFLT *arg6 = (PLFLT *) 0 ;
22938 PLBOOL *arg7 = (PLBOOL *) 0 ;
22939 int val1 ;
22940 int ecode1 = 0 ;
22941 Matrix temp2 ;
22942 Matrix temp4 ;
22943 Matrix temp5 ;
22944 Matrix temp6 ;
22945 Matrix temp7 ;
22946 octave_value_list _out;
22947 octave_value_list *_outp=&_out;
22948 octave_value _outv;
22949
22950 try {
22951 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
22952 SWIG_fail;
22953 }
22954 ecode1 = SWIG_AsVal_int(args(0), &val1);
22955 if (!SWIG_IsOK(ecode1)) {
22956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
22957 }
22958 arg1 = static_cast< PLBOOL >(val1);
22959 {
22960 if ( _n_dims( args(1) ) > 1 )
22961 {
22962 error( "argument must be a scalar or vector" ); SWIG_fail;
22963 }
22964 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22965 temp2 = args(1).matrix_value();
22966 arg3 = &temp2( 0, 0 );
22967 }
22968 {
22969 if ( _n_dims( args(2) ) > 1 )
22970 {
22971 error( "argument must be a scalar or vector" ); SWIG_fail;
22972 }
22973 if ( _dim( args(2), 0 ) != Alen )
22974 {
22975 error( "argument vectors must be same length" ); SWIG_fail;
22976 }
22977 temp4 = args(2).matrix_value();
22978 arg4 = &temp4( 0, 0 );
22979 }
22980 {
22981 if ( _n_dims( args(3) ) > 1 )
22982 {
22983 error( "argument must be a scalar or vector" ); SWIG_fail;
22984 }
22985 if ( _dim( args(3), 0 ) != Alen )
22986 {
22987 error( "argument vectors must be same length" ); SWIG_fail;
22988 }
22989 temp5 = args(3).matrix_value();
22990 arg5 = &temp5( 0, 0 );
22991 }
22992 {
22993 if ( _n_dims( args(4) ) > 1 )
22994 {
22995 error( "argument must be a scalar or vector" ); SWIG_fail;
22996 }
22997 if ( _dim( args(4), 0 ) != Alen )
22998 {
22999 error( "argument vectors must be same length" ); SWIG_fail;
23000 }
23001 temp6 = args(4).matrix_value();
23002 arg6 = &temp6( 0, 0 );
23003 }
23004 {
23005 if ( _n_dims( args(5) ) > 1 )
23006 {
23007 error( "argument must be a scalar or vector" ); SWIG_fail;
23008 }
23009 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23010 {
23011 error( "argument vector must be same length or one less" ); SWIG_fail;
23012 }
23013 temp7 = args(5).matrix_value();
23014 arg7 = new PLINT[Alen];
23015 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23016 }
23017 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23018 _outv = octave_value();
23019 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23020 {
23021
23022 }
23023 {
23024
23025 }
23026 {
23027
23028 }
23029 {
23030
23031 }
23032 {
23033 delete [] arg7;
23034 }
23035 return _out;
23036 fail:
23037 {
23038
23039 }
23040 {
23041
23042 }
23043 {
23044
23045 }
23046 {
23047
23048 }
23049 {
23050 delete [] arg7;
23051 }
23052 return octave_value_list();
23053 }
23054 catch(...) {
23055 {
23056
23057 }
23058 {
23059
23060 }
23061 {
23062
23063 }
23064 {
23065
23066 }
23067 {
23068 delete [] arg7;
23069 }
23070 throw;
23071 }
23072}
23073
23074
23076 PLBOOL arg1 ;
23077 PLINT arg2 ;
23078 PLFLT *arg3 = (PLFLT *) 0 ;
23079 PLFLT *arg4 = (PLFLT *) 0 ;
23080 PLFLT *arg5 = (PLFLT *) 0 ;
23081 PLFLT *arg6 = (PLFLT *) 0 ;
23082 PLFLT *arg7 = (PLFLT *) 0 ;
23083 PLBOOL *arg8 = (PLBOOL *) 0 ;
23084 int val1 ;
23085 int ecode1 = 0 ;
23086 Matrix temp2 ;
23087 Matrix temp4 ;
23088 Matrix temp5 ;
23089 Matrix temp6 ;
23090 Matrix temp7 ;
23091 Matrix temp8 ;
23092 octave_value_list _out;
23093 octave_value_list *_outp=&_out;
23094 octave_value _outv;
23095
23096 try {
23097 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23098 SWIG_fail;
23099 }
23100 ecode1 = SWIG_AsVal_int(args(0), &val1);
23101 if (!SWIG_IsOK(ecode1)) {
23102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23103 }
23104 arg1 = static_cast< PLBOOL >(val1);
23105 {
23106 if ( _n_dims( args(1) ) > 1 )
23107 {
23108 error( "argument must be a scalar or vector" ); SWIG_fail;
23109 }
23110 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23111 temp2 = args(1).matrix_value();
23112 arg3 = &temp2( 0, 0 );
23113 }
23114 {
23115 if ( _n_dims( args(2) ) > 1 )
23116 {
23117 error( "argument must be a scalar or vector" ); SWIG_fail;
23118 }
23119 if ( _dim( args(2), 0 ) != Alen )
23120 {
23121 error( "argument vectors must be same length" ); SWIG_fail;
23122 }
23123 temp4 = args(2).matrix_value();
23124 arg4 = &temp4( 0, 0 );
23125 }
23126 {
23127 if ( _n_dims( args(3) ) > 1 )
23128 {
23129 error( "argument must be a scalar or vector" ); SWIG_fail;
23130 }
23131 if ( _dim( args(3), 0 ) != Alen )
23132 {
23133 error( "argument vectors must be same length" ); SWIG_fail;
23134 }
23135 temp5 = args(3).matrix_value();
23136 arg5 = &temp5( 0, 0 );
23137 }
23138 {
23139 if ( _n_dims( args(4) ) > 1 )
23140 {
23141 error( "argument must be a scalar or vector" ); SWIG_fail;
23142 }
23143 if ( _dim( args(4), 0 ) != Alen )
23144 {
23145 error( "argument vectors must be same length" ); SWIG_fail;
23146 }
23147 temp6 = args(4).matrix_value();
23148 arg6 = &temp6( 0, 0 );
23149 }
23150 {
23151 if ( _n_dims( args(5) ) > 1 )
23152 {
23153 error( "argument must be a scalar or vector" ); SWIG_fail;
23154 }
23155 if ( _dim( args(5), 0 ) != Alen )
23156 {
23157 error( "argument vectors must be same length" ); SWIG_fail;
23158 }
23159 temp7 = args(5).matrix_value();
23160 arg7 = &temp7( 0, 0 );
23161 }
23162 {
23163 if ( _n_dims( args(6) ) > 1 )
23164 {
23165 error( "argument must be a scalar or vector" ); SWIG_fail;
23166 }
23167 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23168 {
23169 error( "argument vector must be same length or one less" ); SWIG_fail;
23170 }
23171 temp8 = args(6).matrix_value();
23172 arg8 = new PLINT[Alen];
23173 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23174 }
23175 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23176 _outv = octave_value();
23177 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23178 {
23179
23180 }
23181 {
23182
23183 }
23184 {
23185
23186 }
23187 {
23188
23189 }
23190 {
23191
23192 }
23193 {
23194 delete [] arg8;
23195 }
23196 return _out;
23197 fail:
23198 {
23199
23200 }
23201 {
23202
23203 }
23204 {
23205
23206 }
23207 {
23208
23209 }
23210 {
23211
23212 }
23213 {
23214 delete [] arg8;
23215 }
23216 return octave_value_list();
23217 }
23218 catch(...) {
23219 {
23220
23221 }
23222 {
23223
23224 }
23225 {
23226
23227 }
23228 {
23229
23230 }
23231 {
23232
23233 }
23234 {
23235 delete [] arg8;
23236 }
23237 throw;
23238 }
23239}
23240
23241
23243 PLINT arg1 ;
23244 int val1 ;
23245 int ecode1 = 0 ;
23246 octave_value_list _out;
23247 octave_value_list *_outp=&_out;
23248 octave_value _outv;
23249
23250 try {
23251 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23252 SWIG_fail;
23253 }
23254 ecode1 = SWIG_AsVal_int(args(0), &val1);
23255 if (!SWIG_IsOK(ecode1)) {
23256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23257 }
23258 arg1 = static_cast< PLINT >(val1);
23259 plscmap1n(arg1);
23260 _outv = octave_value();
23261 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23262 return _out;
23263 fail:
23264 return octave_value_list();
23265 }
23266 catch(...) {
23267 throw;
23268 }
23269}
23270
23271
23273 PLFLT arg1 ;
23274 PLFLT arg2 ;
23275 double val1 ;
23276 int ecode1 = 0 ;
23277 double val2 ;
23278 int ecode2 = 0 ;
23279 octave_value_list _out;
23280 octave_value_list *_outp=&_out;
23281 octave_value _outv;
23282
23283 try {
23284 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23285 SWIG_fail;
23286 }
23287 ecode1 = SWIG_AsVal_double(args(0), &val1);
23288 if (!SWIG_IsOK(ecode1)) {
23289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23290 }
23291 arg1 = static_cast< PLFLT >(val1);
23292 ecode2 = SWIG_AsVal_double(args(1), &val2);
23293 if (!SWIG_IsOK(ecode2)) {
23294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23295 }
23296 arg2 = static_cast< PLFLT >(val2);
23297 plscmap1_range(arg1,arg2);
23298 _outv = octave_value();
23299 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23300 return _out;
23301 fail:
23302 return octave_value_list();
23303 }
23304 catch(...) {
23305 throw;
23306 }
23307}
23308
23309
23311 PLFLT *arg1 = (PLFLT *) 0 ;
23312 PLFLT *arg2 = (PLFLT *) 0 ;
23313 PLFLT temp1 ;
23314 int res1 = SWIG_TMPOBJ ;
23315 PLFLT temp2 ;
23316 int res2 = SWIG_TMPOBJ ;
23317 octave_value_list _out;
23318 octave_value_list *_outp=&_out;
23319 octave_value _outv;
23320
23321 try {
23322 arg1 = &temp1;
23323 arg2 = &temp2;
23324 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23325 SWIG_fail;
23326 }
23327 plgcmap1_range(arg1,arg2);
23328 _outv = octave_value();
23329 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23330 if (SWIG_IsTmpObj(res1)) {
23331 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23332 } else {
23333 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23334 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23335 }
23336 if (SWIG_IsTmpObj(res2)) {
23337 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23338 } else {
23339 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23340 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23341 }
23342 return _out;
23343 fail:
23344 return octave_value_list();
23345 }
23346 catch(...) {
23347 throw;
23348 }
23349}
23350
23351
23353 PLINT arg1 ;
23354 PLINT arg2 ;
23355 PLINT arg3 ;
23356 PLINT arg4 ;
23357 int val1 ;
23358 int ecode1 = 0 ;
23359 int val2 ;
23360 int ecode2 = 0 ;
23361 int val3 ;
23362 int ecode3 = 0 ;
23363 int val4 ;
23364 int ecode4 = 0 ;
23365 octave_value_list _out;
23366 octave_value_list *_outp=&_out;
23367 octave_value _outv;
23368
23369 try {
23370 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23371 SWIG_fail;
23372 }
23373 ecode1 = SWIG_AsVal_int(args(0), &val1);
23374 if (!SWIG_IsOK(ecode1)) {
23375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23376 }
23377 arg1 = static_cast< PLINT >(val1);
23378 ecode2 = SWIG_AsVal_int(args(1), &val2);
23379 if (!SWIG_IsOK(ecode2)) {
23380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23381 }
23382 arg2 = static_cast< PLINT >(val2);
23383 ecode3 = SWIG_AsVal_int(args(2), &val3);
23384 if (!SWIG_IsOK(ecode3)) {
23385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23386 }
23387 arg3 = static_cast< PLINT >(val3);
23388 ecode4 = SWIG_AsVal_int(args(3), &val4);
23389 if (!SWIG_IsOK(ecode4)) {
23390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23391 }
23392 arg4 = static_cast< PLINT >(val4);
23393 plscol0(arg1,arg2,arg3,arg4);
23394 _outv = octave_value();
23395 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23396 return _out;
23397 fail:
23398 return octave_value_list();
23399 }
23400 catch(...) {
23401 throw;
23402 }
23403}
23404
23405
23407 PLINT arg1 ;
23408 PLINT arg2 ;
23409 PLINT arg3 ;
23410 PLINT arg4 ;
23411 PLFLT arg5 ;
23412 int val1 ;
23413 int ecode1 = 0 ;
23414 int val2 ;
23415 int ecode2 = 0 ;
23416 int val3 ;
23417 int ecode3 = 0 ;
23418 int val4 ;
23419 int ecode4 = 0 ;
23420 double val5 ;
23421 int ecode5 = 0 ;
23422 octave_value_list _out;
23423 octave_value_list *_outp=&_out;
23424 octave_value _outv;
23425
23426 try {
23427 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23428 SWIG_fail;
23429 }
23430 ecode1 = SWIG_AsVal_int(args(0), &val1);
23431 if (!SWIG_IsOK(ecode1)) {
23432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23433 }
23434 arg1 = static_cast< PLINT >(val1);
23435 ecode2 = SWIG_AsVal_int(args(1), &val2);
23436 if (!SWIG_IsOK(ecode2)) {
23437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23438 }
23439 arg2 = static_cast< PLINT >(val2);
23440 ecode3 = SWIG_AsVal_int(args(2), &val3);
23441 if (!SWIG_IsOK(ecode3)) {
23442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23443 }
23444 arg3 = static_cast< PLINT >(val3);
23445 ecode4 = SWIG_AsVal_int(args(3), &val4);
23446 if (!SWIG_IsOK(ecode4)) {
23447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23448 }
23449 arg4 = static_cast< PLINT >(val4);
23450 ecode5 = SWIG_AsVal_double(args(4), &val5);
23451 if (!SWIG_IsOK(ecode5)) {
23452 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23453 }
23454 arg5 = static_cast< PLFLT >(val5);
23455 plscol0a(arg1,arg2,arg3,arg4,arg5);
23456 _outv = octave_value();
23457 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23458 return _out;
23459 fail:
23460 return octave_value_list();
23461 }
23462 catch(...) {
23463 throw;
23464 }
23465}
23466
23467
23469 PLINT arg1 ;
23470 PLINT arg2 ;
23471 PLINT arg3 ;
23472 int val1 ;
23473 int ecode1 = 0 ;
23474 int val2 ;
23475 int ecode2 = 0 ;
23476 int val3 ;
23477 int ecode3 = 0 ;
23478 octave_value_list _out;
23479 octave_value_list *_outp=&_out;
23480 octave_value _outv;
23481
23482 try {
23483 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23484 SWIG_fail;
23485 }
23486 ecode1 = SWIG_AsVal_int(args(0), &val1);
23487 if (!SWIG_IsOK(ecode1)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23489 }
23490 arg1 = static_cast< PLINT >(val1);
23491 ecode2 = SWIG_AsVal_int(args(1), &val2);
23492 if (!SWIG_IsOK(ecode2)) {
23493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23494 }
23495 arg2 = static_cast< PLINT >(val2);
23496 ecode3 = SWIG_AsVal_int(args(2), &val3);
23497 if (!SWIG_IsOK(ecode3)) {
23498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23499 }
23500 arg3 = static_cast< PLINT >(val3);
23501 plscolbg(arg1,arg2,arg3);
23502 _outv = octave_value();
23503 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23504 return _out;
23505 fail:
23506 return octave_value_list();
23507 }
23508 catch(...) {
23509 throw;
23510 }
23511}
23512
23513
23515 PLINT arg1 ;
23516 PLINT arg2 ;
23517 PLINT arg3 ;
23518 PLFLT arg4 ;
23519 int val1 ;
23520 int ecode1 = 0 ;
23521 int val2 ;
23522 int ecode2 = 0 ;
23523 int val3 ;
23524 int ecode3 = 0 ;
23525 double val4 ;
23526 int ecode4 = 0 ;
23527 octave_value_list _out;
23528 octave_value_list *_outp=&_out;
23529 octave_value _outv;
23530
23531 try {
23532 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23533 SWIG_fail;
23534 }
23535 ecode1 = SWIG_AsVal_int(args(0), &val1);
23536 if (!SWIG_IsOK(ecode1)) {
23537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23538 }
23539 arg1 = static_cast< PLINT >(val1);
23540 ecode2 = SWIG_AsVal_int(args(1), &val2);
23541 if (!SWIG_IsOK(ecode2)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23543 }
23544 arg2 = static_cast< PLINT >(val2);
23545 ecode3 = SWIG_AsVal_int(args(2), &val3);
23546 if (!SWIG_IsOK(ecode3)) {
23547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23548 }
23549 arg3 = static_cast< PLINT >(val3);
23550 ecode4 = SWIG_AsVal_double(args(3), &val4);
23551 if (!SWIG_IsOK(ecode4)) {
23552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23553 }
23554 arg4 = static_cast< PLFLT >(val4);
23555 plscolbga(arg1,arg2,arg3,arg4);
23556 _outv = octave_value();
23557 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23558 return _out;
23559 fail:
23560 return octave_value_list();
23561 }
23562 catch(...) {
23563 throw;
23564 }
23565}
23566
23567
23569 PLINT arg1 ;
23570 int val1 ;
23571 int ecode1 = 0 ;
23572 octave_value_list _out;
23573 octave_value_list *_outp=&_out;
23574 octave_value _outv;
23575
23576 try {
23577 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23578 SWIG_fail;
23579 }
23580 ecode1 = SWIG_AsVal_int(args(0), &val1);
23581 if (!SWIG_IsOK(ecode1)) {
23582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23583 }
23584 arg1 = static_cast< PLINT >(val1);
23585 plscolor(arg1);
23586 _outv = octave_value();
23587 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23588 return _out;
23589 fail:
23590 return octave_value_list();
23591 }
23592 catch(...) {
23593 throw;
23594 }
23595}
23596
23597
23599 PLINT arg1 ;
23600 int val1 ;
23601 int ecode1 = 0 ;
23602 octave_value_list _out;
23603 octave_value_list *_outp=&_out;
23604 octave_value _outv;
23605
23606 try {
23607 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23608 SWIG_fail;
23609 }
23610 ecode1 = SWIG_AsVal_int(args(0), &val1);
23611 if (!SWIG_IsOK(ecode1)) {
23612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23613 }
23614 arg1 = static_cast< PLINT >(val1);
23615 plscompression(arg1);
23616 _outv = octave_value();
23617 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23618 return _out;
23619 fail:
23620 return octave_value_list();
23621 }
23622 catch(...) {
23623 throw;
23624 }
23625}
23626
23627
23629 char *arg1 = (char *) 0 ;
23630 int res1 ;
23631 char *buf1 = 0 ;
23632 int alloc1 = 0 ;
23633 octave_value_list _out;
23634 octave_value_list *_outp=&_out;
23635 octave_value _outv;
23636
23637 try {
23638 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23639 SWIG_fail;
23640 }
23641 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23642 if (!SWIG_IsOK(res1)) {
23643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23644 }
23645 arg1 = reinterpret_cast< char * >(buf1);
23646 plsdev((char const *)arg1);
23647 _outv = octave_value();
23648 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23649 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23650 return _out;
23651 fail:
23652 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23653 return octave_value_list();
23654 }
23655 catch(...) {
23656 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23657 throw;
23658 }
23659}
23660
23661
23663 PLFLT arg1 ;
23664 PLFLT arg2 ;
23665 PLFLT arg3 ;
23666 PLFLT arg4 ;
23667 double val1 ;
23668 int ecode1 = 0 ;
23669 double val2 ;
23670 int ecode2 = 0 ;
23671 double val3 ;
23672 int ecode3 = 0 ;
23673 double val4 ;
23674 int ecode4 = 0 ;
23675 octave_value_list _out;
23676 octave_value_list *_outp=&_out;
23677 octave_value _outv;
23678
23679 try {
23680 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23681 SWIG_fail;
23682 }
23683 ecode1 = SWIG_AsVal_double(args(0), &val1);
23684 if (!SWIG_IsOK(ecode1)) {
23685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23686 }
23687 arg1 = static_cast< PLFLT >(val1);
23688 ecode2 = SWIG_AsVal_double(args(1), &val2);
23689 if (!SWIG_IsOK(ecode2)) {
23690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23691 }
23692 arg2 = static_cast< PLFLT >(val2);
23693 ecode3 = SWIG_AsVal_double(args(2), &val3);
23694 if (!SWIG_IsOK(ecode3)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23696 }
23697 arg3 = static_cast< PLFLT >(val3);
23698 ecode4 = SWIG_AsVal_double(args(3), &val4);
23699 if (!SWIG_IsOK(ecode4)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23701 }
23702 arg4 = static_cast< PLFLT >(val4);
23703 plsdidev(arg1,arg2,arg3,arg4);
23704 _outv = octave_value();
23705 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23706 return _out;
23707 fail:
23708 return octave_value_list();
23709 }
23710 catch(...) {
23711 throw;
23712 }
23713}
23714
23715
23717 PLINT arg1 ;
23718 PLINT arg2 ;
23719 PLINT arg3 ;
23720 PLINT arg4 ;
23721 PLFLT arg5 ;
23722 PLFLT arg6 ;
23723 int val1 ;
23724 int ecode1 = 0 ;
23725 int val2 ;
23726 int ecode2 = 0 ;
23727 int val3 ;
23728 int ecode3 = 0 ;
23729 int val4 ;
23730 int ecode4 = 0 ;
23731 double val5 ;
23732 int ecode5 = 0 ;
23733 double val6 ;
23734 int ecode6 = 0 ;
23735 octave_value_list _out;
23736 octave_value_list *_outp=&_out;
23737 octave_value _outv;
23738
23739 try {
23740 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23741 SWIG_fail;
23742 }
23743 ecode1 = SWIG_AsVal_int(args(0), &val1);
23744 if (!SWIG_IsOK(ecode1)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23746 }
23747 arg1 = static_cast< PLINT >(val1);
23748 ecode2 = SWIG_AsVal_int(args(1), &val2);
23749 if (!SWIG_IsOK(ecode2)) {
23750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23751 }
23752 arg2 = static_cast< PLINT >(val2);
23753 ecode3 = SWIG_AsVal_int(args(2), &val3);
23754 if (!SWIG_IsOK(ecode3)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23756 }
23757 arg3 = static_cast< PLINT >(val3);
23758 ecode4 = SWIG_AsVal_int(args(3), &val4);
23759 if (!SWIG_IsOK(ecode4)) {
23760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23761 }
23762 arg4 = static_cast< PLINT >(val4);
23763 ecode5 = SWIG_AsVal_double(args(4), &val5);
23764 if (!SWIG_IsOK(ecode5)) {
23765 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23766 }
23767 arg5 = static_cast< PLFLT >(val5);
23768 ecode6 = SWIG_AsVal_double(args(5), &val6);
23769 if (!SWIG_IsOK(ecode6)) {
23770 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23771 }
23772 arg6 = static_cast< PLFLT >(val6);
23773 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23774 _outv = octave_value();
23775 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23776 return _out;
23777 fail:
23778 return octave_value_list();
23779 }
23780 catch(...) {
23781 throw;
23782 }
23783}
23784
23785
23787 PLFLT arg1 ;
23788 double val1 ;
23789 int ecode1 = 0 ;
23790 octave_value_list _out;
23791 octave_value_list *_outp=&_out;
23792 octave_value _outv;
23793
23794 try {
23795 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23796 SWIG_fail;
23797 }
23798 ecode1 = SWIG_AsVal_double(args(0), &val1);
23799 if (!SWIG_IsOK(ecode1)) {
23800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23801 }
23802 arg1 = static_cast< PLFLT >(val1);
23803 plsdiori(arg1);
23804 _outv = octave_value();
23805 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23806 return _out;
23807 fail:
23808 return octave_value_list();
23809 }
23810 catch(...) {
23811 throw;
23812 }
23813}
23814
23815
23817 PLFLT arg1 ;
23818 PLFLT arg2 ;
23819 PLFLT arg3 ;
23820 PLFLT arg4 ;
23821 double val1 ;
23822 int ecode1 = 0 ;
23823 double val2 ;
23824 int ecode2 = 0 ;
23825 double val3 ;
23826 int ecode3 = 0 ;
23827 double val4 ;
23828 int ecode4 = 0 ;
23829 octave_value_list _out;
23830 octave_value_list *_outp=&_out;
23831 octave_value _outv;
23832
23833 try {
23834 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23835 SWIG_fail;
23836 }
23837 ecode1 = SWIG_AsVal_double(args(0), &val1);
23838 if (!SWIG_IsOK(ecode1)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23840 }
23841 arg1 = static_cast< PLFLT >(val1);
23842 ecode2 = SWIG_AsVal_double(args(1), &val2);
23843 if (!SWIG_IsOK(ecode2)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23845 }
23846 arg2 = static_cast< PLFLT >(val2);
23847 ecode3 = SWIG_AsVal_double(args(2), &val3);
23848 if (!SWIG_IsOK(ecode3)) {
23849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23850 }
23851 arg3 = static_cast< PLFLT >(val3);
23852 ecode4 = SWIG_AsVal_double(args(3), &val4);
23853 if (!SWIG_IsOK(ecode4)) {
23854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23855 }
23856 arg4 = static_cast< PLFLT >(val4);
23857 plsdiplt(arg1,arg2,arg3,arg4);
23858 _outv = octave_value();
23859 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23860 return _out;
23861 fail:
23862 return octave_value_list();
23863 }
23864 catch(...) {
23865 throw;
23866 }
23867}
23868
23869
23871 PLFLT arg1 ;
23872 PLFLT arg2 ;
23873 PLFLT arg3 ;
23874 PLFLT arg4 ;
23875 double val1 ;
23876 int ecode1 = 0 ;
23877 double val2 ;
23878 int ecode2 = 0 ;
23879 double val3 ;
23880 int ecode3 = 0 ;
23881 double val4 ;
23882 int ecode4 = 0 ;
23883 octave_value_list _out;
23884 octave_value_list *_outp=&_out;
23885 octave_value _outv;
23886
23887 try {
23888 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23889 SWIG_fail;
23890 }
23891 ecode1 = SWIG_AsVal_double(args(0), &val1);
23892 if (!SWIG_IsOK(ecode1)) {
23893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23894 }
23895 arg1 = static_cast< PLFLT >(val1);
23896 ecode2 = SWIG_AsVal_double(args(1), &val2);
23897 if (!SWIG_IsOK(ecode2)) {
23898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23899 }
23900 arg2 = static_cast< PLFLT >(val2);
23901 ecode3 = SWIG_AsVal_double(args(2), &val3);
23902 if (!SWIG_IsOK(ecode3)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23904 }
23905 arg3 = static_cast< PLFLT >(val3);
23906 ecode4 = SWIG_AsVal_double(args(3), &val4);
23907 if (!SWIG_IsOK(ecode4)) {
23908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23909 }
23910 arg4 = static_cast< PLFLT >(val4);
23911 plsdiplz(arg1,arg2,arg3,arg4);
23912 _outv = octave_value();
23913 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23914 return _out;
23915 fail:
23916 return octave_value_list();
23917 }
23918 catch(...) {
23919 throw;
23920 }
23921}
23922
23923
23925 unsigned int arg1 ;
23926 unsigned int val1 ;
23927 int ecode1 = 0 ;
23928 octave_value_list _out;
23929 octave_value_list *_outp=&_out;
23930 octave_value _outv;
23931
23932 try {
23933 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
23934 SWIG_fail;
23935 }
23936 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23937 if (!SWIG_IsOK(ecode1)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
23939 }
23940 arg1 = static_cast< unsigned int >(val1);
23941 plseed(arg1);
23942 _outv = octave_value();
23943 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23944 return _out;
23945 fail:
23946 return octave_value_list();
23947 }
23948 catch(...) {
23949 throw;
23950 }
23951}
23952
23953
23955 char arg1 ;
23956 char val1 ;
23957 int ecode1 = 0 ;
23958 octave_value_list _out;
23959 octave_value_list *_outp=&_out;
23960 octave_value _outv;
23961
23962 try {
23963 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
23964 SWIG_fail;
23965 }
23966 ecode1 = SWIG_AsVal_char(args(0), &val1);
23967 if (!SWIG_IsOK(ecode1)) {
23968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
23969 }
23970 arg1 = static_cast< char >(val1);
23971 plsesc(arg1);
23972 _outv = octave_value();
23973 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23974 return _out;
23975 fail:
23976 return octave_value_list();
23977 }
23978 catch(...) {
23979 throw;
23980 }
23981}
23982
23983
23984SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
23985 char *arg1 = (char *) 0 ;
23986 char *arg2 = (char *) 0 ;
23987 int res1 ;
23988 char *buf1 = 0 ;
23989 int alloc1 = 0 ;
23990 int res2 ;
23991 char *buf2 = 0 ;
23992 int alloc2 = 0 ;
23993 octave_value_list _out;
23994 octave_value_list *_outp=&_out;
23995 octave_value _outv;
23996 PLINT result;
23997
23998 try {
23999 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24000 SWIG_fail;
24001 }
24002 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24005 }
24006 arg1 = reinterpret_cast< char * >(buf1);
24007 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24008 if (!SWIG_IsOK(res2)) {
24009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24010 }
24011 arg2 = reinterpret_cast< char * >(buf2);
24012 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24013 _outv = SWIG_From_int(static_cast< int >(result));
24014 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24015 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24016 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24017 return _out;
24018 fail:
24019 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24020 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24021 return octave_value_list();
24022 }
24023 catch(...) {
24024 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24025 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24026 throw;
24027 }
24028}
24029
24030
24032 PLINT arg1 ;
24033 PLINT arg2 ;
24034 PLINT arg3 ;
24035 int val1 ;
24036 int ecode1 = 0 ;
24037 int val2 ;
24038 int ecode2 = 0 ;
24039 int val3 ;
24040 int ecode3 = 0 ;
24041 octave_value_list _out;
24042 octave_value_list *_outp=&_out;
24043 octave_value _outv;
24044
24045 try {
24046 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24047 SWIG_fail;
24048 }
24049 ecode1 = SWIG_AsVal_int(args(0), &val1);
24050 if (!SWIG_IsOK(ecode1)) {
24051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24052 }
24053 arg1 = static_cast< PLINT >(val1);
24054 ecode2 = SWIG_AsVal_int(args(1), &val2);
24055 if (!SWIG_IsOK(ecode2)) {
24056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24057 }
24058 arg2 = static_cast< PLINT >(val2);
24059 ecode3 = SWIG_AsVal_int(args(2), &val3);
24060 if (!SWIG_IsOK(ecode3)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24062 }
24063 arg3 = static_cast< PLINT >(val3);
24064 plsfam(arg1,arg2,arg3);
24065 _outv = octave_value();
24066 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24067 return _out;
24068 fail:
24069 return octave_value_list();
24070 }
24071 catch(...) {
24072 throw;
24073 }
24074}
24075
24076
24078 PLUNICODE arg1 ;
24079 unsigned int val1 ;
24080 int ecode1 = 0 ;
24081 octave_value_list _out;
24082 octave_value_list *_outp=&_out;
24083 octave_value _outv;
24084
24085 try {
24086 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24087 SWIG_fail;
24088 }
24089 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24090 if (!SWIG_IsOK(ecode1)) {
24091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24092 }
24093 arg1 = static_cast< PLUNICODE >(val1);
24094 plsfci(arg1);
24095 _outv = octave_value();
24096 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24097 return _out;
24098 fail:
24099 return octave_value_list();
24100 }
24101 catch(...) {
24102 throw;
24103 }
24104}
24105
24106
24108 char *arg1 = (char *) 0 ;
24109 int res1 ;
24110 char *buf1 = 0 ;
24111 int alloc1 = 0 ;
24112 octave_value_list _out;
24113 octave_value_list *_outp=&_out;
24114 octave_value _outv;
24115
24116 try {
24117 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24118 SWIG_fail;
24119 }
24120 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24121 if (!SWIG_IsOK(res1)) {
24122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24123 }
24124 arg1 = reinterpret_cast< char * >(buf1);
24125 plsfnam((char const *)arg1);
24126 _outv = octave_value();
24127 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24128 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24129 return _out;
24130 fail:
24131 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24132 return octave_value_list();
24133 }
24134 catch(...) {
24135 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24136 throw;
24137 }
24138}
24139
24140
24142 PLINT arg1 ;
24143 PLINT arg2 ;
24144 PLINT arg3 ;
24145 int val1 ;
24146 int ecode1 = 0 ;
24147 int val2 ;
24148 int ecode2 = 0 ;
24149 int val3 ;
24150 int ecode3 = 0 ;
24151 octave_value_list _out;
24152 octave_value_list *_outp=&_out;
24153 octave_value _outv;
24154
24155 try {
24156 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24157 SWIG_fail;
24158 }
24159 ecode1 = SWIG_AsVal_int(args(0), &val1);
24160 if (!SWIG_IsOK(ecode1)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24162 }
24163 arg1 = static_cast< PLINT >(val1);
24164 ecode2 = SWIG_AsVal_int(args(1), &val2);
24165 if (!SWIG_IsOK(ecode2)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24167 }
24168 arg2 = static_cast< PLINT >(val2);
24169 ecode3 = SWIG_AsVal_int(args(2), &val3);
24170 if (!SWIG_IsOK(ecode3)) {
24171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24172 }
24173 arg3 = static_cast< PLINT >(val3);
24174 plsfont(arg1,arg2,arg3);
24175 _outv = octave_value();
24176 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24177 return _out;
24178 fail:
24179 return octave_value_list();
24180 }
24181 catch(...) {
24182 throw;
24183 }
24184}
24185
24186
24188 label_func arg1 = (label_func) 0 ;
24189 PLPointer arg2 = (PLPointer) 0 ;
24190 int res2 ;
24191 octave_value_list _out;
24192 octave_value_list *_outp=&_out;
24193 octave_value _outv;
24194
24195 try {
24196 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24197 SWIG_fail;
24198 }
24199 {
24200 octave_value obj = args(0);
24201#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24202 if ( !obj.isempty() )
24203#else
24204 if ( !obj.is_empty() )
24205#endif
24206 {
24207 if ( obj.is_function_handle() || obj.is_inline_function() )
24208 {
24209 fcnLabelFunc = obj.function_value();
24210 }
24211 else if ( obj.is_string() )
24212 {
24213 nameLabelFunc = obj.string_value();
24214 fcnLabelFunc = NULL;
24215 }
24216 arg1 = labelfunc_octave;
24217 }
24218 else
24219 {
24220 arg1 = NULL;
24221 }
24222 }
24223 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24224 if (!SWIG_IsOK(res2)) {
24225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24226 }
24227 plslabelfunc(arg1,arg2);
24228 _outv = octave_value();
24229 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24230 return _out;
24231 fail:
24232 return octave_value_list();
24233 }
24234 catch(...) {
24235 throw;
24236 }
24237}
24238
24239
24241 PLFLT arg1 ;
24242 PLFLT arg2 ;
24243 double val1 ;
24244 int ecode1 = 0 ;
24245 double val2 ;
24246 int ecode2 = 0 ;
24247 octave_value_list _out;
24248 octave_value_list *_outp=&_out;
24249 octave_value _outv;
24250
24251 try {
24252 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24253 SWIG_fail;
24254 }
24255 ecode1 = SWIG_AsVal_double(args(0), &val1);
24256 if (!SWIG_IsOK(ecode1)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24258 }
24259 arg1 = static_cast< PLFLT >(val1);
24260 ecode2 = SWIG_AsVal_double(args(1), &val2);
24261 if (!SWIG_IsOK(ecode2)) {
24262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24263 }
24264 arg2 = static_cast< PLFLT >(val2);
24265 plsmaj(arg1,arg2);
24266 _outv = octave_value();
24267 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24268 return _out;
24269 fail:
24270 return octave_value_list();
24271 }
24272 catch(...) {
24273 throw;
24274 }
24275}
24276
24277
24279 PLFLT arg1 ;
24280 PLFLT arg2 ;
24281 double val1 ;
24282 int ecode1 = 0 ;
24283 double val2 ;
24284 int ecode2 = 0 ;
24285 octave_value_list _out;
24286 octave_value_list *_outp=&_out;
24287 octave_value _outv;
24288
24289 try {
24290 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24291 SWIG_fail;
24292 }
24293 ecode1 = SWIG_AsVal_double(args(0), &val1);
24294 if (!SWIG_IsOK(ecode1)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24296 }
24297 arg1 = static_cast< PLFLT >(val1);
24298 ecode2 = SWIG_AsVal_double(args(1), &val2);
24299 if (!SWIG_IsOK(ecode2)) {
24300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24301 }
24302 arg2 = static_cast< PLFLT >(val2);
24303 plsmin(arg1,arg2);
24304 _outv = octave_value();
24305 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24306 return _out;
24307 fail:
24308 return octave_value_list();
24309 }
24310 catch(...) {
24311 throw;
24312 }
24313}
24314
24315
24317 PLINT arg1 ;
24318 int val1 ;
24319 int ecode1 = 0 ;
24320 octave_value_list _out;
24321 octave_value_list *_outp=&_out;
24322 octave_value _outv;
24323
24324 try {
24325 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24326 SWIG_fail;
24327 }
24328 ecode1 = SWIG_AsVal_int(args(0), &val1);
24329 if (!SWIG_IsOK(ecode1)) {
24330 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24331 }
24332 arg1 = static_cast< PLINT >(val1);
24333 plsori(arg1);
24334 _outv = octave_value();
24335 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24336 return _out;
24337 fail:
24338 return octave_value_list();
24339 }
24340 catch(...) {
24341 throw;
24342 }
24343}
24344
24345
24347 PLFLT arg1 ;
24348 PLFLT arg2 ;
24349 PLINT arg3 ;
24350 PLINT arg4 ;
24351 PLINT arg5 ;
24352 PLINT arg6 ;
24353 double val1 ;
24354 int ecode1 = 0 ;
24355 double val2 ;
24356 int ecode2 = 0 ;
24357 int val3 ;
24358 int ecode3 = 0 ;
24359 int val4 ;
24360 int ecode4 = 0 ;
24361 int val5 ;
24362 int ecode5 = 0 ;
24363 int val6 ;
24364 int ecode6 = 0 ;
24365 octave_value_list _out;
24366 octave_value_list *_outp=&_out;
24367 octave_value _outv;
24368
24369 try {
24370 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24371 SWIG_fail;
24372 }
24373 ecode1 = SWIG_AsVal_double(args(0), &val1);
24374 if (!SWIG_IsOK(ecode1)) {
24375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24376 }
24377 arg1 = static_cast< PLFLT >(val1);
24378 ecode2 = SWIG_AsVal_double(args(1), &val2);
24379 if (!SWIG_IsOK(ecode2)) {
24380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24381 }
24382 arg2 = static_cast< PLFLT >(val2);
24383 ecode3 = SWIG_AsVal_int(args(2), &val3);
24384 if (!SWIG_IsOK(ecode3)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24386 }
24387 arg3 = static_cast< PLINT >(val3);
24388 ecode4 = SWIG_AsVal_int(args(3), &val4);
24389 if (!SWIG_IsOK(ecode4)) {
24390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24391 }
24392 arg4 = static_cast< PLINT >(val4);
24393 ecode5 = SWIG_AsVal_int(args(4), &val5);
24394 if (!SWIG_IsOK(ecode5)) {
24395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24396 }
24397 arg5 = static_cast< PLINT >(val5);
24398 ecode6 = SWIG_AsVal_int(args(5), &val6);
24399 if (!SWIG_IsOK(ecode6)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24401 }
24402 arg6 = static_cast< PLINT >(val6);
24403 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24404 _outv = octave_value();
24405 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24406 return _out;
24407 fail:
24408 return octave_value_list();
24409 }
24410 catch(...) {
24411 throw;
24412 }
24413}
24414
24415
24417 char *arg1 = (char *) 0 ;
24418 int res1 ;
24419 char *buf1 = 0 ;
24420 int alloc1 = 0 ;
24421 octave_value_list _out;
24422 octave_value_list *_outp=&_out;
24423 octave_value _outv;
24424
24425 try {
24426 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24427 SWIG_fail;
24428 }
24429 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24432 }
24433 arg1 = reinterpret_cast< char * >(buf1);
24434 plspal0((char const *)arg1);
24435 _outv = octave_value();
24436 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24437 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24438 return _out;
24439 fail:
24440 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24441 return octave_value_list();
24442 }
24443 catch(...) {
24444 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24445 throw;
24446 }
24447}
24448
24449
24451 char *arg1 = (char *) 0 ;
24452 PLBOOL arg2 ;
24453 int res1 ;
24454 char *buf1 = 0 ;
24455 int alloc1 = 0 ;
24456 int val2 ;
24457 int ecode2 = 0 ;
24458 octave_value_list _out;
24459 octave_value_list *_outp=&_out;
24460 octave_value _outv;
24461
24462 try {
24463 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24464 SWIG_fail;
24465 }
24466 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24467 if (!SWIG_IsOK(res1)) {
24468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24469 }
24470 arg1 = reinterpret_cast< char * >(buf1);
24471 ecode2 = SWIG_AsVal_int(args(1), &val2);
24472 if (!SWIG_IsOK(ecode2)) {
24473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24474 }
24475 arg2 = static_cast< PLBOOL >(val2);
24476 plspal1((char const *)arg1,arg2);
24477 _outv = octave_value();
24478 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24479 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24480 return _out;
24481 fail:
24482 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24483 return octave_value_list();
24484 }
24485 catch(...) {
24486 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24487 throw;
24488 }
24489}
24490
24491
24493 PLBOOL arg1 ;
24494 int val1 ;
24495 int ecode1 = 0 ;
24496 octave_value_list _out;
24497 octave_value_list *_outp=&_out;
24498 octave_value _outv;
24499
24500 try {
24501 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24502 SWIG_fail;
24503 }
24504 ecode1 = SWIG_AsVal_int(args(0), &val1);
24505 if (!SWIG_IsOK(ecode1)) {
24506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24507 }
24508 arg1 = static_cast< PLBOOL >(val1);
24509 plspause(arg1);
24510 _outv = octave_value();
24511 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24512 return _out;
24513 fail:
24514 return octave_value_list();
24515 }
24516 catch(...) {
24517 throw;
24518 }
24519}
24520
24521
24522SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24523 PLINT arg1 ;
24524 int val1 ;
24525 int ecode1 = 0 ;
24526 octave_value_list _out;
24527 octave_value_list *_outp=&_out;
24528 octave_value _outv;
24529
24530 try {
24531 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24532 SWIG_fail;
24533 }
24534 ecode1 = SWIG_AsVal_int(args(0), &val1);
24535 if (!SWIG_IsOK(ecode1)) {
24536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24537 }
24538 arg1 = static_cast< PLINT >(val1);
24539 plsstrm(arg1);
24540 _outv = octave_value();
24541 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24542 return _out;
24543 fail:
24544 return octave_value_list();
24545 }
24546 catch(...) {
24547 throw;
24548 }
24549}
24550
24551
24553 PLINT arg1 ;
24554 PLINT arg2 ;
24555 int val1 ;
24556 int ecode1 = 0 ;
24557 int val2 ;
24558 int ecode2 = 0 ;
24559 octave_value_list _out;
24560 octave_value_list *_outp=&_out;
24561 octave_value _outv;
24562
24563 try {
24564 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24565 SWIG_fail;
24566 }
24567 ecode1 = SWIG_AsVal_int(args(0), &val1);
24568 if (!SWIG_IsOK(ecode1)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24570 }
24571 arg1 = static_cast< PLINT >(val1);
24572 ecode2 = SWIG_AsVal_int(args(1), &val2);
24573 if (!SWIG_IsOK(ecode2)) {
24574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24575 }
24576 arg2 = static_cast< PLINT >(val2);
24577 plssub(arg1,arg2);
24578 _outv = octave_value();
24579 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24580 return _out;
24581 fail:
24582 return octave_value_list();
24583 }
24584 catch(...) {
24585 throw;
24586 }
24587}
24588
24589
24591 PLFLT arg1 ;
24592 PLFLT arg2 ;
24593 double val1 ;
24594 int ecode1 = 0 ;
24595 double val2 ;
24596 int ecode2 = 0 ;
24597 octave_value_list _out;
24598 octave_value_list *_outp=&_out;
24599 octave_value _outv;
24600
24601 try {
24602 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24603 SWIG_fail;
24604 }
24605 ecode1 = SWIG_AsVal_double(args(0), &val1);
24606 if (!SWIG_IsOK(ecode1)) {
24607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24608 }
24609 arg1 = static_cast< PLFLT >(val1);
24610 ecode2 = SWIG_AsVal_double(args(1), &val2);
24611 if (!SWIG_IsOK(ecode2)) {
24612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24613 }
24614 arg2 = static_cast< PLFLT >(val2);
24615 plssym(arg1,arg2);
24616 _outv = octave_value();
24617 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24618 return _out;
24619 fail:
24620 return octave_value_list();
24621 }
24622 catch(...) {
24623 throw;
24624 }
24625}
24626
24627
24629 PLINT arg1 ;
24630 PLINT arg2 ;
24631 int val1 ;
24632 int ecode1 = 0 ;
24633 int val2 ;
24634 int ecode2 = 0 ;
24635 octave_value_list _out;
24636 octave_value_list *_outp=&_out;
24637 octave_value _outv;
24638
24639 try {
24640 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24641 SWIG_fail;
24642 }
24643 ecode1 = SWIG_AsVal_int(args(0), &val1);
24644 if (!SWIG_IsOK(ecode1)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24646 }
24647 arg1 = static_cast< PLINT >(val1);
24648 ecode2 = SWIG_AsVal_int(args(1), &val2);
24649 if (!SWIG_IsOK(ecode2)) {
24650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24651 }
24652 arg2 = static_cast< PLINT >(val2);
24653 plstar(arg1,arg2);
24654 _outv = octave_value();
24655 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24656 return _out;
24657 fail:
24658 return octave_value_list();
24659 }
24660 catch(...) {
24661 throw;
24662 }
24663}
24664
24665
24667 char *arg1 = (char *) 0 ;
24668 PLINT arg2 ;
24669 PLINT arg3 ;
24670 int res1 ;
24671 char *buf1 = 0 ;
24672 int alloc1 = 0 ;
24673 int val2 ;
24674 int ecode2 = 0 ;
24675 int val3 ;
24676 int ecode3 = 0 ;
24677 octave_value_list _out;
24678 octave_value_list *_outp=&_out;
24679 octave_value _outv;
24680
24681 try {
24682 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24683 SWIG_fail;
24684 }
24685 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24686 if (!SWIG_IsOK(res1)) {
24687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24688 }
24689 arg1 = reinterpret_cast< char * >(buf1);
24690 ecode2 = SWIG_AsVal_int(args(1), &val2);
24691 if (!SWIG_IsOK(ecode2)) {
24692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24693 }
24694 arg2 = static_cast< PLINT >(val2);
24695 ecode3 = SWIG_AsVal_int(args(2), &val3);
24696 if (!SWIG_IsOK(ecode3)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24698 }
24699 arg3 = static_cast< PLINT >(val3);
24700 plstart((char const *)arg1,arg2,arg3);
24701 _outv = octave_value();
24702 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24703 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24704 return _out;
24705 fail:
24706 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24707 return octave_value_list();
24708 }
24709 catch(...) {
24710 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24711 throw;
24712 }
24713}
24714
24715
24717 ct_func arg1 = (ct_func) 0 ;
24718 PLPointer arg2 = (PLPointer) 0 ;
24719 int res2 ;
24720 octave_value_list _out;
24721 octave_value_list *_outp=&_out;
24722 octave_value _outv;
24723
24724 try {
24725 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24726 SWIG_fail;
24727 }
24728 {
24729 octave_value obj = args(0);
24730#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24731 if ( !obj.isempty() )
24732#else
24733 if ( !obj.is_empty() )
24734#endif
24735 {
24736 if ( obj.is_function_handle() || obj.is_inline_function() )
24737 {
24738 fcnCoordTrans = obj.function_value();
24739 }
24740 else if ( obj.is_string() )
24741 {
24742 nameCoordTrans = obj.string_value();
24743 fcnCoordTrans = NULL;
24744 }
24745 arg1 = ct_octave;
24746 }
24747 else
24748 {
24749 arg1 = NULL;
24750 }
24751 }
24752 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24753 if (!SWIG_IsOK(res2)) {
24754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24755 }
24756 plstransform(arg1,arg2);
24757 _outv = octave_value();
24758 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24759 return _out;
24760 fail:
24761 return octave_value_list();
24762 }
24763 catch(...) {
24764 throw;
24765 }
24766}
24767
24768
24770 PLINT arg1 ;
24771 PLFLT *arg2 = (PLFLT *) 0 ;
24772 PLFLT *arg3 = (PLFLT *) 0 ;
24773 char *arg4 = (char *) 0 ;
24774 Matrix temp1 ;
24775 Matrix temp3 ;
24776 int res4 ;
24777 char *buf4 = 0 ;
24778 int alloc4 = 0 ;
24779 octave_value_list _out;
24780 octave_value_list *_outp=&_out;
24781 octave_value _outv;
24782
24783 try {
24784 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24785 SWIG_fail;
24786 }
24787 {
24788 if ( _n_dims( args(0) ) > 1 )
24789 {
24790 error( "argument must be a scalar or vector" ); SWIG_fail;
24791 }
24792 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24793 temp1 = args(0).matrix_value();
24794 arg2 = &temp1( 0, 0 );
24795 }
24796 {
24797 if ( _n_dims( args(1) ) > 1 )
24798 {
24799 error( "argument must be a scalar or vector" ); SWIG_fail;
24800 }
24801 if ( _dim( args(1), 0 ) != Alen )
24802 {
24803 error( "argument vectors must be same length" ); SWIG_fail;
24804 }
24805 temp3 = args(1).matrix_value();
24806 arg3 = &temp3( 0, 0 );
24807 }
24808 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24809 if (!SWIG_IsOK(res4)) {
24810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24811 }
24812 arg4 = reinterpret_cast< char * >(buf4);
24813 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24814 _outv = octave_value();
24815 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24816 {
24817
24818 }
24819 {
24820
24821 }
24822 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24823 return _out;
24824 fail:
24825 {
24826
24827 }
24828 {
24829
24830 }
24831 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24832 return octave_value_list();
24833 }
24834 catch(...) {
24835 {
24836
24837 }
24838 {
24839
24840 }
24841 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24842 throw;
24843 }
24844}
24845
24846
24848 PLINT arg1 ;
24849 PLFLT *arg2 = (PLFLT *) 0 ;
24850 PLFLT *arg3 = (PLFLT *) 0 ;
24851 PLFLT *arg4 = (PLFLT *) 0 ;
24852 char *arg5 = (char *) 0 ;
24853 Matrix temp1 ;
24854 Matrix temp3 ;
24855 Matrix temp4 ;
24856 int res5 ;
24857 char *buf5 = 0 ;
24858 int alloc5 = 0 ;
24859 octave_value_list _out;
24860 octave_value_list *_outp=&_out;
24861 octave_value _outv;
24862
24863 try {
24864 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24865 SWIG_fail;
24866 }
24867 {
24868 if ( _n_dims( args(0) ) > 1 )
24869 {
24870 error( "argument must be a scalar or vector" ); SWIG_fail;
24871 }
24872 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24873 temp1 = args(0).matrix_value();
24874 arg2 = &temp1( 0, 0 );
24875 }
24876 {
24877 if ( _n_dims( args(1) ) > 1 )
24878 {
24879 error( "argument must be a scalar or vector" ); SWIG_fail;
24880 }
24881 if ( _dim( args(1), 0 ) != Alen )
24882 {
24883 error( "argument vectors must be same length" ); SWIG_fail;
24884 }
24885 temp3 = args(1).matrix_value();
24886 arg3 = &temp3( 0, 0 );
24887 }
24888 {
24889 if ( _n_dims( args(2) ) > 1 )
24890 {
24891 error( "argument must be a scalar or vector" ); SWIG_fail;
24892 }
24893 if ( _dim( args(2), 0 ) != Alen )
24894 {
24895 error( "argument vectors must be same length" ); SWIG_fail;
24896 }
24897 temp4 = args(2).matrix_value();
24898 arg4 = &temp4( 0, 0 );
24899 }
24900 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24901 if (!SWIG_IsOK(res5)) {
24902 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24903 }
24904 arg5 = reinterpret_cast< char * >(buf5);
24905 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24906 _outv = octave_value();
24907 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24908 {
24909
24910 }
24911 {
24912
24913 }
24914 {
24915
24916 }
24917 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24918 return _out;
24919 fail:
24920 {
24921
24922 }
24923 {
24924
24925 }
24926 {
24927
24928 }
24929 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24930 return octave_value_list();
24931 }
24932 catch(...) {
24933 {
24934
24935 }
24936 {
24937
24938 }
24939 {
24940
24941 }
24942 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24943 throw;
24944 }
24945}
24946
24947
24949 PLINT arg1 ;
24950 PLINT arg2 ;
24951 PLFLT arg3 ;
24952 PLFLT arg4 ;
24953 int val1 ;
24954 int ecode1 = 0 ;
24955 int val2 ;
24956 int ecode2 = 0 ;
24957 double val3 ;
24958 int ecode3 = 0 ;
24959 double val4 ;
24960 int ecode4 = 0 ;
24961 octave_value_list _out;
24962 octave_value_list *_outp=&_out;
24963 octave_value _outv;
24964
24965 try {
24966 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
24967 SWIG_fail;
24968 }
24969 ecode1 = SWIG_AsVal_int(args(0), &val1);
24970 if (!SWIG_IsOK(ecode1)) {
24971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
24972 }
24973 arg1 = static_cast< PLINT >(val1);
24974 ecode2 = SWIG_AsVal_int(args(1), &val2);
24975 if (!SWIG_IsOK(ecode2)) {
24976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
24977 }
24978 arg2 = static_cast< PLINT >(val2);
24979 ecode3 = SWIG_AsVal_double(args(2), &val3);
24980 if (!SWIG_IsOK(ecode3)) {
24981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
24982 }
24983 arg3 = static_cast< PLFLT >(val3);
24984 ecode4 = SWIG_AsVal_double(args(3), &val4);
24985 if (!SWIG_IsOK(ecode4)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
24987 }
24988 arg4 = static_cast< PLFLT >(val4);
24989 plstripa(arg1,arg2,arg3,arg4);
24990 _outv = octave_value();
24991 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24992 return _out;
24993 fail:
24994 return octave_value_list();
24995 }
24996 catch(...) {
24997 throw;
24998 }
24999}
25000
25001
25003 PLINT arg1 ;
25004 int val1 ;
25005 int ecode1 = 0 ;
25006 octave_value_list _out;
25007 octave_value_list *_outp=&_out;
25008 octave_value _outv;
25009
25010 try {
25011 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25012 SWIG_fail;
25013 }
25014 ecode1 = SWIG_AsVal_int(args(0), &val1);
25015 if (!SWIG_IsOK(ecode1)) {
25016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25017 }
25018 arg1 = static_cast< PLINT >(val1);
25019 plstripd(arg1);
25020 _outv = octave_value();
25021 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25022 return _out;
25023 fail:
25024 return octave_value_list();
25025 }
25026 catch(...) {
25027 throw;
25028 }
25029}
25030
25031
25033 PLINT arg1 ;
25034 PLINT *arg2 = (PLINT *) 0 ;
25035 PLINT *arg3 = (PLINT *) 0 ;
25036 Matrix temp1 ;
25037 Matrix temp3 ;
25038 octave_value_list _out;
25039 octave_value_list *_outp=&_out;
25040 octave_value _outv;
25041
25042 try {
25043 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25044 SWIG_fail;
25045 }
25046 {
25047 if ( _n_dims( args(0) ) > 1 )
25048 {
25049 error( "argument must be a scalar or vector" ); SWIG_fail;
25050 }
25051 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25052 arg2 = new PLINT[Alen];
25053 temp1 = args(0).matrix_value();
25054 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25055 }
25056 {
25057 if ( _n_dims( args(1) ) > 1 )
25058 {
25059 error( "argument must be a scalar or vector" ); SWIG_fail;
25060 }
25061 if ( _dim( args(1), 0 ) != Alen )
25062 {
25063 error( "argument vectors must be same length" ); SWIG_fail;
25064 }
25065 temp3 = args(1).matrix_value();
25066 arg3 = new PLINT[Alen];
25067 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25068 }
25069 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25070 _outv = octave_value();
25071 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25072 {
25073 delete [] arg2;
25074 }
25075 {
25076 delete [] arg3;
25077 }
25078 return _out;
25079 fail:
25080 {
25081 delete [] arg2;
25082 }
25083 {
25084 delete [] arg3;
25085 }
25086 return octave_value_list();
25087 }
25088 catch(...) {
25089 {
25090 delete [] arg2;
25091 }
25092 {
25093 delete [] arg3;
25094 }
25095 throw;
25096 }
25097}
25098
25099
25101 PLFLT *arg1 = (PLFLT *) 0 ;
25102 PLFLT *arg2 = (PLFLT *) 0 ;
25103 PLINT arg3 ;
25104 PLBOOL arg4 ;
25105 Matrix temp1 ;
25106 Matrix temp2 ;
25107 int val4 ;
25108 int ecode4 = 0 ;
25109 octave_value_list _out;
25110 octave_value_list *_outp=&_out;
25111 octave_value _outv;
25112
25113 try {
25114 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25115 SWIG_fail;
25116 }
25117 {
25118 if ( _n_dims( args(0) ) > 1 )
25119 {
25120 error( "argument must be a scalar or vector" ); SWIG_fail;
25121 }
25122#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25123 if ( !args(0).isempty() )
25124#else
25125 if ( !args(0).is_empty() )
25126#endif
25127 {
25128 Alen = (PLINT) ( _dim( args(0), 0 ) );
25129 temp1 = args(0).matrix_value();
25130 arg1 = &temp1( 0, 0 );
25131 }
25132 else
25133 {
25134 arg1 = NULL;
25135 Alen = 0;
25136 }
25137 }
25138 {
25139 if ( _n_dims( args(1) ) > 1 )
25140 {
25141 error( "argument must be a scalar or vector" ); SWIG_fail;
25142 }
25143#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25144 if ( !args(1).isempty() )
25145#else
25146 if ( !args(1).is_empty() )
25147#endif
25148 {
25149 if ( _dim( args(1), 0 ) != Alen )
25150 {
25151 error( "argument vectors must be same length" ); SWIG_fail;
25152 }
25153 temp2 = args(1).matrix_value();
25154 arg2 = &temp2( 0, 0 );
25155 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25156 }
25157 else
25158 {
25159 arg2 = NULL;
25160 arg3 = 0;
25161 }
25162 }
25163 ecode4 = SWIG_AsVal_int(args(2), &val4);
25164 if (!SWIG_IsOK(ecode4)) {
25165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25166 }
25167 arg4 = static_cast< PLBOOL >(val4);
25168 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25169 _outv = octave_value();
25170 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25171 {
25172
25173 }
25174 {
25175
25176 }
25177 return _out;
25178 fail:
25179 {
25180
25181 }
25182 {
25183
25184 }
25185 return octave_value_list();
25186 }
25187 catch(...) {
25188 {
25189
25190 }
25191 {
25192
25193 }
25194 throw;
25195 }
25196}
25197
25198
25200 PLFLT arg1 ;
25201 PLFLT arg2 ;
25202 PLFLT arg3 ;
25203 PLFLT arg4 ;
25204 double val1 ;
25205 int ecode1 = 0 ;
25206 double val2 ;
25207 int ecode2 = 0 ;
25208 double val3 ;
25209 int ecode3 = 0 ;
25210 double val4 ;
25211 int ecode4 = 0 ;
25212 octave_value_list _out;
25213 octave_value_list *_outp=&_out;
25214 octave_value _outv;
25215
25216 try {
25217 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25218 SWIG_fail;
25219 }
25220 ecode1 = SWIG_AsVal_double(args(0), &val1);
25221 if (!SWIG_IsOK(ecode1)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25223 }
25224 arg1 = static_cast< PLFLT >(val1);
25225 ecode2 = SWIG_AsVal_double(args(1), &val2);
25226 if (!SWIG_IsOK(ecode2)) {
25227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25228 }
25229 arg2 = static_cast< PLFLT >(val2);
25230 ecode3 = SWIG_AsVal_double(args(2), &val3);
25231 if (!SWIG_IsOK(ecode3)) {
25232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25233 }
25234 arg3 = static_cast< PLFLT >(val3);
25235 ecode4 = SWIG_AsVal_double(args(3), &val4);
25236 if (!SWIG_IsOK(ecode4)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25238 }
25239 arg4 = static_cast< PLFLT >(val4);
25240 plsvpa(arg1,arg2,arg3,arg4);
25241 _outv = octave_value();
25242 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25243 return _out;
25244 fail:
25245 return octave_value_list();
25246 }
25247 catch(...) {
25248 throw;
25249 }
25250}
25251
25252
25254 PLINT arg1 ;
25255 PLINT arg2 ;
25256 int val1 ;
25257 int ecode1 = 0 ;
25258 int val2 ;
25259 int ecode2 = 0 ;
25260 octave_value_list _out;
25261 octave_value_list *_outp=&_out;
25262 octave_value _outv;
25263
25264 try {
25265 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25266 SWIG_fail;
25267 }
25268 ecode1 = SWIG_AsVal_int(args(0), &val1);
25269 if (!SWIG_IsOK(ecode1)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25271 }
25272 arg1 = static_cast< PLINT >(val1);
25273 ecode2 = SWIG_AsVal_int(args(1), &val2);
25274 if (!SWIG_IsOK(ecode2)) {
25275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25276 }
25277 arg2 = static_cast< PLINT >(val2);
25278 plsxax(arg1,arg2);
25279 _outv = octave_value();
25280 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25281 return _out;
25282 fail:
25283 return octave_value_list();
25284 }
25285 catch(...) {
25286 throw;
25287 }
25288}
25289
25290
25292 PLINT arg1 ;
25293 PLINT arg2 ;
25294 int val1 ;
25295 int ecode1 = 0 ;
25296 int val2 ;
25297 int ecode2 = 0 ;
25298 octave_value_list _out;
25299 octave_value_list *_outp=&_out;
25300 octave_value _outv;
25301
25302 try {
25303 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25304 SWIG_fail;
25305 }
25306 ecode1 = SWIG_AsVal_int(args(0), &val1);
25307 if (!SWIG_IsOK(ecode1)) {
25308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25309 }
25310 arg1 = static_cast< PLINT >(val1);
25311 ecode2 = SWIG_AsVal_int(args(1), &val2);
25312 if (!SWIG_IsOK(ecode2)) {
25313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25314 }
25315 arg2 = static_cast< PLINT >(val2);
25316 plsyax(arg1,arg2);
25317 _outv = octave_value();
25318 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25319 return _out;
25320 fail:
25321 return octave_value_list();
25322 }
25323 catch(...) {
25324 throw;
25325 }
25326}
25327
25328
25330 PLINT arg1 ;
25331 PLFLT *arg2 = (PLFLT *) 0 ;
25332 PLFLT *arg3 = (PLFLT *) 0 ;
25333 PLINT arg4 ;
25334 Matrix temp1 ;
25335 Matrix temp3 ;
25336 int val4 ;
25337 int ecode4 = 0 ;
25338 octave_value_list _out;
25339 octave_value_list *_outp=&_out;
25340 octave_value _outv;
25341
25342 try {
25343 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25344 SWIG_fail;
25345 }
25346 {
25347 if ( _n_dims( args(0) ) > 1 )
25348 {
25349 error( "argument must be a scalar or vector" ); SWIG_fail;
25350 }
25351 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25352 temp1 = args(0).matrix_value();
25353 arg2 = &temp1( 0, 0 );
25354 }
25355 {
25356 if ( _n_dims( args(1) ) > 1 )
25357 {
25358 error( "argument must be a scalar or vector" ); SWIG_fail;
25359 }
25360 if ( _dim( args(1), 0 ) != Alen )
25361 {
25362 error( "argument vectors must be same length" ); SWIG_fail;
25363 }
25364 temp3 = args(1).matrix_value();
25365 arg3 = &temp3( 0, 0 );
25366 }
25367 ecode4 = SWIG_AsVal_int(args(2), &val4);
25368 if (!SWIG_IsOK(ecode4)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25370 }
25371 arg4 = static_cast< PLINT >(val4);
25372 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25373 _outv = octave_value();
25374 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25375 {
25376
25377 }
25378 {
25379
25380 }
25381 return _out;
25382 fail:
25383 {
25384
25385 }
25386 {
25387
25388 }
25389 return octave_value_list();
25390 }
25391 catch(...) {
25392 {
25393
25394 }
25395 {
25396
25397 }
25398 throw;
25399 }
25400}
25401
25402
25404 PLINT arg1 ;
25405 PLINT arg2 ;
25406 int val1 ;
25407 int ecode1 = 0 ;
25408 int val2 ;
25409 int ecode2 = 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("plszax",args.length(),2,2,0)) {
25416 SWIG_fail;
25417 }
25418 ecode1 = SWIG_AsVal_int(args(0), &val1);
25419 if (!SWIG_IsOK(ecode1)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25421 }
25422 arg1 = static_cast< PLINT >(val1);
25423 ecode2 = SWIG_AsVal_int(args(1), &val2);
25424 if (!SWIG_IsOK(ecode2)) {
25425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25426 }
25427 arg2 = static_cast< PLINT >(val2);
25428 plszax(arg1,arg2);
25429 _outv = octave_value();
25430 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25431 return _out;
25432 fail:
25433 return octave_value_list();
25434 }
25435 catch(...) {
25436 throw;
25437 }
25438}
25439
25440
25442 octave_value_list _out;
25443 octave_value_list *_outp=&_out;
25444 octave_value _outv;
25445
25446 try {
25447 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25448 SWIG_fail;
25449 }
25450 pltext();
25451 _outv = octave_value();
25452 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25453 return _out;
25454 fail:
25455 return octave_value_list();
25456 }
25457 catch(...) {
25458 throw;
25459 }
25460}
25461
25462
25464 char *arg1 = (char *) 0 ;
25465 int res1 ;
25466 char *buf1 = 0 ;
25467 int alloc1 = 0 ;
25468 octave_value_list _out;
25469 octave_value_list *_outp=&_out;
25470 octave_value _outv;
25471
25472 try {
25473 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25474 SWIG_fail;
25475 }
25476 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25477 if (!SWIG_IsOK(res1)) {
25478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25479 }
25480 arg1 = reinterpret_cast< char * >(buf1);
25481 pltimefmt((char const *)arg1);
25482 _outv = octave_value();
25483 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25484 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25485 return _out;
25486 fail:
25487 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25488 return octave_value_list();
25489 }
25490 catch(...) {
25491 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25492 throw;
25493 }
25494}
25495
25496
25498 PLFLT arg1 ;
25499 double val1 ;
25500 int ecode1 = 0 ;
25501 octave_value_list _out;
25502 octave_value_list *_outp=&_out;
25503 octave_value _outv;
25504
25505 try {
25506 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25507 SWIG_fail;
25508 }
25509 ecode1 = SWIG_AsVal_double(args(0), &val1);
25510 if (!SWIG_IsOK(ecode1)) {
25511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25512 }
25513 arg1 = static_cast< PLFLT >(val1);
25514 plvasp(arg1);
25515 _outv = octave_value();
25516 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25517 return _out;
25518 fail:
25519 return octave_value_list();
25520 }
25521 catch(...) {
25522 throw;
25523 }
25524}
25525
25526
25528 PLFLT arg1 ;
25529 PLFLT arg2 ;
25530 PLFLT arg3 ;
25531 PLFLT arg4 ;
25532 PLFLT arg5 ;
25533 double val1 ;
25534 int ecode1 = 0 ;
25535 double val2 ;
25536 int ecode2 = 0 ;
25537 double val3 ;
25538 int ecode3 = 0 ;
25539 double val4 ;
25540 int ecode4 = 0 ;
25541 double val5 ;
25542 int ecode5 = 0 ;
25543 octave_value_list _out;
25544 octave_value_list *_outp=&_out;
25545 octave_value _outv;
25546
25547 try {
25548 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25549 SWIG_fail;
25550 }
25551 ecode1 = SWIG_AsVal_double(args(0), &val1);
25552 if (!SWIG_IsOK(ecode1)) {
25553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25554 }
25555 arg1 = static_cast< PLFLT >(val1);
25556 ecode2 = SWIG_AsVal_double(args(1), &val2);
25557 if (!SWIG_IsOK(ecode2)) {
25558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25559 }
25560 arg2 = static_cast< PLFLT >(val2);
25561 ecode3 = SWIG_AsVal_double(args(2), &val3);
25562 if (!SWIG_IsOK(ecode3)) {
25563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25564 }
25565 arg3 = static_cast< PLFLT >(val3);
25566 ecode4 = SWIG_AsVal_double(args(3), &val4);
25567 if (!SWIG_IsOK(ecode4)) {
25568 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25569 }
25570 arg4 = static_cast< PLFLT >(val4);
25571 ecode5 = SWIG_AsVal_double(args(4), &val5);
25572 if (!SWIG_IsOK(ecode5)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25574 }
25575 arg5 = static_cast< PLFLT >(val5);
25576 plvpas(arg1,arg2,arg3,arg4,arg5);
25577 _outv = octave_value();
25578 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25579 return _out;
25580 fail:
25581 return octave_value_list();
25582 }
25583 catch(...) {
25584 throw;
25585 }
25586}
25587
25588
25590 PLFLT arg1 ;
25591 PLFLT arg2 ;
25592 PLFLT arg3 ;
25593 PLFLT arg4 ;
25594 double val1 ;
25595 int ecode1 = 0 ;
25596 double val2 ;
25597 int ecode2 = 0 ;
25598 double val3 ;
25599 int ecode3 = 0 ;
25600 double val4 ;
25601 int ecode4 = 0 ;
25602 octave_value_list _out;
25603 octave_value_list *_outp=&_out;
25604 octave_value _outv;
25605
25606 try {
25607 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25608 SWIG_fail;
25609 }
25610 ecode1 = SWIG_AsVal_double(args(0), &val1);
25611 if (!SWIG_IsOK(ecode1)) {
25612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25613 }
25614 arg1 = static_cast< PLFLT >(val1);
25615 ecode2 = SWIG_AsVal_double(args(1), &val2);
25616 if (!SWIG_IsOK(ecode2)) {
25617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25618 }
25619 arg2 = static_cast< PLFLT >(val2);
25620 ecode3 = SWIG_AsVal_double(args(2), &val3);
25621 if (!SWIG_IsOK(ecode3)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25623 }
25624 arg3 = static_cast< PLFLT >(val3);
25625 ecode4 = SWIG_AsVal_double(args(3), &val4);
25626 if (!SWIG_IsOK(ecode4)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25628 }
25629 arg4 = static_cast< PLFLT >(val4);
25630 plvpor(arg1,arg2,arg3,arg4);
25631 _outv = octave_value();
25632 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25633 return _out;
25634 fail:
25635 return octave_value_list();
25636 }
25637 catch(...) {
25638 throw;
25639 }
25640}
25641
25642
25644 octave_value_list _out;
25645 octave_value_list *_outp=&_out;
25646 octave_value _outv;
25647
25648 try {
25649 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25650 SWIG_fail;
25651 }
25652 plvsta();
25653 _outv = octave_value();
25654 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25655 return _out;
25656 fail:
25657 return octave_value_list();
25658 }
25659 catch(...) {
25660 throw;
25661 }
25662}
25663
25664
25666 PLFLT arg1 ;
25667 PLFLT arg2 ;
25668 PLFLT arg3 ;
25669 PLFLT arg4 ;
25670 PLFLT arg5 ;
25671 PLFLT arg6 ;
25672 PLFLT arg7 ;
25673 PLFLT arg8 ;
25674 PLFLT arg9 ;
25675 PLFLT arg10 ;
25676 PLFLT arg11 ;
25677 double val1 ;
25678 int ecode1 = 0 ;
25679 double val2 ;
25680 int ecode2 = 0 ;
25681 double val3 ;
25682 int ecode3 = 0 ;
25683 double val4 ;
25684 int ecode4 = 0 ;
25685 double val5 ;
25686 int ecode5 = 0 ;
25687 double val6 ;
25688 int ecode6 = 0 ;
25689 double val7 ;
25690 int ecode7 = 0 ;
25691 double val8 ;
25692 int ecode8 = 0 ;
25693 double val9 ;
25694 int ecode9 = 0 ;
25695 double val10 ;
25696 int ecode10 = 0 ;
25697 double val11 ;
25698 int ecode11 = 0 ;
25699 octave_value_list _out;
25700 octave_value_list *_outp=&_out;
25701 octave_value _outv;
25702
25703 try {
25704 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25705 SWIG_fail;
25706 }
25707 ecode1 = SWIG_AsVal_double(args(0), &val1);
25708 if (!SWIG_IsOK(ecode1)) {
25709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25710 }
25711 arg1 = static_cast< PLFLT >(val1);
25712 ecode2 = SWIG_AsVal_double(args(1), &val2);
25713 if (!SWIG_IsOK(ecode2)) {
25714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25715 }
25716 arg2 = static_cast< PLFLT >(val2);
25717 ecode3 = SWIG_AsVal_double(args(2), &val3);
25718 if (!SWIG_IsOK(ecode3)) {
25719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25720 }
25721 arg3 = static_cast< PLFLT >(val3);
25722 ecode4 = SWIG_AsVal_double(args(3), &val4);
25723 if (!SWIG_IsOK(ecode4)) {
25724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25725 }
25726 arg4 = static_cast< PLFLT >(val4);
25727 ecode5 = SWIG_AsVal_double(args(4), &val5);
25728 if (!SWIG_IsOK(ecode5)) {
25729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25730 }
25731 arg5 = static_cast< PLFLT >(val5);
25732 ecode6 = SWIG_AsVal_double(args(5), &val6);
25733 if (!SWIG_IsOK(ecode6)) {
25734 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25735 }
25736 arg6 = static_cast< PLFLT >(val6);
25737 ecode7 = SWIG_AsVal_double(args(6), &val7);
25738 if (!SWIG_IsOK(ecode7)) {
25739 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25740 }
25741 arg7 = static_cast< PLFLT >(val7);
25742 ecode8 = SWIG_AsVal_double(args(7), &val8);
25743 if (!SWIG_IsOK(ecode8)) {
25744 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25745 }
25746 arg8 = static_cast< PLFLT >(val8);
25747 ecode9 = SWIG_AsVal_double(args(8), &val9);
25748 if (!SWIG_IsOK(ecode9)) {
25749 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25750 }
25751 arg9 = static_cast< PLFLT >(val9);
25752 ecode10 = SWIG_AsVal_double(args(9), &val10);
25753 if (!SWIG_IsOK(ecode10)) {
25754 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25755 }
25756 arg10 = static_cast< PLFLT >(val10);
25757 ecode11 = SWIG_AsVal_double(args(10), &val11);
25758 if (!SWIG_IsOK(ecode11)) {
25759 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25760 }
25761 arg11 = static_cast< PLFLT >(val11);
25762 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25763 _outv = octave_value();
25764 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25765 return _out;
25766 fail:
25767 return octave_value_list();
25768 }
25769 catch(...) {
25770 throw;
25771 }
25772}
25773
25774
25776 PLFLT arg1 ;
25777 double val1 ;
25778 int ecode1 = 0 ;
25779 octave_value_list _out;
25780 octave_value_list *_outp=&_out;
25781 octave_value _outv;
25782
25783 try {
25784 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25785 SWIG_fail;
25786 }
25787 ecode1 = SWIG_AsVal_double(args(0), &val1);
25788 if (!SWIG_IsOK(ecode1)) {
25789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25790 }
25791 arg1 = static_cast< PLFLT >(val1);
25792 plwidth(arg1);
25793 _outv = octave_value();
25794 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25795 return _out;
25796 fail:
25797 return octave_value_list();
25798 }
25799 catch(...) {
25800 throw;
25801 }
25802}
25803
25804
25806 PLFLT arg1 ;
25807 PLFLT arg2 ;
25808 PLFLT arg3 ;
25809 PLFLT arg4 ;
25810 double val1 ;
25811 int ecode1 = 0 ;
25812 double val2 ;
25813 int ecode2 = 0 ;
25814 double val3 ;
25815 int ecode3 = 0 ;
25816 double val4 ;
25817 int ecode4 = 0 ;
25818 octave_value_list _out;
25819 octave_value_list *_outp=&_out;
25820 octave_value _outv;
25821
25822 try {
25823 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25824 SWIG_fail;
25825 }
25826 ecode1 = SWIG_AsVal_double(args(0), &val1);
25827 if (!SWIG_IsOK(ecode1)) {
25828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25829 }
25830 arg1 = static_cast< PLFLT >(val1);
25831 ecode2 = SWIG_AsVal_double(args(1), &val2);
25832 if (!SWIG_IsOK(ecode2)) {
25833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25834 }
25835 arg2 = static_cast< PLFLT >(val2);
25836 ecode3 = SWIG_AsVal_double(args(2), &val3);
25837 if (!SWIG_IsOK(ecode3)) {
25838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25839 }
25840 arg3 = static_cast< PLFLT >(val3);
25841 ecode4 = SWIG_AsVal_double(args(3), &val4);
25842 if (!SWIG_IsOK(ecode4)) {
25843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25844 }
25845 arg4 = static_cast< PLFLT >(val4);
25846 plwind(arg1,arg2,arg3,arg4);
25847 _outv = octave_value();
25848 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25849 return _out;
25850 fail:
25851 return octave_value_list();
25852 }
25853 catch(...) {
25854 throw;
25855 }
25856}
25857
25858
25860 PLBOOL arg1 ;
25861 PLBOOL *arg2 = (PLBOOL *) 0 ;
25862 int val1 ;
25863 int ecode1 = 0 ;
25864 PLBOOL temp2 ;
25865 int res2 = SWIG_TMPOBJ ;
25866 octave_value_list _out;
25867 octave_value_list *_outp=&_out;
25868 octave_value _outv;
25869
25870 try {
25871 arg2 = &temp2;
25872 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25873 SWIG_fail;
25874 }
25875 ecode1 = SWIG_AsVal_int(args(0), &val1);
25876 if (!SWIG_IsOK(ecode1)) {
25877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25878 }
25879 arg1 = static_cast< PLBOOL >(val1);
25880 plxormod(arg1,arg2);
25881 _outv = octave_value();
25882 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25883 if (SWIG_IsTmpObj(res2)) {
25884 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25885 } else {
25886 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25887 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25888 }
25889 return _out;
25890 fail:
25891 return octave_value_list();
25892 }
25893 catch(...) {
25894 throw;
25895 }
25896}
25897
25898
25900 mapform_func arg1 = (mapform_func) 0 ;
25901 char *arg2 = (char *) 0 ;
25902 PLFLT arg3 ;
25903 PLFLT arg4 ;
25904 PLFLT arg5 ;
25905 PLFLT arg6 ;
25906 int res2 ;
25907 char *buf2 = 0 ;
25908 int alloc2 = 0 ;
25909 double val3 ;
25910 int ecode3 = 0 ;
25911 double val4 ;
25912 int ecode4 = 0 ;
25913 double val5 ;
25914 int ecode5 = 0 ;
25915 double val6 ;
25916 int ecode6 = 0 ;
25917 octave_value_list _out;
25918 octave_value_list *_outp=&_out;
25919 octave_value _outv;
25920
25921 try {
25922 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25923 SWIG_fail;
25924 }
25925 {
25926 octave_value obj = args(0);
25927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25928 if ( !obj.isempty() )
25929#else
25930 if ( !obj.is_empty() )
25931#endif
25932 {
25933 if ( obj.is_function_handle() || obj.is_inline_function() )
25934 {
25935 fcnMapForm = obj.function_value();
25936 }
25937 else if ( obj.is_string() )
25938 {
25939 nameMapForm = obj.string_value();
25940 fcnMapForm = NULL;
25941 }
25942 arg1 = mapform_octave;
25943 }
25944 else
25945 {
25946 arg1 = NULL;
25947 }
25948 }
25949 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25950 if (!SWIG_IsOK(res2)) {
25951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
25952 }
25953 arg2 = reinterpret_cast< char * >(buf2);
25954 ecode3 = SWIG_AsVal_double(args(2), &val3);
25955 if (!SWIG_IsOK(ecode3)) {
25956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
25957 }
25958 arg3 = static_cast< PLFLT >(val3);
25959 ecode4 = SWIG_AsVal_double(args(3), &val4);
25960 if (!SWIG_IsOK(ecode4)) {
25961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
25962 }
25963 arg4 = static_cast< PLFLT >(val4);
25964 ecode5 = SWIG_AsVal_double(args(4), &val5);
25965 if (!SWIG_IsOK(ecode5)) {
25966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
25967 }
25968 arg5 = static_cast< PLFLT >(val5);
25969 ecode6 = SWIG_AsVal_double(args(5), &val6);
25970 if (!SWIG_IsOK(ecode6)) {
25971 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
25972 }
25973 arg6 = static_cast< PLFLT >(val6);
25974 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
25975 _outv = octave_value();
25976 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25977 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25978 return _out;
25979 fail:
25980 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25981 return octave_value_list();
25982 }
25983 catch(...) {
25984 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25985 throw;
25986 }
25987}
25988
25989
25991 mapform_func arg1 = (mapform_func) 0 ;
25992 char *arg2 = (char *) 0 ;
25993 PLFLT arg3 ;
25994 PLFLT arg4 ;
25995 PLFLT arg5 ;
25996 PLFLT arg6 ;
25997 PLINT *arg7 = (PLINT *) 0 ;
25998 PLINT arg8 ;
25999 int res2 ;
26000 char *buf2 = 0 ;
26001 int alloc2 = 0 ;
26002 double val3 ;
26003 int ecode3 = 0 ;
26004 double val4 ;
26005 int ecode4 = 0 ;
26006 double val5 ;
26007 int ecode5 = 0 ;
26008 double val6 ;
26009 int ecode6 = 0 ;
26010 Matrix temp7 ;
26011 octave_value_list _out;
26012 octave_value_list *_outp=&_out;
26013 octave_value _outv;
26014
26015 try {
26016 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26017 SWIG_fail;
26018 }
26019 {
26020 octave_value obj = args(0);
26021#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26022 if ( !obj.isempty() )
26023#else
26024 if ( !obj.is_empty() )
26025#endif
26026 {
26027 if ( obj.is_function_handle() || obj.is_inline_function() )
26028 {
26029 fcnMapForm = obj.function_value();
26030 }
26031 else if ( obj.is_string() )
26032 {
26033 nameMapForm = obj.string_value();
26034 fcnMapForm = NULL;
26035 }
26036 arg1 = mapform_octave;
26037 }
26038 else
26039 {
26040 arg1 = NULL;
26041 }
26042 }
26043 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26044 if (!SWIG_IsOK(res2)) {
26045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26046 }
26047 arg2 = reinterpret_cast< char * >(buf2);
26048 ecode3 = SWIG_AsVal_double(args(2), &val3);
26049 if (!SWIG_IsOK(ecode3)) {
26050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26051 }
26052 arg3 = static_cast< PLFLT >(val3);
26053 ecode4 = SWIG_AsVal_double(args(3), &val4);
26054 if (!SWIG_IsOK(ecode4)) {
26055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26056 }
26057 arg4 = static_cast< PLFLT >(val4);
26058 ecode5 = SWIG_AsVal_double(args(4), &val5);
26059 if (!SWIG_IsOK(ecode5)) {
26060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26061 }
26062 arg5 = static_cast< PLFLT >(val5);
26063 ecode6 = SWIG_AsVal_double(args(5), &val6);
26064 if (!SWIG_IsOK(ecode6)) {
26065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26066 }
26067 arg6 = static_cast< PLFLT >(val6);
26068 {
26069 if ( _n_dims( args(6) ) > 1 )
26070 {
26071 error( "argument must be a scalar or vector" ); SWIG_fail;
26072 }
26073#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26074 if ( !args(6).isempty() )
26075#else
26076 if ( !args(6).is_empty() )
26077#endif
26078 {
26079 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26080 temp7 = args(6).matrix_value();
26081 arg7 = new PLINT[arg8];
26082 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26083 }
26084 else
26085 {
26086 arg7 = NULL;
26087 arg8 = 0;
26088 }
26089 }
26090 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26091 _outv = octave_value();
26092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26093 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26094 {
26095 delete [] arg7;
26096 }
26097 return _out;
26098 fail:
26099 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26100 {
26101 delete [] arg7;
26102 }
26103 return octave_value_list();
26104 }
26105 catch(...) {
26106 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26107 {
26108 delete [] arg7;
26109 }
26110 throw;
26111 }
26112}
26113
26114
26116 mapform_func arg1 = (mapform_func) 0 ;
26117 char *arg2 = (char *) 0 ;
26118 char *arg3 = (char *) 0 ;
26119 PLFLT arg4 ;
26120 PLFLT arg5 ;
26121 PLFLT arg6 ;
26122 PLFLT arg7 ;
26123 PLINT *arg8 = (PLINT *) 0 ;
26124 PLINT arg9 ;
26125 int res2 ;
26126 char *buf2 = 0 ;
26127 int alloc2 = 0 ;
26128 int res3 ;
26129 char *buf3 = 0 ;
26130 int alloc3 = 0 ;
26131 double val4 ;
26132 int ecode4 = 0 ;
26133 double val5 ;
26134 int ecode5 = 0 ;
26135 double val6 ;
26136 int ecode6 = 0 ;
26137 double val7 ;
26138 int ecode7 = 0 ;
26139 Matrix temp8 ;
26140 octave_value_list _out;
26141 octave_value_list *_outp=&_out;
26142 octave_value _outv;
26143
26144 try {
26145 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26146 SWIG_fail;
26147 }
26148 {
26149 octave_value obj = args(0);
26150#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26151 if ( !obj.isempty() )
26152#else
26153 if ( !obj.is_empty() )
26154#endif
26155 {
26156 if ( obj.is_function_handle() || obj.is_inline_function() )
26157 {
26158 fcnMapForm = obj.function_value();
26159 }
26160 else if ( obj.is_string() )
26161 {
26162 nameMapForm = obj.string_value();
26163 fcnMapForm = NULL;
26164 }
26165 arg1 = mapform_octave;
26166 }
26167 else
26168 {
26169 arg1 = NULL;
26170 }
26171 }
26172 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26173 if (!SWIG_IsOK(res2)) {
26174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26175 }
26176 arg2 = reinterpret_cast< char * >(buf2);
26177 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26178 if (!SWIG_IsOK(res3)) {
26179 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26180 }
26181 arg3 = reinterpret_cast< char * >(buf3);
26182 ecode4 = SWIG_AsVal_double(args(3), &val4);
26183 if (!SWIG_IsOK(ecode4)) {
26184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26185 }
26186 arg4 = static_cast< PLFLT >(val4);
26187 ecode5 = SWIG_AsVal_double(args(4), &val5);
26188 if (!SWIG_IsOK(ecode5)) {
26189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26190 }
26191 arg5 = static_cast< PLFLT >(val5);
26192 ecode6 = SWIG_AsVal_double(args(5), &val6);
26193 if (!SWIG_IsOK(ecode6)) {
26194 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26195 }
26196 arg6 = static_cast< PLFLT >(val6);
26197 ecode7 = SWIG_AsVal_double(args(6), &val7);
26198 if (!SWIG_IsOK(ecode7)) {
26199 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26200 }
26201 arg7 = static_cast< PLFLT >(val7);
26202 {
26203 if ( _n_dims( args(7) ) > 1 )
26204 {
26205 error( "argument must be a scalar or vector" ); SWIG_fail;
26206 }
26207#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26208 if ( !args(7).isempty() )
26209#else
26210 if ( !args(7).is_empty() )
26211#endif
26212 {
26213 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26214 temp8 = args(7).matrix_value();
26215 arg8 = new PLINT[arg9];
26216 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26217 }
26218 else
26219 {
26220 arg8 = NULL;
26221 arg9 = 0;
26222 }
26223 }
26224 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26225 _outv = octave_value();
26226 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26227 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26228 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26229 {
26230 delete [] arg8;
26231 }
26232 return _out;
26233 fail:
26234 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26235 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26236 {
26237 delete [] arg8;
26238 }
26239 return octave_value_list();
26240 }
26241 catch(...) {
26242 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26243 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26244 {
26245 delete [] arg8;
26246 }
26247 throw;
26248 }
26249}
26250
26251
26253 mapform_func arg1 = (mapform_func) 0 ;
26254 char *arg2 = (char *) 0 ;
26255 PLFLT arg3 ;
26256 PLFLT arg4 ;
26257 PLFLT arg5 ;
26258 char *arg6 = (char *) 0 ;
26259 PLFLT arg7 ;
26260 PLFLT arg8 ;
26261 PLFLT arg9 ;
26262 PLFLT arg10 ;
26263 PLINT arg11 ;
26264 int res2 ;
26265 char *buf2 = 0 ;
26266 int alloc2 = 0 ;
26267 double val3 ;
26268 int ecode3 = 0 ;
26269 double val4 ;
26270 int ecode4 = 0 ;
26271 double val5 ;
26272 int ecode5 = 0 ;
26273 int res6 ;
26274 char *buf6 = 0 ;
26275 int alloc6 = 0 ;
26276 double val7 ;
26277 int ecode7 = 0 ;
26278 double val8 ;
26279 int ecode8 = 0 ;
26280 double val9 ;
26281 int ecode9 = 0 ;
26282 double val10 ;
26283 int ecode10 = 0 ;
26284 int val11 ;
26285 int ecode11 = 0 ;
26286 octave_value_list _out;
26287 octave_value_list *_outp=&_out;
26288 octave_value _outv;
26289
26290 try {
26291 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26292 SWIG_fail;
26293 }
26294 {
26295 octave_value obj = args(0);
26296#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26297 if ( !obj.isempty() )
26298#else
26299 if ( !obj.is_empty() )
26300#endif
26301 {
26302 if ( obj.is_function_handle() || obj.is_inline_function() )
26303 {
26304 fcnMapForm = obj.function_value();
26305 }
26306 else if ( obj.is_string() )
26307 {
26308 nameMapForm = obj.string_value();
26309 fcnMapForm = NULL;
26310 }
26311 arg1 = mapform_octave;
26312 }
26313 else
26314 {
26315 arg1 = NULL;
26316 }
26317 }
26318 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26319 if (!SWIG_IsOK(res2)) {
26320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26321 }
26322 arg2 = reinterpret_cast< char * >(buf2);
26323 ecode3 = SWIG_AsVal_double(args(2), &val3);
26324 if (!SWIG_IsOK(ecode3)) {
26325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26326 }
26327 arg3 = static_cast< PLFLT >(val3);
26328 ecode4 = SWIG_AsVal_double(args(3), &val4);
26329 if (!SWIG_IsOK(ecode4)) {
26330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26331 }
26332 arg4 = static_cast< PLFLT >(val4);
26333 ecode5 = SWIG_AsVal_double(args(4), &val5);
26334 if (!SWIG_IsOK(ecode5)) {
26335 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26336 }
26337 arg5 = static_cast< PLFLT >(val5);
26338 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26339 if (!SWIG_IsOK(res6)) {
26340 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26341 }
26342 arg6 = reinterpret_cast< char * >(buf6);
26343 ecode7 = SWIG_AsVal_double(args(6), &val7);
26344 if (!SWIG_IsOK(ecode7)) {
26345 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26346 }
26347 arg7 = static_cast< PLFLT >(val7);
26348 ecode8 = SWIG_AsVal_double(args(7), &val8);
26349 if (!SWIG_IsOK(ecode8)) {
26350 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26351 }
26352 arg8 = static_cast< PLFLT >(val8);
26353 ecode9 = SWIG_AsVal_double(args(8), &val9);
26354 if (!SWIG_IsOK(ecode9)) {
26355 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26356 }
26357 arg9 = static_cast< PLFLT >(val9);
26358 ecode10 = SWIG_AsVal_double(args(9), &val10);
26359 if (!SWIG_IsOK(ecode10)) {
26360 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26361 }
26362 arg10 = static_cast< PLFLT >(val10);
26363 ecode11 = SWIG_AsVal_int(args(10), &val11);
26364 if (!SWIG_IsOK(ecode11)) {
26365 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26366 }
26367 arg11 = static_cast< PLINT >(val11);
26368 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26369 _outv = octave_value();
26370 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26371 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26372 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26373 return _out;
26374 fail:
26375 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26376 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26377 return octave_value_list();
26378 }
26379 catch(...) {
26380 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26381 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26382 throw;
26383 }
26384}
26385
26386
26388 mapform_func arg1 = (mapform_func) 0 ;
26389 char *arg2 = (char *) 0 ;
26390 PLFLT arg3 ;
26391 PLFLT arg4 ;
26392 PLFLT arg5 ;
26393 PLFLT arg6 ;
26394 PLINT *arg7 = (PLINT *) 0 ;
26395 PLINT arg8 ;
26396 int res2 ;
26397 char *buf2 = 0 ;
26398 int alloc2 = 0 ;
26399 double val3 ;
26400 int ecode3 = 0 ;
26401 double val4 ;
26402 int ecode4 = 0 ;
26403 double val5 ;
26404 int ecode5 = 0 ;
26405 double val6 ;
26406 int ecode6 = 0 ;
26407 Matrix temp7 ;
26408 octave_value_list _out;
26409 octave_value_list *_outp=&_out;
26410 octave_value _outv;
26411
26412 try {
26413 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26414 SWIG_fail;
26415 }
26416 {
26417 octave_value obj = args(0);
26418#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26419 if ( !obj.isempty() )
26420#else
26421 if ( !obj.is_empty() )
26422#endif
26423 {
26424 if ( obj.is_function_handle() || obj.is_inline_function() )
26425 {
26426 fcnMapForm = obj.function_value();
26427 }
26428 else if ( obj.is_string() )
26429 {
26430 nameMapForm = obj.string_value();
26431 fcnMapForm = NULL;
26432 }
26433 arg1 = mapform_octave;
26434 }
26435 else
26436 {
26437 arg1 = NULL;
26438 }
26439 }
26440 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26441 if (!SWIG_IsOK(res2)) {
26442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26443 }
26444 arg2 = reinterpret_cast< char * >(buf2);
26445 ecode3 = SWIG_AsVal_double(args(2), &val3);
26446 if (!SWIG_IsOK(ecode3)) {
26447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26448 }
26449 arg3 = static_cast< PLFLT >(val3);
26450 ecode4 = SWIG_AsVal_double(args(3), &val4);
26451 if (!SWIG_IsOK(ecode4)) {
26452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26453 }
26454 arg4 = static_cast< PLFLT >(val4);
26455 ecode5 = SWIG_AsVal_double(args(4), &val5);
26456 if (!SWIG_IsOK(ecode5)) {
26457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26458 }
26459 arg5 = static_cast< PLFLT >(val5);
26460 ecode6 = SWIG_AsVal_double(args(5), &val6);
26461 if (!SWIG_IsOK(ecode6)) {
26462 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26463 }
26464 arg6 = static_cast< PLFLT >(val6);
26465 {
26466 if ( _n_dims( args(6) ) > 1 )
26467 {
26468 error( "argument must be a scalar or vector" ); SWIG_fail;
26469 }
26470#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26471 if ( !args(6).isempty() )
26472#else
26473 if ( !args(6).is_empty() )
26474#endif
26475 {
26476 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26477 temp7 = args(6).matrix_value();
26478 arg7 = new PLINT[arg8];
26479 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26480 }
26481 else
26482 {
26483 arg7 = NULL;
26484 arg8 = 0;
26485 }
26486 }
26487 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26488 _outv = octave_value();
26489 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26490 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26491 {
26492 delete [] arg7;
26493 }
26494 return _out;
26495 fail:
26496 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26497 {
26498 delete [] arg7;
26499 }
26500 return octave_value_list();
26501 }
26502 catch(...) {
26503 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26504 {
26505 delete [] arg7;
26506 }
26507 throw;
26508 }
26509}
26510
26511
26513 mapform_func arg1 = (mapform_func) 0 ;
26514 PLFLT arg2 ;
26515 PLFLT arg3 ;
26516 PLFLT arg4 ;
26517 PLFLT arg5 ;
26518 PLFLT arg6 ;
26519 PLFLT arg7 ;
26520 double val2 ;
26521 int ecode2 = 0 ;
26522 double val3 ;
26523 int ecode3 = 0 ;
26524 double val4 ;
26525 int ecode4 = 0 ;
26526 double val5 ;
26527 int ecode5 = 0 ;
26528 double val6 ;
26529 int ecode6 = 0 ;
26530 double val7 ;
26531 int ecode7 = 0 ;
26532 octave_value_list _out;
26533 octave_value_list *_outp=&_out;
26534 octave_value _outv;
26535
26536 try {
26537 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26538 SWIG_fail;
26539 }
26540 {
26541 octave_value obj = args(0);
26542#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26543 if ( !obj.isempty() )
26544#else
26545 if ( !obj.is_empty() )
26546#endif
26547 {
26548 if ( obj.is_function_handle() || obj.is_inline_function() )
26549 {
26550 fcnMapForm = obj.function_value();
26551 }
26552 else if ( obj.is_string() )
26553 {
26554 nameMapForm = obj.string_value();
26555 fcnMapForm = NULL;
26556 }
26557 arg1 = mapform_octave;
26558 }
26559 else
26560 {
26561 arg1 = NULL;
26562 }
26563 }
26564 ecode2 = SWIG_AsVal_double(args(1), &val2);
26565 if (!SWIG_IsOK(ecode2)) {
26566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26567 }
26568 arg2 = static_cast< PLFLT >(val2);
26569 ecode3 = SWIG_AsVal_double(args(2), &val3);
26570 if (!SWIG_IsOK(ecode3)) {
26571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26572 }
26573 arg3 = static_cast< PLFLT >(val3);
26574 ecode4 = SWIG_AsVal_double(args(3), &val4);
26575 if (!SWIG_IsOK(ecode4)) {
26576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26577 }
26578 arg4 = static_cast< PLFLT >(val4);
26579 ecode5 = SWIG_AsVal_double(args(4), &val5);
26580 if (!SWIG_IsOK(ecode5)) {
26581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26582 }
26583 arg5 = static_cast< PLFLT >(val5);
26584 ecode6 = SWIG_AsVal_double(args(5), &val6);
26585 if (!SWIG_IsOK(ecode6)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26587 }
26588 arg6 = static_cast< PLFLT >(val6);
26589 ecode7 = SWIG_AsVal_double(args(6), &val7);
26590 if (!SWIG_IsOK(ecode7)) {
26591 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26592 }
26593 arg7 = static_cast< PLFLT >(val7);
26594 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26595 _outv = octave_value();
26596 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26597 return _out;
26598 fail:
26599 return octave_value_list();
26600 }
26601 catch(...) {
26602 throw;
26603 }
26604}
26605
26606
26608 octave_value_list _out;
26609 octave_value_list *_outp=&_out;
26610 octave_value _outv;
26611
26612 try {
26613 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26614 SWIG_fail;
26615 }
26616 plClearOpts();
26617 _outv = octave_value();
26618 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26619 return _out;
26620 fail:
26621 return octave_value_list();
26622 }
26623 catch(...) {
26624 throw;
26625 }
26626}
26627
26628
26630 octave_value_list _out;
26631 octave_value_list *_outp=&_out;
26632 octave_value _outv;
26633
26634 try {
26635 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26636 SWIG_fail;
26637 }
26638 plResetOpts();
26639 _outv = octave_value();
26640 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26641 return _out;
26642 fail:
26643 return octave_value_list();
26644 }
26645 catch(...) {
26646 throw;
26647 }
26648}
26649
26650
26652 char *arg1 = (char *) 0 ;
26653 char *arg2 = (char *) 0 ;
26654 int res1 ;
26655 char *buf1 = 0 ;
26656 int alloc1 = 0 ;
26657 int res2 ;
26658 char *buf2 = 0 ;
26659 int alloc2 = 0 ;
26660 octave_value_list _out;
26661 octave_value_list *_outp=&_out;
26662 octave_value _outv;
26663
26664 try {
26665 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26666 SWIG_fail;
26667 }
26668 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26671 }
26672 arg1 = reinterpret_cast< char * >(buf1);
26673 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26674 if (!SWIG_IsOK(res2)) {
26675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26676 }
26677 arg2 = reinterpret_cast< char * >(buf2);
26678 plSetUsage((char const *)arg1,(char const *)arg2);
26679 _outv = octave_value();
26680 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26681 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26682 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26683 return _out;
26684 fail:
26685 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26686 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26687 return octave_value_list();
26688 }
26689 catch(...) {
26690 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26691 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26692 throw;
26693 }
26694}
26695
26696
26698 octave_value_list _out;
26699 octave_value_list *_outp=&_out;
26700 octave_value _outv;
26701
26702 try {
26703 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26704 SWIG_fail;
26705 }
26706 plOptUsage();
26707 _outv = octave_value();
26708 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26709 return _out;
26710 fail:
26711 return octave_value_list();
26712 }
26713 catch(...) {
26714 throw;
26715 }
26716}
26717
26718
26719
26720static const struct swig_octave_member swig_globals[] = {
26721{"testppchar",_wrap_testppchar,0,0,2,0},
26722{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26723{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26724{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26725{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26726{"plcont0",_wrap_plcont0,0,0,2,0},
26727{"plcont1",_wrap_plcont1,0,0,2,0},
26728{"plcont2",_wrap_plcont2,0,0,2,0},
26729{"plcont2p",_wrap_plcont2p,0,0,2,0},
26730{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26731{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26732{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26733{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26734{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26735{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26736{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26737{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26738{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26739{"plshade1",_wrap_plshade1,0,0,2,0},
26740{"plshade2",_wrap_plshade2,0,0,2,0},
26741{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26742{"plshadesx",_wrap_plshadesx,0,0,2,0},
26743{"plshades1",_wrap_plshades1,0,0,2,0},
26744{"plshades2",_wrap_plshades2,0,0,2,0},
26745{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26746{"plvect1",_wrap_plvect1,0,0,2,0},
26747{"plvect2",_wrap_plvect2,0,0,2,0},
26748{"pplimage",_wrap_pplimage,0,0,2,0},
26749{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26750{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26751{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26752{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26753{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26754{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26755{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26756{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26757{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26758{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26759{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26760{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26761{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26762{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26763{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26764{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26765{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26766{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26767{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26768{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26769{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26770{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26771{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26772{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26773{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26774{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26775{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26776{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26777{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26778{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26779{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26782{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26783{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26784{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26785{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26786{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26787{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26788{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26789{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26790{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26791{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26792{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26793{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26794{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26795{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26796{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26797{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26798{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26799{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26800{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26801{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26802{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26803{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26804{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26805{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26806{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26807{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26808{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26809{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26810{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26811{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26812{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26813{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26814{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26815{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26816{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26817{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26818{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26819{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26820{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26821{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26822{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26823{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26824{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26825{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26826{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26827{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26828{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26829{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26830{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26831{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26832{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26833{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26834{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26835{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26836{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26837{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26838{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26839{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26840{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26841{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26842{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26843{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26844{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26845{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26846{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26847{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26848{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26849{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26850{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26851{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26852{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26853{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26854{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26855{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26856{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26857{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26858{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26859{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26860{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26861{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26862{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26863{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26864{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26865{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26866{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26867{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26868{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26869{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26870{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26871{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26872{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26873{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26874{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26875{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26876{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26877{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26878{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26879{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26880{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26881{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26882{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26883{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26884{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26885{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26886{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26887{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26888{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26889{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26890{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26891{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26892{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26893{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26894{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26895{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26896{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26897{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26898{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26899{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26900{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26901{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26902{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26903{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26904{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26905{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26906{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26907{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26908{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26909{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26910{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26911{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26912{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26913{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26914{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26915{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26916{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26917{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26918{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26919{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26920{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26921{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26922{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26923{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26924{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26925{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26926{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26927{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
26928{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
26929{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
26930{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
26931{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
26932{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
26933{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
26934{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
26935{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
26936{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
26937{0,0,0,0,0,0}
26938};
26939
26940/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26941
26942static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
26943static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26944static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
26945static 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};
26946static 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};
26947static 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};
26948static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
26949static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26950static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
26951
26962};
26963
26964static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
26965static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26966static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26970static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26971static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26972static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26973
26984};
26985
26986
26987/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26988
26989/* -----------------------------------------------------------------------------
26990 * Type initialization:
26991 * This problem is tough by the requirement that no dynamic
26992 * memory is used. Also, since swig_type_info structures store pointers to
26993 * swig_cast_info structures and swig_cast_info structures store pointers back
26994 * to swig_type_info structures, we need some lookup code at initialization.
26995 * The idea is that swig generates all the structures that are needed.
26996 * The runtime then collects these partially filled structures.
26997 * The SWIG_InitializeModule function takes these initial arrays out of
26998 * swig_module, and does all the lookup, filling in the swig_module.types
26999 * array with the correct data and linking the correct swig_cast_info
27000 * structures together.
27001 *
27002 * The generated swig_type_info structures are assigned statically to an initial
27003 * array. We just loop through that array, and handle each type individually.
27004 * First we lookup if this type has been already loaded, and if so, use the
27005 * loaded structure instead of the generated one. Then we have to fill in the
27006 * cast linked list. The cast data is initially stored in something like a
27007 * two-dimensional array. Each row corresponds to a type (there are the same
27008 * number of rows as there are in the swig_type_initial array). Each entry in
27009 * a column is one of the swig_cast_info structures for that type.
27010 * The cast_initial array is actually an array of arrays, because each row has
27011 * a variable number of columns. So to actually build the cast linked list,
27012 * we find the array of casts associated with the type, and loop through it
27013 * adding the casts to the list. The one last trick we need to do is making
27014 * sure the type pointer in the swig_cast_info struct is correct.
27015 *
27016 * First off, we lookup the cast->type name to see if it is already loaded.
27017 * There are three cases to handle:
27018 * 1) If the cast->type has already been loaded AND the type we are adding
27019 * casting info to has not been loaded (it is in this module), THEN we
27020 * replace the cast->type pointer with the type pointer that has already
27021 * been loaded.
27022 * 2) If BOTH types (the one we are adding casting info to, and the
27023 * cast->type) are loaded, THEN the cast info has already been loaded by
27024 * the previous module so we just ignore it.
27025 * 3) Finally, if cast->type has not already been loaded, then we add that
27026 * swig_cast_info to the linked list (because the cast->type) pointer will
27027 * be correct.
27028 * ----------------------------------------------------------------------------- */
27029
27030#ifdef __cplusplus
27031extern "C" {
27032#if 0
27033} /* c-mode */
27034#endif
27035#endif
27036
27037#if 0
27038#define SWIGRUNTIME_DEBUG
27039#endif
27040
27041#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27042#define SWIG_INIT_CLIENT_DATA_TYPE void *
27043#endif
27044
27045SWIGRUNTIME void
27047 size_t i;
27048 swig_module_info *module_head, *iter;
27049 int init;
27050
27051 /* check to see if the circular list has been setup, if not, set it up */
27052 if (swig_module.next==0) {
27053 /* Initialize the swig_module */
27057 init = 1;
27058 } else {
27059 init = 0;
27060 }
27061
27062 /* Try and load any already created modules */
27063 module_head = SWIG_GetModule(clientdata);
27064 if (!module_head) {
27065 /* This is the first module loaded for this interpreter */
27066 /* so set the swig module into the interpreter */
27067 SWIG_SetModule(clientdata, &swig_module);
27068 } else {
27069 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27070 iter=module_head;
27071 do {
27072 if (iter==&swig_module) {
27073 /* Our module is already in the list, so there's nothing more to do. */
27074 return;
27075 }
27076 iter=iter->next;
27077 } while (iter!= module_head);
27078
27079 /* otherwise we must add our module into the list */
27080 swig_module.next = module_head->next;
27081 module_head->next = &swig_module;
27082 }
27083
27084 /* When multiple interpreters are used, a module could have already been initialized in
27085 a different interpreter, but not yet have a pointer in this interpreter.
27086 In this case, we do not want to continue adding types... everything should be
27087 set up already */
27088 if (init == 0) return;
27089
27090 /* Now work on filling in swig_module.types */
27091#ifdef SWIGRUNTIME_DEBUG
27092 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27093#endif
27094 for (i = 0; i < swig_module.size; ++i) {
27095 swig_type_info *type = 0;
27096 swig_type_info *ret;
27097 swig_cast_info *cast;
27098
27099#ifdef SWIGRUNTIME_DEBUG
27100 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27101#endif
27102
27103 /* if there is another module already loaded */
27104 if (swig_module.next != &swig_module) {
27106 }
27107 if (type) {
27108 /* Overwrite clientdata field */
27109#ifdef SWIGRUNTIME_DEBUG
27110 printf("SWIG_InitializeModule: found type %s\n", type->name);
27111#endif
27114#ifdef SWIGRUNTIME_DEBUG
27115 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27116#endif
27117 }
27118 } else {
27119 type = swig_module.type_initial[i];
27120 }
27121
27122 /* Insert casting types */
27123 cast = swig_module.cast_initial[i];
27124 while (cast->type) {
27125
27126 /* Don't need to add information already in the list */
27127 ret = 0;
27128#ifdef SWIGRUNTIME_DEBUG
27129 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27130#endif
27131 if (swig_module.next != &swig_module) {
27133#ifdef SWIGRUNTIME_DEBUG
27134 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27135#endif
27136 }
27137 if (ret) {
27138 if (type == swig_module.type_initial[i]) {
27139#ifdef SWIGRUNTIME_DEBUG
27140 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27141#endif
27142 cast->type = ret;
27143 ret = 0;
27144 } else {
27145 /* Check for casting already in the list */
27146 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27147#ifdef SWIGRUNTIME_DEBUG
27148 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27149#endif
27150 if (!ocast) ret = 0;
27151 }
27152 }
27153
27154 if (!ret) {
27155#ifdef SWIGRUNTIME_DEBUG
27156 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27157#endif
27158 if (type->cast) {
27159 type->cast->prev = cast;
27160 cast->next = type->cast;
27161 }
27162 type->cast = cast;
27163 }
27164 cast++;
27165 }
27166 /* Set entry in modules->types array equal to the type */
27167 swig_module.types[i] = type;
27168 }
27169 swig_module.types[i] = 0;
27170
27171#ifdef SWIGRUNTIME_DEBUG
27172 printf("**** SWIG_InitializeModule: Cast List ******\n");
27173 for (i = 0; i < swig_module.size; ++i) {
27174 int j = 0;
27176 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27177 while (cast->type) {
27178 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27179 cast++;
27180 ++j;
27181 }
27182 printf("---- Total casts: %d\n",j);
27183 }
27184 printf("**** SWIG_InitializeModule: Cast List ******\n");
27185#endif
27186}
27187
27188/* This function will propagate the clientdata field of type to
27189* any new swig_type_info structures that have been added into the list
27190* of equivalent types. It is like calling
27191* SWIG_TypeClientData(type, clientdata) a second time.
27192*/
27193SWIGRUNTIME void
27195 size_t i;
27196 swig_cast_info *equiv;
27197 static int init_run = 0;
27198
27199 if (init_run) return;
27200 init_run = 1;
27201
27202 for (i = 0; i < swig_module.size; i++) {
27203 if (swig_module.types[i]->clientdata) {
27204 equiv = swig_module.types[i]->cast;
27205 while (equiv) {
27206 if (!equiv->converter) {
27207 if (equiv->type && !equiv->type->clientdata)
27209 }
27210 equiv = equiv->next;
27211 }
27212 }
27213 }
27214}
27215
27216#ifdef __cplusplus
27217#if 0
27218{ /* c-mode */
27219#endif
27220}
27221#endif
27222
27223
27224
27225static bool SWIG_init_user(octave_swig_type* module_ns);
27226
27228 bool retn = false;
27229 {
27230#if SWIG_OCTAVE_PREREQ(6,0,0)
27231#elif SWIG_OCTAVE_PREREQ(4,2,0)
27232 octave::unwind_protect frame;
27233 frame.protect_var(discard_error_messages); discard_error_messages = true;
27234 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27235#elif SWIG_OCTAVE_PREREQ(3,3,50)
27236 unwind_protect frame;
27237 frame.protect_var(error_state); error_state = 0;
27238 frame.protect_var(warning_state); warning_state = 0;
27239 frame.protect_var(discard_error_messages); discard_error_messages = true;
27240 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27241#else
27242 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27243 unwind_protect_int(error_state); error_state = 0;
27244 unwind_protect_int(warning_state); warning_state = 0;
27245 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27246 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27247#endif
27248#if SWIG_OCTAVE_PREREQ(4,2,0)
27249 try {
27250#if SWIG_OCTAVE_PREREQ(4,4,0)
27251 octave::feval(name, octave_value_list(), 0);
27252#else
27253 feval(name, octave_value_list(), 0);
27254#endif
27255 retn = true;
27256 } catch (octave::execution_exception&) { }
27257#else
27258 feval(name, octave_value_list(), 0);
27259 retn = (error_state == 0);
27260#endif
27261#if !SWIG_OCTAVE_PREREQ(3,3,50)
27262 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27263#endif
27264 }
27265 if (!retn) {
27266 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27267 }
27268 return retn;
27269}
27270
27271SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27272 bool retn = false;
27273 {
27274#if SWIG_OCTAVE_PREREQ(6,0,0)
27275#elif SWIG_OCTAVE_PREREQ(4,2,0)
27276 octave::unwind_protect frame;
27277 frame.protect_var(discard_error_messages); discard_error_messages = true;
27278 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27279#elif SWIG_OCTAVE_PREREQ(3,3,50)
27280 unwind_protect frame;
27281 frame.protect_var(error_state); error_state = 0;
27282 frame.protect_var(warning_state); warning_state = 0;
27283 frame.protect_var(discard_error_messages); discard_error_messages = true;
27284 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27285#else
27286 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27287 unwind_protect_int(error_state); error_state = 0;
27288 unwind_protect_int(warning_state); warning_state = 0;
27289 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27290 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27291#endif
27292 octave_value_list args;
27293 args.append(name);
27294 args.append(octloadfcn->fcn_file_name());
27295#if SWIG_OCTAVE_PREREQ(4,2,0)
27296 try {
27297#if SWIG_OCTAVE_PREREQ(4,4,0)
27298 octave::feval("autoload", args, 0);
27299#else
27300 feval("autoload", args, 0);
27301#endif
27302 retn = true;
27303 } catch (octave::execution_exception&) { }
27304#else
27305 feval("autoload", args, 0);
27306 retn = (error_state == 0);
27307#endif
27308#if !SWIG_OCTAVE_PREREQ(3,3,50)
27309 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27310#endif
27311 }
27312 if (!retn) {
27313 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27314 }
27315 return retn;
27316}
27317
27318static const char *const subclass_usage = "-*- texinfo -*- \n\
27319@deftypefn {Loadable Function} {} subclass()\n\
27320@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27321Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27322\n\
27323See the SWIG manual for usage examples.\n\
27324@end deftypefn";
27325
27326DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27328 for (int j = 0; j < args.length(); ++j) {
27329 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27330 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27331 octave_swig_type *ost = osr->get_ptr();
27332 if (!ost->is_owned()) {
27333 error("subclass: cannot subclass object not constructed on octave side");
27334 return octave_value_list();
27335 }
27336 top->merge(*ost);
27337 } else if (args(j).is_function_handle()) {
27338 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27339 } else if (args(j).is_string()) {
27340 if (j + 1 >= args.length()) {
27341 error("subclass: member assignments must be of string,value form");
27342 return octave_value_list();
27343 }
27344 top->assign(args(j).string_value(), args(j + 1));
27345 ++j;
27346 } else {
27347 error("subclass: invalid arguments to subclass()");
27348 return octave_value_list();
27349 }
27350 }
27351 return octave_value(Swig::swig_value_ref(top));
27352}
27353
27354static const char *const swig_type_usage = "-*- texinfo -*- \n\
27355@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27356Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27357@end deftypefn";
27358
27359DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27360 if (args.length() != 1) {
27361 error("swig_type: must be called with only a single object");
27362 return octave_value_list();
27363 }
27365 if (!ost) {
27366 error("swig_type: object is not a swig_ref");
27367 return octave_value_list();
27368 }
27369 return octave_value(ost->swig_type_name());
27370}
27371
27372static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27373@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27374Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27375otherwise return `<unknown>'.\n\
27376@end deftypefn";
27377
27378DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27379 if (args.length() != 1 || !args(0).is_string()) {
27380 error("swig_typequery: must be called with single string argument");
27381 return octave_value_list();
27382 }
27383 swig_module_info *module = SWIG_GetModule(0);
27384 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27385 if (!type)
27386 return octave_value("<unknown>");
27387 return octave_value(type->name);
27388}
27389
27390static const char *const swig_this_usage = "-*- texinfo -*- \n\
27391@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27392Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27393@end deftypefn";
27394
27395DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27396 if (args.length() != 1) {
27397 error("swig_this: must be called with only a single object");
27398 return octave_value_list();
27399 }
27400 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27401 return octave_value(octave_uint64(0));
27403 if (!ost) {
27404 error("swig_this: object is not a swig_ref");
27405 return octave_value_list();
27406 }
27407 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27408}
27409
27410static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27411@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27412Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27413@end deftypefn";
27414
27415DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27416 if (args.length() != 3) {
27417 error("swig_octave_prereq: must be called with 3 arguments");
27418 return octave_value_list();
27419 }
27420 const int major = args(0).int_value();
27421 const int minor = args(1).int_value();
27422 const int patch = args(2).int_value();
27423 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27424 return octave_value(prereq);
27425}
27426
27427static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27428@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27429Exit Octave without performing any memory cleanup.\n\
27430@end deftypefn";
27431
27432DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27433 if (args.length() > 1) {
27434 error("swig_exit: must be called with at most one arguments");
27435 return octave_value_list();
27436 }
27437 int exit_status = 0;
27438 if (args.length() == 1) {
27439 exit_status = args(0).int_value();
27440 }
27441 ::_Exit(exit_status);
27442 return octave_value();
27443}
27444
27445static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27446@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27447Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27448@end deftypefn";
27449
27451
27452 static octave_swig_type* module_ns = 0;
27453
27454 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27455 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27456 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27457 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27458 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27459 // can be turned off with macro definition.
27460#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27461#if !SWIG_OCTAVE_PREREQ(4,4,0)
27462#if SWIG_OCTAVE_PREREQ(3,2,0)
27463 octave_exit = ::_Exit;
27464#endif
27465#endif
27466#endif
27467
27468 // check for no input and output args
27469 if (args.length() != 0 || nargout != 0) {
27470 print_usage();
27471 return octave_value_list();
27472 }
27473
27474 // create module on first function call
27475 if (!module_ns) {
27476
27477 // workaround bug in octave where installing global variable of custom type and then
27478 // exiting without explicitly clearing the variable causes octave to segfault.
27479#if SWIG_OCTAVE_PREREQ(3,2,0)
27480 octave_value_list eval_args;
27481 eval_args.append("base");
27482 eval_args.append("function __swig_atexit__; "
27483 " if mislocked() "
27484 " clear -all; "
27485 " else "
27486 " mlock(); "
27487 " endif; "
27488 "endfunction; "
27489 "__swig_atexit__; "
27490 "atexit(\"__swig_atexit__\", false); "
27491 "atexit(\"__swig_atexit__\")");
27492#if SWIG_OCTAVE_PREREQ(4,4,0)
27493 octave::feval("evalin", eval_args, 0);
27494#else
27495 feval("evalin", eval_args, 0);
27496#endif
27497#endif
27498
27499#if SWIG_OCTAVE_PREREQ(4,4,0)
27500 {
27501 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27502 string_vector types = typeinfo.installed_type_names();
27503 bool register_octave_swig_ref = true;
27504 bool register_octave_swig_packed = true;
27505 for (int i = 0; i < types.numel(); ++i) {
27506 if (types(i) == octave_swig_ref::static_type_name()) {
27507 register_octave_swig_ref = false;
27508 octave_swig_ref::set_type_id(i);
27509 }
27510 if (types(i) == octave_swig_packed::static_type_name()) {
27511 register_octave_swig_packed = false;
27512 octave_swig_packed::set_type_id(i);
27513 }
27514 }
27515 if (register_octave_swig_ref) {
27516 octave_swig_ref::register_type();
27517 }
27518 if (register_octave_swig_packed) {
27519 octave_swig_packed::register_type();
27520 }
27521 }
27522#else
27523 octave_swig_ref::register_type();
27524 octave_swig_packed::register_type();
27525#endif
27528
27529#if SWIG_OCTAVE_PREREQ(6,0,0)
27530 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27531 octave::call_stack& stack = tree_eval.get_call_stack();
27532 octave_function *me = stack.current_function();
27533#elif SWIG_OCTAVE_PREREQ(4,4,0)
27534 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27535 octave_function *me = stack.current();
27536#else
27537 octave_function *me = octave_call_stack::current();
27538#endif
27539
27540 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27541 return octave_value_list();
27542 }
27543 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27544 return octave_value_list();
27545 }
27546 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27547 return octave_value_list();
27548 }
27549 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27550 return octave_value_list();
27551 }
27552 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27553 return octave_value_list();
27554 }
27555 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27556 return octave_value_list();
27557 }
27558
27559 octave_swig_type* cvar_ns=0;
27560 if (std::string(SWIG_global_name) != ".") {
27561 cvar_ns=new octave_swig_type;
27562 for (int j=0;swig_globals[j].name;++j)
27563 if (swig_globals[j].get_method)
27564 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27565 }
27566
27567 module_ns=new octave_swig_type(0, 0, 0, true);
27568 if (std::string(SWIG_global_name) != ".") {
27569 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27570 }
27571 else {
27572 for (int j=0;swig_globals[j].name;++j)
27573 if (swig_globals[j].get_method)
27574 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27575 }
27576 for (int j=0;swig_globals[j].name;++j)
27577 if (swig_globals[j].method)
27578 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27579
27580 // * need better solution here; swig_type -> octave_class mapping is
27581 // * really n-to-1, in some cases such as template partial spec, etc.
27582 // * see failing tests.
27583 for (int j=0;swig_types[j];++j)
27584 if (swig_types[j]->clientdata) {
27586 module_ns->assign(c->name,
27588 (new octave_swig_type(0,swig_types[j])));
27589 }
27590
27591 if (!SWIG_init_user(module_ns)) {
27592 delete module_ns;
27593 module_ns=0;
27594 return octave_value_list();
27595 }
27596
27597 SWIG_InstallOps(octave_swig_ref::static_type_id());
27598
27600 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27601 if (mb->second.first && mb->second.first->method) {
27602 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27603 return octave_value_list();
27604 }
27605 }
27606 }
27607
27608#if SWIG_OCTAVE_PREREQ(4,4,0)
27609 octave::interpreter::the_interpreter()->mlock();
27610#elif SWIG_OCTAVE_PREREQ(3,2,0)
27611 mlock();
27612#else
27613 mlock(me->name());
27614#endif
27615
27616 }
27617
27619 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27620 if (mb->second.second.is_defined()) {
27621 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27622 SWIG_Octave_LinkGlobalValue(mb->first);
27623 }
27624 }
27625
27628
27629 return octave_value_list();
27630
27631}
27632
27633
27634static bool SWIG_init_user(octave_swig_type* module_ns)
27635{
27636 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27637 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27638 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27639 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27640 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27641 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27642 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27643 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27644 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27645 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27646 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27647 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27648 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27649 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27650 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27651 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27652 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27653 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27654 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27655 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27656 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27657 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27658 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27659 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27660 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27661 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27662 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27663 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27664 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27665 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27666 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27667 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27668 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27669 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27670 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27671 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27672 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27673 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27674 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27675 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27676 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27677 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27678 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27679 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27680 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27681 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27682 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27683 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27684 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27685 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27686 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27687 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27688 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27689 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27690 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27691 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27692 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27693 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27694 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27695 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27696 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27697 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27698 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27699 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27700 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27701 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27702 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27703 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27704 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27705 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27706 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27707 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27708 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27709 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27710 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27711 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27712 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27713 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27714 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27715 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27716 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27717 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27718 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27719 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27720 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27721 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27722 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27723 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27724 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27725 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27726 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27727 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27728 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27729 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27730 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27731 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27732 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27733 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27734 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27735 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27736 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27737 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27738 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27739 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27740 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27741 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27742 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27743 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27744 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27745 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27746 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27747 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27748 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27749 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27750 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27751 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27752 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27753 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27754 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27755 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27756 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27757 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27758 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27759 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27760 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27761 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27762 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27763 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27764 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27765 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27766 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27767 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27768 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27769 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27770 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27771 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27772 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27773 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27774 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27775 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27811 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27812 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27813 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27814 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27815 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27816 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27817 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27818 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27819 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27820 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27821 return true;
27822}
27823
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_base_value * empty_clone() const
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
octave_base_value * clone() const
virtual bool save_ascii(std::ostream &os)
virtual string_vector map_keys() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual double scalar_value(bool frc_str_conv=false) const
virtual bool is_object() const
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual bool save_ascii(std::ostream &os)
octave_swig_type * get_ptr() const
dim_vector dims(void) const
octave_base_value * clone() const
virtual Octave_map map_value() const
virtual bool is_map() const
virtual bool is_string() const
virtual std::string string_value(bool force=false) const
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
octave_base_value * empty_clone() const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
octave_swig_ref(octave_swig_type *_ptr=0)
virtual bool load_ascii(std::istream &is)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void load_members(member_map &out) const
virtual Octave_map map_value() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
octave_base_value * empty_clone() const
dim_vector dims(void) const
octave_base_value * clone() const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
virtual bool is_object() const
const char * help_text() const
void assign(const std::string &name, const swig_octave_member *m)
octave_swig_type & operator=(const octave_swig_type &rhs)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
void assign(const std::string &name, const octave_value &ov)
virtual bool is_string() const
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
std::vector< type_ptr_pair > types
virtual double scalar_value(bool frc_str_conv=false) const
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
int cast(void **vptr, swig_type_info *type, int *own, int flags)
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
void merge(octave_swig_type &rhs)
member_map::const_iterator swig_member_const_iterator
void print(std::ostream &os, bool pr_as_read_syntax=false) const
const swig_type_info * construct_type
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
#define min(x, y)
Definition: nnpi.c:87
#define max(x, y)
Definition: nnpi.c:88
void plOptUsage(void)
Definition: plargs.c:1304
void plClearOpts(void)
Definition: plargs.c:830
void plResetOpts(void)
Definition: plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
static int error
Definition: plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plcont.c:508
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plimage.c:238
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
Definition: pllegend.c:1525
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:326
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:150
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:921
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:389
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:860
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:883
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
#define plgfci
Definition: plplot.h:735
#define plgstrm
Definition: plplot.h:744
#define plpat
Definition: plplot.h:779
#define plschr
Definition: plplot.h:790
#define plfontld
Definition: plplot.h:721
#define plpath
Definition: plplot.h:761
#define plerry
Definition: plplot.h:715
#define plsfam
Definition: plplot.h:816
#define plsmaj
Definition: plplot.h:826
#define plsmin
Definition: plplot.h:829
#define pleop
Definition: plplot.h:713
#define plimage
Definition: plplot.h:753
#define plstransform
Definition: plplot.h:840
#define plmap
Definition: plplot.h:764
#define plfill
Definition: plplot.h:717
#define plvpas
Definition: plplot.h:859
#define plgdiplt
Definition: plplot.h:732
#define plerrx
Definition: plplot.h:714
#define plinit
Definition: plplot.h:755
#define plscmap1l
Definition: plplot.h:796
#define plsori
Definition: plplot.h:830
#define plbox3
Definition: plplot.h:698
#define plmapfill
Definition: plplot.h:768
#define plcol1
Definition: plplot.h:703
#define pltimefmt
Definition: plplot.h:856
PLUINT PLUNICODE
Definition: plplot.h:201
#define plmaptex
Definition: plplot.h:767
#define plvect
Definition: plplot.h:858
#define plgchr
Definition: plplot.h:722
float PLFLT
Definition: plplot.h:163
#define pllegend
Definition: plplot.h:758
#define plsyax
Definition: plplot.h:852
#define plgver
Definition: plplot.h:745
#define plscolbg
Definition: plplot.h:802
#define plpsty
Definition: plplot.h:784
#define plgfont
Definition: plplot.h:737
#define plenv
Definition: plplot.h:711
#define pllightsource
Definition: plplot.h:759
#define plpoin3
Definition: plplot.h:781
#define plgspa
Definition: plplot.h:743
#define plscol0
Definition: plplot.h:800
#define plptex
Definition: plplot.h:785
#define plrgbhls
Definition: plplot.h:789
#define plbop
Definition: plplot.h:696
#define plgdidev
Definition: plplot.h:730
#define plpoin
Definition: plplot.h:780
#define plptex3
Definition: plplot.h:786
#define plstripd
Definition: plplot.h:845
#define plhist
Definition: plplot.h:751
#define plmapline
Definition: plplot.h:765
#define plgfnam
Definition: plplot.h:736
#define plgdiori
Definition: plplot.h:731
#define PL_MAXKEY
Definition: plplot.h:408
#define plszax
Definition: plplot.h:854
#define plstripa
Definition: plplot.h:843
#define plgxax
Definition: plplot.h:748
#define plgra
Definition: plplot.h:740
#define plenv0
Definition: plplot.h:712
#define plspal1
Definition: plplot.h:833
#define plstring3
Definition: plplot.h:842
#define plxormod
Definition: plplot.h:865
#define plspause
Definition: plplot.h:834
#define plgdev
Definition: plplot.h:729
#define plgradient
Definition: plplot.h:741
#define plspal0
Definition: plplot.h:832
#define plcalc_world
Definition: plplot.h:700
#define plwidth
Definition: plplot.h:863
#define pllab
Definition: plplot.h:757
#define plsurf3d
Definition: plplot.h:847
#define plsurf3dl
Definition: plplot.h:848
#define plvasp
Definition: plplot.h:857
#define plscmap0n
Definition: plplot.h:793
#define plmtex3
Definition: plplot.h:774
#define plctime
Definition: plplot.h:708
#define plclear
Definition: plplot.h:701
#define plsvpa
Definition: plplot.h:850
#define plw3d
Definition: plplot.h:862
#define plot3dcl
Definition: plplot.h:777
#define plscmap1n
Definition: plplot.h:798
#define plgvpd
Definition: plplot.h:746
#define plhlsrgb
Definition: plplot.h:752
#define pl_setcontlabelformat
Definition: plplot.h:690
#define plsdev
Definition: plplot.h:806
#define plconfigtime
Definition: plplot.h:705
#define plscolbga
Definition: plplot.h:803
#define plscmap1
Definition: plplot.h:794
#define plsdiplz
Definition: plplot.h:811
#define plparseopts
Definition: plplot.h:778
#define plmapstring
Definition: plplot.h:766
#define plot3d
Definition: plplot.h:775
#define plsesc
Definition: plplot.h:814
#define plarc
Definition: plplot.h:693
#define plsetopt
Definition: plplot.h:815
#define plgvpw
Definition: plplot.h:747
#define pltext
Definition: plplot.h:855
#define plstring
Definition: plplot.h:841
#define plsdiori
Definition: plplot.h:809
#define plcont
Definition: plplot.h:706
#define plspage
Definition: plplot.h:831
#define plaxes
Definition: plplot.h:694
#define pllsty
Definition: plplot.h:763
#define plslabelfunc
Definition: plplot.h:825
#define plshades
Definition: plplot.h:824
#define plglevel
Definition: plplot.h:738
#define plscompression
Definition: plplot.h:805
#define plfamadv
Definition: plplot.h:716
#define plfont
Definition: plplot.h:720
#define plscmap0a
Definition: plplot.h:792
#define plgcol0a
Definition: plplot.h:725
#define plscmap1_range
Definition: plplot.h:799
#define plmeshc
Definition: plplot.h:771
#define plshade
Definition: plplot.h:820
#define plsym
Definition: plplot.h:853
#define plscmap1a
Definition: plplot.h:795
#define plscmap0
Definition: plplot.h:791
#define plgriddata
Definition: plplot.h:742
#define plstripc
Definition: plplot.h:844
#define pl_setcontlabelparam
Definition: plplot.h:691
#define plsvect
Definition: plplot.h:849
#define plstyl
Definition: plplot.h:846
#define plline
Definition: plplot.h:760
#define pljoin
Definition: plplot.h:756
#define plgzax
Definition: plplot.h:750
#define plsstrm
Definition: plplot.h:835
#define plscmap1la
Definition: plplot.h:797
#define plssym
Definition: plplot.h:837
#define plscolor
Definition: plplot.h:804
#define plcol0
Definition: plplot.h:702
#define plsdiplt
Definition: plplot.h:810
#define plcolorbar
Definition: plplot.h:704
#define plvsta
Definition: plplot.h:861
#define plmeridians
Definition: plplot.h:769
#define plot3dc
Definition: plplot.h:776
#define plcpstrm
Definition: plplot.h:707
#define plmkstrm
Definition: plplot.h:772
#define plgcol0
Definition: plplot.h:724
#define pladv
Definition: plplot.h:692
#define plgcolbga
Definition: plplot.h:727
#define plline3
Definition: plplot.h:762
#define plprec
Definition: plplot.h:783
#define plfill3
Definition: plplot.h:718
#define plseed
Definition: plplot.h:813
#define plgcompression
Definition: plplot.h:728
#define plimagefr
Definition: plplot.h:754
#define plsfont
Definition: plplot.h:819
int PLINT
Definition: plplot.h:181
#define plgfam
Definition: plplot.h:734
#define plscol0a
Definition: plplot.h:801
#define plend1
Definition: plplot.h:710
#define plrandd
Definition: plplot.h:787
#define plbin
Definition: plplot.h:695
#define plsdidev
Definition: plplot.h:807
#define plsfnam
Definition: plplot.h:818
void * PLPointer
Definition: plplot.h:209
#define plflush
Definition: plplot.h:719
#define plwind
Definition: plplot.h:864
#define plstar
Definition: plplot.h:838
#define plmtex
Definition: plplot.h:773
PLINT PLBOOL
Definition: plplot.h:204
#define plsdimap
Definition: plplot.h:808
#define plsfci
Definition: plplot.h:817
#define plend
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:770
#define plreplot
Definition: plplot.h:788
#define plgcolbg
Definition: plplot.h:726
#define plgcmap1_range
Definition: plplot.h:723
#define plstart
Definition: plplot.h:839
#define plsxax
Definition: plplot.h:851
#define plbox
Definition: plplot.h:697
#define plbtime
Definition: plplot.h:699
#define plgyax
Definition: plplot.h:749
#define plvpor
Definition: plplot.h:860
#define plpoly3
Definition: plplot.h:782
#define plgpage
Definition: plplot.h:739
#define plssub
Definition: plplot.h:836
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
static const char * _wrap_plszax_texinfo
static const char * _wrap_plstring3_texinfo
static const char * _wrap_plvsta_texinfo
static const char * _wrap_plscmap1_texinfo
static const char * _wrap_plbox3_texinfo
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plvpas_texinfo
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
static const char * _wrap_plmkstrm_texinfo
#define SWIG_global_name
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plend_texinfo
static const swig_type_info * swig_PLGraphicsIn_base[]
static const char * _wrap_plsvpa_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
octave_function * fcnCoordTrans
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
#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
plgriddata(x, y, z, xg, yg, type, data)\n\ \n\ \n\ This function is used in example 21.\n\ \n\ \n\ \n\ SYNOPSIS:\n\ \n\ plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ \n\ ARGUMENTS:\n\ \n\ x(PLFLT_VECTOR, input) :The input x vector.\n\ \n\ y(PLFLT_VECTOR, input) :The input y vector.\n\ \n\ z(PLFLT_VECTOR, input) :The input z vector. Each triple x[i],\n\ y[i], z[i] represents one data sample coordinate.\n\ \n\ npts(PLINT, input) :The number of data samples in the x, y and z\n\ vectors.\n\ \n\ xg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the x direction. Usually xg has nptsx equally spaced values\n\ from the minimum to the maximum values of the x input vector.\n\ \n\ nptsx(PLINT, input) :The number of points in the xg vector.\n\ \n\ yg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the y direction. Similar to the xg parameter.\n\ \n\ nptsy(PLINT, input) :The number of points in the yg vector.\n\ \n\ zg(PLFLT_NC_MATRIX, output) :The matrix of interpolated results\n\ where data lies in the grid specified by xg and yg. Therefore the\n\ zg matrix must be dimensioned\n\ nptsx by\n\ nptsy.\n\ \n\ type(PLINT, input) :The type of grid interpolation algorithm to\n\ use, which can be:GRID_CSA:Bivariate Cubic Spline approximation\n\ GRID_DTLI:Delaunay Triangulation Linear Interpolation\n\ GRID_NNI:Natural Neighbors Interpolation\n\ GRID_NNIDW:Nearest Neighbors Inverse Distance Weighted\n\ GRID_NNLI:Nearest Neighbors Linear Interpolation\n\ GRID_NNAIDW:Nearest Neighbors Around Inverse Distance\n\ Weighted\n\ For details of the algorithms read the source file plgridd.c.\n\ \n\ data(PLFLT, input) :Some gridding algorithms require extra data,\n\ which can be specified through this argument. Currently, for\n\ algorithm:GRID_NNIDW, data specifies the number of neighbors to\n\ use, the lower the value, the noisier(more local) the\n\ approximation is.\n\ GRID_NNLI, data specifies what a thin triangle is, in the\n\ range[1. .. 2.]. High values enable the usage of very thin\n\ triangles for interpolation, possibly resulting in error in\n\ the approximation.\n\ GRID_NNI, only weights greater than data will be accepted. If\n\ 0, all weights will be accepted.\n\ " zg
static const char * _wrap_plgvpw_texinfo
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
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
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 shade or gradient plots n n or n gradient plots(See pllegend for similar functionality for creating\n\ legends with discrete elements). The arguments of plcolorbar provide\n\ control over the location and size of the color bar as well as the\n\ location and characteristics of the elements(most of which are\n\ optional) within that color bar. The resulting color bar is clipped\n\ at the boundaries of the current subpage.(N.B. the adopted coordinate\n\ system used for some of the parameters is defined in the documentation\n\ of the position parameter.)\n\ \n\ Redacted form reads the desired grid location from the input vectors n xg[nptsx] and yg[nptsy]
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
octave_function * fcnMapForm
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
static const char * _wrap_pllab_texinfo
static const char * _wrap_plspage_texinfo
static int my_plGetCursor(int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plpoin_texinfo
static const char * _wrap_plspause_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
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