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#if SWIG_OCTAVE_PREREQ(8,0,0)
2504 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2505#else
2506 octave::call_stack& callStack = tree_eval.get_call_stack();
2507 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2508#endif
2509 octave::symbol_record sym=symscope.lookup_symbol(name);
2510 stackFrame->mark_global(sym);
2511#else
2512 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2513 symscope.assign(name, symtab.global_varval(name));
2514 symscope.mark_global(name);
2515#endif
2516#else
2517#if !SWIG_OCTAVE_PREREQ(3,2,0)
2518 link_to_global_variable(curr_sym_tab->lookup(name, true));
2519#else
2520#if !SWIG_OCTAVE_PREREQ(3,8,0)
2521 symbol_table::varref(name);
2522#endif
2523 symbol_table::mark_global(name);
2524#endif
2525#endif
2526}
2527
2529 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2530 if (!ov.is_defined() ||
2531 ov.type_id() != octave_swig_packed::static_type_id())
2532 return 0;
2533 const octave_swig_packed* osp =
2534 static_cast < const octave_swig_packed *> (ov.internal_rep());
2535 swig_module_info *pointer = 0;
2536 osp->copy(0, &pointer, sizeof(swig_module_info *));
2537 return pointer;
2538}
2539
2540SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2541 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2543}
2544
2545
2546SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
2547 if (obj.is_string())
2548 error("%s", obj.string_value().c_str());
2549 else
2550 error("C++ side threw an exception of type %s", type);
2551}
2552
2553
2554
2555#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2556
2557#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2558
2559
2560
2561/* -------- TYPES TABLE (BEGIN) -------- */
2562
2563#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2564#define SWIGTYPE_p_char swig_types[1]
2565#define SWIGTYPE_p_double swig_types[2]
2566#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2567#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2568#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2569#define SWIGTYPE_p_int swig_types[6]
2570#define SWIGTYPE_p_p_char swig_types[7]
2571#define SWIGTYPE_p_unsigned_int swig_types[8]
2573static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2574#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2575#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2576
2577/* -------- TYPES TABLE (END) -------- */
2578
2579
2580#ifdef __cplusplus
2581#include <utility>
2582/* SwigValueWrapper is described in swig.swg */
2583template<typename T> class SwigValueWrapper {
2584 struct SwigSmartPointer {
2585 T *ptr;
2586 SwigSmartPointer(T *p) : ptr(p) { }
2587 ~SwigSmartPointer() { delete ptr; }
2588 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
2589 void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
2590 } pointer;
2591 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
2592 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
2593public:
2594 SwigValueWrapper() : pointer(0) { }
2595 SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
2596#if __cplusplus >=201103L
2597 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
2598 operator T&&() const { return std::move(*pointer.ptr); }
2599#else
2600 operator T&() const { return *pointer.ptr; }
2601#endif
2602 T *operator&() const { return pointer.ptr; }
2603 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2604};
2605
2606/*
2607 * SwigValueInit() is a generic initialisation solution as the following approach:
2608 *
2609 * T c_result = T();
2610 *
2611 * doesn't compile for all types for example:
2612 *
2613 * unsigned int c_result = unsigned int();
2614 */
2615template <typename T> T SwigValueInit() {
2616 return T();
2617}
2618
2619#if __cplusplus >=201103L
2620# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2621#else
2622# define SWIG_STD_MOVE(OBJ) OBJ
2623#endif
2624
2625#endif
2626
2627
2628#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2629#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2630
2631
2632#include <stdexcept>
2633
2634
2635// #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2636#undef PACKAGE
2637#undef VERSION
2638
2639#include "plplotP.h"
2640
2641// Temporary fix for problems with -fvisibility=hidden and octave headers.
2642#ifdef OCTAVE_EXPORT
2643 #if defined ( __GNUC__ ) && __GNUC__ > 3
2644 #undef OCTAVE_EXPORT
2645 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2646 #endif
2647#endif
2648
2649
2650
2651// I hate global variables but this is the best way I can think of
2652// to manage consistency checking among function arguments.
2653 static PLINT Alen = 0;
2654 static PLINT Xlen = 0, Ylen = 0;
2655
2656
2657// Convenience functions copied from matwrap-based approach (currently
2658// stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2659// tricky scalar case and also adopted so that the resulting
2660// swig-generated source code will look similar to the matwrap-generated
2661// source code.
2662
2663 inline int max( int a, int b )
2664 {
2665 return a >= b ? a : b;
2666 }
2667 inline int min( int a, int b )
2668 {
2669 return a >= b ? a : b;
2670 }
2671
2672//
2673// Function to get the total length (rows*columns) of an octave object of
2674// arbitrary type.
2675// Arguments:
2676// 1) The octave object.
2677//
2678// If the object is a scalar, the array length is 1.
2679//
2680 static int
2681 _arraylen( const octave_value &o_obj )
2682 {
2683 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2684 // max is necessary because sometimes
2685 // rows() or columns() return -1 or 0 for
2686 // scalars.
2687 }
2688
2689//
2690// Function to get the number of dimensions of an object.
2691//
2692 static int
2693 _n_dims( const octave_value &o_obj )
2694 {
2695 if ( max( o_obj.columns(), 1 ) > 1 )
2696 return 2;
2697 // max is necessary because sometimes
2698 // rows() or columns() return -1 or 0 for
2699 // scalars.
2700 else if ( max( o_obj.rows(), 1 ) > 1 )
2701 return 1;
2702 else
2703 return 0;
2704 }
2705
2706//
2707// Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2708//
2709 static inline int
2710 _dim( const octave_value &o_obj, int dim_idx )
2711 {
2712 if ( dim_idx == 0 )
2713 return max( o_obj.rows(), 0 );
2714 // max is necessary because sometimes
2715 // rows() or columns() return -1 or 0 for
2716 // scalars.
2717 else if ( dim_idx == 1 )
2718 return max( o_obj.columns(), 0 );
2719 else
2720 return 1;
2721 }
2722
2723//
2724// The following function converts an array of doubles into some other
2725// numeric type. Arguments:
2726// 1) Where to store the result. The type is determined from the type of
2727// this pointer.
2728// 2) A vector of doubles to convert.
2729// 3) The number of doubles.
2730//
2731 template <class FLOAT>
2732 static inline void
2733 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2734 {
2735 while ( n_el-- > 0 )
2736 *out_arr++ = (FLOAT) ( *in_arr++ );
2737 }
2738
2739 template void _cvt_double_to( int *, double *, unsigned );
2740 template void _cvt_double_to( unsigned *, double *, unsigned );
2741 template void _cvt_double_to( long *, double *, unsigned );
2742 template void _cvt_double_to( unsigned long *, double *, unsigned );
2743 template void _cvt_double_to( short *, double *, unsigned );
2744 template void _cvt_double_to( unsigned short *, double *, unsigned );
2745 template void _cvt_double_to( float *, double *, unsigned );
2746 // Instantiate our templates. Octave uses
2747 // manual template instantiation.
2748
2749//
2750// Convert an array of some other type into an array of doubles. Arguments:
2751// 1) The array of objects of other type.
2752// 2) The output array of doubles.
2753// 3) The number of elements to convert.
2754//
2755 template <class FLOAT>
2756 static inline void
2757 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2758 {
2759 while ( n_el-- > 0 )
2760 *d_arr++ = double(*arr++);
2761 }
2762
2763 template void _cvt_to_double( int *, double *, unsigned );
2764 template void _cvt_to_double( unsigned *, double *, unsigned );
2765 template void _cvt_to_double( long *, double *, unsigned );
2766 template void _cvt_to_double( unsigned long *, double *, unsigned );
2767 template void _cvt_to_double( short *, double *, unsigned );
2768 template void _cvt_to_double( unsigned short *, double *, unsigned );
2769 template void _cvt_to_double( float *, double *, unsigned );
2770 // Instantiate our templates. Octave uses
2771 // manual template instantiation.
2772
2773
2774 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2775 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2776 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2777 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2778 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2780 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2781
2782
2783#include <iostream>
2784
2785 octave_function *fcnMapForm;
2786 std::string nameMapForm;
2787
2789 {
2790 octave_idx_type i;
2791 octave_value_list functionArguments;
2792 octave_value_list retval;
2793
2794 Matrix xin( n, 1 );
2795 Matrix yin( n, 1 );
2796 Matrix xout;
2797 Matrix yout;
2798
2799 for ( i = 0; i < n; i++ )
2800 {
2801 xin( i, 0 ) = x[i];
2802 yin( i, 0 ) = y[i];
2803 }
2804
2805 functionArguments( 0 ) = xin;
2806 functionArguments( 1 ) = yin;
2807
2808 if ( fcnMapForm != NULL )
2809#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2810 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2811#else
2812 retval = feval( fcnMapForm, functionArguments, 1 );
2813#endif
2814 else
2815#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2816 retval = octave::feval( nameMapForm, functionArguments, 1 );
2817#else
2818 retval = feval( nameMapForm, functionArguments, 1 );
2819#endif
2820
2821 if ( retval.length() >= 2 )
2822 {
2823 xout = retval( 0 ).matrix_value();
2824 yout = retval( 1 ).matrix_value();
2825
2826 for ( i = 0; i < n; i++ )
2827 {
2828 x[i] = xout( i, 0 );
2829 y[i] = yout( i, 0 );
2830 }
2831 }
2832 }
2833
2834
2835 octave_function *fcnLabelFunc;
2836 std::string nameLabelFunc;
2837
2838 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2839 {
2840 int i;
2841 octave_value_list functionArguments;
2842 octave_value_list retval;
2843
2844 Matrix inAxis( 1, 1 );
2845 Matrix inValue( 1, 1 );
2846 inAxis( 0, 0 ) = axis;
2847 inValue( 0, 0 ) = value;
2848
2849 functionArguments( 0 ) = inAxis;
2850 functionArguments( 1 ) = inValue;
2851
2852 if ( fcnLabelFunc != NULL )
2853#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2854 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2855#else
2856 retval = feval( fcnLabelFunc, functionArguments, 1 );
2857#endif
2858 else
2859#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2860 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2861#else
2862 retval = feval( nameLabelFunc, functionArguments, 1 );
2863#endif
2864
2865 strncpy( label, retval( 0 ).string_value().c_str(), length );
2866 }
2867
2868
2869 octave_function *fcnCoordTrans;
2870 std::string nameCoordTrans;
2871
2872 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2873 {
2874 octave_idx_type i;
2875 octave_value_list functionArguments;
2876 octave_value_list retval;
2877
2878 Matrix xin( 1, 1 );
2879 Matrix yin( 1, 1 );
2880 Matrix xout;
2881 Matrix yout;
2882
2883 xin( 0, 0 ) = x;
2884 yin( 0, 0 ) = y;
2885
2886 functionArguments( 0 ) = xin;
2887 functionArguments( 1 ) = yin;
2888
2889 if ( fcnCoordTrans != NULL )
2890#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2891 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2892#else
2893 retval = feval( fcnCoordTrans, functionArguments, 1 );
2894#endif
2895 else
2896#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2897 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2898#else
2899 retval = feval( nameCoordTrans, functionArguments, 1 );
2900#endif
2901
2902 if ( retval.length() >= 2 )
2903 {
2904 xout = retval( 0 ).matrix_value();
2905 yout = retval( 1 ).matrix_value();
2906
2907 *xt = xout( 0, 0 );
2908 *yt = yout( 0, 0 );
2909 }
2910 }
2911
2912
2913 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2914 {
2915 PLINT i;
2916 printf( "nlegend =%d\n", nlegend );
2917 for ( i = 0; i < nlegend; i++ )
2918 {
2919 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2920 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2921 printf( "text[%d] =%s\n", i, text[i] );
2922 }
2923 }
2924
2925
2926#include <limits.h>
2927#if !defined(SWIG_NO_LLONG_MAX)
2928# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2929# define LLONG_MAX __LONG_LONG_MAX__
2930# define LLONG_MIN (-LLONG_MAX - 1LL)
2931# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2932# endif
2933#endif
2934
2935
2936 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2937 {
2938 if (!ov.is_scalar_type())
2939 return SWIG_TypeError;
2940 if (ov.is_complex_scalar())
2941 return SWIG_TypeError;
2942 if (ov.is_double_type()||ov.is_single_type()) {
2943 double v=ov.double_value();
2944 if (v!=floor(v))
2945 return SWIG_TypeError;
2946 }
2947 if (val)
2948 *val = ov.long_value();
2949 return SWIG_OK;
2950 }
2951
2952
2953SWIGINTERN int
2954SWIG_AsVal_int (octave_value obj, int *val)
2955{
2956 long v;
2957 int res = SWIG_AsVal_long (obj, &v);
2958 if (SWIG_IsOK(res)) {
2959 if ((v < INT_MIN || v > INT_MAX)) {
2960 return SWIG_OverflowError;
2961 } else {
2962 if (val) *val = static_cast< int >(v);
2963 }
2964 }
2965 return res;
2966}
2967
2968
2969 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 )
2970 {
2971 PLGraphicsIn gin;
2972 int status; status = plGetCursor( &gin );
2973 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2974 strncpy( string, gin.string, PL_MAXKEY - 1 );
2975 string[PL_MAXKEY - 1] = '\0';
2976
2977 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2978 return status;
2979 }
2980
2981
2982SWIGINTERN int
2983SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2984{
2985 if (
2986#if SWIG_OCTAVE_PREREQ(4,4,0)
2987 ov.iscell()
2988#else
2989 ov.is_cell()
2990#endif
2991 && ov.rows() == 1 && ov.columns() == 1)
2992 ov = ov.cell_value()(0);
2993 if (!ov.is_string())
2994 return SWIG_TypeError;
2995
2996 std::string str=ov.string_value();
2997 size_t len=str.size();
2998 char* cstr=(char*)str.c_str();
2999 if (alloc) {
3000 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
3001 *alloc = SWIG_NEWOBJ;
3002 } else if (cptr)
3003 *cptr = cstr;
3004 if (psize)
3005 *psize = len + 1;
3006 return SWIG_OK;
3007}
3008
3009
3010
3011
3012
3014 {
3015 return octave_value(value);
3016 }
3017
3018
3019SWIGINTERNINLINE octave_value
3021{
3022 return SWIG_From_long (value);
3023}
3024
3025
3027 {
3028 return octave_value(value);
3029 }
3030
3031
3032// Translates relative device coordinates to world coordinates.
3033 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
3034 {
3035 PLGraphicsIn gin;
3036 int st;
3037 gin.dX = x_in; gin.dY = y_in;
3038 st = plTranslateCursor( &gin );
3039 *x = gin.wX; *y = gin.wY;
3040 return st;
3041 }
3042
3043
3044 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
3045 {
3046 if (!ov.is_scalar_type())
3047 return SWIG_TypeError;
3048 if (ov.is_complex_scalar())
3049 return SWIG_TypeError;
3050 if (val)
3051 *val = ov.double_value();
3052 return SWIG_OK;
3053 }
3054
3055
3056// Create 1d stripchart
3057
3058 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3059 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3060 PLFLT xlpos, PLFLT ylpos,
3061 PLBOOL y_ascl, PLBOOL acc,
3062 PLINT colbox, PLINT collab,
3063 const PLINT *colline, const PLINT *styline,
3064 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3065 const char *labx, const char *laby, const char *labtop )
3066 {
3067 const char *legline[4];
3068 legline[0] = legline1; legline[1] = legline2;
3069 legline[2] = legline3; legline[3] = legline4;
3070 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3071 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3072 labx, laby, labtop );
3073 }
3074
3075
3076// One more hack. As it is not possible (and would not be desirable) to pass
3077// an Octave function to plcont(), I have defined three plcont():
3078// plcont uses a defined here xform()
3079// plcont0 uses pltr0()
3080// plcont1 uses pltr1()
3081// plcont2 uses pltr2()
3082// plcont2p uses pltr2p()
3083//
3084// Also, as plplot expect vectorized bidimensional arrays, I provided a
3085// f2c, which is a #define that does the necessary conversion.
3086//
3087
3088 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3089 {
3090 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3091 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3092 }
3093
3094// convert from Fortran like arrays (one vector), to C like 2D arrays
3095
3096#define f2c( f, ff, nx, ny ) \
3097 PLFLT * *ff; \
3098 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3099 for ( int i = 0; i < nx; i++ ) { \
3100 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3101 for ( int j = 0; j < ny; j++ ) \
3102 *( ff[i] + j ) = *( f + nx * j + i );}
3103
3104// simpler plcont() for use with xform()
3105
3106 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3107 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3108 {
3109 f2c( f, ff, nx, ny );
3110 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3111 }
3112
3113// plcont() for use with pltr0() NOT TESTED
3114
3115 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3116 PLINT ly, const PLFLT *clevel, PLINT nlevel )
3117 {
3118 f2c( f, ff, nx, ny );
3119 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3120 }
3121
3122// plcont() for use with pltr1()
3123
3124 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3125 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3126 {
3127 PLcGrid grid1;
3128 grid1.nx = nx; grid1.ny = ny;
3129 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3130 f2c( f, ff, nx, ny );
3131 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3132 }
3133
3134// plcont() for use with pltr2()
3135 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3136 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3137 {
3138 PLcGrid2 grid2;
3139 f2c( xg, xgg, nx, ny );
3140 f2c( yg, ygg, nx, ny );
3141 grid2.nx = nx; grid2.ny = ny;
3142 grid2.xg = xgg; grid2.yg = ygg;
3143 f2c( f, ff, nx, ny );
3144 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3145 }
3146
3147// plcont() for use with pltr2p()
3148
3149 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3150 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3151 {
3152 PLcGrid2 grid2;
3153 f2c( xg, xgg, nx, ny );
3154 f2c( yg, ygg, nx, ny );
3155 grid2.nx = nx; grid2.ny = ny;
3156 grid2.xg = xgg; grid2.yg = ygg;
3157 f2c( f, ff, nx, ny );
3158 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3159 }
3160
3161
3162 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3163 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3164 PLFLT *zg, int type, PLFLT data )
3165 {
3166 f2c( zg, zgg, nptsx, nptsy );
3167 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3168 for ( int i = 0; i < nptsx; i++ )
3169 for ( int j = 0; j < nptsy; j++ )
3170 *( zg + nptsx * j + i ) = zgg[i][j];
3171 }
3172
3173
3174// Plots a mesh representation of the function z[x][y].
3175
3176 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3177 {
3178 f2c( z, zz, nx, ny );
3179 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3180 }
3181
3182// Plots a mesh representation of the function z[x][y] with contour
3183
3184 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3185 {
3186 f2c( z, zz, nx, ny );
3187 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3188 }
3189
3190
3191// Plots a 3-d representation of the function z[x][y].
3192 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3193 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3194 {
3195 f2c( z, zz, nx, ny );
3196 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3197 }
3198
3199// Plots a 3-d representation of the function z[x][y] with contour
3200 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3201 PLINT nx, PLINT ny, PLINT opt,
3202 const PLFLT *clevel, PLINT nlevel )
3203 {
3204 f2c( z, zz, nx, ny );
3205 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3206 }
3207// Plots a 3-d representation of the function z[x][y] with contour with y
3208// index limits
3209 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3210 PLINT nx, PLINT ny, PLINT opt,
3211 const PLFLT * clevel, PLINT nlevel,
3212 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3213 {
3214 f2c( z, zz, nx, ny );
3215 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3216 indexxmin, indexxmax, indexymin, indexymax );
3217 }
3218
3219
3220 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3221 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3222 {
3223 f2c( z, zz, nx, ny );
3224 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3225 }
3226
3227 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3228 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3229 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3230 {
3231 f2c( z, zz, nx, ny );
3232 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3233 indexxmin, indexxmax, indexymin, indexymax );
3234 }
3235
3236
3237// The same as in plcont. I have hardcoded the first function pointer
3238// to plfill(). The second function pointer will use the same convention
3239// as in plcont().
3240//
3241
3242// the simpler plshade()
3243 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3244 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3245 PLFLT shade_min, PLFLT shade_max,
3246 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3247 PLINT min_color, PLINT min_width,
3248 PLINT max_color, PLINT max_width,
3249 PLINT rectangular, PLFLT *tr )
3250 {
3251 f2c( a, aa, nx, ny );
3252 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3253 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3254 min_color, min_width, max_color, max_width,
3255 plfill, rectangular, xform, tr );
3256 }
3257
3258// plshade() for use with pltr1
3259 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3260 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3261 PLFLT shade_min, PLFLT shade_max,
3262 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3263 PLINT min_color, PLINT min_width,
3264 PLINT max_color, PLINT max_width,
3265 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3266 {
3267 PLcGrid grid1;
3268 grid1.nx = nx; grid1.ny = ny;
3269 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3270 f2c( a, aa, nx, ny );
3271 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3272 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3273 min_color, min_width, max_color, max_width,
3274 plfill, rectangular, pltr1, &grid1 );
3275 }
3276
3277// plshade() for use with pltr2
3278 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3279 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3280 PLFLT shade_min, PLFLT shade_max,
3281 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3282 PLINT min_color, PLINT min_width,
3283 PLINT max_color, PLINT max_width,
3284 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3285 {
3286 PLcGrid2 grid2;
3287 f2c( xg, xgg, nx, ny );
3288 f2c( yg, ygg, nx, ny );
3289 grid2.nx = nx; grid2.ny = ny;
3290 grid2.xg = xgg; grid2.yg = ygg;
3291 f2c( a, aa, nx, ny );
3292 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3293 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3294 min_color, min_width, max_color, max_width,
3295 plfill, rectangular, pltr2, &grid2 );
3296 }
3297
3298
3299
3300 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3301 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3302 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3303 PLINT cont_color, PLINT cont_width,
3304 PLINT rectangular )
3305 {
3306 f2c( a, aa, nx, ny );
3307 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3308 clevel, nlevel, fill_width, cont_color, cont_width,
3309 plfill, rectangular, NULL, NULL );
3310 }
3311
3312 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3313 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3314 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3315 PLINT cont_color, PLINT cont_width,
3316 PLINT rectangular, PLFLT *tr )
3317 {
3318 f2c( a, aa, nx, ny );
3319 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3320 clevel, nlevel, fill_width, cont_color, cont_width,
3321 plfill, rectangular, xform, tr );
3322 }
3323
3324 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3325 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3326 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3327 PLINT cont_color, PLINT cont_width,
3328 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3329 {
3330 PLcGrid grid1;
3331 grid1.nx = nx; grid1.ny = ny;
3332 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3333
3334 f2c( a, aa, nx, ny );
3335 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3336 clevel, nlevel, fill_width, cont_color, cont_width,
3337 plfill, rectangular, pltr1, &grid1 );
3338 }
3339
3340 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3341 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3342 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3343 PLINT cont_color, PLINT cont_width,
3344 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3345 {
3346 PLcGrid2 grid2;
3347 f2c( xg, xgg, nx, ny );
3348 f2c( yg, ygg, nx, ny );
3349 grid2.nx = nx; grid2.ny = ny;
3350 grid2.xg = xgg; grid2.yg = ygg;
3351 f2c( a, aa, nx, ny );
3352 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3353 clevel, nlevel, fill_width, cont_color, cont_width,
3354 plfill, rectangular, pltr2, &grid2 );
3355 }
3356
3357
3358// Plot an array of vector arrows - uses the same function pointer
3359// convention as plcont
3360
3361 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3362 {
3363 f2c( u, uu, nx, ny );
3364 f2c( v, vv, nx, ny );
3365 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3366 }
3367
3368// plvect() for use with pltr1
3369 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3370 {
3371 PLcGrid grid1;
3372 grid1.nx = nx; grid1.ny = ny;
3373 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3374 f2c( u, uu, nx, ny );
3375 f2c( v, vv, nx, ny );
3376 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3377 }
3378
3379// plvect() for use with pltr2
3380 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3381 {
3382 PLcGrid2 grid2;
3383 f2c( xg, xgg, nx, ny );
3384 f2c( yg, ygg, nx, ny );
3385 grid2.nx = nx; grid2.ny = ny;
3386 grid2.xg = xgg; grid2.yg = ygg;
3387 f2c( u, uu, nx, ny );
3388 f2c( v, vv, nx, ny );
3389 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3390 }
3391
3392
3393// Plot an image with distortion - uses the same function pointer
3394 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3395 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3396 PLFLT zmin, PLFLT zmax,
3397 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3398 {
3399 f2c( a, aa, nx, ny );
3400 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3401 }
3402
3403// Plot an image with distortion - uses the same function pointer
3404// convention as plcont
3405 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3406 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3407 PLFLT zmin, PLFLT zmax,
3408 PLFLT valuemin, PLFLT valuemax )
3409 {
3410 f2c( a, aa, nx, ny );
3411 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3412 }
3413
3414 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3415 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3416 PLFLT zmin, PLFLT zmax,
3417 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3418 {
3419 f2c( a, aa, nx, ny );
3420 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3421 }
3422
3423// plimagefr() for use with pltr1
3424 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3425 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3426 PLFLT zmin, PLFLT zmax,
3427 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3428 {
3429 PLcGrid grid1;
3430 grid1.nx = nx + 1; grid1.ny = ny + 1;
3431 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3432 f2c( a, aa, nx, ny );
3433 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3434 }
3435
3436// plimagefr() for use with pltr2
3437 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3438 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3439 PLFLT zmin, PLFLT zmax,
3440 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3441 {
3442 PLcGrid2 grid2;
3443 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3444 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3445 grid2.nx = nx + 1; grid2.ny = ny + 1;
3446 grid2.xg = xgg; grid2.yg = ygg;
3447 f2c( a, aa, nx, ny );
3448 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3449 }
3450
3451
3452
3453 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3454 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3455 PLFLT x_length, PLFLT y_length,
3456 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3457 PLFLT low_cap_color, PLFLT high_cap_color,
3458 PLINT cont_color, PLFLT cont_width,
3459 PLINT n_labels, const PLINT *label_opts, const char **label,
3460 PLINT n_axes, const char ** axis_opts,
3461 const PLFLT *ticks, const PLINT *sub_ticks,
3462 const PLINT *n_values, const PLFLT *a )
3463 {
3464 PLINT nx, ny, i;
3465 nx = n_axes;
3466 ny = -1;
3467 for ( i = 0; i < nx; i++ )
3468 if ( n_values[i] > ny )
3469 ny = n_values[i];
3470 f2c( a, aa, nx, ny );
3471 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3472 opt, position, x, y,
3473 x_length, y_length,
3474 bg_color, bb_color, bb_style,
3475 low_cap_color, high_cap_color,
3476 cont_color, cont_width,
3477 n_labels, label_opts, label,
3478 n_axes, axis_opts,
3479 ticks, sub_ticks,
3480 n_values, aa );
3481 }
3482
3483
3484
3485 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3486 {
3487 if (!ov.is_scalar_type())
3488 return SWIG_TypeError;
3489 if (ov.is_complex_scalar())
3490 return SWIG_TypeError;
3491 if (ov.is_double_type()||ov.is_single_type()) {
3492 double v=ov.double_value();
3493 if (v<0)
3494 return SWIG_OverflowError;
3495 if (v!=floor(v))
3496 return SWIG_TypeError;
3497 }
3498 if (ov.is_int8_type()||ov.is_int16_type()||
3499 ov.is_int32_type()) {
3500 long v=ov.long_value();
3501 if (v<0)
3502 return SWIG_OverflowError;
3503 }
3504 if (ov.is_int64_type()) {
3505 long long v=ov.int64_scalar_value().value();
3506 if (v<0)
3507 return SWIG_OverflowError;
3508 }
3509 if (val)
3510 *val = ov.ulong_value();
3511 return SWIG_OK;
3512 }
3513
3514
3515SWIGINTERN int
3516SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3517{
3518 unsigned long v;
3519 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3520 if (SWIG_IsOK(res)) {
3521 if ((v > UINT_MAX)) {
3522 return SWIG_OverflowError;
3523 } else {
3524 if (val) *val = static_cast< unsigned int >(v);
3525 }
3526 }
3527 return res;
3528}
3529
3530
3532 {
3533 return octave_value(value);
3534 }
3535
3536
3537SWIGINTERNINLINE octave_value
3539{
3541}
3542
3543
3544SWIGINTERN int
3545SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3546{
3547 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3548 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3549 if (SWIG_IsOK(res)) {
3550 /* special case of single char conversion when we don't need space for NUL */
3551 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3552 if (csize <= size) {
3553 if (val) {
3554 if (csize) memcpy(val, cptr, csize*sizeof(char));
3555 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3556 }
3557 if (alloc == SWIG_NEWOBJ) {
3558 delete[] cptr;
3559 res = SWIG_DelNewMask(res);
3560 }
3561 return res;
3562 }
3563 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3564 }
3565 return SWIG_TypeError;
3566}
3567
3568
3571{
3572 static int init = 0;
3573 static swig_type_info* info = 0;
3574 if (!init) {
3575 info = SWIG_TypeQuery("_p_char");
3576 init = 1;
3577 }
3578 return info;
3579}
3580
3581
3582SWIGINTERNINLINE octave_value
3583SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3584{
3585 return std::string(carray,carray+size);
3586}
3587
3588
3589SWIGINTERN size_t
3590SWIG_strnlen(const char* s, size_t maxlen)
3591{
3592 const char *p;
3593 for (p = s; maxlen-- && *p; p++)
3594 ;
3595 return p - s;
3596}
3597
3598
3599SWIGINTERN int
3600SWIG_AsVal_char (octave_value obj, char *val)
3601{
3602 int res = SWIG_AsCharArray(obj, val, 1);
3603 if (!SWIG_IsOK(res)) {
3604 long v;
3605 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3606 if (SWIG_IsOK(res)) {
3607 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3608 if (val) *val = static_cast< char >(v);
3609 } else {
3610 res = SWIG_OverflowError;
3611 }
3612 }
3613 }
3614 return res;
3615}
3616
3617static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
3618Set up transformation from metafile coordinates\n\
3619\n\
3620DESCRIPTION:\n\
3621\n\
3622 Set up transformation from metafile coordinates. The size of the plot\n\
3623 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3624 general-purpose facility just yet (not sure why the user would need\n\
3625 it, for one).\n\
3626\n\
3627 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3628 dimypmm)\n\
3629\n\
3630 This function is not used in any examples.\n\
3631\n\
3632\n\
3633\n\
3634SYNOPSIS:\n\
3635\n\
3636plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3637\n\
3638ARGUMENTS:\n\
3639\n\
3640 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3641\n\
3642 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3643\n\
3644 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3645\n\
3646 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3647\n\
3648 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3649\n\
3650 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3651";
3652static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
3653Set the cmap0 palette using the specified cmap0*.pal format file\n\
3654\n\
3655DESCRIPTION:\n\
3656\n\
3657 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3658\n\
3659 Redacted form: plspal0(filename)\n\
3660\n\
3661 This function is in example 16.\n\
3662\n\
3663\n\
3664\n\
3665SYNOPSIS:\n\
3666\n\
3667plspal0(filename)\n\
3668\n\
3669ARGUMENTS:\n\
3670\n\
3671 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3672 containing the name of the cmap0*.pal file. If this string is\n\
3673 empty, use the default cmap0*.pal file.\n\
3674";
3675static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
3676Set the cmap1 palette using the specified cmap1*.pal format file\n\
3677\n\
3678DESCRIPTION:\n\
3679\n\
3680 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3681\n\
3682 Redacted form: plspal1(filename, interpolate)\n\
3683\n\
3684 This function is used in example 16.\n\
3685\n\
3686\n\
3687\n\
3688SYNOPSIS:\n\
3689\n\
3690plspal1(filename, interpolate)\n\
3691\n\
3692ARGUMENTS:\n\
3693\n\
3694 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3695 containing the name of the cmap1*.pal file. If this string is\n\
3696 empty, use the default cmap1*.pal file.\n\
3697\n\
3698 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3699 columns containing the intensity index, r, g, b, alpha and\n\
3700 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3701 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3702 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3703 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3704 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3705 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3706 are used instead to set the cmap1 palette directly with a call to\n\
3707 plscmap1a.\n\
3708";
3709static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
3710Draw a line in 3 space\n\
3711\n\
3712DESCRIPTION:\n\
3713\n\
3714 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3715 first set up the viewport, the 2d viewing window (in world\n\
3716 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3717 more info.\n\
3718\n\
3719 Redacted form: plline3(x, y, z)\n\
3720\n\
3721 This function is used in example 18.\n\
3722\n\
3723\n\
3724\n\
3725SYNOPSIS:\n\
3726\n\
3727plline3(n, x, y, z)\n\
3728\n\
3729ARGUMENTS:\n\
3730\n\
3731 n (PLINT, input) : Number of points defining line.\n\
3732\n\
3733 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3734 points.\n\
3735\n\
3736 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3737 points.\n\
3738\n\
3739 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3740 points.\n\
3741";
3742static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
3743Magnitude colored plot surface mesh with contour\n\
3744\n\
3745DESCRIPTION:\n\
3746\n\
3747 A more powerful form of plmesh: the surface mesh can be colored\n\
3748 accordingly to the current z value being plotted, a contour plot can\n\
3749 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3750 plotted function border and the base XY plane.\n\
3751\n\
3752 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3753\n\
3754 This function is used in example 11.\n\
3755\n\
3756\n\
3757\n\
3758SYNOPSIS:\n\
3759\n\
3760plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3761\n\
3762ARGUMENTS:\n\
3763\n\
3764 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3765 which the function is evaluated.\n\
3766\n\
3767 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3768 which the function is evaluated.\n\
3769\n\
3770 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3771 plot. Should have dimensions of\n\
3772 nx by\n\
3773 ny.\n\
3774\n\
3775 nx (PLINT, input) : Number of x values at which function is\n\
3776 evaluated.\n\
3777\n\
3778 ny (PLINT, input) : Number of y values at which function is\n\
3779 evaluated.\n\
3780\n\
3781 opt (PLINT, input) : Determines the way in which the surface is\n\
3782 represented. To specify more than one option just add the options,\n\
3783 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3784 showing z as a function of x for each value of y[j] .\n\
3785 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3786 for each value of x[i] .\n\
3787 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3788 at which function is defined.\n\
3789 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3790 the z value being plotted. The color is used from the current\n\
3791 cmap1.\n\
3792 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3793 using parameters\n\
3794 nlevel and\n\
3795 clevel.\n\
3796 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3797 the borders of the plotted function.\n\
3798\n\
3799\n\
3800 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3801 levels.\n\
3802\n\
3803 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3804";
3805static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
3806Draw a line between two points, accounting for coordinate transforms\n\
3807\n\
3808DESCRIPTION:\n\
3809\n\
3810 Joins the point (\n\
3811 x1,\n\
3812 y1) to (\n\
3813 x2,\n\
3814 y2) . If a global coordinate transform is defined then the line is\n\
3815 broken in to n segments to approximate the path. If no transform is\n\
3816 defined then this simply acts like a call to pljoin.\n\
3817\n\
3818 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3819\n\
3820 This function is used in example 22.\n\
3821\n\
3822\n\
3823\n\
3824SYNOPSIS:\n\
3825\n\
3826plpath(n, x1, y1, x2, y2)\n\
3827\n\
3828ARGUMENTS:\n\
3829\n\
3830 n (PLINT, input) : number of points to use to approximate the path.\n\
3831\n\
3832 x1 (PLFLT, input) : x coordinate of first point.\n\
3833\n\
3834 y1 (PLFLT, input) : y coordinate of first point.\n\
3835\n\
3836 x2 (PLFLT, input) : x coordinate of second point.\n\
3837\n\
3838 y2 (PLFLT, input) : y coordinate of second point.\n\
3839";
3840static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
3841Write text inside the viewport\n\
3842\n\
3843DESCRIPTION:\n\
3844\n\
3845 Writes text at a specified position and inclination within the\n\
3846 viewport. Text is clipped at the viewport boundaries. The reference\n\
3847 point of a string lies along a line passing through the string at half\n\
3848 the height of a capital letter. The position of the reference point\n\
3849 along this line is determined by just, the reference point is placed\n\
3850 at world coordinates (\n\
3851 x,\n\
3852 y) within the viewport. The inclination of the string is specified\n\
3853 in terms of differences of world coordinates making it easy to write\n\
3854 text parallel to a line in a graph.\n\
3855\n\
3856 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3857\n\
3858 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3859\n\
3860\n\
3861\n\
3862SYNOPSIS:\n\
3863\n\
3864plptex(x, y, dx, dy, just, text)\n\
3865\n\
3866ARGUMENTS:\n\
3867\n\
3868 x (PLFLT, input) : x coordinate of reference point of string.\n\
3869\n\
3870 y (PLFLT, input) : y coordinate of reference point of string.\n\
3871\n\
3872 dx (PLFLT, input) : Together with dy, this specifies the\n\
3873 inclination of the string. The baseline of the string is parallel\n\
3874 to a line joining (\n\
3875 x,\n\
3876 y) to (\n\
3877 x+\n\
3878 dx,\n\
3879 y+\n\
3880 dy) .\n\
3881\n\
3882 dy (PLFLT, input) : Together with dx, this specifies the\n\
3883 inclination of the string.\n\
3884\n\
3885 just (PLFLT, input) : Specifies the position of the string relative\n\
3886 to its reference point. If just=0. , the reference point is at\n\
3887 the left and if just=1. , it is at the right of the string. Other\n\
3888 values of just give intermediate justifications.\n\
3889\n\
3890 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3891 written out.\n\
3892";
3893static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
3894Set family file parameters\n\
3895\n\
3896DESCRIPTION:\n\
3897\n\
3898 Sets variables dealing with output file familying. Does nothing if\n\
3899 familying not supported by the driver. This routine, if used, must be\n\
3900 called before initializing PLplot. See the PLplot documentation for\n\
3901 more information.\n\
3902\n\
3903 Redacted form: plsfam(fam, num, bmax)\n\
3904\n\
3905 This function is used in examples 14 and 31.\n\
3906\n\
3907\n\
3908\n\
3909SYNOPSIS:\n\
3910\n\
3911plsfam(fam, num, bmax)\n\
3912\n\
3913ARGUMENTS:\n\
3914\n\
3915 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3916 is enabled.\n\
3917\n\
3918 num (PLINT, input) : Current family file number.\n\
3919\n\
3920 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3921 file.\n\
3922";
3923static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3924Set y axis parameters\n\
3925\n\
3926DESCRIPTION:\n\
3927\n\
3928 Identical to plsxax, except that arguments are flags for y axis. See\n\
3929 the description of plsxax for more detail.\n\
3930\n\
3931 Redacted form: plsyax(digmax, digits)\n\
3932\n\
3933 This function is used in examples 1, 14, and 31.\n\
3934\n\
3935\n\
3936\n\
3937SYNOPSIS:\n\
3938\n\
3939plsyax(digmax, digits)\n\
3940\n\
3941ARGUMENTS:\n\
3942\n\
3943 digmax (PLINT, input) : Variable to set the maximum number of\n\
3944 digits for the y axis. If nonzero, the printed label will be\n\
3945 switched to a floating-point representation when the number of\n\
3946 digits exceeds digmax.\n\
3947\n\
3948 digits (PLINT, input) : Field digits value. Currently, changing\n\
3949 its value here has no effect since it is set only by plbox or\n\
3950 plbox3. However, the user may obtain its value after a call to\n\
3951 either of these functions by calling plgyax.\n\
3952";
3953static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
3954Get z axis parameters\n\
3955\n\
3956DESCRIPTION:\n\
3957\n\
3958 Identical to plgxax, except that arguments are flags for z axis. See\n\
3959 the description of plgxax for more detail.\n\
3960\n\
3961 Redacted form: plgzax(p_digmax, p_digits)\n\
3962\n\
3963 This function is used in example 31.\n\
3964\n\
3965\n\
3966\n\
3967SYNOPSIS:\n\
3968\n\
3969plgzax(p_digmax, p_digits)\n\
3970\n\
3971ARGUMENTS:\n\
3972\n\
3973 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
3974 number of digits for the z axis. If nonzero, the printed label\n\
3975 has been switched to a floating-point representation when the\n\
3976 number of digits exceeds this value.\n\
3977\n\
3978 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
3979 number of digits for the numeric labels (z axis) from the last\n\
3980 plot.\n\
3981";
3982static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
3983Set format of numerical label for contours\n\
3984\n\
3985DESCRIPTION:\n\
3986\n\
3987 Set format of numerical label for contours.\n\
3988\n\
3989 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
3990\n\
3991 This function is used example 9.\n\
3992\n\
3993\n\
3994\n\
3995SYNOPSIS:\n\
3996\n\
3997pl_setcontlabelformat(lexp, sigdig)\n\
3998\n\
3999ARGUMENTS:\n\
4000\n\
4001 lexp (PLINT, input) : If the contour numerical label is greater\n\
4002 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4003 format is used. Default value of lexp is 4.\n\
4004\n\
4005 sigdig (PLINT, input) : Number of significant digits. Default\n\
4006 value is 2.\n\
4007";
4008static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
4009Set pen width\n\
4010\n\
4011DESCRIPTION:\n\
4012\n\
4013 Sets the pen width.\n\
4014\n\
4015 Redacted form: plwidth(width)\n\
4016\n\
4017 This function is used in examples 1 and 2.\n\
4018\n\
4019\n\
4020\n\
4021SYNOPSIS:\n\
4022\n\
4023plwidth(width)\n\
4024\n\
4025ARGUMENTS:\n\
4026\n\
4027 width (PLFLT, input) : The desired pen width. If width is negative\n\
4028 or the same as the previous value no action is taken. width = 0.\n\
4029 should be interpreted as as the minimum valid pen width for the\n\
4030 device. The interpretation of positive width values is also\n\
4031 device dependent.\n\
4032";
4033static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
4034Get parameters that define current plot-space window\n\
4035\n\
4036DESCRIPTION:\n\
4037\n\
4038 Get relative minima and maxima that define current plot-space window.\n\
4039 If plsdiplt has not been called the default values pointed to by\n\
4040 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4041\n\
4042 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4043\n\
4044 This function is used in example 31.\n\
4045\n\
4046\n\
4047\n\
4048SYNOPSIS:\n\
4049\n\
4050plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4051\n\
4052ARGUMENTS:\n\
4053\n\
4054 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4055 minimum in x.\n\
4056\n\
4057 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4058 minimum in y.\n\
4059\n\
4060 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4061 maximum in x.\n\
4062\n\
4063 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4064 maximum in y.\n\
4065";
4066static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
4067Set the cmap1 argument range for continuous color plots\n\
4068\n\
4069DESCRIPTION:\n\
4070\n\
4071 Set the cmap1 argument range for continuous color plots that\n\
4072 corresponds to the range of data values. The maximum range\n\
4073 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4074 the cmap1 argument range that is specified with this routine, the\n\
4075 smaller the subset of the cmap1 color palette that is used to\n\
4076 represent the continuous data being plotted. If\n\
4077 min_color is greater than\n\
4078 max_color or\n\
4079 max_color is greater than 1.0 or\n\
4080 min_color is less than 0.0 then no change is made to the cmap1\n\
4081 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4082\n\
4083 Redacted form: plscmap1_range(min_color, max_color)\n\
4084\n\
4085 This function is currently used in example 33.\n\
4086\n\
4087\n\
4088\n\
4089SYNOPSIS:\n\
4090\n\
4091plscmap1_range(min_color, max_color)\n\
4092\n\
4093ARGUMENTS:\n\
4094\n\
4095 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4096 than 0.0, then 0.0 is used instead.\n\
4097\n\
4098 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4099 than 1.0, then 1.0 is used instead.\n\
4100";
4101static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
4102Select standard viewport\n\
4103\n\
4104DESCRIPTION:\n\
4105\n\
4106 Selects the largest viewport within the subpage that leaves a standard\n\
4107 margin (left-hand margin of eight character heights, and a margin\n\
4108 around the other three sides of five character heights).\n\
4109\n\
4110 Redacted form: plvsta()\n\
4111\n\
4112 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4113\n\
4114\n\
4115\n\
4116SYNOPSIS:\n\
4117\n\
4118plvsta()\n\
4119";
4120static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
4121Load Hershey fonts\n\
4122\n\
4123DESCRIPTION:\n\
4124\n\
4125 Loads the Hershey fonts used for text and symbols. This routine may\n\
4126 be called before or after initializing PLplot. If not explicitly\n\
4127 called before PLplot initialization, then by default that\n\
4128 initialization loads Hershey fonts with the extended character set.\n\
4129 This routine only has a practical effect for devices that still use\n\
4130 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4131 system fonts instead of Hershey fonts).\n\
4132\n\
4133 Redacted form: plfontld(fnt)\n\
4134\n\
4135 This function is used in examples 1 and 7.\n\
4136\n\
4137\n\
4138\n\
4139SYNOPSIS:\n\
4140\n\
4141plfontld(fnt)\n\
4142\n\
4143ARGUMENTS:\n\
4144\n\
4145 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4146 A zero value specifies Hershey fonts with the standard character\n\
4147 set and a non-zero value (the default assumed if plfontld is never\n\
4148 called) specifies Hershey fonts with the extended character set.\n\
4149";
4150static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
4151Draw error bars in x direction\n\
4152\n\
4153DESCRIPTION:\n\
4154\n\
4155 Draws a set of n error bars in x direction, the i\'th error bar\n\
4156 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4157 of the error bars are of length equal to the minor tick length\n\
4158 (settable using plsmin).\n\
4159\n\
4160 Redacted form: General: plerrx(xmin, ymax, y)\n\
4161\n\
4162\n\
4163 This function is used in example 29.\n\
4164\n\
4165\n\
4166\n\
4167SYNOPSIS:\n\
4168\n\
4169plerrx(n, xmin, xmax, y)\n\
4170\n\
4171ARGUMENTS:\n\
4172\n\
4173 n (PLINT, input) : Number of error bars to draw.\n\
4174\n\
4175 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4176 of the left-hand endpoints of the error bars.\n\
4177\n\
4178 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4179 of the right-hand endpoints of the error bars.\n\
4180\n\
4181 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4182 the error bars.\n\
4183";
4184static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
4185Plot shaded 3-d surface plot\n\
4186\n\
4187DESCRIPTION:\n\
4188\n\
4189 Plots a three-dimensional shaded surface plot within the environment\n\
4190 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4191 z[\n\
4192 nx][\n\
4193 ny], the point z[i][j] being the value of the function at (\n\
4194 x[i],\n\
4195 y[j]). Note that the points in vectors x and y do not need to be\n\
4196 equally spaced, but must be stored in ascending order. For further\n\
4197 details see the PLplot documentation.\n\
4198\n\
4199 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4200\n\
4201 This function is not used in any examples.\n\
4202\n\
4203\n\
4204\n\
4205SYNOPSIS:\n\
4206\n\
4207plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4208\n\
4209ARGUMENTS:\n\
4210\n\
4211 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4212 which the function is evaluated.\n\
4213\n\
4214 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4215 which the function is evaluated.\n\
4216\n\
4217 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4218 plot. Should have dimensions of\n\
4219 nx by\n\
4220 ny.\n\
4221\n\
4222 nx (PLINT, input) : Number of x values at which function is\n\
4223 evaluated.\n\
4224\n\
4225 ny (PLINT, input) : Number of y values at which function is\n\
4226 evaluated.\n\
4227\n\
4228 opt (PLINT, input) : Determines the way in which the surface is\n\
4229 represented. To specify more than one option just add the options,\n\
4230 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4231 connecting points at which function is defined.\n\
4232 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4233 using parameters\n\
4234 nlevel and\n\
4235 clevel.\n\
4236 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4237 using parameters\n\
4238 nlevel and\n\
4239 clevel.\n\
4240 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4241 the borders of the plotted function.\n\
4242 opt=MAG_COLOR : the surface is colored according to the value\n\
4243 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4244 according to the intensity of the reflected light in the\n\
4245 surface from a light source whose position is set using\n\
4246 pllightsource.\n\
4247\n\
4248\n\
4249 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4250 levels.\n\
4251\n\
4252 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4253";
4254static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
4255Get the current library version number\n\
4256\n\
4257DESCRIPTION:\n\
4258\n\
4259 Get the current library version number. Note: you must have allocated\n\
4260 space for this (80 characters is safe).\n\
4261\n\
4262 Redacted form: plgver(p_ver)\n\
4263\n\
4264 This function is used in example 1.\n\
4265\n\
4266\n\
4267\n\
4268SYNOPSIS:\n\
4269\n\
4270plgver(p_ver)\n\
4271\n\
4272ARGUMENTS:\n\
4273\n\
4274 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4275 (with preallocated length of 80 characters or more) containing the\n\
4276 PLplot version number.\n\
4277";
4278static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
4279End plotting session for current stream\n\
4280\n\
4281DESCRIPTION:\n\
4282\n\
4283 Ends a plotting session for the current output stream only. See\n\
4284 plsstrm for more info.\n\
4285\n\
4286 Redacted form: plend1()\n\
4287\n\
4288 This function is used in examples 1 and 20.\n\
4289\n\
4290\n\
4291\n\
4292SYNOPSIS:\n\
4293\n\
4294plend1()\n\
4295";
4296static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
4297Draw error bars in the y direction\n\
4298\n\
4299DESCRIPTION:\n\
4300\n\
4301 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4302 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4303 of the error bars are of length equal to the minor tick length\n\
4304 (settable using plsmin).\n\
4305\n\
4306 Redacted form: General: plerry(x, ymin, ymax)\n\
4307\n\
4308\n\
4309 This function is used in example 29.\n\
4310\n\
4311\n\
4312\n\
4313SYNOPSIS:\n\
4314\n\
4315plerry(n, x, ymin, ymax)\n\
4316\n\
4317ARGUMENTS:\n\
4318\n\
4319 n (PLINT, input) : Number of error bars to draw.\n\
4320\n\
4321 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4322 the error bars.\n\
4323\n\
4324 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4325 of the lower endpoints of the error bars.\n\
4326\n\
4327 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4328 of the upper endpoints of the error bars.\n\
4329";
4330static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
4331Set seed for internal random number generator.\n\
4332\n\
4333DESCRIPTION:\n\
4334\n\
4335 Set the seed for the internal random number generator. See plrandd for\n\
4336 further details.\n\
4337\n\
4338 Redacted form: plseed(seed)\n\
4339\n\
4340 This function is used in example 21.\n\
4341\n\
4342\n\
4343\n\
4344SYNOPSIS:\n\
4345\n\
4346plseed(seed)\n\
4347\n\
4348ARGUMENTS:\n\
4349\n\
4350 seed (unsigned int, input) : Seed for random number generator.\n\
4351";
4352static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4353Specify viewport using normalized subpage coordinates\n\
4354\n\
4355DESCRIPTION:\n\
4356\n\
4357 Device-independent routine for setting up the viewport. This defines\n\
4358 the viewport in terms of normalized subpage coordinates which run from\n\
4359 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4360 current subpage. Use the alternate routine plsvpa in order to create\n\
4361 a viewport of a definite size.\n\
4362\n\
4363 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4364\n\
4365 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4366 24, 26, 27, and 31.\n\
4367\n\
4368\n\
4369\n\
4370SYNOPSIS:\n\
4371\n\
4372plvpor(xmin, xmax, ymin, ymax)\n\
4373\n\
4374ARGUMENTS:\n\
4375\n\
4376 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4377 left-hand edge of the viewport.\n\
4378\n\
4379 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4380 right-hand edge of the viewport.\n\
4381\n\
4382 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4383 bottom edge of the viewport.\n\
4384\n\
4385 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4386 edge of the viewport.\n\
4387";
4388static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
4389Plot surface mesh\n\
4390\n\
4391DESCRIPTION:\n\
4392\n\
4393 Plots a surface mesh within the environment set up by plw3d. The\n\
4394 surface is defined by the matrix z[\n\
4395 nx][\n\
4396 ny] , the point z[i][j] being the value of the function at (\n\
4397 x[i],\n\
4398 y[j]). Note that the points in vectors x and y do not need to be\n\
4399 equally spaced, but must be stored in ascending order. The parameter\n\
4400 opt controls the way in which the surface is displayed. For further\n\
4401 details see the PLplot documentation.\n\
4402\n\
4403 Redacted form: plmesh(x, y, z, opt)\n\
4404\n\
4405 This function is used in example 11.\n\
4406\n\
4407\n\
4408\n\
4409SYNOPSIS:\n\
4410\n\
4411plmesh(x, y, z, nx, ny, opt)\n\
4412\n\
4413ARGUMENTS:\n\
4414\n\
4415 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4416 which the function is evaluated.\n\
4417\n\
4418 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4419 which the function is evaluated.\n\
4420\n\
4421 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4422 plot. Should have dimensions of\n\
4423 nx by\n\
4424 ny.\n\
4425\n\
4426 nx (PLINT, input) : Number of x values at which function has been\n\
4427 evaluated.\n\
4428\n\
4429 ny (PLINT, input) : Number of y values at which function has been\n\
4430 evaluated.\n\
4431\n\
4432 opt (PLINT, input) : Determines the way in which the surface is\n\
4433 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4434 function of x for each value of y[j] .\n\
4435 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4436 for each value of x[i] .\n\
4437 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4438 at which function is defined.\n\
4439";
4440static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
4441Get the cmap1 argument range for continuous color plots\n\
4442\n\
4443DESCRIPTION:\n\
4444\n\
4445 Get the cmap1 argument range for continuous color plots. (Use\n\
4446 plscmap1_range to set the cmap1 argument range.)\n\
4447\n\
4448 Redacted form: plgcmap1_range(min_color, max_color)\n\
4449\n\
4450 This function is currently not used in any example.\n\
4451\n\
4452\n\
4453\n\
4454SYNOPSIS:\n\
4455\n\
4456plgcmap1_range(min_color, max_color)\n\
4457\n\
4458ARGUMENTS:\n\
4459\n\
4460 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4461 minimum cmap1 argument.\n\
4462\n\
4463 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4464 maximum cmap1 argument.\n\
4465";
4466static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4467Set arrow style for vector plots\n\
4468\n\
4469DESCRIPTION:\n\
4470\n\
4471 Set the style for the arrow used by plvect to plot vectors.\n\
4472\n\
4473 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4474\n\
4475 This function is used in example 22.\n\
4476\n\
4477\n\
4478\n\
4479SYNOPSIS:\n\
4480\n\
4481plsvect(arrowx, arrowy, npts, fill)\n\
4482\n\
4483ARGUMENTS:\n\
4484\n\
4485 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4486 the x and y points which make up the arrow. The arrow is plotted\n\
4487 by joining these points to form a polygon. The scaling assumes\n\
4488 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4489 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4490 will be reset to its default.\n\
4491\n\
4492 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4493 arrowy.\n\
4494\n\
4495 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4496 fill is false then the arrow is open.\n\
4497";
4498static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4499Draw filled polygon\n\
4500\n\
4501DESCRIPTION:\n\
4502\n\
4503 Fills the polygon defined by the n points (\n\
4504 x[i],\n\
4505 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4506 style is a solid fill. The routine will automatically close the\n\
4507 polygon between the last and first vertices. If multiple closed\n\
4508 polygons are passed in x and y then plfill will fill in between them.\n\
4509\n\
4510 Redacted form: plfill(x,y)\n\
4511\n\
4512 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4513\n\
4514\n\
4515\n\
4516SYNOPSIS:\n\
4517\n\
4518plfill(n, x, y)\n\
4519\n\
4520ARGUMENTS:\n\
4521\n\
4522 n (PLINT, input) : Number of vertices in polygon.\n\
4523\n\
4524 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4525 vertices.\n\
4526\n\
4527 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4528 vertices.\n\
4529";
4530static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
4531Convert HLS color to RGB\n\
4532\n\
4533DESCRIPTION:\n\
4534\n\
4535 Convert HLS color coordinates to RGB.\n\
4536\n\
4537 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4538\n\
4539\n\
4540 This function is used in example 2.\n\
4541\n\
4542\n\
4543\n\
4544SYNOPSIS:\n\
4545\n\
4546plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4547\n\
4548ARGUMENTS:\n\
4549\n\
4550 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4551 cylinder.\n\
4552\n\
4553 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4554 the axis of the color cylinder.\n\
4555\n\
4556 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4557 the radius of the color cylinder.\n\
4558\n\
4559 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4560 (0.0-1.0) of the color.\n\
4561\n\
4562 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4563 intensity (0.0-1.0) of the color.\n\
4564\n\
4565 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4566 intensity (0.0-1.0) of the color.\n\
4567";
4568static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
4569Set format for date / time labels\n\
4570\n\
4571DESCRIPTION:\n\
4572\n\
4573 Sets the format for date / time labels. To enable date / time format\n\
4574 labels see the options to plbox, plbox3, and plenv.\n\
4575\n\
4576 Redacted form: pltimefmt(fmt)\n\
4577\n\
4578 This function is used in example 29.\n\
4579\n\
4580\n\
4581\n\
4582SYNOPSIS:\n\
4583\n\
4584pltimefmt(fmt)\n\
4585\n\
4586ARGUMENTS:\n\
4587\n\
4588 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4589 interpreted similarly to the format specifier of typical system\n\
4590 strftime routines except that PLplot ignores locale and also\n\
4591 supplies some useful extensions in the context of plotting. All\n\
4592 text in the string is printed as-is other than conversion\n\
4593 specifications which take the form of a \'%\' character followed by\n\
4594 further conversion specification character. The conversion\n\
4595 specifications which are similar to those provided by system\n\
4596 strftime routines are the following: %a: The abbreviated (English)\n\
4597 weekday name.\n\
4598 %A: The full (English) weekday name.\n\
4599 %b: The abbreviated (English) month name.\n\
4600 %B: The full (English) month name.\n\
4601 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4602 %C: The century number (year/100) as a 2-digit integer.\n\
4603 %d: The day of the month as a decimal number (range 01 to 31).\n\
4604 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4605 %e: Like %d, but a leading zero is replaced by a space.\n\
4606 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4607 %h: Equivalent to %b.\n\
4608 %H: The hour as a decimal number using a 24-hour clock (range\n\
4609 00 to 23).\n\
4610 %I: The hour as a decimal number using a 12-hour clock (range\n\
4611 01 to 12).\n\
4612 %j: The day of the year as a decimal number (range 001 to\n\
4613 366).\n\
4614 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4615 23); single digits are preceded by a blank. (See also %H.)\n\
4616 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4617 12); single digits are preceded by a blank. (See also %I.)\n\
4618 %m: The month as a decimal number (range 01 to 12).\n\
4619 %M: The minute as a decimal number (range 00 to 59).\n\
4620 %n: A newline character.\n\
4621 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4622 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4623 %r: Equivalent to %I:%M:%S %p.\n\
4624 %R: The time in 24-hour notation (%H:%M). For a version\n\
4625 including the seconds, see %T below.\n\
4626 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4627 +0000 (UTC).\n\
4628 %S: The second as a decimal number (range 00 to 60). (The\n\
4629 range is up to 60 to allow for occasional leap seconds.)\n\
4630 %t: A tab character.\n\
4631 %T: The time in 24-hour notation (%H:%M:%S).\n\
4632 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4633 being 1. See also %w.\n\
4634 %U: The week number of the current year as a decimal number,\n\
4635 range 00 to 53, starting with the first Sunday as the first\n\
4636 day of week 01. See also %V and %W.\n\
4637 %v: Equivalent to %e-%b-%Y.\n\
4638 %V: The ISO 8601 week number of the current year as a decimal\n\
4639 number, range 01 to 53, where week 1 is the first week that\n\
4640 has at least 4 days in the new year. See also %U and %W.\n\
4641 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4642 being 0. See also %u.\n\
4643 %W: The week number of the current year as a decimal number,\n\
4644 range 00 to 53, starting with the first Monday as the first\n\
4645 day of week 01.\n\
4646 %x: Equivalent to %a %b %d %Y.\n\
4647 %X: Equivalent to %T.\n\
4648 %y: The year as a decimal number without a century (range 00\n\
4649 to 99).\n\
4650 %Y: The year as a decimal number including a century.\n\
4651 %z: The UTC time-zone string = \"+0000\".\n\
4652 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4653 %+: The UTC date and time in default format of the Unix date\n\
4654 command which is equivalent to %a %b %d %T %Z %Y.\n\
4655 %%: A literal \"%\" character.\n\
4656 The conversion specifications which are extensions to those normally\n\
4657 provided by system strftime routines are the following: %(0-9):\n\
4658 The fractional part of the seconds field (including leading\n\
4659 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4660 seconds to millisecond accuracy (00.000).\n\
4661 %.: The fractional part of the seconds field (including\n\
4662 leading decimal point) to the maximum available accuracy. Thus\n\
4663 %S%. would give seconds with fractional part up to 9 decimal\n\
4664 places if available.\n\
4665";
4666static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
4667Get current subpage parameters\n\
4668\n\
4669DESCRIPTION:\n\
4670\n\
4671 Gets the size of the current subpage in millimeters measured from the\n\
4672 bottom left hand corner of the output device page or screen. Can be\n\
4673 used in conjunction with plsvpa for setting the size of a viewport in\n\
4674 absolute coordinates (millimeters).\n\
4675\n\
4676 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4677\n\
4678 This function is used in example 23.\n\
4679\n\
4680\n\
4681\n\
4682SYNOPSIS:\n\
4683\n\
4684plgspa(xmin, xmax, ymin, ymax)\n\
4685\n\
4686ARGUMENTS:\n\
4687\n\
4688 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4689 the left hand edge of the subpage in millimeters.\n\
4690\n\
4691 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4692 the right hand edge of the subpage in millimeters.\n\
4693\n\
4694 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4695 the bottom edge of the subpage in millimeters.\n\
4696\n\
4697 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4698 the top edge of the subpage in millimeters.\n\
4699";
4700static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
4701Calculate world coordinates and corresponding window index from relative device coordinates\n\
4702\n\
4703DESCRIPTION:\n\
4704\n\
4705 Calculate world coordinates, wx and wy, and corresponding window index\n\
4706 from relative device coordinates, rx and ry.\n\
4707\n\
4708 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4709\n\
4710\n\
4711 This function is used in example 31.\n\
4712\n\
4713\n\
4714\n\
4715SYNOPSIS:\n\
4716\n\
4717plcalc_world(rx, ry, wx, wy, window)\n\
4718\n\
4719ARGUMENTS:\n\
4720\n\
4721 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4722 the x coordinate.\n\
4723\n\
4724 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4725 the y coordinate.\n\
4726\n\
4727 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4728 coordinate corresponding to the relative device coordinates rx and\n\
4729 ry.\n\
4730\n\
4731 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4732 coordinate corresponding to the relative device coordinates rx and\n\
4733 ry.\n\
4734\n\
4735 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4736 defined window index that corresponds to the input relative device\n\
4737 coordinates (and the returned world coordinates). To give some\n\
4738 background on the window index, for each page the initial window\n\
4739 index is set to zero, and each time plwind is called within the\n\
4740 page, world and device coordinates are stored for the window and\n\
4741 the window index is incremented. Thus, for a simple page layout\n\
4742 with non-overlapping viewports and one window per viewport, window\n\
4743 corresponds to the viewport index (in the order which the\n\
4744 viewport/windows were created) of the only viewport/window\n\
4745 corresponding to rx and ry. However, for more complicated layouts\n\
4746 with potentially overlapping viewports and possibly more than one\n\
4747 window (set of world coordinates) per viewport, window and the\n\
4748 corresponding output world coordinates corresponds to the last\n\
4749 window created that fulfills the criterion that the relative\n\
4750 device coordinates are inside it. Finally, in all cases where the\n\
4751 input relative device coordinates are not inside any\n\
4752 viewport/window, then the returned value of the last defined\n\
4753 window index is set to -1.\n\
4754";
4755static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
4756Get output file name\n\
4757\n\
4758DESCRIPTION:\n\
4759\n\
4760 Gets the current output file name, if applicable.\n\
4761\n\
4762 Redacted form: plgfnam(fnam)\n\
4763\n\
4764 This function is used in example 31.\n\
4765\n\
4766\n\
4767\n\
4768SYNOPSIS:\n\
4769\n\
4770plgfnam(fnam)\n\
4771\n\
4772ARGUMENTS:\n\
4773\n\
4774 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4775 (with preallocated length of 80 characters or more) containing the\n\
4776 file name.\n\
4777";
4778static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
4779Vector plot\n\
4780\n\
4781DESCRIPTION:\n\
4782\n\
4783 Draws a plot of vector data contained in the matrices (\n\
4784 u[\n\
4785 nx][\n\
4786 ny],\n\
4787 v[\n\
4788 nx][\n\
4789 ny]) . The scaling factor for the vectors is given by scale. A\n\
4790 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4791 additional data required by the transformation routine to map indices\n\
4792 within the matrices to the world coordinates. The style of the vector\n\
4793 arrow may be set using plsvect.\n\
4794\n\
4795 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4796 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4797 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4798 with either one or two dimensions.\n\
4799\n\
4800 This function is used in example 22.\n\
4801\n\
4802\n\
4803\n\
4804SYNOPSIS:\n\
4805\n\
4806plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4807\n\
4808ARGUMENTS:\n\
4809\n\
4810 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4811 and y components of the vector data to be plotted.\n\
4812\n\
4813 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4814\n\
4815 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4816 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4817 automatically calculated for the data. If scale < 0 then the\n\
4818 scaling factor is automatically calculated for the data and then\n\
4819 multiplied by -\n\
4820 scale. If scale > 0 then the scaling factor is set to scale.\n\
4821\n\
4822 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4823 defines the transformation between the zero-based indices of the\n\
4824 matrices u and v and world coordinates.For the C case,\n\
4825 transformation functions are provided in the PLplot library: pltr0\n\
4826 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4827 mappings respectively defined by vectors and matrices. In\n\
4828 addition, C callback routines for the transformation can be\n\
4829 supplied by the user such as the mypltr function in\n\
4830 examples/c/x09c.c which provides a general linear transformation\n\
4831 between index coordinates and world coordinates.For languages\n\
4832 other than C you should consult the PLplot documentation for the\n\
4833 details concerning how PLTRANSFORM_callback arguments are\n\
4834 interfaced. However, in general, a particular pattern of\n\
4835 callback-associated arguments such as a tr vector with 6 elements;\n\
4836 xg and yg vectors; or xg and yg matrices are respectively\n\
4837 interfaced to a linear-transformation routine similar to the above\n\
4838 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4839 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4840 support native language callbacks for handling index to\n\
4841 world-coordinate transformations. Examples of these various\n\
4842 approaches are given in examples/<language>x09*,\n\
4843 examples/<language>x16*, examples/<language>x20*,\n\
4844 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4845 supported languages.\n\
4846\n\
4847 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4848 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4849 that is externally supplied.\n\
4850";
4851static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
4852Plot a glyph at the specified points\n\
4853\n\
4854DESCRIPTION:\n\
4855\n\
4856 Plot a glyph at the specified points. (This function is largely\n\
4857 superseded by plstring which gives access to many[!] more glyphs.)\n\
4858\n\
4859 Redacted form: plsym(x, y, code)\n\
4860\n\
4861 This function is used in example 7.\n\
4862\n\
4863\n\
4864\n\
4865SYNOPSIS:\n\
4866\n\
4867plsym(n, x, y, code)\n\
4868\n\
4869ARGUMENTS:\n\
4870\n\
4871 n (PLINT, input) : Number of points in the x and y vectors.\n\
4872\n\
4873 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4874 the points.\n\
4875\n\
4876 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4877 the points.\n\
4878\n\
4879 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4880 to be plotted at each of the n points.\n\
4881";
4882static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
4883Get viewport limits in normalized device coordinates\n\
4884\n\
4885DESCRIPTION:\n\
4886\n\
4887 Get viewport limits in normalized device coordinates.\n\
4888\n\
4889 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4890\n\
4891\n\
4892 This function is used in example 31.\n\
4893\n\
4894\n\
4895\n\
4896SYNOPSIS:\n\
4897\n\
4898plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4899\n\
4900ARGUMENTS:\n\
4901\n\
4902 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4903 viewport limit of the normalized device coordinate in x.\n\
4904\n\
4905 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4906 viewport limit of the normalized device coordinate in x.\n\
4907\n\
4908 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4909 viewport limit of the normalized device coordinate in y.\n\
4910\n\
4911 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4912 viewport limit of the normalized device coordinate in y.\n\
4913";
4914static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
4915Get page parameters\n\
4916\n\
4917DESCRIPTION:\n\
4918\n\
4919 Gets the current page configuration. The length and offset values are\n\
4920 expressed in units that are specific to the current driver. For\n\
4921 instance: screen drivers will usually interpret them as number of\n\
4922 pixels, whereas printer drivers will usually use mm.\n\
4923\n\
4924 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4925\n\
4926 This function is used in examples 14 and 31.\n\
4927\n\
4928\n\
4929\n\
4930SYNOPSIS:\n\
4931\n\
4932plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4933\n\
4934ARGUMENTS:\n\
4935\n\
4936 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4937 pixels/inch (DPI) in x.\n\
4938\n\
4939 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4940 pixels/inch (DPI) in y.\n\
4941\n\
4942 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4943 length.\n\
4944\n\
4945 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4946 length.\n\
4947\n\
4948 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4949 offset.\n\
4950\n\
4951 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4952 offset.\n\
4953";
4954static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
4955Plot a glyph at the specified 3D points\n\
4956\n\
4957DESCRIPTION:\n\
4958\n\
4959 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
4960 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
4961 this function similar to what is done for plline3. The glyph is\n\
4962 specified with a PLplot user string. Note that the user string is not\n\
4963 actually limited to one glyph so it is possible (but not normally\n\
4964 useful) to plot more than one glyph at the specified points with this\n\
4965 function. As with plmtex and plptex, the user string can contain FCI\n\
4966 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4967 else PLplot escapes for Hershey or unicode text to determine the\n\
4968 glyph.\n\
4969\n\
4970 Redacted form: plstring3(x, y, z, string)\n\
4971\n\
4972 This function is used in example 18.\n\
4973\n\
4974\n\
4975\n\
4976SYNOPSIS:\n\
4977\n\
4978plstring3(n, x, y, z, string)\n\
4979\n\
4980ARGUMENTS:\n\
4981\n\
4982 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
4983\n\
4984 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4985 the points.\n\
4986\n\
4987 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4988 the points.\n\
4989\n\
4990 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
4991 the points.\n\
4992\n\
4993 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4994 the glyph(s) to be plotted at each of the n points. points.\n\
4995";
4996static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
4997Shade regions on the basis of value\n\
4998\n\
4999DESCRIPTION:\n\
5000\n\
5001 Shade regions on the basis of value. This is the high-level routine\n\
5002 for making continuous color shaded plots with cmap1 while plshade\n\
5003 should be used to plot individual shaded regions using either cmap0 or\n\
5004 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5005 our supported languages.\n\
5006\n\
5007 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5008 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5009 pltr_data)\n\
5010\n\
5011\n\
5012 This function is used in examples 16, 21, and 22.\n\
5013\n\
5014\n\
5015\n\
5016SYNOPSIS:\n\
5017\n\
5018plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5019\n\
5020ARGUMENTS:\n\
5021\n\
5022 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5023 plot. Should have dimensions of\n\
5024 nx by\n\
5025 ny.\n\
5026\n\
5027 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5028\n\
5029 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5030\n\
5031 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5032 the region that should be plotted in the shade plot. This\n\
5033 function accepts x and y coordinates as input arguments and must\n\
5034 return 1 if the point is to be included in the shade plot and 0\n\
5035 otherwise. If you want to plot the entire shade plot (the usual\n\
5036 case), this argument should be set to NULL.\n\
5037\n\
5038 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5039 pltr below for how these arguments are used (only for the special case\n\
5040 when the callback function\n\
5041 pltr is not supplied).\n\
5042\n\
5043 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5044 corresponding to the edges of each shaded region that will be\n\
5045 plotted by this function. To work properly the levels should be\n\
5046 monotonic.\n\
5047\n\
5048 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5049 of shade edge values in clevel).\n\
5050\n\
5051 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5052 pattern.\n\
5053\n\
5054 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5055 contours defining edges of shaded regions. The pen color is only\n\
5056 temporary set for the contour drawing. Set this value to zero or\n\
5057 less if no shade edge contours are wanted.\n\
5058\n\
5059 cont_width (PLFLT, input) : Defines line width used for contours\n\
5060 defining edges of shaded regions. This value may not be honored\n\
5061 by all drivers. The pen width is only temporary set for the\n\
5062 contour drawing. Set this value to zero or less if no shade edge\n\
5063 contours are wanted.\n\
5064\n\
5065 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5066 region. Use plfill for this purpose.\n\
5067\n\
5068 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5069 map to rectangles after coordinate transformation with pltrl.\n\
5070 Otherwise, set rectangular to false. If rectangular is set to\n\
5071 true, plshade tries to save time by filling large rectangles.\n\
5072 This optimization fails if the coordinate transformation distorts\n\
5073 the shape of rectangles. For example a plot in polar coordinates\n\
5074 has to have rectangular set to false.\n\
5075\n\
5076 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5077 defines the transformation between the zero-based indices of the\n\
5078 matrix a and world coordinates. If\n\
5079 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5080 indices of a are mapped to the range\n\
5081 xmin through\n\
5082 xmax and the y indices of a are mapped to the range\n\
5083 ymin through\n\
5084 ymax.For the C case, transformation functions are provided in the\n\
5085 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5086 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5087 matrices. In addition, C callback routines for the transformation\n\
5088 can be supplied by the user such as the mypltr function in\n\
5089 examples/c/x09c.c which provides a general linear transformation\n\
5090 between index coordinates and world coordinates.For languages\n\
5091 other than C you should consult the PLplot documentation for the\n\
5092 details concerning how PLTRANSFORM_callback arguments are\n\
5093 interfaced. However, in general, a particular pattern of\n\
5094 callback-associated arguments such as a tr vector with 6 elements;\n\
5095 xg and yg vectors; or xg and yg matrices are respectively\n\
5096 interfaced to a linear-transformation routine similar to the above\n\
5097 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5098 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5099 support native language callbacks for handling index to\n\
5100 world-coordinate transformations. Examples of these various\n\
5101 approaches are given in examples/<language>x09*,\n\
5102 examples/<language>x16*, examples/<language>x20*,\n\
5103 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5104 supported languages.\n\
5105\n\
5106 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5107 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5108 externally supplied.\n\
5109";
5110static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
5111Set output file name\n\
5112\n\
5113DESCRIPTION:\n\
5114\n\
5115 Sets the current output file name, if applicable. If the file name\n\
5116 has not been specified and is required by the driver, the user will be\n\
5117 prompted for it. If using the X-windows output driver, this sets the\n\
5118 display name. This routine, if used, must be called before\n\
5119 initializing PLplot.\n\
5120\n\
5121 Redacted form: plsfnam(fnam)\n\
5122\n\
5123 This function is used in examples 1 and 20.\n\
5124\n\
5125\n\
5126\n\
5127SYNOPSIS:\n\
5128\n\
5129plsfnam(fnam)\n\
5130\n\
5131ARGUMENTS:\n\
5132\n\
5133 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5134 the file name.\n\
5135";
5136static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5137Contour plot\n\
5138\n\
5139DESCRIPTION:\n\
5140\n\
5141 Draws a contour plot of the data in f[\n\
5142 nx][\n\
5143 ny], using the nlevel contour levels specified by clevel. Only the\n\
5144 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5145 where all these index ranges are interpreted as one-based for\n\
5146 historical reasons. A transformation routine pointed to by pltr with\n\
5147 a generic pointer pltr_data for additional data required by the\n\
5148 transformation routine is used to map indices within the matrix to the\n\
5149 world coordinates.\n\
5150\n\
5151 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5152 where (see above discussion) the pltr, pltr_data callback arguments\n\
5153 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5154 vectors; or xg and yg matrices.\n\
5155\n\
5156 This function is used in examples 9, 14, 16, and 22.\n\
5157\n\
5158\n\
5159\n\
5160SYNOPSIS:\n\
5161\n\
5162plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5163\n\
5164ARGUMENTS:\n\
5165\n\
5166 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5167\n\
5168 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5169\n\
5170 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5171 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5172 zero-based for historical backwards-compatibility reasons.\n\
5173\n\
5174 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5175 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5176 zero-based for historical backwards-compatibility reasons.\n\
5177\n\
5178 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5179 which to draw contours.\n\
5180\n\
5181 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5182\n\
5183 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5184 defines the transformation between the zero-based indices of the\n\
5185 matrix f and the world coordinates.For the C case, transformation\n\
5186 functions are provided in the PLplot library: pltr0 for the\n\
5187 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5188 respectively defined by vectors and matrices. In addition, C\n\
5189 callback routines for the transformation can be supplied by the\n\
5190 user such as the mypltr function in examples/c/x09c.c which\n\
5191 provides a general linear transformation between index coordinates\n\
5192 and world coordinates.For languages other than C you should\n\
5193 consult the PLplot documentation for the details concerning how\n\
5194 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5195 general, a particular pattern of callback-associated arguments\n\
5196 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5197 yg matrices are respectively interfaced to a linear-transformation\n\
5198 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5199 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5200 the PLplot documentation) support native language callbacks for\n\
5201 handling index to world-coordinate transformations. Examples of\n\
5202 these various approaches are given in examples/<language>x09*,\n\
5203 examples/<language>x16*, examples/<language>x20*,\n\
5204 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5205 supported languages.\n\
5206\n\
5207 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5208 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5209 that is externally supplied.\n\
5210";
5211static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
5212Set parameters that define current plot-space window\n\
5213\n\
5214DESCRIPTION:\n\
5215\n\
5216 Set relative minima and maxima that define the current plot-space\n\
5217 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5218 xmax, and ymax are 0., 0., 1., and 1.\n\
5219\n\
5220 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5221\n\
5222 This function is used in example 31.\n\
5223\n\
5224\n\
5225\n\
5226SYNOPSIS:\n\
5227\n\
5228plsdiplt(xmin, ymin, xmax, ymax)\n\
5229\n\
5230ARGUMENTS:\n\
5231\n\
5232 xmin (PLFLT, input) : Relative minimum in x.\n\
5233\n\
5234 ymin (PLFLT, input) : Relative minimum in y.\n\
5235\n\
5236 xmax (PLFLT, input) : Relative maximum in x.\n\
5237\n\
5238 ymax (PLFLT, input) : Relative maximum in y.\n\
5239";
5240static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
5241Write text inside the viewport of a 3D plot\n\
5242\n\
5243DESCRIPTION:\n\
5244\n\
5245 Writes text at a specified position and inclination and with a\n\
5246 specified shear within the viewport. Text is clipped at the viewport\n\
5247 boundaries. The reference point of a string lies along a line passing\n\
5248 through the string at half the height of a capital letter. The\n\
5249 position of the reference point along this line is determined by just,\n\
5250 and the reference point is placed at world coordinates (\n\
5251 wx,\n\
5252 wy,\n\
5253 wz) within the viewport. The inclination and shear of the string is\n\
5254 specified in terms of differences of world coordinates making it easy\n\
5255 to write text parallel to a line in a graph.\n\
5256\n\
5257 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5258\n\
5259 This function is used in example 28.\n\
5260\n\
5261\n\
5262\n\
5263SYNOPSIS:\n\
5264\n\
5265plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5266\n\
5267ARGUMENTS:\n\
5268\n\
5269 wx (PLFLT, input) : x world coordinate of reference point of\n\
5270 string.\n\
5271\n\
5272 wy (PLFLT, input) : y world coordinate of reference point of\n\
5273 string.\n\
5274\n\
5275 wz (PLFLT, input) : z world coordinate of reference point of\n\
5276 string.\n\
5277\n\
5278 dx (PLFLT, input) : Together with dy and\n\
5279 dz , this specifies the inclination of the string. The baseline of\n\
5280 the string is parallel to a line joining (\n\
5281 x,\n\
5282 y,\n\
5283 z) to (\n\
5284 x+\n\
5285 dx,\n\
5286 y+\n\
5287 dy,\n\
5288 z+\n\
5289 dz) .\n\
5290\n\
5291 dy (PLFLT, input) : Together with dx and\n\
5292 dz, this specifies the inclination of the string.\n\
5293\n\
5294 dz (PLFLT, input) : Together with dx and\n\
5295 dy, this specifies the inclination of the string.\n\
5296\n\
5297 sx (PLFLT, input) : Together with sy and\n\
5298 sz , this specifies the shear of the string. The string is sheared so\n\
5299 that the characters are vertically parallel to a line joining (\n\
5300 x,\n\
5301 y,\n\
5302 z) to (\n\
5303 x+\n\
5304 sx,\n\
5305 y+\n\
5306 sy,\n\
5307 z+\n\
5308 sz) . If sx =\n\
5309 sy =\n\
5310 sz = 0.) then the text is not sheared.\n\
5311\n\
5312 sy (PLFLT, input) : Together with sx and\n\
5313 sz, this specifies shear of the string.\n\
5314\n\
5315 sz (PLFLT, input) : Together with sx and\n\
5316 sy, this specifies shear of the string.\n\
5317\n\
5318 just (PLFLT, input) : Specifies the position of the string relative\n\
5319 to its reference point. If just=0. , the reference point is at\n\
5320 the left and if just=1. , it is at the right of the string. Other\n\
5321 values of just give intermediate justifications.\n\
5322\n\
5323 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5324 written out.\n\
5325";
5326static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5327Plot continental outline or shapefile data in world coordinates\n\
5328\n\
5329DESCRIPTION:\n\
5330\n\
5331 Plots continental outlines or shapefile data in world coordinates. A\n\
5332 demonstration of how to use this function to create different\n\
5333 projections can be found in examples/c/x19c. PLplot is provided with\n\
5334 basic coastal outlines and USA state borders. To use the map\n\
5335 functionality PLplot must be compiled with the shapelib library.\n\
5336 Shapefiles have become a popular standard for geographical data and\n\
5337 data in this format can be easily found from a number of online\n\
5338 sources. Shapefile data is actually provided as three or more files\n\
5339 with the same filename, but different extensions. The .shp and .shx\n\
5340 files are required for plotting Shapefile data with PLplot.\n\
5341\n\
5342 PLplot currently supports the point, multipoint, polyline and polygon\n\
5343 objects within shapefiles. However holes in polygons are not\n\
5344 supported. When plmap is used the type of object is derived from the\n\
5345 shapefile, if you wish to override the type then use one of the other\n\
5346 plmap variants. The built in maps have line data only.\n\
5347\n\
5348 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5349\n\
5350 This function is used in example 19.\n\
5351\n\
5352\n\
5353\n\
5354SYNOPSIS:\n\
5355\n\
5356plmap(mapform, name, minx, maxx, miny, maxy)\n\
5357\n\
5358ARGUMENTS:\n\
5359\n\
5360 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5361 transform the original map data coordinates to a new coordinate\n\
5362 system. The PLplot-supplied map data is provided as latitudes and\n\
5363 longitudes; other Shapefile data may be provided in other\n\
5364 coordinate systems as can be found in their .prj plain text files.\n\
5365 For example, by using this transform we can change from a\n\
5366 longitude, latitude coordinate to a polar stereographic\n\
5367 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5368 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5369 corresponding y coordinates (latitudes for the PLplot supplied\n\
5370 data). After the call to mapform(), x[] and y[] should be\n\
5371 replaced by the corresponding plot coordinates. If no transform is\n\
5372 desired, mapform can be replaced by NULL.\n\
5373\n\
5374 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5375 the type of map plotted. This is either one of the PLplot built-in\n\
5376 maps or the file name of a set of Shapefile files without the file\n\
5377 extensions. For the PLplot built-in maps the possible values are:\n\
5378 \"globe\" -- continental outlines\n\
5379 \"usa\" -- USA and state boundaries\n\
5380 \"cglobe\" -- continental outlines and countries\n\
5381 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5382\n\
5383\n\
5384 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5385 drawn. The units must match the shapefile (built in maps are\n\
5386 degrees lat/lon). Objects in the file which do not encroach on the\n\
5387 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5388 note this is simply an optimisation, not a clipping so for objects\n\
5389 with some points inside the box and some points outside the box\n\
5390 all the points will be rendered. These parameters also define\n\
5391 latitude and longitude wrapping for shapefiles using these units.\n\
5392 Longitude points will be wrapped by integer multiples of 360\n\
5393 degrees to place them in the box. This allows the same data to be\n\
5394 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5395 you plot from -180-540 you will get two cycles of data drawn. The\n\
5396 value of minx must be less than the value of maxx. Passing in a\n\
5397 nan, max/-max floating point number or +/-infinity will case the\n\
5398 bounding box from the shapefile to be used.\n\
5399\n\
5400 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5401 drawn - see minx.\n\
5402\n\
5403 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5404 drawn - see minx.\n\
5405\n\
5406 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5407 drawn - see minx.\n\
5408";
5409static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5410Specify viewport using coordinates and aspect ratio\n\
5411\n\
5412DESCRIPTION:\n\
5413\n\
5414 Device-independent routine for setting up the viewport. The viewport\n\
5415 is chosen to be the largest with the given aspect ratio that fits\n\
5416 within the specified region (in terms of normalized subpage\n\
5417 coordinates). This routine is functionally equivalent to plvpor when\n\
5418 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5419 routine reserves no extra space at the edges for labels.\n\
5420\n\
5421 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5422\n\
5423 This function is used in example 9.\n\
5424\n\
5425\n\
5426\n\
5427SYNOPSIS:\n\
5428\n\
5429plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5430\n\
5431ARGUMENTS:\n\
5432\n\
5433 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5434 left-hand edge of the viewport.\n\
5435\n\
5436 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5437 right-hand edge of the viewport.\n\
5438\n\
5439 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5440 bottom edge of the viewport.\n\
5441\n\
5442 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5443 edge of the viewport.\n\
5444\n\
5445 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5446 axis.\n\
5447";
5448static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
5449Set the pause (on end-of-page) status\n\
5450\n\
5451DESCRIPTION:\n\
5452\n\
5453 Set the pause (on end-of-page) status.\n\
5454\n\
5455 Redacted form: plspause(pause)\n\
5456\n\
5457 This function is in examples 14,20.\n\
5458\n\
5459\n\
5460\n\
5461SYNOPSIS:\n\
5462\n\
5463plspause(pause)\n\
5464\n\
5465ARGUMENTS:\n\
5466\n\
5467 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5468 end-of-page for those drivers which support this. Otherwise there\n\
5469 is no pause.\n\
5470";
5471static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5472Plot 3-d surface plot\n\
5473\n\
5474DESCRIPTION:\n\
5475\n\
5476 Plots a three-dimensional surface plot within the environment set up\n\
5477 by plw3d. The surface is defined by the matrix z[\n\
5478 nx][\n\
5479 ny] , the point z[i][j] being the value of the function at (\n\
5480 x[i],\n\
5481 y[j]). Note that the points in vectors x and y do not need to be\n\
5482 equally spaced, but must be stored in ascending order. The parameter\n\
5483 opt controls the way in which the surface is displayed. For further\n\
5484 details see the PLplot documentation. The only difference between\n\
5485 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5486 while plot3d only draws the surface as viewed from the top.\n\
5487\n\
5488 Redacted form: plot3d(x, y, z, opt, side)\n\
5489\n\
5490 This function is used in examples 11 and 21.\n\
5491\n\
5492\n\
5493\n\
5494SYNOPSIS:\n\
5495\n\
5496plot3d(x, y, z, nx, ny, opt, side)\n\
5497\n\
5498ARGUMENTS:\n\
5499\n\
5500 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5501 which the function is evaluated.\n\
5502\n\
5503 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5504 which the function is evaluated.\n\
5505\n\
5506 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5507 plot. Should have dimensions of\n\
5508 nx by\n\
5509 ny.\n\
5510\n\
5511 nx (PLINT, input) : Number of x values at which function is\n\
5512 evaluated.\n\
5513\n\
5514 ny (PLINT, input) : Number of y values at which function is\n\
5515 evaluated.\n\
5516\n\
5517 opt (PLINT, input) : Determines the way in which the surface is\n\
5518 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5519 function of x for each value of y[j] .\n\
5520 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5521 for each value of x[i] .\n\
5522 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5523 at which function is defined.\n\
5524\n\
5525\n\
5526 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5527 should be draw on the figure. If side is true sides are drawn,\n\
5528 otherwise no sides are drawn.\n\
5529";
5530static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5531Copy state parameters from the reference stream to the current stream\n\
5532\n\
5533DESCRIPTION:\n\
5534\n\
5535 Copies state parameters from the reference stream to the current\n\
5536 stream. Tell driver interface to map device coordinates unless flags\n\
5537 == 1.\n\
5538\n\
5539 This function is used for making save files of selected plots (e.g.\n\
5540 from the TK driver). After initializing, you can get a copy of the\n\
5541 current plot to the specified device by switching to this stream and\n\
5542 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5543 appropriate. The plot buffer must have previously been enabled (done\n\
5544 automatically by some display drivers, such as X).\n\
5545\n\
5546 Redacted form: plcpstrm(iplsr, flags)\n\
5547\n\
5548 This function is used in example 1,20.\n\
5549\n\
5550\n\
5551\n\
5552SYNOPSIS:\n\
5553\n\
5554plcpstrm(iplsr, flags)\n\
5555\n\
5556ARGUMENTS:\n\
5557\n\
5558 iplsr (PLINT, input) : Number of reference stream.\n\
5559\n\
5560 flags (PLBOOL, input) : If flags is set to true the device\n\
5561 coordinates are not copied from the reference to current stream.\n\
5562";
5563static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5564Set page parameters\n\
5565\n\
5566DESCRIPTION:\n\
5567\n\
5568 Sets the page configuration (optional). If an individual parameter is\n\
5569 zero then that parameter value is not updated. Not all parameters are\n\
5570 recognized by all drivers and the interpretation is device-dependent.\n\
5571 The X-window driver uses the length and offset parameters to determine\n\
5572 the window size and location. The length and offset values are\n\
5573 expressed in units that are specific to the current driver. For\n\
5574 instance: screen drivers will usually interpret them as number of\n\
5575 pixels, whereas printer drivers will usually use mm.\n\
5576\n\
5577 This routine, if used, must be called before initializing PLplot. It\n\
5578 may be called at later times for interactive drivers to change only\n\
5579 the dpi for subsequent redraws which you can force via a call to\n\
5580 plreplot. If this function is not called then the page size defaults\n\
5581 to landscape A4 for drivers which use real world page sizes and 744\n\
5582 pixels wide by 538 pixels high for raster drivers. The default value\n\
5583 for dx and dy is 90 pixels per inch for raster drivers.\n\
5584\n\
5585\n\
5586\n\
5587 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5588\n\
5589 This function is used in examples 14 and 31.\n\
5590\n\
5591\n\
5592\n\
5593SYNOPSIS:\n\
5594\n\
5595plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5596\n\
5597ARGUMENTS:\n\
5598\n\
5599 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5600 by raster drivers, ignored by drivers which use \"real world\" units\n\
5601 (e.g. mm).\n\
5602\n\
5603 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5604 by raster drivers, ignored by drivers which use \"real world\" units\n\
5605 (e.g. mm).\n\
5606\n\
5607 xleng (PLINT, input) : Page length, x.\n\
5608\n\
5609 yleng (PLINT, input) : Page length, y.\n\
5610\n\
5611 xoff (PLINT, input) : Page offset, x.\n\
5612\n\
5613 yoff (PLINT, input) : Page offset, y.\n\
5614";
5615static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
5616Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5617\n\
5618DESCRIPTION:\n\
5619\n\
5620 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5621 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5622 Values are negative if an invalid color id is given.\n\
5623\n\
5624 Redacted form: plgcola(r, g, b)\n\
5625\n\
5626 This function is used in example 30.\n\
5627\n\
5628\n\
5629\n\
5630SYNOPSIS:\n\
5631\n\
5632plgcol0a(icol0, r, g, b, alpha)\n\
5633\n\
5634ARGUMENTS:\n\
5635\n\
5636 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5637\n\
5638 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5639 in the range from 0 to 255.\n\
5640\n\
5641 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5642 in the range from 0 to 255.\n\
5643\n\
5644 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5645 in the range from 0 to 255.\n\
5646\n\
5647 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5648 transparency in the range from (0.0-1.0).\n\
5649";
5650static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
5651Returns 8-bit RGB values for given color index from cmap0\n\
5652\n\
5653DESCRIPTION:\n\
5654\n\
5655 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5656 PLplot documentation). Values are negative if an invalid color id is\n\
5657 given.\n\
5658\n\
5659 Redacted form: plgcol0(icol0, r, g, b)\n\
5660\n\
5661 This function is used in example 2.\n\
5662\n\
5663\n\
5664\n\
5665SYNOPSIS:\n\
5666\n\
5667plgcol0(icol0, r, g, b)\n\
5668\n\
5669ARGUMENTS:\n\
5670\n\
5671 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5672\n\
5673 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5674 value.\n\
5675\n\
5676 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5677 value.\n\
5678\n\
5679 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5680 value.\n\
5681";
5682static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
5683Set parameters incrementally (zoom mode) that define current plot-space window\n\
5684\n\
5685DESCRIPTION:\n\
5686\n\
5687 Set relative minima and maxima incrementally (zoom mode) that define\n\
5688 the current plot-space window. This function has the same effect as\n\
5689 plsdiplt if that function has not been previously called. Otherwise,\n\
5690 this function implements zoom mode using the transformation min_used =\n\
5691 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5692 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5693 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5694\n\
5695 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5696\n\
5697 This function is used in example 31.\n\
5698\n\
5699\n\
5700\n\
5701SYNOPSIS:\n\
5702\n\
5703plsdiplz(xmin, ymin, xmax, ymax)\n\
5704\n\
5705ARGUMENTS:\n\
5706\n\
5707 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5708\n\
5709 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5710\n\
5711 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5712\n\
5713 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5714";
5715static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
5716Plot all or a subset of Shapefile data, filling the polygons\n\
5717\n\
5718DESCRIPTION:\n\
5719\n\
5720 As per plmapline, however the items are filled in the same way as\n\
5721 plfill.\n\
5722\n\
5723 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5724 plotentries)\n\
5725\n\
5726 This function is used in example 19.\n\
5727\n\
5728\n\
5729\n\
5730SYNOPSIS:\n\
5731\n\
5732plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5733\n\
5734ARGUMENTS:\n\
5735\n\
5736 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5737 transform the coordinates given in the shapefile into a plot\n\
5738 coordinate system. By using this transform, we can change from a\n\
5739 longitude, latitude coordinate to a polar stereographic project,\n\
5740 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5741 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5742 mapform(), x[] and y[] should be replaced by the corresponding\n\
5743 plot coordinates. If no transform is desired, mapform can be\n\
5744 replaced by NULL.\n\
5745\n\
5746 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5747 the file name of a set of Shapefile files without the file\n\
5748 extension.\n\
5749\n\
5750 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5751 be in the same units as used by the Shapefile. You could use a\n\
5752 very large negative number to plot everything, but you can improve\n\
5753 performance by limiting the area drawn. The units must match those\n\
5754 of the Shapefile projection, which may be for example longitude or\n\
5755 distance. The value of minx must be less than the value of maxx.\n\
5756\n\
5757 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5758 use a very large number to plot everything, but you can improve\n\
5759 performance by limiting the area drawn.\n\
5760\n\
5761 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5762 be in the same units as used by the Shapefile. You could use a\n\
5763 very large negative number to plot everything, but you can improve\n\
5764 performance by limiting the area drawn. The units must match those\n\
5765 of the Shapefile projection, which may be for example latitude or\n\
5766 distance. The value of miny must be less than the value of maxy.\n\
5767\n\
5768 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5769 use a very large number to plot everything, but you can improve\n\
5770 performance by limiting the area drawn.\n\
5771\n\
5772 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5773 zero-based indices of the Shapefile elements which will be drawn.\n\
5774 Setting\n\
5775 plotentries to NULL will plot all elements of the Shapefile.\n\
5776\n\
5777 nplotentries (PLINT, input) : The number of items in\n\
5778 plotentries. Ignored if\n\
5779 plotentries is NULL.\n\
5780";
5781static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
5782Draw a line\n\
5783\n\
5784DESCRIPTION:\n\
5785\n\
5786 Draws line defined by n points in x and y.\n\
5787\n\
5788 Redacted form: plline(x, y)\n\
5789\n\
5790 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5791 25-27, and 29.\n\
5792\n\
5793\n\
5794\n\
5795SYNOPSIS:\n\
5796\n\
5797plline(n, x, y)\n\
5798\n\
5799ARGUMENTS:\n\
5800\n\
5801 n (PLINT, input) : Number of points defining line.\n\
5802\n\
5803 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5804 points.\n\
5805\n\
5806 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5807 points.\n\
5808";
5809static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
5810Get viewport limits in world coordinates\n\
5811\n\
5812DESCRIPTION:\n\
5813\n\
5814 Get viewport limits in world coordinates.\n\
5815\n\
5816 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5817\n\
5818\n\
5819 This function is used in example 31.\n\
5820\n\
5821\n\
5822\n\
5823SYNOPSIS:\n\
5824\n\
5825plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5826\n\
5827ARGUMENTS:\n\
5828\n\
5829 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5830 viewport limit of the world coordinate in x.\n\
5831\n\
5832 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5833 viewport limit of the world coordinate in x.\n\
5834\n\
5835 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5836 viewport limit of the world coordinate in y.\n\
5837\n\
5838 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5839 viewport limit of the world coordinate in y.\n\
5840";
5841static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5842Set area line fill pattern\n\
5843\n\
5844DESCRIPTION:\n\
5845\n\
5846 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5847 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5848 inclinations and spacings. The arguments to this routine are the\n\
5849 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5850 elements) specifying the inclinations in tenths of a degree and the\n\
5851 spacing in micrometers. (See also plpsty)\n\
5852\n\
5853 Redacted form: General: plpat(inc, del)\n\
5854\n\
5855\n\
5856 This function is used in example 15.\n\
5857\n\
5858\n\
5859\n\
5860SYNOPSIS:\n\
5861\n\
5862plpat(nlin, inc, del)\n\
5863\n\
5864ARGUMENTS:\n\
5865\n\
5866 nlin (PLINT, input) : Number of sets of lines making up the\n\
5867 pattern, either 1 or 2.\n\
5868\n\
5869 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5870 inclination in tenths of a degree. (Should be between -900 and\n\
5871 900).\n\
5872\n\
5873 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5874 spacing in micrometers between the lines making up the pattern.\n\
5875";
5876static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
5877Set x axis parameters\n\
5878\n\
5879DESCRIPTION:\n\
5880\n\
5881 Sets values of the digmax and digits flags for the x axis. See the\n\
5882 PLplot documentation for more information.\n\
5883\n\
5884 Redacted form: plsxax(digmax, digits)\n\
5885\n\
5886 This function is used in example 31.\n\
5887\n\
5888\n\
5889\n\
5890SYNOPSIS:\n\
5891\n\
5892plsxax(digmax, digits)\n\
5893\n\
5894ARGUMENTS:\n\
5895\n\
5896 digmax (PLINT, input) : Variable to set the maximum number of\n\
5897 digits for the x axis. If nonzero, the printed label will be\n\
5898 switched to a floating-point representation when the number of\n\
5899 digits exceeds digmax.\n\
5900\n\
5901 digits (PLINT, input) : Field digits value. Currently, changing\n\
5902 its value here has no effect since it is set only by plbox or\n\
5903 plbox3. However, the user may obtain its value after a call to\n\
5904 either of these functions by calling plgxax.\n\
5905";
5906static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5907Get family file parameters\n\
5908\n\
5909DESCRIPTION:\n\
5910\n\
5911 Gets information about current family file, if familying is enabled.\n\
5912 See the PLplot documentation for more information.\n\
5913\n\
5914 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5915\n\
5916 This function is used in examples 14 and 31.\n\
5917\n\
5918\n\
5919\n\
5920SYNOPSIS:\n\
5921\n\
5922plgfam(p_fam, p_num, p_bmax)\n\
5923\n\
5924ARGUMENTS:\n\
5925\n\
5926 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5927 family flag value. If nonzero, familying is enabled for the\n\
5928 current device.\n\
5929\n\
5930 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5931 family file number.\n\
5932\n\
5933 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5934 file size (in bytes) for a family file.\n\
5935";
5936static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
5937Get y axis parameters\n\
5938\n\
5939DESCRIPTION:\n\
5940\n\
5941 Identical to plgxax, except that arguments are flags for y axis. See\n\
5942 the description of plgxax for more detail.\n\
5943\n\
5944 Redacted form: plgyax(p_digmax, p_digits)\n\
5945\n\
5946 This function is used in example 31.\n\
5947\n\
5948\n\
5949\n\
5950SYNOPSIS:\n\
5951\n\
5952plgyax(p_digmax, p_digits)\n\
5953\n\
5954ARGUMENTS:\n\
5955\n\
5956 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5957 number of digits for the y axis. If nonzero, the printed label\n\
5958 has been switched to a floating-point representation when the\n\
5959 number of digits exceeds this value.\n\
5960\n\
5961 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5962 number of digits for the numeric labels (y axis) from the last\n\
5963 plot.\n\
5964";
5965static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
5966Plot a glyph at the specified points\n\
5967\n\
5968DESCRIPTION:\n\
5969\n\
5970 Plot a glyph at the specified points. (This function is largely\n\
5971 superseded by plstring which gives access to many[!] more glyphs.)\n\
5972 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5973 and a draw at the same place. Not ideal, since a sufficiently\n\
5974 intelligent output device may optimize it away, or there may be faster\n\
5975 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5976 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5977 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5978 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5979 code <= 127 the corresponding printable ASCII character is plotted.\n\
5980\n\
5981 Redacted form: plpoin(x, y, code)\n\
5982\n\
5983 This function is used in examples 1, 6, 14, and 29.\n\
5984\n\
5985\n\
5986\n\
5987SYNOPSIS:\n\
5988\n\
5989plpoin(n, x, y, code)\n\
5990\n\
5991ARGUMENTS:\n\
5992\n\
5993 n (PLINT, input) : Number of points in the x and y vectors.\n\
5994\n\
5995 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5996 points.\n\
5997\n\
5998 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5999 points.\n\
6000\n\
6001 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6002 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6003 each of the n points.\n\
6004";
6005static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
6006Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6007\n\
6008DESCRIPTION:\n\
6009\n\
6010 As per plmapline, however the items are plotted as strings or points\n\
6011 in the same way as plstring.\n\
6012\n\
6013 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6014 maxy, plotentries)\n\
6015\n\
6016 This function is not used in any examples.\n\
6017\n\
6018\n\
6019\n\
6020SYNOPSIS:\n\
6021\n\
6022plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6023\n\
6024ARGUMENTS:\n\
6025\n\
6026 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6027 transform the coordinates given in the shapefile into a plot\n\
6028 coordinate system. By using this transform, we can change from a\n\
6029 longitude, latitude coordinate to a polar stereographic project,\n\
6030 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6031 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6032 mapform(), x[] and y[] should be replaced by the corresponding\n\
6033 plot coordinates. If no transform is desired, mapform can be\n\
6034 replaced by NULL.\n\
6035\n\
6036 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6037 the file name of a set of Shapefile files without the file\n\
6038 extension.\n\
6039\n\
6040 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6041 drawn.\n\
6042\n\
6043 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6044 be in the same units as used by the Shapefile. You could use a\n\
6045 very large negative number to plot everything, but you can improve\n\
6046 performance by limiting the area drawn. The units must match those\n\
6047 of the Shapefile projection, which may be for example longitude or\n\
6048 distance. The value of minx must be less than the value of maxx.\n\
6049\n\
6050 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6051 use a very large number to plot everything, but you can improve\n\
6052 performance by limiting the area drawn.\n\
6053\n\
6054 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6055 be in the same units as used by the Shapefile. You could use a\n\
6056 very large negative number to plot everything, but you can improve\n\
6057 performance by limiting the area drawn. The units must match those\n\
6058 of the Shapefile projection, which may be for example latitude or\n\
6059 distance. The value of miny must be less than the value of maxy.\n\
6060\n\
6061 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6062 use a very large number to plot everything, but you can improve\n\
6063 performance by limiting the area drawn.\n\
6064\n\
6065 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6066 zero-based indices of the Shapefile elements which will be drawn.\n\
6067 Setting\n\
6068 plotentries to NULL will plot all elements of the Shapefile.\n\
6069\n\
6070 nplotentries (PLINT, input) : The number of items in\n\
6071 plotentries. Ignored if\n\
6072 plotentries is NULL.\n\
6073";
6074static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
6075Select area fill pattern\n\
6076\n\
6077DESCRIPTION:\n\
6078\n\
6079 If\n\
6080 patt is zero or less use either a hardware solid fill if the drivers\n\
6081 have that capability (virtually all do) or fall back to a software\n\
6082 emulation of a solid fill using the eighth area line fill pattern. If\n\
6083 0 <\n\
6084 patt <= 8, then select one of eight predefined area line fill patterns\n\
6085 to use (see plpat if you desire other patterns).\n\
6086\n\
6087 Redacted form: plpsty(patt)\n\
6088\n\
6089 This function is used in examples 12, 13, 15, 16, and 25.\n\
6090\n\
6091\n\
6092\n\
6093SYNOPSIS:\n\
6094\n\
6095plpsty(patt)\n\
6096\n\
6097ARGUMENTS:\n\
6098\n\
6099 patt (PLINT, input) : The desired pattern index. If\n\
6100 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6101 above) used. For\n\
6102 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6103 line fill capability itself (most deliberately do not so that line\n\
6104 fill patterns look identical for those drivers), the patterns\n\
6105 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6106 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6107 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6108 (8) lines at both 45 degrees and -45 degrees.\n\
6109";
6110static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6111Set 8-bit RGB values for given cmap0 color index\n\
6112\n\
6113DESCRIPTION:\n\
6114\n\
6115 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6116 index. Overwrites the previous color value for the given index and,\n\
6117 thus, does not result in any additional allocation of space for\n\
6118 colors.\n\
6119\n\
6120 Redacted form: plscol0(icol0, r, g, b)\n\
6121\n\
6122 This function is used in any example 31.\n\
6123\n\
6124\n\
6125\n\
6126SYNOPSIS:\n\
6127\n\
6128plscol0(icol0, r, g, b)\n\
6129\n\
6130ARGUMENTS:\n\
6131\n\
6132 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6133 number of colors (which is set by default, by plscmap0n, or even\n\
6134 by plscmap0).\n\
6135\n\
6136 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6137 degree of red in the color.\n\
6138\n\
6139 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6140 degree of green in the color.\n\
6141\n\
6142 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6143 degree of blue in the color.\n\
6144";
6145static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6146Used to globally turn color output on/off\n\
6147\n\
6148DESCRIPTION:\n\
6149\n\
6150 Used to globally turn color output on/off for those drivers/devices\n\
6151 that support it.\n\
6152\n\
6153 Redacted form: plscolor(color)\n\
6154\n\
6155 This function is used in example 31.\n\
6156\n\
6157\n\
6158\n\
6159SYNOPSIS:\n\
6160\n\
6161plscolor(color)\n\
6162\n\
6163ARGUMENTS:\n\
6164\n\
6165 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6166 turned off. If non-zero, color is turned on.\n\
6167";
6168static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6169End plotting session\n\
6170\n\
6171DESCRIPTION:\n\
6172\n\
6173 Ends a plotting session, tidies up all the output files, switches\n\
6174 interactive devices back into text mode and frees up any memory that\n\
6175 was allocated. Must be called before end of program.\n\
6176\n\
6177 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6178 wait state after a call to plend or other functions which trigger the\n\
6179 end of a plot page. To avoid this, use the plspause function.\n\
6180\n\
6181 Redacted form: plend()\n\
6182\n\
6183 This function is used in all of the examples.\n\
6184\n\
6185\n\
6186\n\
6187SYNOPSIS:\n\
6188\n\
6189plend()\n\
6190";
6191static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
6192Plot a histogram from binned data\n\
6193\n\
6194DESCRIPTION:\n\
6195\n\
6196 Plots a histogram consisting of nbin bins. The value associated with\n\
6197 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6198 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6199 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6200 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6201 placed midway between the values in the x vector. Also see plhist for\n\
6202 drawing histograms from unbinned data.\n\
6203\n\
6204 Redacted form: General: plbin(x, y, opt)\n\
6205 Python: plbin(nbin, x, y, opt)\n\
6206\n\
6207\n\
6208 This function is not used in any examples.\n\
6209\n\
6210\n\
6211\n\
6212SYNOPSIS:\n\
6213\n\
6214plbin(nbin, x, y, opt)\n\
6215\n\
6216ARGUMENTS:\n\
6217\n\
6218 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6219 and y vectors.)\n\
6220\n\
6221 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6222 with bins. These must form a strictly increasing sequence.\n\
6223\n\
6224 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6225 proportional to the number of points in each bin. This is a PLFLT\n\
6226 (instead of PLINT) vector so as to allow histograms of\n\
6227 probabilities, etc.\n\
6228\n\
6229 opt (PLINT, input) : Is a combination of several flags:\n\
6230 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6231 outer bins are expanded to fill up the entire x-axis and bins of\n\
6232 zero height are simply drawn.\n\
6233 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6234 between the x values. If the values in x are equally spaced,\n\
6235 the values are the center values of the bins.\n\
6236 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6237 size as the ones inside.\n\
6238 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6239 (there is a gap for such bins).\n\
6240";
6241static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
6242Plot a 2D matrix using cmap1\n\
6243\n\
6244DESCRIPTION:\n\
6245\n\
6246 Plot a 2D matrix using cmap1.\n\
6247\n\
6248 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6249 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6250\n\
6251\n\
6252 This function is used in example 20.\n\
6253\n\
6254\n\
6255\n\
6256SYNOPSIS:\n\
6257\n\
6258plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6259\n\
6260ARGUMENTS:\n\
6261\n\
6262 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6263 plot. Should have dimensions of\n\
6264 nx by\n\
6265 ny.\n\
6266\n\
6267 nx, ny (PLINT, input) : Dimensions of idata\n\
6268\n\
6269 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6270 pltr below for how these arguments are used (only for the special case\n\
6271 when the callback function\n\
6272 pltr is not supplied).\n\
6273\n\
6274 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6275 (inclusive) will be plotted.\n\
6276\n\
6277 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6278 values to use for value to color mappings. A datum equal to or\n\
6279 less than valuemin will be plotted with color 0.0, while a datum\n\
6280 equal to or greater than valuemax will be plotted with color 1.0.\n\
6281 Data between valuemin and valuemax map linearly to colors in the\n\
6282 range (0.0-1.0).\n\
6283\n\
6284 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6285 defines the transformation between the zero-based indices of the\n\
6286 matrix idata and world coordinates. If\n\
6287 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6288 indices of idata are mapped to the range\n\
6289 xmin through\n\
6290 xmax and the y indices of idata are mapped to the range\n\
6291 ymin through\n\
6292 ymax.For the C case, transformation functions are provided in the\n\
6293 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6294 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6295 matrices. In addition, C callback routines for the transformation\n\
6296 can be supplied by the user such as the mypltr function in\n\
6297 examples/c/x09c.c which provides a general linear transformation\n\
6298 between index coordinates and world coordinates.For languages\n\
6299 other than C you should consult the PLplot documentation for the\n\
6300 details concerning how PLTRANSFORM_callback arguments are\n\
6301 interfaced. However, in general, a particular pattern of\n\
6302 callback-associated arguments such as a tr vector with 6 elements;\n\
6303 xg and yg vectors; or xg and yg matrices are respectively\n\
6304 interfaced to a linear-transformation routine similar to the above\n\
6305 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6306 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6307 support native language callbacks for handling index to\n\
6308 world-coordinate transformations. Examples of these various\n\
6309 approaches are given in examples/<language>x09*,\n\
6310 examples/<language>x16*, examples/<language>x20*,\n\
6311 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6312 supported languages.\n\
6313\n\
6314 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6315 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6316 externally supplied.\n\
6317";
6318static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6319Sets the 3D position of the light source\n\
6320\n\
6321DESCRIPTION:\n\
6322\n\
6323 Sets the 3D position of the light source for use with plsurf3d and\n\
6324 plsurf3dl\n\
6325\n\
6326 Redacted form: pllightsource(x, y, z)\n\
6327\n\
6328 This function is used in example 8.\n\
6329\n\
6330\n\
6331\n\
6332SYNOPSIS:\n\
6333\n\
6334pllightsource(x, y, z)\n\
6335\n\
6336ARGUMENTS:\n\
6337\n\
6338 x (PLFLT, input) : X-coordinate of the light source.\n\
6339\n\
6340 y (PLFLT, input) : Y-coordinate of the light source.\n\
6341\n\
6342 z (PLFLT, input) : Z-coordinate of the light source.\n\
6343";
6344static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
6345Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6346\n\
6347DESCRIPTION:\n\
6348\n\
6349 When the implementation is completed this variant of plot3dc (see that\n\
6350 function\'s documentation for more details) should be suitable for the\n\
6351 case where the area of the x, y coordinate grid where z is defined can\n\
6352 be non-rectangular. The implementation is incomplete so the last 4\n\
6353 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6354 indexymax; are currently ignored and the functionality is otherwise\n\
6355 identical to that of plot3dc.\n\
6356\n\
6357 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6358 indexymin, indexymax)\n\
6359\n\
6360\n\
6361 This function is not used in any example.\n\
6362\n\
6363\n\
6364\n\
6365SYNOPSIS:\n\
6366\n\
6367plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6368\n\
6369ARGUMENTS:\n\
6370\n\
6371 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6372 which the function is evaluated.\n\
6373\n\
6374 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6375 which the function is evaluated.\n\
6376\n\
6377 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6378 plot. Should have dimensions of\n\
6379 nx by\n\
6380 ny.\n\
6381\n\
6382 nx (PLINT, input) : Number of x values at which the function is\n\
6383 evaluated.\n\
6384\n\
6385 ny (PLINT, input) : Number of y values at which the function is\n\
6386 evaluated.\n\
6387\n\
6388 opt (PLINT, input) : Determines the way in which the surface is\n\
6389 represented. To specify more than one option just add the options,\n\
6390 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6391 showing z as a function of x for each value of y[j] .\n\
6392 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6393 for each value of x[i] .\n\
6394 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6395 at which function is defined.\n\
6396 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6397 the z value being plotted. The color is used from the current\n\
6398 cmap1.\n\
6399 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6400 using parameters\n\
6401 nlevel and\n\
6402 clevel.\n\
6403 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6404 the borders of the plotted function.\n\
6405\n\
6406\n\
6407 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6408 levels.\n\
6409\n\
6410 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6411\n\
6412 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6413 corresponds to the first x index where z is defined.\n\
6414\n\
6415 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6416 which corresponds (by convention) to one more than the last x\n\
6417 index value where z is defined.\n\
6418\n\
6419 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6420 values which all must be ≥ 0. These values are the first y index\n\
6421 where z is defined for a particular x index in the range from\n\
6422 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6423 indexxmax.\n\
6424\n\
6425 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6426 values which all must be ≤ ny. These values correspond (by\n\
6427 convention) to one more than the last y index where z is defined\n\
6428 for a particular x index in the range from indexxmin to indexxmax\n\
6429 - 1. The dimension of indexymax is indexxmax.\n\
6430";
6431static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6432Creates a new stream and makes it the default\n\
6433\n\
6434DESCRIPTION:\n\
6435\n\
6436 Creates a new stream and makes it the default. Differs from using\n\
6437 plsstrm, in that a free stream number is found, and returned.\n\
6438 Unfortunately, I have to start at stream 1 and work upward, since\n\
6439 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6440 that no initial, library-opening call is required. So stream 0 must\n\
6441 be preallocated, and there is no simple way of determining whether it\n\
6442 is already in use or not.\n\
6443\n\
6444 Redacted form: plmkstrm(p_strm)\n\
6445\n\
6446 This function is used in examples 1 and 20.\n\
6447\n\
6448\n\
6449\n\
6450SYNOPSIS:\n\
6451\n\
6452plmkstrm(p_strm)\n\
6453\n\
6454ARGUMENTS:\n\
6455\n\
6456 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6457 number of the created stream.\n\
6458";
6459static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
6460Set FCI (font characterization integer)\n\
6461\n\
6462DESCRIPTION:\n\
6463\n\
6464 Sets font characteristics to be used at the start of the next string\n\
6465 using the FCI approach. See the PLplot documentation for more\n\
6466 information. Note, plsfont (which calls plsfci internally) provides a\n\
6467 more user-friendly API for setting the font characterisitics.\n\
6468\n\
6469 Redacted form: General: plsfci(fci)\n\
6470\n\
6471\n\
6472 This function is used in example 23.\n\
6473\n\
6474\n\
6475\n\
6476SYNOPSIS:\n\
6477\n\
6478plsfci(fci)\n\
6479\n\
6480ARGUMENTS:\n\
6481\n\
6482 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6483 of FCI.\n\
6484";
6485static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
6486Initialize PLplot\n\
6487\n\
6488DESCRIPTION:\n\
6489\n\
6490 Initializing the plotting package. The program prompts for the device\n\
6491 keyword or number of the desired output device. Hitting a RETURN in\n\
6492 response to the prompt is the same as selecting the first device.\n\
6493 plinit will issue no prompt if either the device was specified\n\
6494 previously (via command line flag, the plsetopt function, or the\n\
6495 plsdev function), or if only one device is enabled when PLplot is\n\
6496 installed. If subpages have been specified, the output device is\n\
6497 divided into nx by ny subpages, each of which may be used\n\
6498 independently. If plinit is called again during a program, the\n\
6499 previously opened file will be closed. The subroutine pladv is used\n\
6500 to advance from one subpage to the next.\n\
6501\n\
6502 Redacted form: plinit()\n\
6503\n\
6504 This function is used in all of the examples.\n\
6505\n\
6506\n\
6507\n\
6508SYNOPSIS:\n\
6509\n\
6510plinit()\n\
6511";
6512static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
6513Set line style\n\
6514\n\
6515DESCRIPTION:\n\
6516\n\
6517 This sets up the line style for all lines subsequently drawn. A line\n\
6518 consists of segments in which the pen is alternately down and up. The\n\
6519 lengths of these segments are passed in the vectors mark and space\n\
6520 respectively. The number of mark-space pairs is specified by nms. In\n\
6521 order to return the line style to the default continuous line, plstyl\n\
6522 should be called with nms =0 .(see also pllsty)\n\
6523\n\
6524 Redacted form: plstyl(mark, space)\n\
6525\n\
6526 This function is used in examples 1, 9, and 14.\n\
6527\n\
6528\n\
6529\n\
6530SYNOPSIS:\n\
6531\n\
6532plstyl(nms, mark, space)\n\
6533\n\
6534ARGUMENTS:\n\
6535\n\
6536 nms (PLINT, input) : The number of mark and space elements in a\n\
6537 line. Thus a simple broken line can be obtained by setting nms=1\n\
6538 . A continuous line is specified by setting nms=0 .\n\
6539\n\
6540 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6541 segments during which the pen is down, measured in micrometers.\n\
6542\n\
6543 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6544 the segments during which the pen is up, measured in micrometers.\n\
6545";
6546static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
6547Set length of minor ticks\n\
6548\n\
6549DESCRIPTION:\n\
6550\n\
6551 This sets up the length of the minor ticks and the length of the\n\
6552 terminals on error bars. The actual length is the product of the\n\
6553 default length and a scaling factor as for character height.\n\
6554\n\
6555 Redacted form: plsmin(def, scale)\n\
6556\n\
6557 This function is used in example 29.\n\
6558\n\
6559\n\
6560\n\
6561SYNOPSIS:\n\
6562\n\
6563plsmin(def, scale)\n\
6564\n\
6565ARGUMENTS:\n\
6566\n\
6567 def (PLFLT, input) : The default length of a minor tick in\n\
6568 millimeters, should be set to zero if the default length is to\n\
6569 remain unchanged.\n\
6570\n\
6571 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6572 actual tick length.\n\
6573";
6574static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6575Draw a box with axes, etc, in 3-d\n\
6576\n\
6577DESCRIPTION:\n\
6578\n\
6579 Draws axes, numeric and text labels for a three-dimensional surface\n\
6580 plot. For a more complete description of three-dimensional plotting\n\
6581 see the PLplot documentation.\n\
6582\n\
6583 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6584 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6585\n\
6586\n\
6587 This function is used in examples 8, 11, 18, and 21.\n\
6588\n\
6589\n\
6590\n\
6591SYNOPSIS:\n\
6592\n\
6593plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6594\n\
6595ARGUMENTS:\n\
6596\n\
6597 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6598 options for the x axis. The string can include any combination of\n\
6599 the following letters (upper or lower case) in any order: b: Draws\n\
6600 axis at base, at height z=\n\
6601 zmin where zmin is defined by call to plw3d. This character must be\n\
6602 specified in order to use any of the other options.\n\
6603 d: Plot labels as date / time. Values are assumed to be\n\
6604 seconds since the epoch (as used by gmtime).\n\
6605 f: Always use fixed point numeric labels.\n\
6606 i: Inverts tick marks, so they are drawn downwards, rather\n\
6607 than upwards.\n\
6608 l: Labels axis logarithmically. This only affects the labels,\n\
6609 not the data, and so it is necessary to compute the logarithms\n\
6610 of data points before passing them to any of the drawing\n\
6611 routines.\n\
6612 n: Writes numeric labels at major tick intervals.\n\
6613 o: Use custom labelling function to generate axis label text.\n\
6614 The custom labelling function can be defined with the\n\
6615 plslabelfunc command.\n\
6616 s: Enables subticks between major ticks, only valid if t is\n\
6617 also specified.\n\
6618 t: Draws major ticks.\n\
6619 u: If this is specified, the text label for the axis is\n\
6620 written under the axis.\n\
6621\n\
6622\n\
6623 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6624 the text label for the x axis. It is only drawn if u is in the\n\
6625 xopt string.\n\
6626\n\
6627 xtick (PLFLT, input) : World coordinate interval between major\n\
6628 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6629 generates a suitable tick interval.\n\
6630\n\
6631 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6632 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6633 generates a suitable minor tick interval.\n\
6634\n\
6635 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6636 options for the y axis. The string is interpreted in the same way\n\
6637 as xopt.\n\
6638\n\
6639 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6640 the text label for the y axis. It is only drawn if u is in the\n\
6641 yopt string.\n\
6642\n\
6643 ytick (PLFLT, input) : World coordinate interval between major\n\
6644 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6645 generates a suitable tick interval.\n\
6646\n\
6647 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6648 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6649 generates a suitable minor tick interval.\n\
6650\n\
6651 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6652 options for the z axis. The string can include any combination of\n\
6653 the following letters (upper or lower case) in any order: b: Draws\n\
6654 z axis to the left of the surface plot.\n\
6655 c: Draws z axis to the right of the surface plot.\n\
6656 d: Draws grid lines parallel to the x-y plane behind the\n\
6657 figure. These lines are not drawn until after plot3d or\n\
6658 plmesh are called because of the need for hidden line removal.\n\
6659 e: Plot labels as date / time. Values are assumed to be\n\
6660 seconds since the epoch (as used by gmtime). Note this\n\
6661 suboption is interpreted the same as the d suboption for xopt\n\
6662 and yopt, but it has to be identified as e for zopt since d\n\
6663 has already been used for the different purpose above.\n\
6664 f: Always use fixed point numeric labels.\n\
6665 i: Inverts tick marks, so they are drawn away from the center.\n\
6666 l: Labels axis logarithmically. This only affects the labels,\n\
6667 not the data, and so it is necessary to compute the logarithms\n\
6668 of data points before passing them to any of the drawing\n\
6669 routines.\n\
6670 m: Writes numeric labels at major tick intervals on the\n\
6671 right-hand z axis.\n\
6672 n: Writes numeric labels at major tick intervals on the\n\
6673 left-hand z axis.\n\
6674 o: Use custom labelling function to generate axis label text.\n\
6675 The custom labelling function can be defined with the\n\
6676 plslabelfunc command.\n\
6677 s: Enables subticks between major ticks, only valid if t is\n\
6678 also specified.\n\
6679 t: Draws major ticks.\n\
6680 u: If this is specified, the text label is written beside the\n\
6681 left-hand axis.\n\
6682 v: If this is specified, the text label is written beside the\n\
6683 right-hand axis.\n\
6684\n\
6685\n\
6686 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6687 the text label for the z axis. It is only drawn if u or v are in\n\
6688 the zopt string.\n\
6689\n\
6690 ztick (PLFLT, input) : World coordinate interval between major\n\
6691 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6692 generates a suitable tick interval.\n\
6693\n\
6694 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6695 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6696 generates a suitable minor tick interval.\n\
6697";
6698static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
6699Set character size\n\
6700\n\
6701DESCRIPTION:\n\
6702\n\
6703 This sets up the size of all subsequent characters drawn. The actual\n\
6704 height of a character is the product of the default character size and\n\
6705 a scaling factor.\n\
6706\n\
6707 Redacted form: plschr(def, scale)\n\
6708\n\
6709 This function is used in examples 2, 13, 23, and 24.\n\
6710\n\
6711\n\
6712\n\
6713SYNOPSIS:\n\
6714\n\
6715plschr(def, scale)\n\
6716\n\
6717ARGUMENTS:\n\
6718\n\
6719 def (PLFLT, input) : The default height of a character in\n\
6720 millimeters, should be set to zero if the default height is to\n\
6721 remain unchanged. For rasterized drivers the dx and dy values\n\
6722 specified in plspage are used to convert from mm to pixels (note\n\
6723 the different unit systems used). This dpi aware scaling is not\n\
6724 implemented for all drivers yet.\n\
6725\n\
6726 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6727 actual character height.\n\
6728";
6729static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6730Calculate continuous time from broken-down time for the current stream\n\
6731\n\
6732DESCRIPTION:\n\
6733\n\
6734 Calculate continuous time, ctime, from broken-down time for the\n\
6735 current stream. The broken-down\n\
6736 time is specified by the following parameters: year, month, day, hour,\n\
6737 min, and sec. This function is the inverse of plbtime.\n\
6738\n\
6739 The PLplot definition of broken-down time is a calendar time that\n\
6740 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6741 responsibility to apply those offsets (if so desired) before using the\n\
6742 PLplot time API. By default broken-down time is defined using the\n\
6743 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6744 continuous time is defined as the number of seconds since the Unix\n\
6745 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6746 broken-down and continuous time are possible, see plconfigtime which\n\
6747 specifies that transformation for the current stream.\n\
6748\n\
6749 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6750 ctime)\n\
6751\n\
6752\n\
6753 This function is used in example 29.\n\
6754\n\
6755\n\
6756\n\
6757SYNOPSIS:\n\
6758\n\
6759plctime(year, month, day, hour, min, sec, ctime)\n\
6760\n\
6761ARGUMENTS:\n\
6762\n\
6763 year (PLINT, input) : Input year.\n\
6764\n\
6765 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6766 (December).\n\
6767\n\
6768 day (PLINT, input) : Input day in range from 1 to 31.\n\
6769\n\
6770 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6771\n\
6772 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6773\n\
6774 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6775\n\
6776 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6777 time calculated from the broken-down time specified by the\n\
6778 previous parameters.\n\
6779";
6780static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6781Set color, cmap0\n\
6782\n\
6783DESCRIPTION:\n\
6784\n\
6785 Sets the color index for cmap0 (see the PLplot documentation).\n\
6786\n\
6787 Redacted form: plcol0(icol0)\n\
6788\n\
6789 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6790\n\
6791\n\
6792\n\
6793SYNOPSIS:\n\
6794\n\
6795plcol0(icol0)\n\
6796\n\
6797ARGUMENTS:\n\
6798\n\
6799 icol0 (PLINT, input) : Integer representing the color. The\n\
6800 defaults at present are (these may change):\n\
6801 0 black (default background)\n\
6802 1 red (default foreground)\n\
6803 2 yellow\n\
6804 3 green\n\
6805 4 aquamarine\n\
6806 5 pink\n\
6807 6 wheat\n\
6808 7 grey\n\
6809 8 brown\n\
6810 9 blue\n\
6811 10 BlueViolet\n\
6812 11 cyan\n\
6813 12 turquoise\n\
6814 13 magenta\n\
6815 14 salmon\n\
6816 15 white\n\
6817\n\
6818 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6819 change an individual color in the cmap0 color palette.\n\
6820";
6821static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6822Set color, cmap1\n\
6823\n\
6824DESCRIPTION:\n\
6825\n\
6826 Sets the color for cmap1 (see the PLplot documentation).\n\
6827\n\
6828 Redacted form: plcol1(col1)\n\
6829\n\
6830 This function is used in examples 12 and 21.\n\
6831\n\
6832\n\
6833\n\
6834SYNOPSIS:\n\
6835\n\
6836plcol1(col1)\n\
6837\n\
6838ARGUMENTS:\n\
6839\n\
6840 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6841 is mapped to color using the continuous cmap1 palette which by\n\
6842 default ranges from blue to the background color to red. The\n\
6843 cmap1 palette can also be straightforwardly changed by the user\n\
6844 with plscmap1 or plscmap1l.\n\
6845";
6846static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
6847Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6848\n\
6849DESCRIPTION:\n\
6850\n\
6851 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6852\n\
6853 Redacted form: plgcolbg(r, g, b)\n\
6854\n\
6855 This function is used in example 31.\n\
6856\n\
6857\n\
6858\n\
6859SYNOPSIS:\n\
6860\n\
6861plgcolbg(r, g, b)\n\
6862\n\
6863ARGUMENTS:\n\
6864\n\
6865 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6866 in the range from 0 to 255.\n\
6867\n\
6868 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6869 in the range from 0 to 255.\n\
6870\n\
6871 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6872 in the range from 0 to 255.\n\
6873";
6874static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
6875Draw a circular or elliptical arc\n\
6876\n\
6877DESCRIPTION:\n\
6878\n\
6879 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6880 semiminor axis b, starting at angle1 and ending at angle2.\n\
6881\n\
6882 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6883 fill)\n\
6884\n\
6885\n\
6886 This function is used in examples 3 and 27.\n\
6887\n\
6888\n\
6889\n\
6890SYNOPSIS:\n\
6891\n\
6892plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6893\n\
6894ARGUMENTS:\n\
6895\n\
6896 x (PLFLT, input) : X coordinate of arc center.\n\
6897\n\
6898 y (PLFLT, input) : Y coordinate of arc center.\n\
6899\n\
6900 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6901\n\
6902 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6903\n\
6904 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6905 semimajor axis.\n\
6906\n\
6907 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6908 semimajor axis.\n\
6909\n\
6910 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6911 X-axis.\n\
6912\n\
6913 fill (PLBOOL, input) : Draw a filled arc.\n\
6914";
6915static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6916Parse command-line arguments\n\
6917\n\
6918DESCRIPTION:\n\
6919\n\
6920 Parse command-line arguments.\n\
6921\n\
6922 plparseopts removes all recognized flags (decreasing argc\n\
6923 accordingly), so that invalid input may be readily detected. It can\n\
6924 also be used to process user command line flags. The user can merge\n\
6925 an option table of type PLOptionTable into the internal option table\n\
6926 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6927 the external table(s) be parsed by calling plClearOpts before\n\
6928 plMergeOpts.\n\
6929\n\
6930 The default action taken by plparseopts is as follows:\n\
6931 Returns with an error if an unrecognized option or badly formed\n\
6932 option-value pair are encountered.\n\
6933 Returns immediately (return code 0) when the first non-option command\n\
6934 line argument is found.\n\
6935 Returns with the return code of the option handler, if one was called.\n\
6936\n\
6937 Deletes command line arguments from argv list as they are found, and\n\
6938 decrements argc accordingly.\n\
6939 Does not show \"invisible\" options in usage or help messages.\n\
6940 Assumes the program name is contained in argv[0].\n\
6941\n\
6942 These behaviors may be controlled through the\n\
6943 mode argument.\n\
6944\n\
6945 Redacted form: General: plparseopts(argv, mode)\n\
6946\n\
6947\n\
6948 This function is used in all of the examples.\n\
6949\n\
6950\n\
6951\n\
6952SYNOPSIS:\n\
6953\n\
6954PLINT plparseopts(p_argc, argv, mode)\n\
6955\n\
6956ARGUMENTS:\n\
6957\n\
6958 p_argc (int *, input/output) : Number of arguments.\n\
6959\n\
6960 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6961 strings containing *p_argc command-line arguments.\n\
6962\n\
6963 mode (PLINT, input) : Parsing mode with the following\n\
6964 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6965 and all error messages enabled, including program exit when an\n\
6966 error occurs. Anything on the command line that isn\'t recognized\n\
6967 as a valid option or option argument is flagged as an error.\n\
6968 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6969 of errors.\n\
6970 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6971 arguments.\n\
6972 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6973 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6974 pointer to the program name.\n\
6975 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6976 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6977 unrecognized arguments.\n\
6978";
6979static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
6980Get parameters that define current device-space window\n\
6981\n\
6982DESCRIPTION:\n\
6983\n\
6984 Get relative margin width, aspect ratio, and relative justification\n\
6985 that define current device-space window. If plsdidev has not been\n\
6986 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
6987 p_jy will all be 0.\n\
6988\n\
6989 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6990\n\
6991 This function is used in example 31.\n\
6992\n\
6993\n\
6994\n\
6995SYNOPSIS:\n\
6996\n\
6997plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6998\n\
6999ARGUMENTS:\n\
7000\n\
7001 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7002 margin width.\n\
7003\n\
7004 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7005 ratio.\n\
7006\n\
7007 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7008 justification in x.\n\
7009\n\
7010 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7011 justification in y.\n\
7012";
7013static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
7014Assign a function to use for generating custom axis labels\n\
7015\n\
7016DESCRIPTION:\n\
7017\n\
7018 This function allows a user to provide their own function to provide\n\
7019 axis label text. The user function is given the numeric value for a\n\
7020 point on an axis and returns a string label to correspond with that\n\
7021 value. Custom axis labels can be enabled by passing appropriate\n\
7022 arguments to plenv, plbox, plbox3 and similar functions.\n\
7023\n\
7024 This function is used in example 19.\n\
7025\n\
7026\n\
7027\n\
7028SYNOPSIS:\n\
7029\n\
7030plslabelfunc(label_func, label_data)\n\
7031\n\
7032ARGUMENTS:\n\
7033\n\
7034 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7035 label function. In order to reset to the default labelling, set\n\
7036 this to NULL. The labelling function parameters are, in order:\n\
7037 axis: This indicates which axis a label is being requested for.\n\
7038 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7039\n\
7040 value: This is the value along the axis which is being labelled.\n\
7041\n\
7042 label_text: The string representation of the label value.\n\
7043\n\
7044 length: The maximum length in characters allowed for label_text.\n\
7045\n\
7046\n\
7047 label_data (PLPointer, input) : This parameter may be used to pass\n\
7048 data to the label_func function.\n\
7049";
7050static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7051Get the (current) run level\n\
7052\n\
7053DESCRIPTION:\n\
7054\n\
7055 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7056 1, initialized\n\
7057 2, viewport defined\n\
7058 3, world coordinates defined\n\
7059\n\
7060\n\
7061 Redacted form: plglevel(p_level)\n\
7062\n\
7063 This function is used in example 31.\n\
7064\n\
7065\n\
7066\n\
7067SYNOPSIS:\n\
7068\n\
7069plglevel(p_level)\n\
7070\n\
7071ARGUMENTS:\n\
7072\n\
7073 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7074 level.\n\
7075";
7076static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7077Select line style\n\
7078\n\
7079DESCRIPTION:\n\
7080\n\
7081 This sets the line style according to one of eight predefined patterns\n\
7082 (also see plstyl).\n\
7083\n\
7084 Redacted form: pllsty(lin)\n\
7085\n\
7086 This function is used in examples 9, 12, 22, and 25.\n\
7087\n\
7088\n\
7089\n\
7090SYNOPSIS:\n\
7091\n\
7092pllsty(lin)\n\
7093\n\
7094ARGUMENTS:\n\
7095\n\
7096 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7097 a continuous line, line style 2 is a line with short dashes and\n\
7098 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7099 4 has long dashes and short gaps and so on.\n\
7100";
7101static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
7102Set up standard window and draw box\n\
7103\n\
7104DESCRIPTION:\n\
7105\n\
7106 Sets up plotter environment for simple graphs by calling pladv and\n\
7107 setting up viewport and window to sensible default values. plenv\n\
7108 leaves a standard margin (left-hand margin of eight character heights,\n\
7109 and a margin around the other three sides of five character heights)\n\
7110 around most graphs for axis labels and a title. When these defaults\n\
7111 are not suitable, use the individual routines plvpas, plvpor, or\n\
7112 plvasp for setting up the viewport, plwind for defining the window,\n\
7113 and plbox for drawing the box.\n\
7114\n\
7115 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7116\n\
7117 This function is used in example 1,3,9,13,14,19-22,29.\n\
7118\n\
7119\n\
7120\n\
7121SYNOPSIS:\n\
7122\n\
7123plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7124\n\
7125ARGUMENTS:\n\
7126\n\
7127 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7128 world coordinates).\n\
7129\n\
7130 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7131 world coordinates).\n\
7132\n\
7133 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7134 coordinates).\n\
7135\n\
7136 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7137 coordinates).\n\
7138\n\
7139 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7140 scales will not be set, the user must set up the scale before\n\
7141 calling plenv using plsvpa, plvasp or other.\n\
7142 0: the x and y axes are scaled independently to use as much of\n\
7143 the screen as possible.\n\
7144 1: the scales of the x and y axes are made equal.\n\
7145 2: the axis of the x and y axes are made equal, and the plot\n\
7146 box will be square.\n\
7147\n\
7148\n\
7149 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7150 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7151 -1: draw box only.\n\
7152 0: draw box, ticks, and numeric tick labels.\n\
7153 1: also draw coordinate axes at x=0 and y=0.\n\
7154 2: also draw a grid at major tick positions in both\n\
7155 coordinates.\n\
7156 3: also draw a grid at minor tick positions in both\n\
7157 coordinates.\n\
7158 10: same as 0 except logarithmic x tick marks. (The x data\n\
7159 have to be converted to logarithms separately.)\n\
7160 11: same as 1 except logarithmic x tick marks. (The x data\n\
7161 have to be converted to logarithms separately.)\n\
7162 12: same as 2 except logarithmic x tick marks. (The x data\n\
7163 have to be converted to logarithms separately.)\n\
7164 13: same as 3 except logarithmic x tick marks. (The x data\n\
7165 have to be converted to logarithms separately.)\n\
7166 20: same as 0 except logarithmic y tick marks. (The y data\n\
7167 have to be converted to logarithms separately.)\n\
7168 21: same as 1 except logarithmic y tick marks. (The y data\n\
7169 have to be converted to logarithms separately.)\n\
7170 22: same as 2 except logarithmic y tick marks. (The y data\n\
7171 have to be converted to logarithms separately.)\n\
7172 23: same as 3 except logarithmic y tick marks. (The y data\n\
7173 have to be converted to logarithms separately.)\n\
7174 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7175 and y data have to be converted to logarithms separately.)\n\
7176 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7177 and y data have to be converted to logarithms separately.)\n\
7178 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7179 and y data have to be converted to logarithms separately.)\n\
7180 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7181 and y data have to be converted to logarithms separately.)\n\
7182 40: same as 0 except date / time x labels.\n\
7183 41: same as 1 except date / time x labels.\n\
7184 42: same as 2 except date / time x labels.\n\
7185 43: same as 3 except date / time x labels.\n\
7186 50: same as 0 except date / time y labels.\n\
7187 51: same as 1 except date / time y labels.\n\
7188 52: same as 2 except date / time y labels.\n\
7189 53: same as 3 except date / time y labels.\n\
7190 60: same as 0 except date / time x and y labels.\n\
7191 61: same as 1 except date / time x and y labels.\n\
7192 62: same as 2 except date / time x and y labels.\n\
7193 63: same as 3 except date / time x and y labels.\n\
7194 70: same as 0 except custom x and y labels.\n\
7195 71: same as 1 except custom x and y labels.\n\
7196 72: same as 2 except custom x and y labels.\n\
7197 73: same as 3 except custom x and y labels.\n\
7198";
7199static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
7200Initialization\n\
7201\n\
7202DESCRIPTION:\n\
7203\n\
7204 Alternative to plstar for initializing the plotting package. The\n\
7205 device name keyword for the desired output device must be supplied as\n\
7206 an argument. These keywords are the same as those printed out by\n\
7207 plstar. If the requested device is not available, or if the input\n\
7208 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7209 is used. This routine also divides the output device page into nx by\n\
7210 ny subpages, each of which may be used independently. The subroutine\n\
7211 pladv is used to advance from one subpage to the next.\n\
7212\n\
7213 Redacted form: General: plstart(devname, nx, ny)\n\
7214\n\
7215\n\
7216 This function is not used in any examples.\n\
7217\n\
7218\n\
7219\n\
7220SYNOPSIS:\n\
7221\n\
7222plstart(devname, nx, ny)\n\
7223\n\
7224ARGUMENTS:\n\
7225\n\
7226 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7227 containing the device name keyword of the required output device.\n\
7228 If\n\
7229 devname is NULL or if the first character of the string is a ``?\'\',\n\
7230 the normal (prompted) start up is used.\n\
7231\n\
7232 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7233 x direction.\n\
7234\n\
7235 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7236 y direction.\n\
7237";
7238static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
7239Plot a glyph at the specified points\n\
7240\n\
7241DESCRIPTION:\n\
7242\n\
7243 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7244 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7245 is specified with a PLplot user string. Note that the user string is\n\
7246 not actually limited to one glyph so it is possible (but not normally\n\
7247 useful) to plot more than one glyph at the specified points with this\n\
7248 function. As with plmtex and plptex, the user string can contain FCI\n\
7249 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7250 else PLplot escapes for Hershey or unicode text to determine the\n\
7251 glyph.\n\
7252\n\
7253 Redacted form: plstring(x, y, string)\n\
7254\n\
7255 This function is used in examples 4, 21 and 26.\n\
7256\n\
7257\n\
7258\n\
7259SYNOPSIS:\n\
7260\n\
7261plstring(n, x, y, string)\n\
7262\n\
7263ARGUMENTS:\n\
7264\n\
7265 n (PLINT, input) : Number of points in the x and y vectors.\n\
7266\n\
7267 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7268 the points.\n\
7269\n\
7270 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7271 the points.\n\
7272\n\
7273 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7274 the glyph(s) to be plotted at each of the n points.\n\
7275";
7276static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
7277Write text relative to viewport boundaries in 3D plots\n\
7278\n\
7279DESCRIPTION:\n\
7280\n\
7281 Writes text at a specified position relative to the viewport\n\
7282 boundaries. Text may be written inside or outside the viewport, but\n\
7283 is clipped at the subpage boundaries. The reference point of a string\n\
7284 lies along a line passing through the string at half the height of a\n\
7285 capital letter. The position of the reference point along this line\n\
7286 is determined by just, and the position of the reference point\n\
7287 relative to the viewport is set by disp and pos.\n\
7288\n\
7289 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7290\n\
7291 This function is used in example 28.\n\
7292\n\
7293\n\
7294\n\
7295SYNOPSIS:\n\
7296\n\
7297plmtex3(side, disp, pos, just, text)\n\
7298\n\
7299ARGUMENTS:\n\
7300\n\
7301 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7302 the side of the viewport along which the text is to be written.\n\
7303 The string should contain one or more of the following characters:\n\
7304 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7305 only label the X axis, not both the X and Y axes. x: Label the X\n\
7306 axis.\n\
7307 y: Label the Y axis.\n\
7308 z: Label the Z axis.\n\
7309 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7310 For X it is the axis that starts at y-min. For Y it is the\n\
7311 axis that starts at x-min.\n\
7312 s: Label the secondary axis.\n\
7313 v: Draw the text perpendicular to the axis.\n\
7314\n\
7315\n\
7316 disp (PLFLT, input) : Position of the reference point of string,\n\
7317 measured outwards from the specified viewport edge in units of the\n\
7318 current character height. Use negative disp to write within the\n\
7319 viewport.\n\
7320\n\
7321 pos (PLFLT, input) : Position of the reference point of string\n\
7322 along the specified edge, expressed as a fraction of the length of\n\
7323 the edge.\n\
7324\n\
7325 just (PLFLT, input) : Specifies the position of the string relative\n\
7326 to its reference point. If just=0. , the reference point is at\n\
7327 the left and if just=1. , it is at the right of the string. Other\n\
7328 values of just give intermediate justifications.\n\
7329\n\
7330 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7331 written out.\n\
7332";
7333static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7334Get plot orientation\n\
7335\n\
7336DESCRIPTION:\n\
7337\n\
7338 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7339 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7340 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7341 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7342 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7343 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7344 not been called the default value pointed to by p_rot will be 0.\n\
7345\n\
7346 Redacted form: plgdiori(p_rot)\n\
7347\n\
7348 This function is not used in any examples.\n\
7349\n\
7350\n\
7351\n\
7352SYNOPSIS:\n\
7353\n\
7354plgdiori(p_rot)\n\
7355\n\
7356ARGUMENTS:\n\
7357\n\
7358 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7359 parameter.\n\
7360";
7361static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
7362Simple routine to write labels\n\
7363\n\
7364DESCRIPTION:\n\
7365\n\
7366 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7367\n\
7368 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7369\n\
7370 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7371\n\
7372\n\
7373\n\
7374SYNOPSIS:\n\
7375\n\
7376pllab(xlabel, ylabel, tlabel)\n\
7377\n\
7378ARGUMENTS:\n\
7379\n\
7380 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7381 the label for the x axis.\n\
7382\n\
7383 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7384 the label for the y axis.\n\
7385\n\
7386 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7387 the title of the plot.\n\
7388";
7389static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7390Switch to text screen\n\
7391\n\
7392DESCRIPTION:\n\
7393\n\
7394 Sets an interactive device to text mode, used in conjunction with\n\
7395 plgra to allow graphics and text to be interspersed. On a device\n\
7396 which supports separate text and graphics windows, this command causes\n\
7397 control to be switched to the text window. This can be useful for\n\
7398 printing diagnostic messages or getting user input, which would\n\
7399 otherwise interfere with the plots. The program must switch back to\n\
7400 the graphics window before issuing plot commands, as the text (or\n\
7401 console) device will probably become quite confused otherwise. If\n\
7402 already in text mode, this command is ignored. It is also ignored on\n\
7403 devices which only support a single window or use a different method\n\
7404 for shifting focus (see also plgra).\n\
7405\n\
7406 Redacted form: pltext()\n\
7407\n\
7408 This function is used in example 1.\n\
7409\n\
7410\n\
7411\n\
7412SYNOPSIS:\n\
7413\n\
7414pltext()\n\
7415";
7416static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
7417Plot all or a subset of Shapefile data using lines in world coordinates\n\
7418\n\
7419DESCRIPTION:\n\
7420\n\
7421 Plot all or a subset of Shapefile data using lines in world\n\
7422 coordinates. Our 19th standard example demonstrates how to use this\n\
7423 function. This function plots data from a Shapefile using lines as in\n\
7424 plmap, however it also has the option of also only drawing specified\n\
7425 elements from the Shapefile. The vector of indices of the required\n\
7426 elements are passed as a function argument. The Shapefile data should\n\
7427 include a metadata file (extension.dbf) listing all items within the\n\
7428 Shapefile. This file can be opened by most popular spreadsheet\n\
7429 programs and can be used to decide which indices to pass to this\n\
7430 function.\n\
7431\n\
7432 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7433 plotentries)\n\
7434\n\
7435 This function is used in example 19.\n\
7436\n\
7437\n\
7438\n\
7439SYNOPSIS:\n\
7440\n\
7441plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7442\n\
7443ARGUMENTS:\n\
7444\n\
7445 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7446 transform the coordinates given in the shapefile into a plot\n\
7447 coordinate system. By using this transform, we can change from a\n\
7448 longitude, latitude coordinate to a polar stereographic project,\n\
7449 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7450 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7451 mapform(), x[] and y[] should be replaced by the corresponding\n\
7452 plot coordinates. If no transform is desired, mapform can be\n\
7453 replaced by NULL.\n\
7454\n\
7455 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7456 the file name of a set of Shapefile files without the file\n\
7457 extension.\n\
7458\n\
7459 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7460 be in the same units as used by the Shapefile. You could use a\n\
7461 very large negative number to plot everything, but you can improve\n\
7462 performance by limiting the area drawn. The units must match those\n\
7463 of the Shapefile projection, which may be for example longitude or\n\
7464 distance. The value of minx must be less than the value of maxx.\n\
7465\n\
7466 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7467 use a very large number to plot everything, but you can improve\n\
7468 performance by limiting the area drawn.\n\
7469\n\
7470 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7471 be in the same units as used by the Shapefile. You could use a\n\
7472 very large negative number to plot everything, but you can improve\n\
7473 performance by limiting the area drawn. The units must match those\n\
7474 of the Shapefile projection, which may be for example latitude or\n\
7475 distance. The value of miny must be less than the value of maxy.\n\
7476\n\
7477 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7478 use a very large number to plot everything, but you can improve\n\
7479 performance by limiting the area drawn.\n\
7480\n\
7481 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7482 zero-based indices of the Shapefile elements which will be drawn.\n\
7483 Setting\n\
7484 plotentries to NULL will plot all elements of the Shapefile.\n\
7485\n\
7486 nplotentries (PLINT, input) : The number of items in\n\
7487 plotentries. Ignored if\n\
7488 plotentries is NULL.\n\
7489";
7490static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7491Set precision in numeric labels\n\
7492\n\
7493DESCRIPTION:\n\
7494\n\
7495 Sets the number of places after the decimal point in numeric labels.\n\
7496\n\
7497 Redacted form: plprec(setp, prec)\n\
7498\n\
7499 This function is used in example 29.\n\
7500\n\
7501\n\
7502\n\
7503SYNOPSIS:\n\
7504\n\
7505plprec(setp, prec)\n\
7506\n\
7507ARGUMENTS:\n\
7508\n\
7509 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7510 automatically determines the number of places to use after the\n\
7511 decimal point in numeric labels (like those used to label axes).\n\
7512 If setp is 1 then prec sets the number of places.\n\
7513\n\
7514 prec (PLINT, input) : The number of characters to draw after the\n\
7515 decimal point in numeric labels.\n\
7516";
7517static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
7518Draw a line between two points\n\
7519\n\
7520DESCRIPTION:\n\
7521\n\
7522 Joins the point (\n\
7523 x1,\n\
7524 y1) to (\n\
7525 x2,\n\
7526 y2).\n\
7527\n\
7528 Redacted form: pljoin(x1,y1,x2,y2)\n\
7529\n\
7530 This function is used in examples 3 and 14.\n\
7531\n\
7532\n\
7533\n\
7534SYNOPSIS:\n\
7535\n\
7536pljoin(x1, y1, x2, y2)\n\
7537\n\
7538ARGUMENTS:\n\
7539\n\
7540 x1 (PLFLT, input) : x coordinate of first point.\n\
7541\n\
7542 y1 (PLFLT, input) : y coordinate of first point.\n\
7543\n\
7544 x2 (PLFLT, input) : x coordinate of second point.\n\
7545\n\
7546 y2 (PLFLT, input) : y coordinate of second point.\n\
7547";
7548static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7549Set the device (keyword) name\n\
7550\n\
7551DESCRIPTION:\n\
7552\n\
7553 Set the device (keyword) name.\n\
7554\n\
7555 Redacted form: plsdev(devname)\n\
7556\n\
7557 This function is used in examples 1, 14, and 20.\n\
7558\n\
7559\n\
7560\n\
7561SYNOPSIS:\n\
7562\n\
7563plsdev(devname)\n\
7564\n\
7565ARGUMENTS:\n\
7566\n\
7567 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7568 containing the device name keyword of the required output device.\n\
7569 If\n\
7570 devname is NULL or if the first character of the string is a ``?\'\',\n\
7571 the normal (prompted) start up is used.\n\
7572";
7573static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
7574Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7575\n\
7576DESCRIPTION:\n\
7577\n\
7578 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7579 (see the PLplot documentation) index. Overwrites the previous color\n\
7580 value for the given index and, thus, does not result in any additional\n\
7581 allocation of space for colors.\n\
7582\n\
7583 This function is used in example 30.\n\
7584\n\
7585\n\
7586\n\
7587SYNOPSIS:\n\
7588\n\
7589plscol0a(icol0, r, g, b, alpha)\n\
7590\n\
7591ARGUMENTS:\n\
7592\n\
7593 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7594 number of colors (which is set by default, by plscmap0n, or even\n\
7595 by plscmap0).\n\
7596\n\
7597 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7598 degree of red in the color.\n\
7599\n\
7600 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7601 degree of green in the color.\n\
7602\n\
7603 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7604 degree of blue in the color.\n\
7605\n\
7606 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7607 (0.0-1.0).\n\
7608";
7609static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
7610Draw filled polygon in 3D\n\
7611\n\
7612DESCRIPTION:\n\
7613\n\
7614 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7615 vectors using the pattern defined by plpsty or plpat. The routine\n\
7616 will automatically close the polygon between the last and first\n\
7617 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7618 plfill3 will fill in between them.\n\
7619\n\
7620 Redacted form: General: plfill3(x, y, z)\n\
7621\n\
7622\n\
7623 This function is used in example 15.\n\
7624\n\
7625\n\
7626\n\
7627SYNOPSIS:\n\
7628\n\
7629plfill3(n, x, y, z)\n\
7630\n\
7631ARGUMENTS:\n\
7632\n\
7633 n (PLINT, input) : Number of vertices in polygon.\n\
7634\n\
7635 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7636 vertices.\n\
7637\n\
7638 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7639 vertices.\n\
7640\n\
7641 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7642 vertices.\n\
7643";
7644static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
7645Specify window\n\
7646\n\
7647DESCRIPTION:\n\
7648\n\
7649 Specify the window, i.e., the world coordinates of the edges of the\n\
7650 viewport.\n\
7651\n\
7652 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7653\n\
7654 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7655 29, and 31.\n\
7656\n\
7657\n\
7658\n\
7659SYNOPSIS:\n\
7660\n\
7661plwind(xmin, xmax, ymin, ymax)\n\
7662\n\
7663ARGUMENTS:\n\
7664\n\
7665 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7666 of the viewport.\n\
7667\n\
7668 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7669 of the viewport.\n\
7670\n\
7671 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7672 the viewport.\n\
7673\n\
7674 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7675 viewport.\n\
7676";
7677static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
7678Draw text at points defined by Shapefile data in world coordinates\n\
7679\n\
7680DESCRIPTION:\n\
7681\n\
7682 As per plmapline, however the items are plotted as text in the same\n\
7683 way as plptex.\n\
7684\n\
7685 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7686 miny, maxy, plotentry)\n\
7687\n\
7688 This function is used in example 19.\n\
7689\n\
7690\n\
7691\n\
7692SYNOPSIS:\n\
7693\n\
7694plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7695\n\
7696ARGUMENTS:\n\
7697\n\
7698 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7699 transform the coordinates given in the shapefile into a plot\n\
7700 coordinate system. By using this transform, we can change from a\n\
7701 longitude, latitude coordinate to a polar stereographic project,\n\
7702 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7703 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7704 mapform(), x[] and y[] should be replaced by the corresponding\n\
7705 plot coordinates. If no transform is desired, mapform can be\n\
7706 replaced by NULL.\n\
7707\n\
7708 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7709 the file name of a set of Shapefile files without the file\n\
7710 extension.\n\
7711\n\
7712 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7713 dy/dx.\n\
7714\n\
7715 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7716 dy/dx.\n\
7717\n\
7718 just (PLFLT, input) : Set the justification of the text. The value\n\
7719 given will be the fraction of the distance along the string that\n\
7720 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7721 centralized text and 1.0 gives right aligned text.\n\
7722\n\
7723 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7724\n\
7725 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7726 be in the same units as used by the Shapefile. You could use a\n\
7727 very large negative number to plot everything, but you can improve\n\
7728 performance by limiting the area drawn. The units must match those\n\
7729 of the Shapefile projection, which may be for example longitude or\n\
7730 distance. The value of minx must be less than the value of maxx.\n\
7731\n\
7732 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7733 use a very large number to plot everything, but you can improve\n\
7734 performance by limiting the area drawn.\n\
7735\n\
7736 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7737 be in the same units as used by the Shapefile. You could use a\n\
7738 very large negative number to plot everything, but you can improve\n\
7739 performance by limiting the area drawn. The units must match those\n\
7740 of the Shapefile projection, which may be for example latitude or\n\
7741 distance. The value of miny must be less than the value of maxy.\n\
7742\n\
7743 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7744 use a very large number to plot everything, but you can improve\n\
7745 performance by limiting the area drawn.\n\
7746\n\
7747 plotentry (PLINT, input) : An integer indicating which text string\n\
7748 of the Shapefile (zero indexed) will be drawn.\n\
7749";
7750static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
7751Switch to graphics screen\n\
7752\n\
7753DESCRIPTION:\n\
7754\n\
7755 Sets an interactive device to graphics mode, used in conjunction with\n\
7756 pltext to allow graphics and text to be interspersed. On a device\n\
7757 which supports separate text and graphics windows, this command causes\n\
7758 control to be switched to the graphics window. If already in graphics\n\
7759 mode, this command is ignored. It is also ignored on devices which\n\
7760 only support a single window or use a different method for shifting\n\
7761 focus. See also pltext.\n\
7762\n\
7763 Redacted form: plgra()\n\
7764\n\
7765 This function is used in example 1.\n\
7766\n\
7767\n\
7768\n\
7769SYNOPSIS:\n\
7770\n\
7771plgra()\n\
7772";
7773static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7774Set parameters of contour labelling other than format of numerical label\n\
7775\n\
7776DESCRIPTION:\n\
7777\n\
7778 Set parameters of contour labelling other than those handled by\n\
7779 pl_setcontlabelformat.\n\
7780\n\
7781 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7782\n\
7783 This function is used in example 9.\n\
7784\n\
7785\n\
7786\n\
7787SYNOPSIS:\n\
7788\n\
7789pl_setcontlabelparam(offset, size, spacing, active)\n\
7790\n\
7791ARGUMENTS:\n\
7792\n\
7793 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7794 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7795\n\
7796 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7797 Default value is 0.3.\n\
7798\n\
7799 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7800 Default value is 0.1.\n\
7801\n\
7802 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7803 contour labels on. Default is off (0).\n\
7804";
7805static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7806Get family, style and weight of the current font\n\
7807\n\
7808DESCRIPTION:\n\
7809\n\
7810 Gets information about current font. See the PLplot documentation for\n\
7811 more information on font selection.\n\
7812\n\
7813 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7814\n\
7815 This function is used in example 23.\n\
7816\n\
7817\n\
7818\n\
7819SYNOPSIS:\n\
7820\n\
7821plgfont(p_family, p_style, p_weight)\n\
7822\n\
7823ARGUMENTS:\n\
7824\n\
7825 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7826 font family. The available values are given by the PL_FCI_*\n\
7827 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7828 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7829 p_family is NULL then the font family is not returned.\n\
7830\n\
7831 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7832 font style. The available values are given by the PL_FCI_*\n\
7833 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7834 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7835 style is not returned.\n\
7836\n\
7837 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7838 font weight. The available values are given by the PL_FCI_*\n\
7839 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7840 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7841 returned.\n\
7842";
7843static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7844Plot a histogram from unbinned data\n\
7845\n\
7846DESCRIPTION:\n\
7847\n\
7848 Plots a histogram from n data points stored in the data vector. This\n\
7849 routine bins the data into nbin bins equally spaced between datmin and\n\
7850 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7851 opt allows, among other things, the histogram either to be plotted in\n\
7852 an existing window or causes plhist to call plenv with suitable limits\n\
7853 before plotting the histogram.\n\
7854\n\
7855 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7856\n\
7857 This function is used in example 5.\n\
7858\n\
7859\n\
7860\n\
7861SYNOPSIS:\n\
7862\n\
7863plhist(n, data, datmin, datmax, nbin, opt)\n\
7864\n\
7865ARGUMENTS:\n\
7866\n\
7867 n (PLINT, input) : Number of data points.\n\
7868\n\
7869 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7870 n data points.\n\
7871\n\
7872 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7873\n\
7874 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7875\n\
7876 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7877 divide the interval xmin to xmax.\n\
7878\n\
7879 opt (PLINT, input) : Is a combination of several flags:\n\
7880 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7881 the histogram data, the outer bins are expanded to fill up the\n\
7882 entire x-axis, data outside the given extremes are assigned to the\n\
7883 outer bins and bins of zero height are simply drawn.\n\
7884 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7885 to fit the histogram data, without this flag, plenv is called\n\
7886 to set the world coordinates.\n\
7887 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7888 extremes are not taken into account. This option should\n\
7889 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7890 properly present the data.\n\
7891 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7892 size as the ones inside.\n\
7893 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7894 (there is a gap for such bins).\n\
7895";
7896static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7897Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7898\n\
7899DESCRIPTION:\n\
7900\n\
7901 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7902 alpha transparency value.\n\
7903\n\
7904 This function is used in example 31.\n\
7905\n\
7906\n\
7907\n\
7908SYNOPSIS:\n\
7909\n\
7910plgcolbga(r, g, b, alpha)\n\
7911\n\
7912ARGUMENTS:\n\
7913\n\
7914 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7915 in the range from 0 to 255.\n\
7916\n\
7917 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7918 in the range from 0 to 255.\n\
7919\n\
7920 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7921 in the range from 0 to 255.\n\
7922\n\
7923 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7924 transparency in the range (0.0-1.0).\n\
7925";
7926static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
7927Set orientation\n\
7928\n\
7929DESCRIPTION:\n\
7930\n\
7931 Set integer plot orientation parameter. This function is identical to\n\
7932 plsdiori except for the type of the argument, and should be used in\n\
7933 the same way. See the documentation of plsdiori for details.\n\
7934\n\
7935 Redacted form: plsori(ori)\n\
7936\n\
7937 This function is used in example 3.\n\
7938\n\
7939\n\
7940\n\
7941SYNOPSIS:\n\
7942\n\
7943plsori(ori)\n\
7944\n\
7945ARGUMENTS:\n\
7946\n\
7947 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
7948 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
7949 angle.\n\
7950";
7951static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
7952Plot latitude and longitude lines\n\
7953\n\
7954DESCRIPTION:\n\
7955\n\
7956 Displays latitude and longitude on the current plot. The lines are\n\
7957 plotted in the current color and line style.\n\
7958\n\
7959 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
7960 minlat, maxlat)\n\
7961\n\
7962 This function is used in example 19.\n\
7963\n\
7964\n\
7965\n\
7966SYNOPSIS:\n\
7967\n\
7968plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7969\n\
7970ARGUMENTS:\n\
7971\n\
7972 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7973 transform the coordinate longitudes and latitudes to a plot\n\
7974 coordinate system. By using this transform, we can change from a\n\
7975 longitude, latitude coordinate to a polar stereographic project,\n\
7976 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7977 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7978 mapform(), x[] and y[] should be replaced by the corresponding\n\
7979 plot coordinates. If no transform is desired, mapform can be\n\
7980 replaced by NULL.\n\
7981\n\
7982 dlong (PLFLT, input) : The interval in degrees at which the\n\
7983 longitude lines are to be plotted.\n\
7984\n\
7985 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7986 lines are to be plotted.\n\
7987\n\
7988 minlong (PLFLT, input) : The value of the longitude on the left\n\
7989 side of the plot. The value of minlong must be less than the value\n\
7990 of maxlong, and the quantity maxlong-minlong must be less than or\n\
7991 equal to 360.\n\
7992\n\
7993 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7994 side of the plot.\n\
7995\n\
7996 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7997 background. One can always use -90.0 as the boundary outside the\n\
7998 plot window will be automatically eliminated. However, the\n\
7999 program will be faster if one can reduce the size of the\n\
8000 background plotted.\n\
8001\n\
8002 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8003 background. One can always use 90.0 as the boundary outside the\n\
8004 plot window will be automatically eliminated.\n\
8005";
8006static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8007Clear current (sub)page\n\
8008\n\
8009DESCRIPTION:\n\
8010\n\
8011 Clears the current page, effectively erasing everything that have been\n\
8012 drawn. This command only works with interactive drivers; if the\n\
8013 driver does not support this, the page is filled with the background\n\
8014 color in use. If the current page is divided into subpages, only the\n\
8015 current subpage is erased. The nth subpage can be selected with\n\
8016 pladv(n).\n\
8017\n\
8018 Redacted form: General: plclear()\n\
8019\n\
8020\n\
8021 This function is not used in any examples.\n\
8022\n\
8023\n\
8024\n\
8025SYNOPSIS:\n\
8026\n\
8027plclear()\n\
8028";
8029static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
8030Initialization\n\
8031\n\
8032DESCRIPTION:\n\
8033\n\
8034 Initializing the plotting package. The program prompts for the device\n\
8035 keyword or number of the desired output device. Hitting a RETURN in\n\
8036 response to the prompt is the same as selecting the first device. If\n\
8037 only one device is enabled when PLplot is installed, plstar will issue\n\
8038 no prompt. The output device is divided into nx by ny subpages, each\n\
8039 of which may be used independently. The subroutine pladv is used to\n\
8040 advance from one subpage to the next.\n\
8041\n\
8042 Redacted form: plstar(nx, ny)\n\
8043\n\
8044 This function is used in example 1.\n\
8045\n\
8046\n\
8047\n\
8048SYNOPSIS:\n\
8049\n\
8050plstar(nx, ny)\n\
8051\n\
8052ARGUMENTS:\n\
8053\n\
8054 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8055 x direction.\n\
8056\n\
8057 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8058 y direction.\n\
8059";
8060static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
8061Write text relative to viewport boundaries\n\
8062\n\
8063DESCRIPTION:\n\
8064\n\
8065 Writes text at a specified position relative to the viewport\n\
8066 boundaries. Text may be written inside or outside the viewport, but\n\
8067 is clipped at the subpage boundaries. The reference point of a string\n\
8068 lies along a line passing through the string at half the height of a\n\
8069 capital letter. The position of the reference point along this line\n\
8070 is determined by just, and the position of the reference point\n\
8071 relative to the viewport is set by disp and pos.\n\
8072\n\
8073 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8074\n\
8075\n\
8076 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8077 26.\n\
8078\n\
8079\n\
8080\n\
8081SYNOPSIS:\n\
8082\n\
8083plmtex(side, disp, pos, just, text)\n\
8084\n\
8085ARGUMENTS:\n\
8086\n\
8087 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8088 the side of the viewport along which the text is to be written.\n\
8089 The string must be one of: b: Bottom of viewport, text written\n\
8090 parallel to edge.\n\
8091 bv: Bottom of viewport, text written at right angles to edge.\n\
8092 l: Left of viewport, text written parallel to edge.\n\
8093 lv: Left of viewport, text written at right angles to edge.\n\
8094 r: Right of viewport, text written parallel to edge.\n\
8095 rv: Right of viewport, text written at right angles to edge.\n\
8096 t: Top of viewport, text written parallel to edge.\n\
8097 tv: Top of viewport, text written at right angles to edge.\n\
8098\n\
8099\n\
8100 disp (PLFLT, input) : Position of the reference point of string,\n\
8101 measured outwards from the specified viewport edge in units of the\n\
8102 current character height. Use negative disp to write within the\n\
8103 viewport.\n\
8104\n\
8105 pos (PLFLT, input) : Position of the reference point of string\n\
8106 along the specified edge, expressed as a fraction of the length of\n\
8107 the edge.\n\
8108\n\
8109 just (PLFLT, input) : Specifies the position of the string relative\n\
8110 to its reference point. If just=0. , the reference point is at\n\
8111 the left and if just=1. , it is at the right of the string. Other\n\
8112 values of just give intermediate justifications.\n\
8113\n\
8114 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8115 written out.\n\
8116";
8117static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
8118Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8119\n\
8120DESCRIPTION:\n\
8121\n\
8122 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8123 PLFLT alpha transparency value (see the PLplot documentation).\n\
8124\n\
8125 This function is used in example 31.\n\
8126\n\
8127\n\
8128\n\
8129SYNOPSIS:\n\
8130\n\
8131plscolbga(r, g, b, alpha)\n\
8132\n\
8133ARGUMENTS:\n\
8134\n\
8135 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8136 degree of red in the color.\n\
8137\n\
8138 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8139 degree of green in the color.\n\
8140\n\
8141 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8142 degree of blue in the color.\n\
8143\n\
8144 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8145 (0.0-1.0).\n\
8146";
8147static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
8148Replays contents of plot buffer to current device/file\n\
8149\n\
8150DESCRIPTION:\n\
8151\n\
8152 Replays contents of plot buffer to current device/file.\n\
8153\n\
8154 Redacted form: plreplot()\n\
8155\n\
8156 This function is used in example 1,20.\n\
8157\n\
8158\n\
8159\n\
8160SYNOPSIS:\n\
8161\n\
8162plreplot()\n\
8163";
8164static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
8165Plot a glyph at the specified 3D points\n\
8166\n\
8167DESCRIPTION:\n\
8168\n\
8169 Plot a glyph at the specified 3D points. (This function is largely\n\
8170 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8171 Set up the call to this function similar to what is done for plline3.\n\
8172 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8173 and a draw at the same place. Not ideal, since a sufficiently\n\
8174 intelligent output device may optimize it away, or there may be faster\n\
8175 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8176 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8177 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8178 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8179 code <= 127 the corresponding printable ASCII character is plotted.\n\
8180\n\
8181 Redacted form: plpoin3(x, y, z, code)\n\
8182\n\
8183 This function is not used in any example.\n\
8184\n\
8185\n\
8186\n\
8187SYNOPSIS:\n\
8188\n\
8189plpoin3(n, x, y, z, code)\n\
8190\n\
8191ARGUMENTS:\n\
8192\n\
8193 n (PLINT, input) : Number of points in the x and y vectors.\n\
8194\n\
8195 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8196 points.\n\
8197\n\
8198 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8199 points.\n\
8200\n\
8201 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8202 points.\n\
8203\n\
8204 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8205 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8206 each of the n points.\n\
8207";
8208static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
8209Set family, style and weight of the current font\n\
8210\n\
8211DESCRIPTION:\n\
8212\n\
8213 Sets the current font. See the PLplot documentation for more\n\
8214 information on font selection.\n\
8215\n\
8216 Redacted form: plsfont(family, style, weight)\n\
8217\n\
8218 This function is used in example 23.\n\
8219\n\
8220\n\
8221\n\
8222SYNOPSIS:\n\
8223\n\
8224plsfont(family, style, weight)\n\
8225\n\
8226ARGUMENTS:\n\
8227\n\
8228 family (PLINT, input) : Font family to select for the current font.\n\
8229 The available values are given by the PL_FCI_* constants in\n\
8230 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8231 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8232 signifies that the font family should not be altered.\n\
8233\n\
8234 style (PLINT, input) : Font style to select for the current font.\n\
8235 The available values are given by the PL_FCI_* constants in\n\
8236 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8237 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8238 should not be altered.\n\
8239\n\
8240 weight (PLINT, input) : Font weight to select for the current font.\n\
8241 The available values are given by the PL_FCI_* constants in\n\
8242 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8243 negative value signifies that the font weight should not be\n\
8244 altered.\n\
8245";
8246static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
8247Draw a box with axes, etc. with arbitrary origin\n\
8248\n\
8249DESCRIPTION:\n\
8250\n\
8251 Draws a box around the currently defined viewport with arbitrary\n\
8252 world-coordinate origin specified by x0 and y0 and labels it with\n\
8253 world coordinate values appropriate to the window. Thus plaxes should\n\
8254 only be called after defining both viewport and window. The ascii\n\
8255 character strings xopt and yopt specify how the box should be drawn as\n\
8256 described below. If ticks and/or subticks are to be drawn for a\n\
8257 particular axis, the tick intervals and number of subintervals may be\n\
8258 specified explicitly, or they may be defaulted by setting the\n\
8259 appropriate arguments to zero.\n\
8260\n\
8261 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8262 ytick, nysub)\n\
8263\n\
8264\n\
8265 This function is not used in any examples.\n\
8266\n\
8267\n\
8268\n\
8269SYNOPSIS:\n\
8270\n\
8271plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8272\n\
8273ARGUMENTS:\n\
8274\n\
8275 x0 (PLFLT, input) : World X coordinate of origin.\n\
8276\n\
8277 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8278\n\
8279 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8280 options for the x axis. The string can include any combination of\n\
8281 the following letters (upper or lower case) in any order: a: Draws\n\
8282 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8283 (x=0).\n\
8284 b: Draws bottom (X) or left (Y) edge of frame.\n\
8285 c: Draws top (X) or right (Y) edge of frame.\n\
8286 d: Plot labels as date / time. Values are assumed to be\n\
8287 seconds since the epoch (as used by gmtime).\n\
8288 f: Always use fixed point numeric labels.\n\
8289 g: Draws a grid at the major tick interval.\n\
8290 h: Draws a grid at the minor tick interval.\n\
8291 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8292 inwards.\n\
8293 l: Labels axis logarithmically. This only affects the labels,\n\
8294 not the data, and so it is necessary to compute the logarithms\n\
8295 of data points before passing them to any of the drawing\n\
8296 routines.\n\
8297 m: Writes numeric labels at major tick intervals in the\n\
8298 unconventional location (above box for X, right of box for Y).\n\
8299 n: Writes numeric labels at major tick intervals in the\n\
8300 conventional location (below box for X, left of box for Y).\n\
8301 o: Use custom labelling function to generate axis label text.\n\
8302 The custom labelling function can be defined with the\n\
8303 plslabelfunc command.\n\
8304 s: Enables subticks between major ticks, only valid if t is\n\
8305 also specified.\n\
8306 t: Draws major ticks.\n\
8307 u: Exactly like \"b\" except don\'t draw edge line.\n\
8308 w: Exactly like \"c\" except don\'t draw edge line.\n\
8309 x: Exactly like \"t\" (including the side effect of the\n\
8310 numerical labels for the major ticks) except exclude drawing\n\
8311 the major and minor tick marks.\n\
8312\n\
8313\n\
8314 xtick (PLFLT, input) : World coordinate interval between major\n\
8315 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8316 generates a suitable tick interval.\n\
8317\n\
8318 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8319 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8320 generates a suitable minor tick interval.\n\
8321\n\
8322 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8323 options for the y axis. The string can include any combination of\n\
8324 the letters defined above for xopt, and in addition may contain:\n\
8325 v: Write numeric labels for the y axis parallel to the base of the\n\
8326 graph, rather than parallel to the axis.\n\
8327\n\
8328\n\
8329 ytick (PLFLT, input) : World coordinate interval between major\n\
8330 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8331 generates a suitable tick interval.\n\
8332\n\
8333 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8334 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8335 generates a suitable minor tick interval.\n\
8336";
8337static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
8338Begin a new page\n\
8339\n\
8340DESCRIPTION:\n\
8341\n\
8342 Begins a new page. For a file driver, the output file is opened if\n\
8343 necessary. Advancing the page via pleop and plbop is useful when a\n\
8344 page break is desired at a particular point when plotting to subpages.\n\
8345 Another use for pleop and plbop is when plotting pages to different\n\
8346 files, since you can manually set the file name by calling plsfnam\n\
8347 after the call to pleop. (In fact some drivers may only support a\n\
8348 single page per file, making this a necessity.) One way to handle\n\
8349 this case automatically is to page advance via pladv, but enable\n\
8350 familying (see plsfam) with a small limit on the file size so that a\n\
8351 new family member file will be created on each page break.\n\
8352\n\
8353 Redacted form: plbop()\n\
8354\n\
8355 This function is used in examples 2 and 20.\n\
8356\n\
8357\n\
8358\n\
8359SYNOPSIS:\n\
8360\n\
8361plbop()\n\
8362";
8363static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8364Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8365\n\
8366DESCRIPTION:\n\
8367\n\
8368 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8369 and PLFLT alpha transparency value. This sets the entire color map --\n\
8370 only as many colors as specified will be allocated.\n\
8371\n\
8372 Redacted form: plscmap0a(r, g, b, alpha)\n\
8373\n\
8374 This function is used in examples 30.\n\
8375\n\
8376\n\
8377\n\
8378SYNOPSIS:\n\
8379\n\
8380plscmap0a(r, g, b, alpha, ncol0)\n\
8381\n\
8382ARGUMENTS:\n\
8383\n\
8384 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8385 integers (0-255) representing the degree of red in the color.\n\
8386\n\
8387 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8388 integers (0-255) representing the degree of green in the color.\n\
8389\n\
8390 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8391 integers (0-255) representing the degree of blue in the color.\n\
8392\n\
8393 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8394 representing the alpha transparency of the color.\n\
8395\n\
8396 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8397 vectors.\n\
8398";
8399static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
8400Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8401\n\
8402DESCRIPTION:\n\
8403\n\
8404 This is a variant of plscmap1l that supports alpha channel\n\
8405 transparency. It sets cmap1 colors using a piece-wise linear\n\
8406 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8407 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8408 transparency value (0.0-1.0). It may be called at any time.\n\
8409\n\
8410 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8411 alpha, alt_hue_path)\n\
8412\n\
8413 This function is used in example 30.\n\
8414\n\
8415\n\
8416\n\
8417SYNOPSIS:\n\
8418\n\
8419plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8420\n\
8421ARGUMENTS:\n\
8422\n\
8423 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8424\n\
8425 npts (PLINT, input) : number of control points.\n\
8426\n\
8427 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8428 intensity index (0.0-1.0) in ascending order for each control\n\
8429 point.\n\
8430\n\
8431 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8432 coordinate (H or R) for each control point.\n\
8433\n\
8434 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8435 coordinate (L or G) for each control point.\n\
8436\n\
8437 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8438 coordinate (S or B) for each control point.\n\
8439\n\
8440 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8441 transparency value (0.0-1.0) for each control point.\n\
8442\n\
8443 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8444 npts - 1 elements) containing the alternative interpolation method\n\
8445 Boolean value for each control point interval. (alt_hue_path[i]\n\
8446 refers to the interpolation interval between the i and i + 1\n\
8447 control points).\n\
8448";
8449static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
8450Enter or leave xor mode\n\
8451\n\
8452DESCRIPTION:\n\
8453\n\
8454 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8455 those drivers (e.g., the xwin driver) that support it. Enables\n\
8456 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8457 is not capable of xor operation it returns a status of false.\n\
8458\n\
8459 Redacted form: plxormod(mode, status)\n\
8460\n\
8461 This function is used in examples 1 and 20.\n\
8462\n\
8463\n\
8464\n\
8465SYNOPSIS:\n\
8466\n\
8467plxormod(mode, status)\n\
8468\n\
8469ARGUMENTS:\n\
8470\n\
8471 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8472 is false means leave xor mode.\n\
8473\n\
8474 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8475 modestatus of true (false) means driver is capable (incapable) of\n\
8476 xor mode.\n\
8477";
8478static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8479Eject current page\n\
8480\n\
8481DESCRIPTION:\n\
8482\n\
8483 Clears the graphics screen of an interactive device, or ejects a page\n\
8484 on a plotter. See plbop for more information.\n\
8485\n\
8486 Redacted form: pleop()\n\
8487\n\
8488 This function is used in example 2,14.\n\
8489\n\
8490\n\
8491\n\
8492SYNOPSIS:\n\
8493\n\
8494pleop()\n\
8495";
8496static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
8497Draw a box with axes, etc\n\
8498\n\
8499DESCRIPTION:\n\
8500\n\
8501 Draws a box around the currently defined viewport, and labels it with\n\
8502 world coordinate values appropriate to the window. Thus plbox should\n\
8503 only be called after defining both viewport and window. The ascii\n\
8504 character strings xopt and yopt specify how the box should be drawn as\n\
8505 described below. If ticks and/or subticks are to be drawn for a\n\
8506 particular axis, the tick intervals and number of subintervals may be\n\
8507 specified explicitly, or they may be defaulted by setting the\n\
8508 appropriate arguments to zero.\n\
8509\n\
8510 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8511\n\
8512\n\
8513 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8514 and 29.\n\
8515\n\
8516\n\
8517\n\
8518SYNOPSIS:\n\
8519\n\
8520plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8521\n\
8522ARGUMENTS:\n\
8523\n\
8524 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8525 options for the x axis. The string can include any combination of\n\
8526 the following letters (upper or lower case) in any order: a: Draws\n\
8527 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8528 (x=0).\n\
8529 b: Draws bottom (X) or left (Y) edge of frame.\n\
8530 c: Draws top (X) or right (Y) edge of frame.\n\
8531 d: Plot labels as date / time. Values are assumed to be\n\
8532 seconds since the epoch (as used by gmtime).\n\
8533 f: Always use fixed point numeric labels.\n\
8534 g: Draws a grid at the major tick interval.\n\
8535 h: Draws a grid at the minor tick interval.\n\
8536 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8537 inwards.\n\
8538 l: Labels axis logarithmically. This only affects the labels,\n\
8539 not the data, and so it is necessary to compute the logarithms\n\
8540 of data points before passing them to any of the drawing\n\
8541 routines.\n\
8542 m: Writes numeric labels at major tick intervals in the\n\
8543 unconventional location (above box for X, right of box for Y).\n\
8544 n: Writes numeric labels at major tick intervals in the\n\
8545 conventional location (below box for X, left of box for Y).\n\
8546 o: Use custom labelling function to generate axis label text.\n\
8547 The custom labelling function can be defined with the\n\
8548 plslabelfunc command.\n\
8549 s: Enables subticks between major ticks, only valid if t is\n\
8550 also specified.\n\
8551 t: Draws major ticks.\n\
8552 u: Exactly like \"b\" except don\'t draw edge line.\n\
8553 w: Exactly like \"c\" except don\'t draw edge line.\n\
8554 x: Exactly like \"t\" (including the side effect of the\n\
8555 numerical labels for the major ticks) except exclude drawing\n\
8556 the major and minor tick marks.\n\
8557\n\
8558\n\
8559 xtick (PLFLT, input) : World coordinate interval between major\n\
8560 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8561 generates a suitable tick interval.\n\
8562\n\
8563 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8564 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8565 generates a suitable minor tick interval.\n\
8566\n\
8567 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8568 options for the y axis. The string can include any combination of\n\
8569 the letters defined above for xopt, and in addition may contain:\n\
8570 v: Write numeric labels for the y axis parallel to the base of the\n\
8571 graph, rather than parallel to the axis.\n\
8572\n\
8573\n\
8574 ytick (PLFLT, input) : World coordinate interval between major\n\
8575 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8576 generates a suitable tick interval.\n\
8577\n\
8578 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8579 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8580 generates a suitable minor tick interval.\n\
8581";
8582static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
8583Get x axis parameters\n\
8584\n\
8585DESCRIPTION:\n\
8586\n\
8587 Returns current values of the p_digmax and p_digits flags for the x\n\
8588 axis. p_digits is updated after the plot is drawn, so this routine\n\
8589 should only be called after the call to plbox (or plbox3) is complete.\n\
8590 See the PLplot documentation for more information.\n\
8591\n\
8592 Redacted form: plgxax(p_digmax, p_digits)\n\
8593\n\
8594 This function is used in example 31.\n\
8595\n\
8596\n\
8597\n\
8598SYNOPSIS:\n\
8599\n\
8600plgxax(p_digmax, p_digits)\n\
8601\n\
8602ARGUMENTS:\n\
8603\n\
8604 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8605 number of digits for the x axis. If nonzero, the printed label\n\
8606 has been switched to a floating-point representation when the\n\
8607 number of digits exceeds this value.\n\
8608\n\
8609 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8610 number of digits for the numeric labels (x axis) from the last\n\
8611 plot.\n\
8612";
8613static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
8614Set font\n\
8615\n\
8616DESCRIPTION:\n\
8617\n\
8618 Sets the font used for subsequent text and symbols. For devices that\n\
8619 still use Hershey fonts this routine has no effect unless the Hershey\n\
8620 fonts with extended character set are loaded (see plfontld). For\n\
8621 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8622 this routine calls the plsfci routine with argument set up\n\
8623 appropriately for the various cases below. However, this method of\n\
8624 specifying the font for unicode-aware devices is deprecated, and the\n\
8625 much more flexible method of calling plsfont directly is recommended\n\
8626 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8627\n\
8628 Redacted form: plfont(ifont)\n\
8629\n\
8630 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8631\n\
8632\n\
8633\n\
8634SYNOPSIS:\n\
8635\n\
8636plfont(ifont)\n\
8637\n\
8638ARGUMENTS:\n\
8639\n\
8640 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8641 (simplest and fastest)\n\
8642 2: Serif font\n\
8643 3: Italic font\n\
8644 4: Script font\n\
8645";
8646static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
8647Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8648\n\
8649DESCRIPTION:\n\
8650\n\
8651 Routine for creating a discrete plot legend with a plotted filled box,\n\
8652 line, and/or line of symbols for each annotated legend entry. (See\n\
8653 plcolorbar for similar functionality for creating continuous color\n\
8654 bars.) The arguments of pllegend provide control over the location\n\
8655 and size of the legend as well as the location and characteristics of\n\
8656 the elements (most of which are optional) within that legend. The\n\
8657 resulting legend is clipped at the boundaries of the current subpage.\n\
8658 (N.B. the adopted coordinate system used for some of the parameters is\n\
8659 defined in the documentation of the position parameter.)\n\
8660\n\
8661 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8662 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8663 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8664 test_justification, text_colors, text, box_colors, box_patterns,\n\
8665 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8666 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8667\n\
8668 This function is used in examples 4, 26, and 33.\n\
8669\n\
8670\n\
8671\n\
8672SYNOPSIS:\n\
8673\n\
8674pllegend(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\
8675\n\
8676ARGUMENTS:\n\
8677\n\
8678 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8679 legend width in adopted coordinates. This quantity is calculated\n\
8680 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8681 the routine depending on nlegend and nrow), and the length\n\
8682 (calculated internally) of the longest text string.\n\
8683\n\
8684 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8685 legend height in adopted coordinates. This quantity is calculated\n\
8686 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8687 the routine depending on nlegend and nrow).\n\
8688\n\
8689 opt (PLINT, input) : opt contains bits controlling the overall\n\
8690 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8691 on the left of the legend and the plotted area on the right.\n\
8692 Otherwise, put the text area on the right of the legend and the\n\
8693 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8694 plot a (semitransparent) background for the legend. If the\n\
8695 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8696 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8697 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8698 plot the resulting array of legend entries in row-major order.\n\
8699 Otherwise, plot the legend entries in column-major order.\n\
8700\n\
8701 position (PLINT, input) : position contains bits which control the\n\
8702 overall position of the legend and the definition of the adopted\n\
8703 coordinates used for positions just like what is done for the\n\
8704 position argument for plcolorbar. However, note that the defaults\n\
8705 for the position bits (see below) are different than the\n\
8706 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8707 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8708 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8709 the 16 possible standard positions (the 4 corners and centers of\n\
8710 the 4 sides for both the inside and outside cases) of the legend\n\
8711 relative to the adopted coordinate system. The corner positions\n\
8712 are specified by the appropriate combination of two of the\n\
8713 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8714 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8715 value of one of those bits. The adopted coordinates are\n\
8716 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8717 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8718 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8719 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8720 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8721 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8722 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8723 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8724\n\
8725 x (PLFLT, input) : X offset of the legend position in adopted\n\
8726 coordinates from the specified standard position of the legend.\n\
8727 For positive x, the direction of motion away from the standard\n\
8728 position is inward/outward from the standard corner positions or\n\
8729 standard left or right positions if the\n\
8730 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8731 For the standard top or bottom positions, the direction of motion\n\
8732 is toward positive X.\n\
8733\n\
8734 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8735 coordinates from the specified standard position of the legend.\n\
8736 For positive y, the direction of motion away from the standard\n\
8737 position is inward/outward from the standard corner positions or\n\
8738 standard top or bottom positions if the\n\
8739 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8740 the standard left or right positions, the direction of motion is\n\
8741 toward positive Y.\n\
8742\n\
8743 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8744 of the plot area (where the colored boxes, lines, and/or lines of\n\
8745 symbols are drawn) of the legend.\n\
8746\n\
8747 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8748 legend (PL_LEGEND_BACKGROUND).\n\
8749\n\
8750 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8751 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8752\n\
8753 bb_style (PLINT, input) : The pllsty style number for the\n\
8754 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8755\n\
8756 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8757 render the\n\
8758 nlegend legend entries. For internal transformations of\n\
8759 nrow, see further remarks under\n\
8760 nlegend.\n\
8761\n\
8762 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8763 to render the\n\
8764 nlegend legend entries. For internal transformations of\n\
8765 ncolumn, see further remarks under\n\
8766 nlegend.\n\
8767\n\
8768 nlegend (PLINT, input) : Number of legend entries. The above\n\
8769 nrow and\n\
8770 ncolumn values are transformed internally to be consistent with\n\
8771 nlegend. If either\n\
8772 nrow or\n\
8773 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8774 of\n\
8775 nrow and\n\
8776 ncolumn is less than\n\
8777 nlegend, the smaller of the two (or\n\
8778 nrow, if\n\
8779 nrow ==\n\
8780 ncolumn) is increased so the product is >=\n\
8781 nlegend. Thus, for example, the common\n\
8782 nrow = 0,\n\
8783 ncolumn = 0 case is transformed internally to\n\
8784 nrow =\n\
8785 nlegend,\n\
8786 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8787 column.\n\
8788\n\
8789 opt_array (PLINT_VECTOR, input) : A vector of\n\
8790 nlegend values of options to control each individual plotted area\n\
8791 corresponding to a legend entry. If the\n\
8792 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8793 area. If the\n\
8794 PL_LEGEND_COLOR_BOX,\n\
8795 PL_LEGEND_LINE, and/or\n\
8796 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8797 entry is plotted with a colored box; a line; and/or a line of\n\
8798 symbols.\n\
8799\n\
8800 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8801 area in units of character width.\n\
8802\n\
8803 text_scale (PLFLT, input) : Character height scale for text\n\
8804 annotations.\n\
8805\n\
8806 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8807 character height from one legend entry to the next.\n\
8808\n\
8809 text_justification (PLFLT, input) : Justification parameter used\n\
8810 for text justification. The most common values of\n\
8811 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8812 is left justified, centred, or right justified within the text\n\
8813 area, but other values are allowed as well.\n\
8814\n\
8815 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8816 nlegend cmap0 text colors.\n\
8817\n\
8818 text (PLCHAR_MATRIX, input) : A vector of\n\
8819 nlegend UTF-8 character strings containing the legend annotations.\n\
8820\n\
8821 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8822 nlegend cmap0 colors for the discrete colored boxes (\n\
8823 PL_LEGEND_COLOR_BOX).\n\
8824\n\
8825 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8826 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8827 PL_LEGEND_COLOR_BOX).\n\
8828\n\
8829 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8830 nlegend scales (units of fraction of character height) for the height\n\
8831 of the discrete colored boxes (\n\
8832 PL_LEGEND_COLOR_BOX).\n\
8833\n\
8834 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8835 nlegend line widths for the patterns specified by box_patterns (\n\
8836 PL_LEGEND_COLOR_BOX).\n\
8837\n\
8838 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8839 nlegend cmap0 line colors (\n\
8840 PL_LEGEND_LINE).\n\
8841\n\
8842 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8843 nlegend line styles (plsty indices) (\n\
8844 PL_LEGEND_LINE).\n\
8845\n\
8846 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8847 nlegend line widths (\n\
8848 PL_LEGEND_LINE).\n\
8849\n\
8850 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8851 nlegend cmap0 symbol colors (\n\
8852 PL_LEGEND_SYMBOL).\n\
8853\n\
8854 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8855 nlegend scale values for the symbol height (\n\
8856 PL_LEGEND_SYMBOL).\n\
8857\n\
8858 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8859 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8860 area (\n\
8861 PL_LEGEND_SYMBOL).\n\
8862\n\
8863 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8864 nlegend UTF-8 character strings containing the legend symbols. (\n\
8865 PL_LEGEND_SYMBOL).\n\
8866";
8867static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8868Set the background color by 8-bit RGB value\n\
8869\n\
8870DESCRIPTION:\n\
8871\n\
8872 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8873 the PLplot documentation).\n\
8874\n\
8875 Redacted form: plscolbg(r, g, b)\n\
8876\n\
8877 This function is used in examples 15 and 31.\n\
8878\n\
8879\n\
8880\n\
8881SYNOPSIS:\n\
8882\n\
8883plscolbg(r, g, b)\n\
8884\n\
8885ARGUMENTS:\n\
8886\n\
8887 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8888 degree of red in the color.\n\
8889\n\
8890 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8891 degree of green in the color.\n\
8892\n\
8893 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8894 degree of blue in the color.\n\
8895";
8896static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
8897Set parameters that define current device-space window\n\
8898\n\
8899DESCRIPTION:\n\
8900\n\
8901 Set relative margin width, aspect ratio, and relative justification\n\
8902 that define current device-space window. If you want to just use the\n\
8903 previous value for any of these, just pass in the magic value\n\
8904 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8905 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8906 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8907 to a device-specific value.\n\
8908\n\
8909 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8910\n\
8911 This function is used in example 31.\n\
8912\n\
8913\n\
8914\n\
8915SYNOPSIS:\n\
8916\n\
8917plsdidev(mar, aspect, jx, jy)\n\
8918\n\
8919ARGUMENTS:\n\
8920\n\
8921 mar (PLFLT, input) : Relative margin width.\n\
8922\n\
8923 aspect (PLFLT, input) : Aspect ratio.\n\
8924\n\
8925 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8926 the range -0.5 to 0.5.\n\
8927\n\
8928 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8929 the range -0.5 to 0.5.\n\
8930";
8931static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
8932Specify viewport using aspect ratio only\n\
8933\n\
8934DESCRIPTION:\n\
8935\n\
8936 Selects the largest viewport with the given aspect ratio within the\n\
8937 subpage that leaves a standard margin (left-hand margin of eight\n\
8938 character heights, and a margin around the other three sides of five\n\
8939 character heights).\n\
8940\n\
8941 Redacted form: plvasp(aspect)\n\
8942\n\
8943 This function is used in example 13.\n\
8944\n\
8945\n\
8946\n\
8947SYNOPSIS:\n\
8948\n\
8949plvasp(aspect)\n\
8950\n\
8951ARGUMENTS:\n\
8952\n\
8953 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8954 axis of resulting viewport.\n\
8955";
8956static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
8957Configure the transformations required for projecting a 3D surface on a 2D window\n\
8958\n\
8959DESCRIPTION:\n\
8960\n\
8961 Configure the transformations required for projecting a 3D surface on\n\
8962 an existing 2D window. Those transformations (see the PLplot\n\
8963 documentation) are done to a rectangular cuboid enclosing the 3D\n\
8964 surface which has its limits expressed in 3D world coordinates and\n\
8965 also normalized 3D coordinates (used for interpreting the altitude and\n\
8966 azimuth of the viewing angle). The transformations consist of the\n\
8967 linear transform from 3D world coordinates to normalized 3D\n\
8968 coordinates, and the 3D rotation of normalized coordinates required to\n\
8969 align the pole of the new 3D coordinate system with the viewing\n\
8970 direction specified by altitude and azimuth so that x and y of the\n\
8971 surface elements in that transformed coordinate system are the\n\
8972 projection of the 3D surface with given viewing direction on the 2D\n\
8973 window.\n\
8974\n\
8975 The enclosing rectangular cuboid for the surface plot is defined by\n\
8976 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
8977 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
8978 sizes of basex by basey by height so that xmin maps to -\n\
8979 basex/2, xmax maps to basex/2, ymin maps to -\n\
8980 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
8981 The resulting rectangular cuboid in normalized coordinates is then\n\
8982 viewed by an observer at altitude alt and azimuth az. This routine\n\
8983 must be called before plbox3 or any of the 3D surface plotting\n\
8984 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
8985 plsurf3dl or plfill3.\n\
8986\n\
8987 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
8988 zmin, zmax, alt, az)\n\
8989\n\
8990 This function is examples 8, 11, 18, and 21.\n\
8991\n\
8992\n\
8993\n\
8994SYNOPSIS:\n\
8995\n\
8996plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
8997\n\
8998ARGUMENTS:\n\
8999\n\
9000 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9001 rectangular cuboid.\n\
9002\n\
9003 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9004 rectangular cuboid.\n\
9005\n\
9006 height (PLFLT, input) : The normalized z coordinate size of the\n\
9007 rectangular cuboid.\n\
9008\n\
9009 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9010 rectangular cuboid.\n\
9011\n\
9012 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9013 rectangular cuboid.\n\
9014\n\
9015 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9016 rectangular cuboid.\n\
9017\n\
9018 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9019 rectangular cuboid.\n\
9020\n\
9021 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9022 rectangular cuboid.\n\
9023\n\
9024 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9025 rectangular cuboid.\n\
9026\n\
9027 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9028 plane of the rectangular cuboid in normalized coordinates.\n\
9029\n\
9030 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9031 rectangular cuboid in normalized coordinates. When az=0, the\n\
9032 observer is looking face onto the zx plane of the rectangular\n\
9033 cuboid in normalized coordinates, and as az is increased, the\n\
9034 observer moves clockwise around that cuboid when viewed from above\n\
9035 the xy plane.\n\
9036";
9037static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
9038Wait for graphics input event and translate to world coordinates.\n\
9039\n\
9040DESCRIPTION:\n\
9041\n\
9042 Wait for graphics input event and translate to world coordinates.\n\
9043 Returns 0 if no translation to world coordinates is possible.\n\
9044\n\
9045 This function returns 1 on success and 0 if no translation to world\n\
9046 coordinates is possible.\n\
9047\n\
9048 Redacted form: plGetCursor(gin)\n\
9049\n\
9050 This function is used in examples 1 and 20.\n\
9051\n\
9052\n\
9053\n\
9054SYNOPSIS:\n\
9055\n\
9056PLINT plGetCursor(gin)\n\
9057\n\
9058ARGUMENTS:\n\
9059\n\
9060 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9061 which will contain the output. The structure is not allocated by\n\
9062 the routine and must exist before the function is called.\n\
9063";
9064static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9065Set number of colors in cmap0\n\
9066\n\
9067DESCRIPTION:\n\
9068\n\
9069 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9070 (or reallocate) cmap0, and fill with default values for those colors\n\
9071 not previously allocated. The first 16 default colors are given in\n\
9072 the plcol0 documentation. For larger indices the default color is\n\
9073 red.\n\
9074\n\
9075 The drivers are not guaranteed to support more than 16 colors.\n\
9076\n\
9077 Redacted form: plscmap0n(ncol0)\n\
9078\n\
9079 This function is used in examples 15, 16, and 24.\n\
9080\n\
9081\n\
9082\n\
9083SYNOPSIS:\n\
9084\n\
9085plscmap0n(ncol0)\n\
9086\n\
9087ARGUMENTS:\n\
9088\n\
9089 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9090 the cmap0 palette. If this number is zero or less, then the value\n\
9091 from the previous call to plscmap0n is used and if there is no\n\
9092 previous call, then a default value is used.\n\
9093";
9094static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
9095Set z axis parameters\n\
9096\n\
9097DESCRIPTION:\n\
9098\n\
9099 Identical to plsxax, except that arguments are flags for z axis. See\n\
9100 the description of plsxax for more detail.\n\
9101\n\
9102 Redacted form: plszax(digmax, digits)\n\
9103\n\
9104 This function is used in example 31.\n\
9105\n\
9106\n\
9107\n\
9108SYNOPSIS:\n\
9109\n\
9110plszax(digmax, digits)\n\
9111\n\
9112ARGUMENTS:\n\
9113\n\
9114 digmax (PLINT, input) : Variable to set the maximum number of\n\
9115 digits for the z axis. If nonzero, the printed label will be\n\
9116 switched to a floating-point representation when the number of\n\
9117 digits exceeds digmax.\n\
9118\n\
9119 digits (PLINT, input) : Field digits value. Currently, changing\n\
9120 its value here has no effect since it is set only by plbox or\n\
9121 plbox3. However, the user may obtain its value after a call to\n\
9122 either of these functions by calling plgzax.\n\
9123";
9124static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
9125Get FCI (font characterization integer)\n\
9126\n\
9127DESCRIPTION:\n\
9128\n\
9129 Gets information about the current font using the FCI approach. See\n\
9130 the PLplot documentation for more information.\n\
9131\n\
9132 Redacted form: plgfci(p_fci)\n\
9133\n\
9134 This function is used in example 23.\n\
9135\n\
9136\n\
9137\n\
9138SYNOPSIS:\n\
9139\n\
9140plgfci(p_fci)\n\
9141\n\
9142ARGUMENTS:\n\
9143\n\
9144 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9145 FCI value.\n\
9146";
9147static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
9148Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9149\n\
9150DESCRIPTION:\n\
9151\n\
9152 Sets up plotter environment for simple graphs by calling pladv and\n\
9153 setting up viewport and window to sensible default values. plenv0\n\
9154 leaves a standard margin (left-hand margin of eight character heights,\n\
9155 and a margin around the other three sides of five character heights)\n\
9156 around most graphs for axis labels and a title. When these defaults\n\
9157 are not suitable, use the individual routines plvpas, plvpor, or\n\
9158 plvasp for setting up the viewport, plwind for defining the window,\n\
9159 and plbox for drawing the box.\n\
9160\n\
9161 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9162\n\
9163 This function is used in example 21.\n\
9164\n\
9165\n\
9166\n\
9167SYNOPSIS:\n\
9168\n\
9169plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9170\n\
9171ARGUMENTS:\n\
9172\n\
9173 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9174 world coordinates).\n\
9175\n\
9176 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9177 world coordinates).\n\
9178\n\
9179 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9180 coordinates).\n\
9181\n\
9182 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9183 coordinates).\n\
9184\n\
9185 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9186 scales will not be set, the user must set up the scale before\n\
9187 calling plenv0 using plsvpa, plvasp or other.\n\
9188 0: the x and y axes are scaled independently to use as much of\n\
9189 the screen as possible.\n\
9190 1: the scales of the x and y axes are made equal.\n\
9191 2: the axis of the x and y axes are made equal, and the plot\n\
9192 box will be square.\n\
9193\n\
9194\n\
9195 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9196 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9197 -1: draw box only.\n\
9198 0: draw box, ticks, and numeric tick labels.\n\
9199 1: also draw coordinate axes at x=0 and y=0.\n\
9200 2: also draw a grid at major tick positions in both\n\
9201 coordinates.\n\
9202 3: also draw a grid at minor tick positions in both\n\
9203 coordinates.\n\
9204 10: same as 0 except logarithmic x tick marks. (The x data\n\
9205 have to be converted to logarithms separately.)\n\
9206 11: same as 1 except logarithmic x tick marks. (The x data\n\
9207 have to be converted to logarithms separately.)\n\
9208 12: same as 2 except logarithmic x tick marks. (The x data\n\
9209 have to be converted to logarithms separately.)\n\
9210 13: same as 3 except logarithmic x tick marks. (The x data\n\
9211 have to be converted to logarithms separately.)\n\
9212 20: same as 0 except logarithmic y tick marks. (The y data\n\
9213 have to be converted to logarithms separately.)\n\
9214 21: same as 1 except logarithmic y tick marks. (The y data\n\
9215 have to be converted to logarithms separately.)\n\
9216 22: same as 2 except logarithmic y tick marks. (The y data\n\
9217 have to be converted to logarithms separately.)\n\
9218 23: same as 3 except logarithmic y tick marks. (The y data\n\
9219 have to be converted to logarithms separately.)\n\
9220 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9221 and y data have to be converted to logarithms separately.)\n\
9222 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9223 and y data have to be converted to logarithms separately.)\n\
9224 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9225 and y data have to be converted to logarithms separately.)\n\
9226 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9227 and y data have to be converted to logarithms separately.)\n\
9228 40: same as 0 except date / time x labels.\n\
9229 41: same as 1 except date / time x labels.\n\
9230 42: same as 2 except date / time x labels.\n\
9231 43: same as 3 except date / time x labels.\n\
9232 50: same as 0 except date / time y labels.\n\
9233 51: same as 1 except date / time y labels.\n\
9234 52: same as 2 except date / time y labels.\n\
9235 53: same as 3 except date / time y labels.\n\
9236 60: same as 0 except date / time x and y labels.\n\
9237 61: same as 1 except date / time x and y labels.\n\
9238 62: same as 2 except date / time x and y labels.\n\
9239 63: same as 3 except date / time x and y labels.\n\
9240 70: same as 0 except custom x and y labels.\n\
9241 71: same as 1 except custom x and y labels.\n\
9242 72: same as 2 except custom x and y labels.\n\
9243 73: same as 3 except custom x and y labels.\n\
9244";
9245static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
9246Set symbol size\n\
9247\n\
9248DESCRIPTION:\n\
9249\n\
9250 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9251 plsym. The actual height of a symbol is the product of the default\n\
9252 symbol size and a scaling factor as for the character height.\n\
9253\n\
9254 Redacted form: plssym(def, scale)\n\
9255\n\
9256 This function is used in example 29.\n\
9257\n\
9258\n\
9259\n\
9260SYNOPSIS:\n\
9261\n\
9262plssym(def, scale)\n\
9263\n\
9264ARGUMENTS:\n\
9265\n\
9266 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9267 should be set to zero if the default height is to remain\n\
9268 unchanged.\n\
9269\n\
9270 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9271 actual symbol height.\n\
9272";
9273static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
9274Set plot orientation\n\
9275\n\
9276DESCRIPTION:\n\
9277\n\
9278 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9279 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9280 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9281 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9282 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9283 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9284 not called the default value of rot is 0.\n\
9285\n\
9286 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9287 probably want to change the aspect ratio to a value suitable for the\n\
9288 plot orientation using a call to plsdidev or the command-line options\n\
9289 -a or -freeaspect. For more documentation of those options see the\n\
9290 PLplot documentation. Such command-line options can be set internally\n\
9291 using plsetopt or set directly using the command line and parsed using\n\
9292 a call to plparseopts.\n\
9293\n\
9294 Redacted form: plsdiori(rot)\n\
9295\n\
9296 This function is not used in any examples.\n\
9297\n\
9298\n\
9299\n\
9300SYNOPSIS:\n\
9301\n\
9302plsdiori(rot)\n\
9303\n\
9304ARGUMENTS:\n\
9305\n\
9306 rot (PLFLT, input) : Plot orientation parameter.\n\
9307";
9308static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
9309Advance the (sub-)page\n\
9310\n\
9311DESCRIPTION:\n\
9312\n\
9313 Advances to the next subpage if sub=0, performing a page advance if\n\
9314 there are no remaining subpages on the current page. If subpages\n\
9315 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9316 PLplot switches to the specified subpage. Note that this allows you\n\
9317 to overwrite a plot on the specified subpage; if this is not what you\n\
9318 intended, use pleop followed by plbop to first advance the page. This\n\
9319 routine is called automatically (with page=0) by plenv, but if plenv\n\
9320 is not used, pladv must be called after initializing PLplot but before\n\
9321 defining the viewport.\n\
9322\n\
9323 Redacted form: pladv(page)\n\
9324\n\
9325 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9326 29, and 31.\n\
9327\n\
9328\n\
9329\n\
9330SYNOPSIS:\n\
9331\n\
9332pladv(page)\n\
9333\n\
9334ARGUMENTS:\n\
9335\n\
9336 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9337 in the top left corner and increasing along the rows) to which to\n\
9338 advance. Set to zero to advance to the next subpage (or to the\n\
9339 next page if subpages are not being used).\n\
9340";
9341static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
9342Set cmap0 colors by 8-bit RGB values\n\
9343\n\
9344DESCRIPTION:\n\
9345\n\
9346 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9347 documentation). This sets the entire color map -- only as many colors\n\
9348 as specified will be allocated.\n\
9349\n\
9350 Redacted form: plscmap0(r, g, b)\n\
9351\n\
9352 This function is used in examples 2 and 24.\n\
9353\n\
9354\n\
9355\n\
9356SYNOPSIS:\n\
9357\n\
9358plscmap0(r, g, b, ncol0)\n\
9359\n\
9360ARGUMENTS:\n\
9361\n\
9362 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9363 integers (0-255) representing the degree of red in the color.\n\
9364\n\
9365 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9366 integers (0-255) representing the degree of green in the color.\n\
9367\n\
9368 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9369 integers (0-255) representing the degree of blue in the color.\n\
9370\n\
9371 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9372";
9373static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
9374Get character default height and current (scaled) height\n\
9375\n\
9376DESCRIPTION:\n\
9377\n\
9378 Get character default height and current (scaled) height.\n\
9379\n\
9380 Redacted form: plgchr(p_def, p_ht)\n\
9381\n\
9382 This function is used in example 23.\n\
9383\n\
9384\n\
9385\n\
9386SYNOPSIS:\n\
9387\n\
9388plgchr(p_def, p_ht)\n\
9389\n\
9390ARGUMENTS:\n\
9391\n\
9392 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9393 character height (mm).\n\
9394\n\
9395 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9396 character height (mm).\n\
9397";
9398static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
9399Set opaque RGB cmap1 colors values\n\
9400\n\
9401DESCRIPTION:\n\
9402\n\
9403 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9404 vector values. This function also sets the number of cmap1 colors.\n\
9405 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9406 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9407 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9408 to\n\
9409 ncol1-1. So in order for this continuous color model to work\n\
9410 properly, it is the responsibility of the user of plscmap1 to insure\n\
9411 that these RGB vectors are continuous functions of their integer\n\
9412 indices.\n\
9413\n\
9414 Redacted form: plscmap1(r, g, b)\n\
9415\n\
9416 This function is used in example 31.\n\
9417\n\
9418\n\
9419\n\
9420SYNOPSIS:\n\
9421\n\
9422plscmap1(r, g, b, ncol1)\n\
9423\n\
9424ARGUMENTS:\n\
9425\n\
9426 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9427 8-bit integers in the range from 0-255) the degree of red in the\n\
9428 color as a continuous function of the integer index of the vector.\n\
9429\n\
9430 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9431 8-bit integers in the range from 0-255) the degree of green in the\n\
9432 color as a continuous function of the integer index of the vector.\n\
9433\n\
9434 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9435 8-bit integers in the range from 0-255) the degree of blue in the\n\
9436 color as a continuous function of the integer index of the vector.\n\
9437\n\
9438 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9439";
9440static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
9441Set any command-line option\n\
9442\n\
9443DESCRIPTION:\n\
9444\n\
9445 Set any command-line option internally from a program before it\n\
9446 invokes plinit. opt is the name of the command-line option and optarg\n\
9447 is the corresponding command-line option argument.\n\
9448\n\
9449 This function returns 0 on success.\n\
9450\n\
9451 Redacted form: plsetopt(opt, optarg)\n\
9452\n\
9453 This function is used in example 14.\n\
9454\n\
9455\n\
9456\n\
9457SYNOPSIS:\n\
9458\n\
9459PLINT plsetopt(opt, optarg)\n\
9460\n\
9461ARGUMENTS:\n\
9462\n\
9463 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9464 the command-line option.\n\
9465\n\
9466 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9467 containing the argument of the command-line option.\n\
9468";
9469static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
9470Draw linear gradient inside polygon\n\
9471\n\
9472DESCRIPTION:\n\
9473\n\
9474 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9475 points (\n\
9476 x[i],\n\
9477 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9478 polygon coordinates and the gradient angle are all expressed in world\n\
9479 coordinates. The angle from the x axis for both the rotated\n\
9480 coordinate system and the gradient vector is specified by angle. The\n\
9481 magnitude of the gradient vector is the difference between the maximum\n\
9482 and minimum values of x for the vertices in the rotated coordinate\n\
9483 system. The origin of the gradient vector can be interpreted as being\n\
9484 anywhere on the line corresponding to the minimum x value for the\n\
9485 vertices in the rotated coordinate system. The distance along the\n\
9486 gradient vector is linearly transformed to the independent variable of\n\
9487 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9488 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9489 color corresponding to the independent variable of cmap1. For more\n\
9490 information about cmap1 (see the PLplot documentation).\n\
9491\n\
9492 Redacted form: plgradient(x,y,angle)\n\
9493\n\
9494 This function is used in examples 25 and 30.\n\
9495\n\
9496\n\
9497\n\
9498SYNOPSIS:\n\
9499\n\
9500plgradient(n, x, y, angle)\n\
9501\n\
9502ARGUMENTS:\n\
9503\n\
9504 n (PLINT, input) : Number of vertices in polygon.\n\
9505\n\
9506 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9507 vertices.\n\
9508\n\
9509 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9510 vertices.\n\
9511\n\
9512 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9513 axis.\n\
9514";
9515static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
9516Set length of major ticks\n\
9517\n\
9518DESCRIPTION:\n\
9519\n\
9520 This sets up the length of the major ticks. The actual length is the\n\
9521 product of the default length and a scaling factor as for character\n\
9522 height.\n\
9523\n\
9524 Redacted form: plsmaj(def, scale)\n\
9525\n\
9526 This function is used in example 29.\n\
9527\n\
9528\n\
9529\n\
9530SYNOPSIS:\n\
9531\n\
9532plsmaj(def, scale)\n\
9533\n\
9534ARGUMENTS:\n\
9535\n\
9536 def (PLFLT, input) : The default length of a major tick in\n\
9537 millimeters, should be set to zero if the default length is to\n\
9538 remain unchanged.\n\
9539\n\
9540 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9541 actual tick length.\n\
9542";
9543static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
9544Set a global coordinate transform function\n\
9545\n\
9546DESCRIPTION:\n\
9547\n\
9548 This function can be used to define a coordinate transformation which\n\
9549 affects all elements drawn within the current plot window. The\n\
9550 coordinate_transform callback function is similar to that provided for\n\
9551 the plmap and plmeridians functions. The coordinate_transform_data\n\
9552 parameter may be used to pass extra data to coordinate_transform.\n\
9553\n\
9554 Redacted form: General: plstransform(coordinate_transform,\n\
9555 coordinate_transform_data)\n\
9556\n\
9557\n\
9558 This function is used in examples 19 and 22.\n\
9559\n\
9560\n\
9561\n\
9562SYNOPSIS:\n\
9563\n\
9564plstransform(coordinate_transform, coordinate_transform_data)\n\
9565\n\
9566ARGUMENTS:\n\
9567\n\
9568 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9569 function that defines the transformation from the input (x, y)\n\
9570 world coordinates to new PLplot world coordinates. If\n\
9571 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9572 case), then no transform is applied.\n\
9573\n\
9574 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9575 for\n\
9576 coordinate_transform.\n\
9577";
9578static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
9579Configure the transformation between continuous and broken-down time for the current stream\n\
9580\n\
9581DESCRIPTION:\n\
9582\n\
9583 Configure the transformation between continuous and broken-down time\n\
9584 for the current stream. This transformation is used by both plbtime\n\
9585 and plctime.\n\
9586\n\
9587 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9588 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9589\n\
9590\n\
9591 This function is used in example 29.\n\
9592\n\
9593\n\
9594\n\
9595SYNOPSIS:\n\
9596\n\
9597plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9598\n\
9599ARGUMENTS:\n\
9600\n\
9601 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9602 As a special case, if\n\
9603 scale is 0., then all other arguments are ignored, and the result (the\n\
9604 default used by PLplot) is the equivalent of a call to\n\
9605 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9606 That is, for this special case broken-down time is calculated with\n\
9607 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9608 and the continuous time is defined as the number of seconds since\n\
9609 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9610\n\
9611 offset1 (PLFLT, input) : If\n\
9612 ifbtime_offset is true, the parameters\n\
9613 offset1 and\n\
9614 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9615 (with units in days) specify the epoch of the continuous time\n\
9616 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9617 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9618 are used to specify the origin to allow users (by specifying\n\
9619 offset1 as an integer that can be exactly represented by a\n\
9620 floating-point variable and specifying\n\
9621 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9622 the numerical errors of the continuous time representation.\n\
9623\n\
9624 offset2 (PLFLT, input) : See documentation of\n\
9625 offset1.\n\
9626\n\
9627 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9628 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9629 calendar is used for broken-down time rather than the proleptic\n\
9630 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9631 have been historically used to define UTC are inserted into the\n\
9632 broken-down time. Other possibilities for additional control bits\n\
9633 for ccontrol exist such as making the historical time corrections\n\
9634 in the broken-down time corresponding to ET (ephemeris time) or\n\
9635 making the (slightly non-constant) corrections from international\n\
9636 atomic time (TAI) to what astronomers define as terrestrial time\n\
9637 (TT). But those additional possibilities have not been\n\
9638 implemented yet in the qsastime library (one of the PLplot utility\n\
9639 libraries).\n\
9640\n\
9641 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9642 epoch of the continuous time scale is specified by the user. If\n\
9643 ifbtime_offset is false, then\n\
9644 offset1 and\n\
9645 offset2 are used to specify the epoch, and the following broken-down\n\
9646 time parameters are completely ignored. If\n\
9647 ifbtime_offset is true, then\n\
9648 offset1 and\n\
9649 offset2 are completely ignored, and the following broken-down time\n\
9650 parameters are used to specify the epoch.\n\
9651\n\
9652 year (PLINT, input) : Year of epoch.\n\
9653\n\
9654 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9655 11 (December).\n\
9656\n\
9657 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9658\n\
9659 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9660\n\
9661 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9662\n\
9663 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9664";
9665static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
9666Flushes the output stream\n\
9667\n\
9668DESCRIPTION:\n\
9669\n\
9670 Flushes the output stream. Use sparingly, if at all.\n\
9671\n\
9672 Redacted form: plflush()\n\
9673\n\
9674 This function is used in examples 1 and 14.\n\
9675\n\
9676\n\
9677\n\
9678SYNOPSIS:\n\
9679\n\
9680plflush()\n\
9681";
9682static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
9683Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9684\n\
9685DESCRIPTION:\n\
9686\n\
9687 This variant of plsurf3d (see that function\'s documentation for more\n\
9688 details) should be suitable for the case where the area of the x, y\n\
9689 coordinate grid where z is defined can be non-rectangular. The limits\n\
9690 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9691 indexymin, and indexymax.\n\
9692\n\
9693 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9694 indexymax)\n\
9695\n\
9696 This function is used in example 8.\n\
9697\n\
9698\n\
9699\n\
9700SYNOPSIS:\n\
9701\n\
9702plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9703\n\
9704ARGUMENTS:\n\
9705\n\
9706 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9707 which the function is evaluated.\n\
9708\n\
9709 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9710 which the function is evaluated.\n\
9711\n\
9712 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9713 plot. Should have dimensions of\n\
9714 nx by\n\
9715 ny.\n\
9716\n\
9717 nx (PLINT, input) : Number of x values at which function is\n\
9718 evaluated.\n\
9719\n\
9720 ny (PLINT, input) : Number of y values at which function is\n\
9721 evaluated.\n\
9722\n\
9723 opt (PLINT, input) : Determines the way in which the surface is\n\
9724 represented. To specify more than one option just add the options,\n\
9725 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9726 connecting points at which function is defined.\n\
9727 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9728 using parameters\n\
9729 nlevel and\n\
9730 clevel.\n\
9731 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9732 using parameters\n\
9733 nlevel and\n\
9734 clevel.\n\
9735 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9736 the borders of the plotted function.\n\
9737 opt=MAG_COLOR : the surface is colored according to the value\n\
9738 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9739 according to the intensity of the reflected light in the\n\
9740 surface from a light source whose position is set using\n\
9741 pllightsource.\n\
9742\n\
9743\n\
9744 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9745 levels.\n\
9746\n\
9747 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9748\n\
9749 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9750 corresponds to the first x index where z is defined.\n\
9751\n\
9752 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9753 which corresponds (by convention) to one more than the last x\n\
9754 index value where z is defined.\n\
9755\n\
9756 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9757 values which all must be ≥ 0. These values are the first y index\n\
9758 where z is defined for a particular x index in the range from\n\
9759 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9760 indexxmax.\n\
9761\n\
9762 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9763 values which all must be ≤ ny. These values correspond (by\n\
9764 convention) to one more than the last y index where z is defined\n\
9765 for a particular x index in the range from indexxmin to indexxmax\n\
9766 - 1. The dimension of indexymax is indexxmax.\n\
9767";
9768static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
9769Set semitransparent cmap1 RGBA colors.\n\
9770\n\
9771DESCRIPTION:\n\
9772\n\
9773 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9774 RGBA vector values. This function also sets the number of cmap1\n\
9775 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9776 floating-point index in the range from 0.0-1.0 which is linearly\n\
9777 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9778 vectors in the range from 0 to\n\
9779 ncol1-1. So in order for this continuous color model to work\n\
9780 properly, it is the responsibility of the user of plscmap1 to insure\n\
9781 that these RGBA vectors are continuous functions of their integer\n\
9782 indices.\n\
9783\n\
9784 Redacted form: plscmap1a(r, g, b, alpha)\n\
9785\n\
9786 This function is used in example 31.\n\
9787\n\
9788\n\
9789\n\
9790SYNOPSIS:\n\
9791\n\
9792plscmap1a(r, g, b, alpha, ncol1)\n\
9793\n\
9794ARGUMENTS:\n\
9795\n\
9796 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9797 8-bit integers in the range from 0-255) the degree of red in the\n\
9798 color as a continuous function of the integer index of the vector.\n\
9799\n\
9800 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9801 8-bit integers in the range from 0-255) the degree of green in the\n\
9802 color as a continuous function of the integer index of the vector.\n\
9803\n\
9804 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9805 8-bit integers in the range from 0-255) the degree of blue in the\n\
9806 color as a continuous function of the integer index of the vector.\n\
9807\n\
9808 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9809 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9810 completely transparent and 1.0 corresponds to completely opaque)\n\
9811 the alpha transparency of the color as a continuous function of\n\
9812 the integer index of the vector.\n\
9813\n\
9814 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9815 vectors.\n\
9816";
9817static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
9818Calculate broken-down time from continuous time for the current stream\n\
9819\n\
9820DESCRIPTION:\n\
9821\n\
9822 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9823 continuous time, ctime for the current stream. This function is the\n\
9824 inverse of plctime.\n\
9825\n\
9826 The PLplot definition of broken-down time is a calendar time that\n\
9827 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9828 responsibility to apply those offsets (if so desired) before using the\n\
9829 PLplot time API. By default broken-down time is defined using the\n\
9830 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9831 continuous time is defined as the number of seconds since the Unix\n\
9832 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9833 broken-down and continuous time are possible, see plconfigtime.\n\
9834\n\
9835 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9836 ctime)\n\
9837\n\
9838\n\
9839 This function is used in example 29.\n\
9840\n\
9841\n\
9842\n\
9843SYNOPSIS:\n\
9844\n\
9845plbtime(year, month, day, hour, min, sec, ctime)\n\
9846\n\
9847ARGUMENTS:\n\
9848\n\
9849 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9850 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9851 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9852 BCE, etc.)\n\
9853\n\
9854 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9855 the year in the range from 0 (January) to 11 (December).\n\
9856\n\
9857 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9858 month in the range from 1 to 31.\n\
9859\n\
9860 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9861 day in the range from 0 to 23.\n\
9862\n\
9863 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9864 hour in the range from 0 to 59\n\
9865\n\
9866 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9867 minute in range from 0. to 60.\n\
9868\n\
9869 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9870 time is calculated.\n\
9871";
9872static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9873Convert RGB color to HLS\n\
9874\n\
9875DESCRIPTION:\n\
9876\n\
9877 Convert RGB color coordinates to HLS\n\
9878\n\
9879 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9880\n\
9881\n\
9882 This function is used in example 2.\n\
9883\n\
9884\n\
9885\n\
9886SYNOPSIS:\n\
9887\n\
9888plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9889\n\
9890ARGUMENTS:\n\
9891\n\
9892 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9893\n\
9894 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9895\n\
9896 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9897\n\
9898 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9899 degrees (0.0-360.0) on the color cylinder.\n\
9900\n\
9901 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9902 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9903 cylinder.\n\
9904\n\
9905 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9906 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9907 cylinder.\n\
9908";
9909static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
9910Get the current device (keyword) name\n\
9911\n\
9912DESCRIPTION:\n\
9913\n\
9914 Get the current device (keyword) name. Note: you must have allocated\n\
9915 space for this (80 characters is safe).\n\
9916\n\
9917 Redacted form: plgdev(p_dev)\n\
9918\n\
9919 This function is used in example 14.\n\
9920\n\
9921\n\
9922\n\
9923SYNOPSIS:\n\
9924\n\
9925plgdev(p_dev)\n\
9926\n\
9927ARGUMENTS:\n\
9928\n\
9929 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9930 (with preallocated length of 80 characters or more) containing the\n\
9931 device (keyword) name.\n\
9932";
9933static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
9934Set the number of subpages in x and y\n\
9935\n\
9936DESCRIPTION:\n\
9937\n\
9938 Set the number of subpages in x and y.\n\
9939\n\
9940 Redacted form: plssub(nx, ny)\n\
9941\n\
9942 This function is examples 1,2,14,21,25,27.\n\
9943\n\
9944\n\
9945\n\
9946SYNOPSIS:\n\
9947\n\
9948plssub(nx, ny)\n\
9949\n\
9950ARGUMENTS:\n\
9951\n\
9952 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
9953 of window columns).\n\
9954\n\
9955 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
9956 of window rows).\n\
9957";
9958static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
9959Get current stream number\n\
9960\n\
9961DESCRIPTION:\n\
9962\n\
9963 Gets the number of the current output stream. See also plsstrm.\n\
9964\n\
9965 Redacted form: plgstrm(p_strm)\n\
9966\n\
9967 This function is used in example 1,20.\n\
9968\n\
9969\n\
9970\n\
9971SYNOPSIS:\n\
9972\n\
9973plgstrm(p_strm)\n\
9974\n\
9975ARGUMENTS:\n\
9976\n\
9977 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9978 stream value.\n\
9979";
9980static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
9981Random number generator returning a real random number in the range [0,1]\n\
9982\n\
9983DESCRIPTION:\n\
9984\n\
9985 Random number generator returning a real random number in the range\n\
9986 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
9987 / compilers provide their own random number generator, and so this is\n\
9988 provided purely for convenience and to give a consistent random number\n\
9989 generator across all languages supported by PLplot. This is\n\
9990 particularly useful for comparing results from the test suite of\n\
9991 examples.\n\
9992\n\
9993 Redacted form: plrandd()\n\
9994\n\
9995 This function is used in examples 17 and 21.\n\
9996\n\
9997\n\
9998\n\
9999SYNOPSIS:\n\
10000\n\
10001plrandd()\n\
10002";
10003static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
10004Add a point to a strip chart\n\
10005\n\
10006DESCRIPTION:\n\
10007\n\
10008 Add a point to a given pen of a given strip chart. There is no need\n\
10009 for all pens to have the same number of points or to be equally\n\
10010 sampled in the x coordinate. Allocates memory and rescales as\n\
10011 necessary.\n\
10012\n\
10013 Redacted form: plstripa(id, pen, x, y)\n\
10014\n\
10015 This function is used in example 17.\n\
10016\n\
10017\n\
10018\n\
10019SYNOPSIS:\n\
10020\n\
10021plstripa(id, pen, x, y)\n\
10022\n\
10023ARGUMENTS:\n\
10024\n\
10025 id (PLINT, input) : Identification number of the strip chart (set\n\
10026 up in plstripc).\n\
10027\n\
10028 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10029\n\
10030 x (PLFLT, input) : X coordinate of point to plot.\n\
10031\n\
10032 y (PLFLT, input) : Y coordinate of point to plot.\n\
10033";
10034static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
10035Set device-compression level\n\
10036\n\
10037DESCRIPTION:\n\
10038\n\
10039 Set device-compression level. Only used for drivers that provide\n\
10040 compression. This function, if used, should be invoked before a call\n\
10041 to plinit.\n\
10042\n\
10043 Redacted form: plscompression(compression)\n\
10044\n\
10045 This function is used in example 31.\n\
10046\n\
10047\n\
10048\n\
10049SYNOPSIS:\n\
10050\n\
10051plscompression(compression)\n\
10052\n\
10053ARGUMENTS:\n\
10054\n\
10055 compression (PLINT, input) : The desired compression level. This is\n\
10056 a device-dependent value. Currently only the jpeg and png devices\n\
10057 use these values. For jpeg value is the jpeg quality which should\n\
10058 normally be in the range 0-95. Higher values denote higher quality\n\
10059 and hence larger image sizes. For png values are in the range -1\n\
10060 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10061 A value of -1 denotes the default zlib compression level. Values\n\
10062 in the range 10-99 are divided by 10 and then used as the zlib\n\
10063 compression level. Higher compression levels correspond to greater\n\
10064 compression and small file sizes at the expense of more\n\
10065 computation.\n\
10066";
10067static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
10068Specify viewport in absolute coordinates\n\
10069\n\
10070DESCRIPTION:\n\
10071\n\
10072 Alternate routine to plvpor for setting up the viewport. This routine\n\
10073 should be used only if the viewport is required to have a definite\n\
10074 size in millimeters. The routine plgspa is useful for finding out the\n\
10075 size of the current subpage.\n\
10076\n\
10077 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10078\n\
10079 This function is used in example 10.\n\
10080\n\
10081\n\
10082\n\
10083SYNOPSIS:\n\
10084\n\
10085plsvpa(xmin, xmax, ymin, ymax)\n\
10086\n\
10087ARGUMENTS:\n\
10088\n\
10089 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10090 viewport from the left-hand edge of the subpage in millimeters.\n\
10091\n\
10092 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10093 viewport from the left-hand edge of the subpage in millimeters.\n\
10094\n\
10095 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10096 viewport from the bottom edge of the subpage in millimeters.\n\
10097\n\
10098 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10099 from the bottom edge of the subpage in millimeters.\n\
10100";
10101static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10102Draw a polygon in 3 space\n\
10103\n\
10104DESCRIPTION:\n\
10105\n\
10106 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10107 like plline3, but differs from that function in that plpoly3 attempts\n\
10108 to determine if the polygon is viewable depending on the order of the\n\
10109 points within the vector and the value of ifcc. If the back of\n\
10110 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10111 you want, then use plline3 instead.\n\
10112\n\
10113 The points are assumed to be in a plane, and the directionality of the\n\
10114 plane is determined from the first three points. Additional points do\n\
10115 not have to lie on the plane defined by the first three, but if they\n\
10116 do not, then the determination of visibility obviously can\'t be 100%\n\
10117 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10118 consider breaking them into smaller polygons. 3 points define a plane\n\
10119 :-).\n\
10120\n\
10121 Bugs: If one of the first two segments is of zero length, or if they\n\
10122 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10123 being correct. Avoid such situations :-). See x18c.c for an example\n\
10124 of this problem. (Search for 20.1).\n\
10125\n\
10126 Redacted form: plpoly3(x, y, z, code)\n\
10127\n\
10128 This function is used in example 18.\n\
10129\n\
10130\n\
10131\n\
10132SYNOPSIS:\n\
10133\n\
10134plpoly3(n, x, y, z, draw, ifcc)\n\
10135\n\
10136ARGUMENTS:\n\
10137\n\
10138 n (PLINT, input) : Number of points defining line.\n\
10139\n\
10140 x (PLFLT_VECTOR, input) : A vector containing\n\
10141 n x coordinates of points.\n\
10142\n\
10143 y (PLFLT_VECTOR, input) : A vector containing\n\
10144 n y coordinates of points.\n\
10145\n\
10146 z (PLFLT_VECTOR, input) : A vector containing\n\
10147 n z coordinates of points.\n\
10148\n\
10149 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10150 n-1 Boolean values which control drawing the segments of the polygon.\n\
10151 If draw[i] is true, then the polygon segment from index [i] to\n\
10152 [i+1] is drawn, otherwise, not.\n\
10153\n\
10154 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10155 polygon is determined by assuming the points are laid out in a\n\
10156 counter-clockwise order. Otherwise, the directionality of the\n\
10157 polygon is determined by assuming the points are laid out in a\n\
10158 clockwise order.\n\
10159";
10160static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
10161Magnitude colored plot surface with contour\n\
10162\n\
10163DESCRIPTION:\n\
10164\n\
10165 Aside from dropping the\n\
10166 side functionality this is a more powerful form of plot3d: the surface\n\
10167 mesh can be colored accordingly to the current z value being plotted,\n\
10168 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10169 drawn between the plotted function border and the base XY plane. The\n\
10170 arguments are identical to those of plmeshc. The only difference\n\
10171 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10172 the surface, while plot3dc only draws the surface as viewed from the\n\
10173 top.\n\
10174\n\
10175 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10176\n\
10177\n\
10178 This function is used in example 21.\n\
10179\n\
10180\n\
10181\n\
10182SYNOPSIS:\n\
10183\n\
10184plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10185\n\
10186ARGUMENTS:\n\
10187\n\
10188 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10189 which the function is evaluated.\n\
10190\n\
10191 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10192 which the function is evaluated.\n\
10193\n\
10194 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10195 plot. Should have dimensions of\n\
10196 nx by\n\
10197 ny.\n\
10198\n\
10199 nx (PLINT, input) : Number of x values at which function is\n\
10200 evaluated.\n\
10201\n\
10202 ny (PLINT, input) : Number of y values at which function is\n\
10203 evaluated.\n\
10204\n\
10205 opt (PLINT, input) : Determines the way in which the surface is\n\
10206 represented. To specify more than one option just add the options,\n\
10207 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10208 showing z as a function of x for each value of y[j] .\n\
10209 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10210 for each value of x[i] .\n\
10211 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10212 at which function is defined.\n\
10213 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10214 the z value being plotted. The color is used from the current\n\
10215 cmap1.\n\
10216 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10217 using parameters\n\
10218 nlevel and\n\
10219 clevel.\n\
10220 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10221 the borders of the plotted function.\n\
10222\n\
10223\n\
10224 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10225 levels.\n\
10226\n\
10227 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10228";
10229static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
10230Create a 4-pen strip chart\n\
10231\n\
10232DESCRIPTION:\n\
10233\n\
10234 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10235\n\
10236 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10237 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10238 styline, legline, labx, laby, labz)\n\
10239\n\
10240\n\
10241 This function is used in example 17.\n\
10242\n\
10243\n\
10244\n\
10245SYNOPSIS:\n\
10246\n\
10247plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10248\n\
10249ARGUMENTS:\n\
10250\n\
10251 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10252 number of the strip chart to use on plstripa and plstripd.\n\
10253\n\
10254 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10255 the x-axis specification as in plbox.\n\
10256\n\
10257 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10258 the y-axis specification as in plbox.\n\
10259\n\
10260 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10261 change as data are added.\n\
10262\n\
10263 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10264 change as data are added.\n\
10265\n\
10266 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10267 is multiplied by the factor (1 +\n\
10268 xjump) .\n\
10269\n\
10270 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10271 change as data are added.\n\
10272\n\
10273 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10274 change as data are added.\n\
10275\n\
10276 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10277\n\
10278 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10279\n\
10280 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10281 true, otherwise not.\n\
10282\n\
10283 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10284 otherwise slide display.\n\
10285\n\
10286 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10287\n\
10288 collab (PLINT, input) : Legend color index (cmap0).\n\
10289\n\
10290 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10291 indices for the 4 pens.\n\
10292\n\
10293 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10294 indices for the 4 pens.\n\
10295\n\
10296 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10297 strings containing legends for the 4 pens.\n\
10298\n\
10299 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10300 the label for the x axis.\n\
10301\n\
10302 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10303 the label for the y axis.\n\
10304\n\
10305 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10306 the plot title.\n\
10307";
10308static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
10309Deletes and releases memory used by a strip chart\n\
10310\n\
10311DESCRIPTION:\n\
10312\n\
10313 Deletes and releases memory used by a strip chart.\n\
10314\n\
10315 Redacted form: plstripd(id)\n\
10316\n\
10317 This function is used in example 17.\n\
10318\n\
10319\n\
10320\n\
10321SYNOPSIS:\n\
10322\n\
10323plstripd(id)\n\
10324\n\
10325ARGUMENTS:\n\
10326\n\
10327 id (PLINT, input) : Identification number of strip chart to delete.\n\
10328";
10329static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
10330Set cmap1 colors using a piece-wise linear relationship\n\
10331\n\
10332DESCRIPTION:\n\
10333\n\
10334 Set cmap1 colors using a piece-wise linear relationship between the\n\
10335 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10336 (see the PLplot documentation). May be called at any time.\n\
10337\n\
10338 The idea here is to specify a number of control points that define the\n\
10339 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10340 these points, linear interpolation is used which gives a smooth\n\
10341 variation of color with intensity index. Any number of control points\n\
10342 may be specified, located at arbitrary positions, although typically 2\n\
10343 - 4 are enough. Another way of stating this is that we are traversing\n\
10344 a given number of lines through HLS or RGB space as we move through\n\
10345 cmap1 intensity indices. The control points at the minimum and\n\
10346 maximum position (0 and 1) must always be specified. By adding more\n\
10347 control points you can get more variation. One good technique for\n\
10348 plotting functions that vary about some expected average is to use an\n\
10349 additional 2 control points in the center (position ~= 0.5) that are\n\
10350 the same lightness as the background (typically white for paper\n\
10351 output, black for crt), and same hue as the boundary control points.\n\
10352 This allows the highs and lows to be very easily distinguished.\n\
10353\n\
10354 Each control point must specify the cmap1 intensity index and the\n\
10355 associated three coordinates in HLS or RGB space. The first point\n\
10356 must correspond to position = 0, and the last to position = 1.\n\
10357\n\
10358 If RGB colors are provided then the interpolation takes place in RGB\n\
10359 space and is trivial. However if HLS colors are provided then, because\n\
10360 of the circular nature of the color wheel for the hue coordinate, the\n\
10361 interpolation could be performed in either direction around the color\n\
10362 wheel. The default behaviour is for the hue to be linearly\n\
10363 interpolated ignoring this circular property of hue. So for example,\n\
10364 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10365 green and cyan. If instead you wish to interpolate the other way\n\
10366 around the color wheel you have two options. You may provide hues\n\
10367 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10368 for red the interpolation will proceed via magenta. Alternatively you\n\
10369 can utilise the alt_hue_path variable to reverse the direction of\n\
10370 interpolation if you need to provide hues within the [0-360) range.\n\
10371\n\
10372 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10373 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10374 -120]falsegreen-yellow-red-magenta-blue[240\n\
10375 480]falseblue-magenta-red-yellow-green[120\n\
10376 240]truegreen-yellow-red-magenta-blue[240\n\
10377 120]trueblue-magenta-red-yellow-green\n\
10378\n\
10379 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10380 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10381 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10382\n\
10383 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10384 alt_hue_path)\n\
10385\n\
10386 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10387\n\
10388\n\
10389\n\
10390SYNOPSIS:\n\
10391\n\
10392plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10393\n\
10394ARGUMENTS:\n\
10395\n\
10396 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10397\n\
10398 npts (PLINT, input) : number of control points\n\
10399\n\
10400 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10401 intensity index (0.0-1.0) in ascending order for each control\n\
10402 point.\n\
10403\n\
10404 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10405 coordinate (H or R) for each control point.\n\
10406\n\
10407 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10408 coordinate (L or G) for each control point.\n\
10409\n\
10410 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10411 coordinate (S or B) for each control point.\n\
10412\n\
10413 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10414 npts - 1 elements), each containing either true to use the reversed\n\
10415 HLS interpolation or false to use the regular HLS interpolation.\n\
10416 (alt_hue_path[i] refers to the interpolation interval between the\n\
10417 i and i + 1 control points). This parameter is not used for RGB\n\
10418 colors (\n\
10419 itype = true).\n\
10420";
10421static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
10422Shade individual region on the basis of value\n\
10423\n\
10424DESCRIPTION:\n\
10425\n\
10426 Shade individual region on the basis of value. Use plshades if you\n\
10427 want to shade a number of contiguous regions using continuous colors.\n\
10428 In particular the edge contours are treated properly in plshades. If\n\
10429 you attempt to do contiguous regions with plshade the contours at the\n\
10430 edge of the shade are partially obliterated by subsequent plots of\n\
10431 contiguous shaded regions.\n\
10432\n\
10433 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10434 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10435 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10436\n\
10437\n\
10438 This function is used in example 15.\n\
10439\n\
10440\n\
10441\n\
10442SYNOPSIS:\n\
10443\n\
10444plshade(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\
10445\n\
10446ARGUMENTS:\n\
10447\n\
10448 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10449 plot. Should have dimensions of\n\
10450 nx by\n\
10451 ny.\n\
10452\n\
10453 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10454\n\
10455 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10456\n\
10457 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10458 the region that should be plotted in the shade plot. This\n\
10459 function accepts x and y coordinates as input arguments and must\n\
10460 return 1 if the point is to be included in the shade plot and 0\n\
10461 otherwise. If you want to plot the entire shade plot (the usual\n\
10462 case), this argument should be set to NULL.\n\
10463\n\
10464 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10465 pltr below for how these arguments are used (only for the special case\n\
10466 when the callback function\n\
10467 pltr is not supplied).\n\
10468\n\
10469 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10470 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10471\n\
10472 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10473 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10474\n\
10475 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10476 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10477 then sh_color is interpreted as a cmap1 argument in the range\n\
10478 (0.0-1.0).\n\
10479\n\
10480 sh_color (PLFLT, input) : Defines color map index with integer\n\
10481 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10482\n\
10483 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10484\n\
10485 min_color (PLINT, input) : Defines pen color, width used by the\n\
10486 boundary of shaded region. The min values are used for the\n\
10487 shade_min boundary, and the max values are used on the shade_max\n\
10488 boundary. Set color and width to zero for no plotted boundaries.\n\
10489\n\
10490 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10491 boundary of shaded region. The min values are used for the\n\
10492 shade_min boundary, and the max values are used on the shade_max\n\
10493 boundary. Set color and width to zero for no plotted boundaries.\n\
10494\n\
10495 max_color (PLINT, input) : Defines pen color, width used by the\n\
10496 boundary of shaded region. The min values are used for the\n\
10497 shade_min boundary, and the max values are used on the shade_max\n\
10498 boundary. Set color and width to zero for no plotted boundaries.\n\
10499\n\
10500 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10501 boundary of shaded region. The min values are used for the\n\
10502 shade_min boundary, and the max values are used on the shade_max\n\
10503 boundary. Set color and width to zero for no plotted boundaries.\n\
10504\n\
10505 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10506 Use plfill. Future version of PLplot may have other fill\n\
10507 routines.\n\
10508\n\
10509 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10510 map to rectangles after coordinate transformation with pltrl.\n\
10511 Otherwise, set rectangular to false. If rectangular is set to\n\
10512 true, plshade tries to save time by filling large rectangles.\n\
10513 This optimization fails if the coordinate transformation distorts\n\
10514 the shape of rectangles. For example a plot in polar coordinates\n\
10515 has to have rectangular set to false.\n\
10516\n\
10517 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10518 defines the transformation between the zero-based indices of the\n\
10519 matrix a and world coordinates. If\n\
10520 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10521 indices of a are mapped to the range\n\
10522 xmin through\n\
10523 xmax and the y indices of a are mapped to the range\n\
10524 ymin through\n\
10525 ymax.For the C case, transformation functions are provided in the\n\
10526 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10527 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10528 matrices. In addition, C callback routines for the transformation\n\
10529 can be supplied by the user such as the mypltr function in\n\
10530 examples/c/x09c.c which provides a general linear transformation\n\
10531 between index coordinates and world coordinates.For languages\n\
10532 other than C you should consult the PLplot documentation for the\n\
10533 details concerning how PLTRANSFORM_callback arguments are\n\
10534 interfaced. However, in general, a particular pattern of\n\
10535 callback-associated arguments such as a tr vector with 6 elements;\n\
10536 xg and yg vectors; or xg and yg matrices are respectively\n\
10537 interfaced to a linear-transformation routine similar to the above\n\
10538 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10539 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10540 support native language callbacks for handling index to\n\
10541 world-coordinate transformations. Examples of these various\n\
10542 approaches are given in examples/<language>x09*,\n\
10543 examples/<language>x16*, examples/<language>x20*,\n\
10544 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10545 supported languages.\n\
10546\n\
10547 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10548 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10549 externally supplied.\n\
10550";
10551static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
10552Set number of colors in cmap1\n\
10553\n\
10554DESCRIPTION:\n\
10555\n\
10556 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10557 values if this is the first allocation (see the PLplot documentation).\n\
10558\n\
10559 Redacted form: plscmap1n(ncol1)\n\
10560\n\
10561 This function is used in examples 8, 11, 20, and 21.\n\
10562\n\
10563\n\
10564\n\
10565SYNOPSIS:\n\
10566\n\
10567plscmap1n(ncol1)\n\
10568\n\
10569ARGUMENTS:\n\
10570\n\
10571 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10572 the cmap1 palette. If this number is zero or less, then the value\n\
10573 from the previous call to plscmap1n is used and if there is no\n\
10574 previous call, then a default value is used.\n\
10575";
10576static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
10577Advance to the next family file on the next new page\n\
10578\n\
10579DESCRIPTION:\n\
10580\n\
10581 Advance to the next family file on the next new page.\n\
10582\n\
10583 Redacted form: plfamadv()\n\
10584\n\
10585 This function is not used in any examples.\n\
10586\n\
10587\n\
10588\n\
10589SYNOPSIS:\n\
10590\n\
10591plfamadv()\n\
10592";
10593static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
10594Set the escape character for text strings\n\
10595\n\
10596DESCRIPTION:\n\
10597\n\
10598 Set the escape character for text strings. From C (in contrast to\n\
10599 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10600 characters are allowed to prevent the user from shooting himself in\n\
10601 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10602 use of backslash as a character escape). Here are the allowed escape\n\
10603 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10604 #, ASCII 35\n\
10605 $, ASCII 36\n\
10606 %, ASCII 37\n\
10607 &, ASCII 38\n\
10608 *, ASCII 42\n\
10609 @, ASCII 64\n\
10610 ^, ASCII 94\n\
10611 ~, ASCII 126\n\
10612\n\
10613\n\
10614 Redacted form: General: plsesc(esc)\n\
10615\n\
10616\n\
10617 This function is used in example 29.\n\
10618\n\
10619\n\
10620\n\
10621SYNOPSIS:\n\
10622\n\
10623plsesc(esc)\n\
10624\n\
10625ARGUMENTS:\n\
10626\n\
10627 esc (char, input) : Escape character.\n\
10628";
10629static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
10630Plot color bar for image, shade or gradient plots\n\
10631\n\
10632DESCRIPTION:\n\
10633\n\
10634 Routine for creating a continuous color bar for image, shade, or\n\
10635 gradient plots. (See pllegend for similar functionality for creating\n\
10636 legends with discrete elements). The arguments of plcolorbar provide\n\
10637 control over the location and size of the color bar as well as the\n\
10638 location and characteristics of the elements (most of which are\n\
10639 optional) within that color bar. The resulting color bar is clipped\n\
10640 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10641 system used for some of the parameters is defined in the documentation\n\
10642 of the position parameter.)\n\
10643\n\
10644 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10645 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10646 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10647 labels, axis_opts, ticks, sub_ticks, values)\n\
10648\n\
10649 This function is used in examples 16 and 33.\n\
10650\n\
10651\n\
10652\n\
10653SYNOPSIS:\n\
10654\n\
10655plcolorbar(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\
10656\n\
10657ARGUMENTS:\n\
10658\n\
10659 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10660 labelled and decorated color bar width in adopted coordinates.\n\
10661\n\
10662 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10663 labelled and decorated color bar height in adopted coordinates.\n\
10664\n\
10665 opt (PLINT, input) : opt contains bits controlling the overall\n\
10666 color bar. The orientation (direction of the maximum value) of\n\
10667 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10668 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10669 specified, the default orientation is toward the top if the\n\
10670 colorbar is placed on the left or right of the viewport or toward\n\
10671 the right if the colorbar is placed on the top or bottom of the\n\
10672 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10673 (semitransparent) background for the color bar. If the\n\
10674 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10675 color bar. The type of color bar must be specified with one of\n\
10676 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10677 more than one of those bits is set only the first one in the above\n\
10678 list is honored. The position of the (optional) label/title can be\n\
10679 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10680 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10681 will be drawn. If more than one of this list of bits is specified,\n\
10682 only the first one on the list is honored. End-caps for the color\n\
10683 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10684 If a particular color bar cap option is not specified then no cap\n\
10685 will be drawn for that end. As a special case for\n\
10686 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10687 specified. If this option is provided then any tick marks and tick\n\
10688 labels will be placed at the breaks between shaded segments. TODO:\n\
10689 This should be expanded to support custom placement of tick marks\n\
10690 and tick labels at custom value locations for any color bar type.\n\
10691\n\
10692 position (PLINT, input) : position contains bits which control the\n\
10693 overall position of the color bar and the definition of the\n\
10694 adopted coordinates used for positions just like what is done for\n\
10695 the position argument for pllegend. However, note that the\n\
10696 defaults for the position bits (see below) are different than the\n\
10697 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10698 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10699 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10700 the 16 possible standard positions (the 4 corners and centers of\n\
10701 the 4 sides for both the inside and outside cases) of the color\n\
10702 bar relative to the adopted coordinate system. The corner\n\
10703 positions are specified by the appropriate combination of two of\n\
10704 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10705 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10706 value of one of those bits. The adopted coordinates are\n\
10707 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10708 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10709 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10710 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10711 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10712 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10713 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10714 PL_POSITION_VIEWPORT.\n\
10715\n\
10716 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10717 coordinates from the specified standard position of the color bar.\n\
10718 For positive x, the direction of motion away from the standard\n\
10719 position is inward/outward from the standard corner positions or\n\
10720 standard left or right positions if the\n\
10721 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10722 For the standard top or bottom positions, the direction of motion\n\
10723 is toward positive X.\n\
10724\n\
10725 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10726 coordinates from the specified standard position of the color bar.\n\
10727 For positive y, the direction of motion away from the standard\n\
10728 position is inward/outward from the standard corner positions or\n\
10729 standard top or bottom positions if the\n\
10730 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10731 For the standard left or right positions, the direction of motion\n\
10732 is toward positive Y.\n\
10733\n\
10734 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10735 the X direction in adopted coordinates.\n\
10736\n\
10737 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10738 the Y direction in adopted coordinates.\n\
10739\n\
10740 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10741 color bar (PL_COLORBAR_BACKGROUND).\n\
10742\n\
10743 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10744 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10745\n\
10746 bb_style (PLINT, input) : The pllsty style number for the\n\
10747 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10748\n\
10749 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10750 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10751\n\
10752 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10753 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10754\n\
10755 cont_color (PLINT, input) : The cmap0 contour color for\n\
10756 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10757 it will be interpreted according to the design of plshades.\n\
10758\n\
10759 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10760 plots. This is passed directly to plshades, so it will be\n\
10761 interpreted according to the design of plshades.\n\
10762\n\
10763 n_labels (PLINT, input) : Number of labels to place around the\n\
10764 color bar.\n\
10765\n\
10766 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10767 n_labels labels.\n\
10768\n\
10769 labels (PLCHAR_MATRIX, input) : A vector of\n\
10770 n_labels UTF-8 character strings containing the labels for the color\n\
10771 bar. Ignored if no label position is specified with one of the\n\
10772 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10773 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10774 corresponding label_opts field.\n\
10775\n\
10776 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10777 value must be greater than 0. It is typically 1 (numerical axis\n\
10778 labels are provided for one of the long edges of the color bar),\n\
10779 but it can be larger if multiple numerical axis labels for the\n\
10780 long edges of the color bar are desired.\n\
10781\n\
10782 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10783 n_axes ascii character strings containing options (interpreted as for\n\
10784 plbox) for the color bar\'s axis definitions.\n\
10785\n\
10786 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10787 spacing of the major tick marks (interpreted as for plbox) for the\n\
10788 color bar\'s axis definitions.\n\
10789\n\
10790 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10791 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10792 axis definitions.\n\
10793\n\
10794 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10795 elements in each of the n_axes rows of the values matrix.\n\
10796\n\
10797 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10798 values for the data range represented by the color bar. For a row\n\
10799 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10800 elements in the row is specified by n_values[i_axis]. For\n\
10801 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10802 is 2, and the corresponding row elements of the values matrix are\n\
10803 the minimum and maximum value represented by the colorbar. For\n\
10804 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10805 of the values matrix is interpreted the same as the nlevel and\n\
10806 clevel arguments of plshades.\n\
10807";
10808static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
10809Set current output stream\n\
10810\n\
10811DESCRIPTION:\n\
10812\n\
10813 Sets the number of the current output stream. The stream number\n\
10814 defaults to 0 unless changed by this routine. The first use of this\n\
10815 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10816\n\
10817 Redacted form: plsstrm(strm)\n\
10818\n\
10819 This function is examples 1,14,20.\n\
10820\n\
10821\n\
10822\n\
10823SYNOPSIS:\n\
10824\n\
10825plsstrm(strm)\n\
10826\n\
10827ARGUMENTS:\n\
10828\n\
10829 strm (PLINT, input) : The current stream number.\n\
10830";
10831static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
10832Get the current device-compression setting\n\
10833\n\
10834DESCRIPTION:\n\
10835\n\
10836 Get the current device-compression setting. This parameter is only\n\
10837 used for drivers that provide compression.\n\
10838\n\
10839 Redacted form: plgcompression(compression)\n\
10840\n\
10841 This function is used in example 31.\n\
10842\n\
10843\n\
10844\n\
10845SYNOPSIS:\n\
10846\n\
10847plgcompression(compression)\n\
10848\n\
10849ARGUMENTS:\n\
10850\n\
10851 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10852 compression setting for the current device.\n\
10853";
10854static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
10855Grid data from irregularly sampled data\n\
10856\n\
10857DESCRIPTION:\n\
10858\n\
10859 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10860 require data organized as a grid, i.e., with x sample point values\n\
10861 independent of y coordinate and vice versa. This function takes\n\
10862 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10863 vectors; reads the desired grid location from the input vectors\n\
10864 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10865 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10866 interpolate the data to the grid is specified with the argument type\n\
10867 which can have one parameter specified in argument data.\n\
10868\n\
10869 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10870 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10871\n\
10872\n\
10873 This function is used in example 21.\n\
10874\n\
10875\n\
10876\n\
10877SYNOPSIS:\n\
10878\n\
10879plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10880\n\
10881ARGUMENTS:\n\
10882\n\
10883 x (PLFLT_VECTOR, input) : The input x vector.\n\
10884\n\
10885 y (PLFLT_VECTOR, input) : The input y vector.\n\
10886\n\
10887 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10888 y[i], z[i] represents one data sample coordinate.\n\
10889\n\
10890 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10891 vectors.\n\
10892\n\
10893 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10894 in the x direction. Usually xg has nptsx equally spaced values\n\
10895 from the minimum to the maximum values of the x input vector.\n\
10896\n\
10897 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10898\n\
10899 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10900 in the y direction. Similar to the xg parameter.\n\
10901\n\
10902 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10903\n\
10904 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10905 where data lies in the grid specified by xg and yg. Therefore the\n\
10906 zg matrix must be dimensioned\n\
10907 nptsx by\n\
10908 nptsy.\n\
10909\n\
10910 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10911 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10912 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10913 GRID_NNI: Natural Neighbors Interpolation\n\
10914 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10915 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10916 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10917 Weighted\n\
10918 For details of the algorithms read the source file plgridd.c.\n\
10919\n\
10920 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10921 which can be specified through this argument. Currently, for\n\
10922 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10923 use, the lower the value, the noisier (more local) the\n\
10924 approximation is.\n\
10925 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10926 range [1. .. 2.]. High values enable the usage of very thin\n\
10927 triangles for interpolation, possibly resulting in error in\n\
10928 the approximation.\n\
10929 GRID_NNI, only weights greater than data will be accepted. If\n\
10930 0, all weights will be accepted.\n\
10931";
10932
10933SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10934 PLINT arg1 ;
10935 PLINT *arg2 = (PLINT *) 0 ;
10936 char **arg3 = (char **) 0 ;
10937 Matrix temp1 ;
10938 octave_value_list _out;
10939 octave_value_list *_outp=&_out;
10940 octave_value _outv;
10941
10942 try {
10943 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10944 SWIG_fail;
10945 }
10946 {
10947 if ( _n_dims( args(0) ) > 1 )
10948 {
10949 error( "argument must be a scalar or vector" ); SWIG_fail;
10950 }
10951 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10952 arg2 = new PLINT[Alen];
10953 temp1 = args(0).matrix_value();
10954 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10955 }
10956 {
10957 charMatrix temp_matrix;
10958 Cell temp_cell;
10959 char *tmp_cstring;
10960 std::string str;
10961 size_t max_length = 0, non_blank_length;
10962 int i, ifcell;
10963 if ( _n_dims( args(1) ) > 2 )
10964 {
10965 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10966 }
10967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10968 if ( !args(1).isempty() )
10969#else
10970 if ( !args(1).is_empty() )
10971#endif
10972 {
10973 if ( _dim( args(1), 0 ) != Alen )
10974 {
10975 error( "first dimension must be same length as previous vector" ); SWIG_fail;
10976 }
10977 arg3 = new char*[Alen];
10978#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10979 ifcell = args(1).iscell();
10980#else
10981 ifcell = args(1).is_cell();
10982#endif
10983 if ( ifcell )
10984 {
10985 temp_cell = args(1).cell_value();
10986 }
10987 else
10988 {
10989 temp_matrix = args(1).char_matrix_value();
10990 // Allow one extra space for null termination.
10991 max_length = _dim( args(1), 1 ) + 1;
10992 }
10993
10994 for ( i = 0; i < Alen; i++ )
10995 {
10996 // Must copy string to "permanent" location because the string
10997 // location corresponding to tmp_cstring gets
10998 // overwritten for each iteration of loop.
10999 if ( ifcell )
11000 {
11001 if ( temp_cell.elem( i ).is_string() )
11002 {
11003 str = temp_cell.elem( i ).string_value();
11004 // leave room for null termination.
11005 max_length = str.size() + 1;
11006 tmp_cstring = (char *) str.c_str();
11007 }
11008 else
11009 {
11010 // Use null string if user attempts to pass a cell array
11011 // with a non-string element (likely an empty element
11012 // since that should be allowed by the PLplot interface
11013 // if that element is going to be unused).
11014 // leave room for null termination.
11015 max_length = 1;
11016 tmp_cstring = (char *) "";
11017 }
11018 }
11019 else
11020 {
11021 str = temp_matrix.row_as_string( i );
11022 tmp_cstring = (char *) str.c_str();
11023 }
11024 arg3[i] = new char[max_length];
11025 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11026 arg3[i][max_length - 1] = '\0';
11027 // All the trailing blank crapola should not be needed for
11028 // string cell arrays.
11029 if ( !ifcell )
11030 {
11031 // remove trailing-blank padding that is used by the
11032 // charMatrix class to insure all strings in a given
11033 // charMatrix instance have the same length.
11034 // This transformation also removes legitimate trailing
11035 // blanks but there is nothing we can do about that
11036 // for the charMatrix class.
11037
11038 // Look for trailing nulls first (just in case, although that
11039 // shouldn't happen if charMatrix implemented as documented)
11040 // before looking for trailing blanks.
11041 non_blank_length = max_length - 2;
11042 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
11043 {
11044 non_blank_length--;
11045 }
11046 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
11047 {
11048 non_blank_length--;
11049 }
11050 arg3[i][non_blank_length + 1] = '\0';
11051 }
11052 }
11053 }
11054 else
11055 {
11056 arg3 = NULL;
11057 }
11058 }
11059 testppchar(arg1,(int const *)arg2,(char const **)arg3);
11060 _outv = octave_value();
11061 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11062 {
11063 delete [] arg2;
11064 }
11065 {
11066 int i;
11067 if ( arg3 != NULL )
11068 {
11069 for ( i = 0; i < Alen; i++ )
11070 {
11071 delete[] arg3[i];
11072 }
11073 delete[] arg3;
11074 }
11075 }
11076 return _out;
11077 fail:
11078 {
11079 delete [] arg2;
11080 }
11081 {
11082 int i;
11083 if ( arg3 != NULL )
11084 {
11085 for ( i = 0; i < Alen; i++ )
11086 {
11087 delete[] arg3[i];
11088 }
11089 delete[] arg3;
11090 }
11091 }
11092 return octave_value_list();
11093 }
11094 catch(...) {
11095 {
11096 delete [] arg2;
11097 }
11098 {
11099 int i;
11100 if ( arg3 != NULL )
11101 {
11102 for ( i = 0; i < Alen; i++ )
11103 {
11104 delete[] arg3[i];
11105 }
11106 delete[] arg3;
11107 }
11108 }
11109 throw;
11110 }
11111}
11112
11113
11115 int *arg1 = (int *) 0 ;
11116 int *arg2 = (int *) 0 ;
11117 int *arg3 = (int *) 0 ;
11118 char *arg4 = (char *) 0 ;
11119 int *arg5 = (int *) 0 ;
11120 int *arg6 = (int *) 0 ;
11121 PLFLT *arg7 = (PLFLT *) 0 ;
11122 PLFLT *arg8 = (PLFLT *) 0 ;
11123 PLFLT *arg9 = (PLFLT *) 0 ;
11124 PLFLT *arg10 = (PLFLT *) 0 ;
11125 int *arg11 = (int *) 0 ;
11126 int temp1 ;
11127 int res1 = SWIG_TMPOBJ ;
11128 int temp2 ;
11129 int res2 = SWIG_TMPOBJ ;
11130 int temp3 ;
11131 int res3 = SWIG_TMPOBJ ;
11132 char local_string4[80] ;
11133 int temp5 ;
11134 int res5 = SWIG_TMPOBJ ;
11135 int temp6 ;
11136 int res6 = SWIG_TMPOBJ ;
11137 PLFLT temp7 ;
11138 int res7 = SWIG_TMPOBJ ;
11139 PLFLT temp8 ;
11140 int res8 = SWIG_TMPOBJ ;
11141 PLFLT temp9 ;
11142 int res9 = SWIG_TMPOBJ ;
11143 PLFLT temp10 ;
11144 int res10 = SWIG_TMPOBJ ;
11145 int temp11 ;
11146 int res11 = SWIG_TMPOBJ ;
11147 size_t local_string_length4 ;
11148 charMatrix local_charMatrix4 ;
11149 octave_value_list retval4 ;
11150 octave_value_list _out;
11151 octave_value_list *_outp=&_out;
11152 octave_value _outv;
11153 int result;
11154
11155 try {
11156 arg1 = &temp1;
11157 arg2 = &temp2;
11158 arg3 = &temp3;
11159 {
11160 arg4 = local_string4;
11161 }
11162 arg5 = &temp5;
11163 arg6 = &temp6;
11164 arg7 = &temp7;
11165 arg8 = &temp8;
11166 arg9 = &temp9;
11167 arg10 = &temp10;
11168 arg11 = &temp11;
11169 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11170 SWIG_fail;
11171 }
11172 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11173 _outv = SWIG_From_int(static_cast< int >(result));
11174 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11175 if (SWIG_IsTmpObj(res1)) {
11176 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11177 } else {
11178 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11179 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11180 }
11181 if (SWIG_IsTmpObj(res2)) {
11182 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11183 } else {
11184 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11185 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11186 }
11187 if (SWIG_IsTmpObj(res3)) {
11188 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11189 } else {
11190 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11191 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11192 }
11193 {
11194 local_string_length4 = strlen( local_string4 );
11195 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11196 local_charMatrix4.insert( local_string4, 0, 0 );
11197 retval4( 0 ) = octave_value( local_charMatrix4 );
11198 _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11199 }
11200 if (SWIG_IsTmpObj(res5)) {
11201 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11202 } else {
11203 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11204 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11205 }
11206 if (SWIG_IsTmpObj(res6)) {
11207 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11208 } else {
11209 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11210 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11211 }
11212 if (SWIG_IsTmpObj(res7)) {
11213 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11214 } else {
11215 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11216 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11217 }
11218 if (SWIG_IsTmpObj(res8)) {
11219 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11220 } else {
11221 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11222 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11223 }
11224 if (SWIG_IsTmpObj(res9)) {
11225 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11226 } else {
11227 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11228 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11229 }
11230 if (SWIG_IsTmpObj(res10)) {
11231 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11232 } else {
11233 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11234 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11235 }
11236 if (SWIG_IsTmpObj(res11)) {
11237 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11238 } else {
11239 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11240 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11241 }
11242 return _out;
11243 fail:
11244 return octave_value_list();
11245 }
11246 catch(...) {
11247 throw;
11248 }
11249}
11250
11251
11252SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11253 PLFLT *arg1 = (PLFLT *) 0 ;
11254 PLFLT *arg2 = (PLFLT *) 0 ;
11255 PLFLT arg3 ;
11256 PLFLT arg4 ;
11257 PLFLT temp1 ;
11258 int res1 = SWIG_TMPOBJ ;
11259 PLFLT temp2 ;
11260 int res2 = SWIG_TMPOBJ ;
11261 double val3 ;
11262 int ecode3 = 0 ;
11263 double val4 ;
11264 int ecode4 = 0 ;
11265 octave_value_list _out;
11266 octave_value_list *_outp=&_out;
11267 octave_value _outv;
11268 int result;
11269
11270 try {
11271 arg1 = &temp1;
11272 arg2 = &temp2;
11273 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11274 SWIG_fail;
11275 }
11276 ecode3 = SWIG_AsVal_double(args(0), &val3);
11277 if (!SWIG_IsOK(ecode3)) {
11278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11279 }
11280 arg3 = static_cast< PLFLT >(val3);
11281 ecode4 = SWIG_AsVal_double(args(1), &val4);
11282 if (!SWIG_IsOK(ecode4)) {
11283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11284 }
11285 arg4 = static_cast< PLFLT >(val4);
11286 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11287 _outv = SWIG_From_int(static_cast< int >(result));
11288 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11289 if (SWIG_IsTmpObj(res1)) {
11290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11291 } else {
11292 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11293 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11294 }
11295 if (SWIG_IsTmpObj(res2)) {
11296 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11297 } else {
11298 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11299 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11300 }
11301 return _out;
11302 fail:
11303 return octave_value_list();
11304 }
11305 catch(...) {
11306 throw;
11307 }
11308}
11309
11310
11312 PLINT *arg1 = (PLINT *) 0 ;
11313 char *arg2 = (char *) 0 ;
11314 char *arg3 = (char *) 0 ;
11315 PLFLT arg4 ;
11316 PLFLT arg5 ;
11317 PLFLT arg6 ;
11318 PLFLT arg7 ;
11319 PLFLT arg8 ;
11320 PLFLT arg9 ;
11321 PLFLT arg10 ;
11322 PLBOOL arg11 ;
11323 PLBOOL arg12 ;
11324 PLINT arg13 ;
11325 PLINT arg14 ;
11326 PLINT *arg15 = (PLINT *) 0 ;
11327 PLINT *arg16 = (PLINT *) 0 ;
11328 char *arg17 = (char *) 0 ;
11329 char *arg18 = (char *) 0 ;
11330 char *arg19 = (char *) 0 ;
11331 char *arg20 = (char *) 0 ;
11332 char *arg21 = (char *) 0 ;
11333 char *arg22 = (char *) 0 ;
11334 char *arg23 = (char *) 0 ;
11335 PLINT temp1 ;
11336 int res1 = SWIG_TMPOBJ ;
11337 int res2 ;
11338 char *buf2 = 0 ;
11339 int alloc2 = 0 ;
11340 int res3 ;
11341 char *buf3 = 0 ;
11342 int alloc3 = 0 ;
11343 double val4 ;
11344 int ecode4 = 0 ;
11345 double val5 ;
11346 int ecode5 = 0 ;
11347 double val6 ;
11348 int ecode6 = 0 ;
11349 double val7 ;
11350 int ecode7 = 0 ;
11351 double val8 ;
11352 int ecode8 = 0 ;
11353 double val9 ;
11354 int ecode9 = 0 ;
11355 double val10 ;
11356 int ecode10 = 0 ;
11357 int val11 ;
11358 int ecode11 = 0 ;
11359 int val12 ;
11360 int ecode12 = 0 ;
11361 int val13 ;
11362 int ecode13 = 0 ;
11363 int val14 ;
11364 int ecode14 = 0 ;
11365 Matrix temp15 ;
11366 Matrix temp16 ;
11367 int res17 ;
11368 char *buf17 = 0 ;
11369 int alloc17 = 0 ;
11370 int res18 ;
11371 char *buf18 = 0 ;
11372 int alloc18 = 0 ;
11373 int res19 ;
11374 char *buf19 = 0 ;
11375 int alloc19 = 0 ;
11376 int res20 ;
11377 char *buf20 = 0 ;
11378 int alloc20 = 0 ;
11379 int res21 ;
11380 char *buf21 = 0 ;
11381 int alloc21 = 0 ;
11382 int res22 ;
11383 char *buf22 = 0 ;
11384 int alloc22 = 0 ;
11385 int res23 ;
11386 char *buf23 = 0 ;
11387 int alloc23 = 0 ;
11388 octave_value_list _out;
11389 octave_value_list *_outp=&_out;
11390 octave_value _outv;
11391
11392 try {
11393 arg1 = &temp1;
11394 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11395 SWIG_fail;
11396 }
11397 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11398 if (!SWIG_IsOK(res2)) {
11399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11400 }
11401 arg2 = reinterpret_cast< char * >(buf2);
11402 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11403 if (!SWIG_IsOK(res3)) {
11404 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11405 }
11406 arg3 = reinterpret_cast< char * >(buf3);
11407 ecode4 = SWIG_AsVal_double(args(2), &val4);
11408 if (!SWIG_IsOK(ecode4)) {
11409 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11410 }
11411 arg4 = static_cast< PLFLT >(val4);
11412 ecode5 = SWIG_AsVal_double(args(3), &val5);
11413 if (!SWIG_IsOK(ecode5)) {
11414 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11415 }
11416 arg5 = static_cast< PLFLT >(val5);
11417 ecode6 = SWIG_AsVal_double(args(4), &val6);
11418 if (!SWIG_IsOK(ecode6)) {
11419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11420 }
11421 arg6 = static_cast< PLFLT >(val6);
11422 ecode7 = SWIG_AsVal_double(args(5), &val7);
11423 if (!SWIG_IsOK(ecode7)) {
11424 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11425 }
11426 arg7 = static_cast< PLFLT >(val7);
11427 ecode8 = SWIG_AsVal_double(args(6), &val8);
11428 if (!SWIG_IsOK(ecode8)) {
11429 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11430 }
11431 arg8 = static_cast< PLFLT >(val8);
11432 ecode9 = SWIG_AsVal_double(args(7), &val9);
11433 if (!SWIG_IsOK(ecode9)) {
11434 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11435 }
11436 arg9 = static_cast< PLFLT >(val9);
11437 ecode10 = SWIG_AsVal_double(args(8), &val10);
11438 if (!SWIG_IsOK(ecode10)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11440 }
11441 arg10 = static_cast< PLFLT >(val10);
11442 ecode11 = SWIG_AsVal_int(args(9), &val11);
11443 if (!SWIG_IsOK(ecode11)) {
11444 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11445 }
11446 arg11 = static_cast< PLBOOL >(val11);
11447 ecode12 = SWIG_AsVal_int(args(10), &val12);
11448 if (!SWIG_IsOK(ecode12)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11450 }
11451 arg12 = static_cast< PLBOOL >(val12);
11452 ecode13 = SWIG_AsVal_int(args(11), &val13);
11453 if (!SWIG_IsOK(ecode13)) {
11454 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11455 }
11456 arg13 = static_cast< PLINT >(val13);
11457 ecode14 = SWIG_AsVal_int(args(12), &val14);
11458 if (!SWIG_IsOK(ecode14)) {
11459 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11460 }
11461 arg14 = static_cast< PLINT >(val14);
11462 {
11463 if ( _n_dims( args(13) ) > 1 )
11464 {
11465 error( "argument must be a scalar or vector" ); SWIG_fail;
11466 }
11467 Alen = (PLINT) ( _dim( args(13), 0 ) );
11468 temp15 = args(13).matrix_value();
11469 arg15 = new PLINT[Alen];
11470 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11471 }
11472 {
11473 if ( _n_dims( args(14) ) > 1 )
11474 {
11475 error( "argument must be a scalar or vector" ); SWIG_fail;
11476 }
11477 if ( _dim( args(14), 0 ) != Alen )
11478 {
11479 error( "argument vectors must be same length" ); SWIG_fail;
11480 }
11481 temp16 = args(14).matrix_value();
11482 arg16 = new PLINT[Alen];
11483 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11484 }
11485 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11486 if (!SWIG_IsOK(res17)) {
11487 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11488 }
11489 arg17 = reinterpret_cast< char * >(buf17);
11490 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11491 if (!SWIG_IsOK(res18)) {
11492 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11493 }
11494 arg18 = reinterpret_cast< char * >(buf18);
11495 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11496 if (!SWIG_IsOK(res19)) {
11497 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11498 }
11499 arg19 = reinterpret_cast< char * >(buf19);
11500 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11501 if (!SWIG_IsOK(res20)) {
11502 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11503 }
11504 arg20 = reinterpret_cast< char * >(buf20);
11505 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11506 if (!SWIG_IsOK(res21)) {
11507 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11508 }
11509 arg21 = reinterpret_cast< char * >(buf21);
11510 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11511 if (!SWIG_IsOK(res22)) {
11512 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11513 }
11514 arg22 = reinterpret_cast< char * >(buf22);
11515 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11516 if (!SWIG_IsOK(res23)) {
11517 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11518 }
11519 arg23 = reinterpret_cast< char * >(buf23);
11520 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);
11521 _outv = octave_value();
11522 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11523 if (SWIG_IsTmpObj(res1)) {
11524 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11525 } else {
11526 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11528 }
11529 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11530 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11531 {
11532 delete [] arg15;
11533 }
11534 {
11535 delete [] arg16;
11536 }
11537 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11538 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11539 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11540 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11541 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11542 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11543 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11544 return _out;
11545 fail:
11546 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11547 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11548 {
11549 delete [] arg15;
11550 }
11551 {
11552 delete [] arg16;
11553 }
11554 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11555 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11556 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11557 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11558 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11559 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11560 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11561 return octave_value_list();
11562 }
11563 catch(...) {
11564 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11565 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11566 {
11567 delete [] arg15;
11568 }
11569 {
11570 delete [] arg16;
11571 }
11572 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11573 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11574 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11575 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11576 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11577 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11578 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11579 throw;
11580 }
11581}
11582
11583
11585 PLFLT *arg1 = (PLFLT *) 0 ;
11586 PLINT arg2 ;
11587 PLINT arg3 ;
11588 PLINT arg4 ;
11589 PLINT arg5 ;
11590 PLINT arg6 ;
11591 PLINT arg7 ;
11592 PLFLT *arg8 = (PLFLT *) 0 ;
11593 PLINT arg9 ;
11594 PLFLT *arg10 = (PLFLT *) 0 ;
11595 Matrix temp1 ;
11596 int val4 ;
11597 int ecode4 = 0 ;
11598 int val5 ;
11599 int ecode5 = 0 ;
11600 int val6 ;
11601 int ecode6 = 0 ;
11602 int val7 ;
11603 int ecode7 = 0 ;
11604 Matrix temp8 ;
11605 Matrix temp10 ;
11606 octave_value_list _out;
11607 octave_value_list *_outp=&_out;
11608 octave_value _outv;
11609
11610 try {
11611 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11612 SWIG_fail;
11613 }
11614 {
11615 if ( _n_dims( args(0) ) > 2 )
11616 {
11617 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11618 }
11619 temp1 = args(0).matrix_value();
11620 arg1 = &temp1( 0, 0 );
11621 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11622 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11623 }
11624 ecode4 = SWIG_AsVal_int(args(1), &val4);
11625 if (!SWIG_IsOK(ecode4)) {
11626 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11627 }
11628 arg4 = static_cast< PLINT >(val4);
11629 ecode5 = SWIG_AsVal_int(args(2), &val5);
11630 if (!SWIG_IsOK(ecode5)) {
11631 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11632 }
11633 arg5 = static_cast< PLINT >(val5);
11634 ecode6 = SWIG_AsVal_int(args(3), &val6);
11635 if (!SWIG_IsOK(ecode6)) {
11636 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11637 }
11638 arg6 = static_cast< PLINT >(val6);
11639 ecode7 = SWIG_AsVal_int(args(4), &val7);
11640 if (!SWIG_IsOK(ecode7)) {
11641 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11642 }
11643 arg7 = static_cast< PLINT >(val7);
11644 {
11645 if ( _n_dims( args(5) ) > 1 )
11646 {
11647 error( "argument must be a scalar or vector" ); SWIG_fail;
11648 }
11649 temp8 = args(5).matrix_value();
11650 arg8 = &temp8( 0, 0 );
11651 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11652 }
11653 {
11654 if ( _n_dims( args(6) ) > 1 )
11655 {
11656 error( "argument must be a scalar or vector" ); SWIG_fail;
11657 }
11658 if ( _dim( args(6), 0 ) != 6 )
11659 {
11660 error( "argument vectors must have length of 6" ); SWIG_fail;
11661 }
11662 temp10 = args(6).matrix_value();
11663 arg10 = &temp10( 0, 0 );
11664 }
11665 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11666 _outv = octave_value();
11667 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11668 {
11669
11670 }
11671 {
11672
11673 }
11674 {
11675
11676 }
11677 return _out;
11678 fail:
11679 {
11680
11681 }
11682 {
11683
11684 }
11685 {
11686
11687 }
11688 return octave_value_list();
11689 }
11690 catch(...) {
11691 {
11692
11693 }
11694 {
11695
11696 }
11697 {
11698
11699 }
11700 throw;
11701 }
11702}
11703
11704
11705SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11706 PLFLT *arg1 = (PLFLT *) 0 ;
11707 PLINT arg2 ;
11708 PLINT arg3 ;
11709 PLINT arg4 ;
11710 PLINT arg5 ;
11711 PLINT arg6 ;
11712 PLINT arg7 ;
11713 PLFLT *arg8 = (PLFLT *) 0 ;
11714 PLINT arg9 ;
11715 Matrix temp1 ;
11716 int val4 ;
11717 int ecode4 = 0 ;
11718 int val5 ;
11719 int ecode5 = 0 ;
11720 int val6 ;
11721 int ecode6 = 0 ;
11722 int val7 ;
11723 int ecode7 = 0 ;
11724 Matrix temp8 ;
11725 octave_value_list _out;
11726 octave_value_list *_outp=&_out;
11727 octave_value _outv;
11728
11729 try {
11730 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11731 SWIG_fail;
11732 }
11733 {
11734 if ( _n_dims( args(0) ) > 2 )
11735 {
11736 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11737 }
11738 temp1 = args(0).matrix_value();
11739 arg1 = &temp1( 0, 0 );
11740 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11741 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11742 }
11743 ecode4 = SWIG_AsVal_int(args(1), &val4);
11744 if (!SWIG_IsOK(ecode4)) {
11745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11746 }
11747 arg4 = static_cast< PLINT >(val4);
11748 ecode5 = SWIG_AsVal_int(args(2), &val5);
11749 if (!SWIG_IsOK(ecode5)) {
11750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11751 }
11752 arg5 = static_cast< PLINT >(val5);
11753 ecode6 = SWIG_AsVal_int(args(3), &val6);
11754 if (!SWIG_IsOK(ecode6)) {
11755 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11756 }
11757 arg6 = static_cast< PLINT >(val6);
11758 ecode7 = SWIG_AsVal_int(args(4), &val7);
11759 if (!SWIG_IsOK(ecode7)) {
11760 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11761 }
11762 arg7 = static_cast< PLINT >(val7);
11763 {
11764 if ( _n_dims( args(5) ) > 1 )
11765 {
11766 error( "argument must be a scalar or vector" ); SWIG_fail;
11767 }
11768 temp8 = args(5).matrix_value();
11769 arg8 = &temp8( 0, 0 );
11770 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11771 }
11772 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11773 _outv = octave_value();
11774 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11775 {
11776
11777 }
11778 {
11779
11780 }
11781 return _out;
11782 fail:
11783 {
11784
11785 }
11786 {
11787
11788 }
11789 return octave_value_list();
11790 }
11791 catch(...) {
11792 {
11793
11794 }
11795 {
11796
11797 }
11798 throw;
11799 }
11800}
11801
11802
11803SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11804 PLFLT *arg1 = (PLFLT *) 0 ;
11805 PLINT arg2 ;
11806 PLINT arg3 ;
11807 PLINT arg4 ;
11808 PLINT arg5 ;
11809 PLINT arg6 ;
11810 PLINT arg7 ;
11811 PLFLT *arg8 = (PLFLT *) 0 ;
11812 PLINT arg9 ;
11813 PLFLT *arg10 = (PLFLT *) 0 ;
11814 PLFLT *arg11 = (PLFLT *) 0 ;
11815 Matrix temp1 ;
11816 int val4 ;
11817 int ecode4 = 0 ;
11818 int val5 ;
11819 int ecode5 = 0 ;
11820 int val6 ;
11821 int ecode6 = 0 ;
11822 int val7 ;
11823 int ecode7 = 0 ;
11824 Matrix temp8 ;
11825 Matrix temp10 ;
11826 Matrix temp11 ;
11827 octave_value_list _out;
11828 octave_value_list *_outp=&_out;
11829 octave_value _outv;
11830
11831 try {
11832 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11833 SWIG_fail;
11834 }
11835 {
11836 if ( _n_dims( args(0) ) > 2 )
11837 {
11838 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11839 }
11840 temp1 = args(0).matrix_value();
11841 arg1 = &temp1( 0, 0 );
11842 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11843 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11844 }
11845 ecode4 = SWIG_AsVal_int(args(1), &val4);
11846 if (!SWIG_IsOK(ecode4)) {
11847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11848 }
11849 arg4 = static_cast< PLINT >(val4);
11850 ecode5 = SWIG_AsVal_int(args(2), &val5);
11851 if (!SWIG_IsOK(ecode5)) {
11852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11853 }
11854 arg5 = static_cast< PLINT >(val5);
11855 ecode6 = SWIG_AsVal_int(args(3), &val6);
11856 if (!SWIG_IsOK(ecode6)) {
11857 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11858 }
11859 arg6 = static_cast< PLINT >(val6);
11860 ecode7 = SWIG_AsVal_int(args(4), &val7);
11861 if (!SWIG_IsOK(ecode7)) {
11862 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11863 }
11864 arg7 = static_cast< PLINT >(val7);
11865 {
11866 if ( _n_dims( args(5) ) > 1 )
11867 {
11868 error( "argument must be a scalar or vector" ); SWIG_fail;
11869 }
11870 temp8 = args(5).matrix_value();
11871 arg8 = &temp8( 0, 0 );
11872 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11873 }
11874 {
11875 if ( _n_dims( args(6) ) > 1 )
11876 {
11877 error( "argument must be a scalar or vector" ); SWIG_fail;
11878 }
11879 if ( _dim( args(6), 0 ) != Xlen )
11880 {
11881 error( "argument vectors must be same length" ); SWIG_fail;
11882 }
11883 temp10 = args(6).matrix_value();
11884 arg10 = &temp10( 0, 0 );
11885 }
11886 {
11887 if ( _n_dims( args(7) ) > 1 )
11888 {
11889 error( "argument must be a scalar or vector" ); SWIG_fail;
11890 }
11891 if ( _dim( args(7), 0 ) != Ylen )
11892 {
11893 error( "argument vectors must be same length" ); SWIG_fail;
11894 }
11895 temp11 = args(7).matrix_value();
11896 arg11 = &temp11( 0, 0 );
11897 }
11898 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11899 _outv = octave_value();
11900 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11901 {
11902
11903 }
11904 {
11905
11906 }
11907 {
11908
11909 }
11910 {
11911
11912 }
11913 return _out;
11914 fail:
11915 {
11916
11917 }
11918 {
11919
11920 }
11921 {
11922
11923 }
11924 {
11925
11926 }
11927 return octave_value_list();
11928 }
11929 catch(...) {
11930 {
11931
11932 }
11933 {
11934
11935 }
11936 {
11937
11938 }
11939 {
11940
11941 }
11942 throw;
11943 }
11944}
11945
11946
11947SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11948 PLFLT *arg1 = (PLFLT *) 0 ;
11949 PLINT arg2 ;
11950 PLINT arg3 ;
11951 PLINT arg4 ;
11952 PLINT arg5 ;
11953 PLINT arg6 ;
11954 PLINT arg7 ;
11955 PLFLT *arg8 = (PLFLT *) 0 ;
11956 PLINT arg9 ;
11957 PLFLT *arg10 = (PLFLT *) 0 ;
11958 PLFLT *arg11 = (PLFLT *) 0 ;
11959 Matrix temp1 ;
11960 int val4 ;
11961 int ecode4 = 0 ;
11962 int val5 ;
11963 int ecode5 = 0 ;
11964 int val6 ;
11965 int ecode6 = 0 ;
11966 int val7 ;
11967 int ecode7 = 0 ;
11968 Matrix temp8 ;
11969 Matrix temp10 ;
11970 Matrix temp11 ;
11971 octave_value_list _out;
11972 octave_value_list *_outp=&_out;
11973 octave_value _outv;
11974
11975 try {
11976 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11977 SWIG_fail;
11978 }
11979 {
11980 if ( _n_dims( args(0) ) > 2 )
11981 {
11982 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11983 }
11984 temp1 = args(0).matrix_value();
11985 arg1 = &temp1( 0, 0 );
11986 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11987 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11988 }
11989 ecode4 = SWIG_AsVal_int(args(1), &val4);
11990 if (!SWIG_IsOK(ecode4)) {
11991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11992 }
11993 arg4 = static_cast< PLINT >(val4);
11994 ecode5 = SWIG_AsVal_int(args(2), &val5);
11995 if (!SWIG_IsOK(ecode5)) {
11996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11997 }
11998 arg5 = static_cast< PLINT >(val5);
11999 ecode6 = SWIG_AsVal_int(args(3), &val6);
12000 if (!SWIG_IsOK(ecode6)) {
12001 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
12002 }
12003 arg6 = static_cast< PLINT >(val6);
12004 ecode7 = SWIG_AsVal_int(args(4), &val7);
12005 if (!SWIG_IsOK(ecode7)) {
12006 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
12007 }
12008 arg7 = static_cast< PLINT >(val7);
12009 {
12010 if ( _n_dims( args(5) ) > 1 )
12011 {
12012 error( "argument must be a scalar or vector" ); SWIG_fail;
12013 }
12014 temp8 = args(5).matrix_value();
12015 arg8 = &temp8( 0, 0 );
12016 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12017 }
12018 {
12019 if ( _n_dims( args(6) ) > 2 )
12020 {
12021 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12022 }
12023 if ( _dim( args(6), 0 ) != Xlen )
12024 {
12025 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12026 }
12027 if ( _dim( args(6), 1 ) != Ylen )
12028 {
12029 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12030 }
12031 temp10 = args(6).matrix_value();
12032 arg10 = &temp10( 0, 0 );
12033 }
12034 {
12035 if ( _n_dims( args(7) ) > 2 )
12036 {
12037 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12038 }
12039 if ( _dim( args(7), 0 ) != Xlen )
12040 {
12041 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12042 }
12043 if ( _dim( args(7), 1 ) != Ylen )
12044 {
12045 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12046 }
12047 temp11 = args(7).matrix_value();
12048 arg11 = &temp11( 0, 0 );
12049 }
12050 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12051 _outv = octave_value();
12052 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12053 {
12054
12055 }
12056 {
12057
12058 }
12059 {
12060
12061 }
12062 {
12063
12064 }
12065 return _out;
12066 fail:
12067 {
12068
12069 }
12070 {
12071
12072 }
12073 {
12074
12075 }
12076 {
12077
12078 }
12079 return octave_value_list();
12080 }
12081 catch(...) {
12082 {
12083
12084 }
12085 {
12086
12087 }
12088 {
12089
12090 }
12091 {
12092
12093 }
12094 throw;
12095 }
12096}
12097
12098
12099SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12100 PLFLT *arg1 = (PLFLT *) 0 ;
12101 PLINT arg2 ;
12102 PLINT arg3 ;
12103 PLINT arg4 ;
12104 PLINT arg5 ;
12105 PLINT arg6 ;
12106 PLINT arg7 ;
12107 PLFLT *arg8 = (PLFLT *) 0 ;
12108 PLINT arg9 ;
12109 PLFLT *arg10 = (PLFLT *) 0 ;
12110 PLFLT *arg11 = (PLFLT *) 0 ;
12111 Matrix temp1 ;
12112 int val4 ;
12113 int ecode4 = 0 ;
12114 int val5 ;
12115 int ecode5 = 0 ;
12116 int val6 ;
12117 int ecode6 = 0 ;
12118 int val7 ;
12119 int ecode7 = 0 ;
12120 Matrix temp8 ;
12121 Matrix temp10 ;
12122 Matrix temp11 ;
12123 octave_value_list _out;
12124 octave_value_list *_outp=&_out;
12125 octave_value _outv;
12126
12127 try {
12128 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12129 SWIG_fail;
12130 }
12131 {
12132 if ( _n_dims( args(0) ) > 2 )
12133 {
12134 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12135 }
12136 temp1 = args(0).matrix_value();
12137 arg1 = &temp1( 0, 0 );
12138 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12139 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12140 }
12141 ecode4 = SWIG_AsVal_int(args(1), &val4);
12142 if (!SWIG_IsOK(ecode4)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12144 }
12145 arg4 = static_cast< PLINT >(val4);
12146 ecode5 = SWIG_AsVal_int(args(2), &val5);
12147 if (!SWIG_IsOK(ecode5)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12149 }
12150 arg5 = static_cast< PLINT >(val5);
12151 ecode6 = SWIG_AsVal_int(args(3), &val6);
12152 if (!SWIG_IsOK(ecode6)) {
12153 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12154 }
12155 arg6 = static_cast< PLINT >(val6);
12156 ecode7 = SWIG_AsVal_int(args(4), &val7);
12157 if (!SWIG_IsOK(ecode7)) {
12158 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12159 }
12160 arg7 = static_cast< PLINT >(val7);
12161 {
12162 if ( _n_dims( args(5) ) > 1 )
12163 {
12164 error( "argument must be a scalar or vector" ); SWIG_fail;
12165 }
12166 temp8 = args(5).matrix_value();
12167 arg8 = &temp8( 0, 0 );
12168 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12169 }
12170 {
12171 if ( _n_dims( args(6) ) > 2 )
12172 {
12173 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12174 }
12175 if ( _dim( args(6), 0 ) != Xlen )
12176 {
12177 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12178 }
12179 if ( _dim( args(6), 1 ) != Ylen )
12180 {
12181 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12182 }
12183 temp10 = args(6).matrix_value();
12184 arg10 = &temp10( 0, 0 );
12185 }
12186 {
12187 if ( _n_dims( args(7) ) > 2 )
12188 {
12189 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12190 }
12191 if ( _dim( args(7), 0 ) != Xlen )
12192 {
12193 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12194 }
12195 if ( _dim( args(7), 1 ) != Ylen )
12196 {
12197 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12198 }
12199 temp11 = args(7).matrix_value();
12200 arg11 = &temp11( 0, 0 );
12201 }
12202 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12203 _outv = octave_value();
12204 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12205 {
12206
12207 }
12208 {
12209
12210 }
12211 {
12212
12213 }
12214 {
12215
12216 }
12217 return _out;
12218 fail:
12219 {
12220
12221 }
12222 {
12223
12224 }
12225 {
12226
12227 }
12228 {
12229
12230 }
12231 return octave_value_list();
12232 }
12233 catch(...) {
12234 {
12235
12236 }
12237 {
12238
12239 }
12240 {
12241
12242 }
12243 {
12244
12245 }
12246 throw;
12247 }
12248}
12249
12250
12251SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
12252 PLFLT *arg1 = (PLFLT *) 0 ;
12253 PLFLT *arg2 = (PLFLT *) 0 ;
12254 PLFLT *arg3 = (PLFLT *) 0 ;
12255 PLINT arg4 ;
12256 PLFLT *arg5 = (PLFLT *) 0 ;
12257 PLINT arg6 ;
12258 PLFLT *arg7 = (PLFLT *) 0 ;
12259 PLINT arg8 ;
12260 PLFLT *arg9 = (PLFLT *) 0 ;
12261 PLINT arg10 ;
12262 PLFLT arg11 ;
12263 Matrix temp1 ;
12264 Matrix temp2 ;
12265 Matrix temp3 ;
12266 Matrix temp5 ;
12267 Matrix temp7 ;
12268 octave_value_list retval7 ;
12269 int val10 ;
12270 int ecode10 = 0 ;
12271 double val11 ;
12272 int ecode11 = 0 ;
12273 octave_value_list _out;
12274 octave_value_list *_outp=&_out;
12275 octave_value _outv;
12276
12277 try {
12278 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12279 SWIG_fail;
12280 }
12281 {
12282 if ( _n_dims( args(0) ) > 1 )
12283 {
12284 error( "argument must be a scalar or vector" ); SWIG_fail;
12285 }
12286 Alen = (PLINT) ( _dim( args(0), 0 ) );
12287 temp1 = args(0).matrix_value();
12288 arg1 = &temp1( 0, 0 );
12289 }
12290 {
12291 if ( _n_dims( args(1) ) > 1 )
12292 {
12293 error( "argument must be a scalar or vector" ); SWIG_fail;
12294 }
12295 if ( _dim( args(1), 0 ) != Alen )
12296 {
12297 error( "argument vectors must be same length" ); SWIG_fail;
12298 }
12299 temp2 = args(1).matrix_value();
12300 arg2 = &temp2( 0, 0 );
12301 }
12302 {
12303 if ( _n_dims( args(2) ) > 1 )
12304 {
12305 error( "argument must be a scalar or vector" ); SWIG_fail;
12306 }
12307 if ( _dim( args(2), 0 ) != Alen )
12308 {
12309 error( "argument vectors must be same length" ); SWIG_fail;
12310 }
12311 temp3 = args(2).matrix_value();
12312 arg3 = &temp3( 0, 0 );
12313 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12314 }
12315 {
12316 if ( _n_dims( args(3) ) > 1 )
12317 {
12318 error( "argument must be a scalar or vector" ); SWIG_fail;
12319 }
12320 temp5 = args(3).matrix_value();
12321 arg5 = &temp5( 0, 0 );
12322 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12323 }
12324 {
12325 if ( _n_dims( args(4) ) > 1 )
12326 {
12327 error( "argument must be a scalar or vector" ); SWIG_fail;
12328 }
12329 temp7 = args(4).matrix_value();
12330 arg7 = &temp7( 0, 0 );
12331 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12332 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12333 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12334 }
12335 ecode10 = SWIG_AsVal_int(args(5), &val10);
12336 if (!SWIG_IsOK(ecode10)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12338 }
12339 arg10 = static_cast< PLINT >(val10);
12340 ecode11 = SWIG_AsVal_double(args(6), &val11);
12341 if (!SWIG_IsOK(ecode11)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12343 }
12344 arg11 = static_cast< PLFLT >(val11);
12345 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12346 _outv = octave_value();
12347 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12348 {
12349 _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12350 }
12351 {
12352
12353 }
12354 {
12355
12356 }
12357 {
12358
12359 }
12360 {
12361
12362 }
12363 {
12364
12365 }
12366 return _out;
12367 fail:
12368 {
12369
12370 }
12371 {
12372
12373 }
12374 {
12375
12376 }
12377 {
12378
12379 }
12380 {
12381
12382 }
12383 return octave_value_list();
12384 }
12385 catch(...) {
12386 {
12387
12388 }
12389 {
12390
12391 }
12392 {
12393
12394 }
12395 {
12396
12397 }
12398 {
12399
12400 }
12401 throw;
12402 }
12403}
12404
12405
12407 PLFLT *arg1 = (PLFLT *) 0 ;
12408 PLFLT *arg2 = (PLFLT *) 0 ;
12409 PLFLT *arg3 = (PLFLT *) 0 ;
12410 PLINT arg4 ;
12411 PLINT arg5 ;
12412 PLINT arg6 ;
12413 Matrix temp1 ;
12414 Matrix temp2 ;
12415 Matrix temp3 ;
12416 int val6 ;
12417 int ecode6 = 0 ;
12418 octave_value_list _out;
12419 octave_value_list *_outp=&_out;
12420 octave_value _outv;
12421
12422 try {
12423 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12424 SWIG_fail;
12425 }
12426 {
12427 if ( _n_dims( args(0) ) > 1 )
12428 {
12429 error( "argument must be a scalar or vector" ); SWIG_fail;
12430 }
12431 temp1 = args(0).matrix_value();
12432 arg1 = &temp1( 0, 0 );
12433 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12434 }
12435 {
12436 if ( _n_dims( args(1) ) > 1 )
12437 {
12438 error( "argument must be a scalar or vector" ); SWIG_fail;
12439 }
12440 temp2 = args(1).matrix_value();
12441 arg2 = &temp2( 0, 0 );
12442 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12443 }
12444 {
12445 if ( _n_dims( args(2) ) > 2 )
12446 {
12447 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12448 }
12449 if ( _dim( args(2), 0 ) != Xlen )
12450 {
12451 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12452 }
12453 if ( _dim( args(2), 1 ) != Ylen )
12454 {
12455 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12456 }
12457 temp3 = args(2).matrix_value();
12458 arg3 = &temp3( 0, 0 );
12459 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12460 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12461 }
12462 ecode6 = SWIG_AsVal_int(args(3), &val6);
12463 if (!SWIG_IsOK(ecode6)) {
12464 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12465 }
12466 arg6 = static_cast< PLINT >(val6);
12467 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12468 _outv = octave_value();
12469 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12470 {
12471
12472 }
12473 {
12474
12475 }
12476 {
12477
12478 }
12479 return _out;
12480 fail:
12481 {
12482
12483 }
12484 {
12485
12486 }
12487 {
12488
12489 }
12490 return octave_value_list();
12491 }
12492 catch(...) {
12493 {
12494
12495 }
12496 {
12497
12498 }
12499 {
12500
12501 }
12502 throw;
12503 }
12504}
12505
12506
12508 PLFLT *arg1 = (PLFLT *) 0 ;
12509 PLFLT *arg2 = (PLFLT *) 0 ;
12510 PLFLT *arg3 = (PLFLT *) 0 ;
12511 PLINT arg4 ;
12512 PLINT arg5 ;
12513 PLINT arg6 ;
12514 PLFLT *arg7 = (PLFLT *) 0 ;
12515 PLINT arg8 ;
12516 Matrix temp1 ;
12517 Matrix temp2 ;
12518 Matrix temp3 ;
12519 int val6 ;
12520 int ecode6 = 0 ;
12521 Matrix temp7 ;
12522 octave_value_list _out;
12523 octave_value_list *_outp=&_out;
12524 octave_value _outv;
12525
12526 try {
12527 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12528 SWIG_fail;
12529 }
12530 {
12531 if ( _n_dims( args(0) ) > 1 )
12532 {
12533 error( "argument must be a scalar or vector" ); SWIG_fail;
12534 }
12535 temp1 = args(0).matrix_value();
12536 arg1 = &temp1( 0, 0 );
12537 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12538 }
12539 {
12540 if ( _n_dims( args(1) ) > 1 )
12541 {
12542 error( "argument must be a scalar or vector" ); SWIG_fail;
12543 }
12544 temp2 = args(1).matrix_value();
12545 arg2 = &temp2( 0, 0 );
12546 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12547 }
12548 {
12549 if ( _n_dims( args(2) ) > 2 )
12550 {
12551 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12552 }
12553 if ( _dim( args(2), 0 ) != Xlen )
12554 {
12555 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12556 }
12557 if ( _dim( args(2), 1 ) != Ylen )
12558 {
12559 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12560 }
12561 temp3 = args(2).matrix_value();
12562 arg3 = &temp3( 0, 0 );
12563 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12564 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12565 }
12566 ecode6 = SWIG_AsVal_int(args(3), &val6);
12567 if (!SWIG_IsOK(ecode6)) {
12568 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12569 }
12570 arg6 = static_cast< PLINT >(val6);
12571 {
12572 if ( _n_dims( args(4) ) > 1 )
12573 {
12574 error( "argument must be a scalar or vector" ); SWIG_fail;
12575 }
12576 temp7 = args(4).matrix_value();
12577 arg7 = &temp7( 0, 0 );
12578 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12579 }
12580 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12581 _outv = octave_value();
12582 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12583 {
12584
12585 }
12586 {
12587
12588 }
12589 {
12590
12591 }
12592 {
12593
12594 }
12595 return _out;
12596 fail:
12597 {
12598
12599 }
12600 {
12601
12602 }
12603 {
12604
12605 }
12606 {
12607
12608 }
12609 return octave_value_list();
12610 }
12611 catch(...) {
12612 {
12613
12614 }
12615 {
12616
12617 }
12618 {
12619
12620 }
12621 {
12622
12623 }
12624 throw;
12625 }
12626}
12627
12628
12630 PLFLT *arg1 = (PLFLT *) 0 ;
12631 PLFLT *arg2 = (PLFLT *) 0 ;
12632 PLFLT *arg3 = (PLFLT *) 0 ;
12633 PLINT arg4 ;
12634 PLINT arg5 ;
12635 PLINT arg6 ;
12636 PLBOOL arg7 ;
12637 Matrix temp1 ;
12638 Matrix temp2 ;
12639 Matrix temp3 ;
12640 int val6 ;
12641 int ecode6 = 0 ;
12642 int val7 ;
12643 int ecode7 = 0 ;
12644 octave_value_list _out;
12645 octave_value_list *_outp=&_out;
12646 octave_value _outv;
12647
12648 try {
12649 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12650 SWIG_fail;
12651 }
12652 {
12653 if ( _n_dims( args(0) ) > 1 )
12654 {
12655 error( "argument must be a scalar or vector" ); SWIG_fail;
12656 }
12657 temp1 = args(0).matrix_value();
12658 arg1 = &temp1( 0, 0 );
12659 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12660 }
12661 {
12662 if ( _n_dims( args(1) ) > 1 )
12663 {
12664 error( "argument must be a scalar or vector" ); SWIG_fail;
12665 }
12666 temp2 = args(1).matrix_value();
12667 arg2 = &temp2( 0, 0 );
12668 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12669 }
12670 {
12671 if ( _n_dims( args(2) ) > 2 )
12672 {
12673 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12674 }
12675 if ( _dim( args(2), 0 ) != Xlen )
12676 {
12677 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12678 }
12679 if ( _dim( args(2), 1 ) != Ylen )
12680 {
12681 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12682 }
12683 temp3 = args(2).matrix_value();
12684 arg3 = &temp3( 0, 0 );
12685 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12686 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12687 }
12688 ecode6 = SWIG_AsVal_int(args(3), &val6);
12689 if (!SWIG_IsOK(ecode6)) {
12690 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12691 }
12692 arg6 = static_cast< PLINT >(val6);
12693 ecode7 = SWIG_AsVal_int(args(4), &val7);
12694 if (!SWIG_IsOK(ecode7)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12696 }
12697 arg7 = static_cast< PLBOOL >(val7);
12698 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12699 _outv = octave_value();
12700 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12701 {
12702
12703 }
12704 {
12705
12706 }
12707 {
12708
12709 }
12710 return _out;
12711 fail:
12712 {
12713
12714 }
12715 {
12716
12717 }
12718 {
12719
12720 }
12721 return octave_value_list();
12722 }
12723 catch(...) {
12724 {
12725
12726 }
12727 {
12728
12729 }
12730 {
12731
12732 }
12733 throw;
12734 }
12735}
12736
12737
12739 PLFLT *arg1 = (PLFLT *) 0 ;
12740 PLFLT *arg2 = (PLFLT *) 0 ;
12741 PLFLT *arg3 = (PLFLT *) 0 ;
12742 PLINT arg4 ;
12743 PLINT arg5 ;
12744 PLINT arg6 ;
12745 PLFLT *arg7 = (PLFLT *) 0 ;
12746 PLINT arg8 ;
12747 Matrix temp1 ;
12748 Matrix temp2 ;
12749 Matrix temp3 ;
12750 int val6 ;
12751 int ecode6 = 0 ;
12752 Matrix temp7 ;
12753 octave_value_list _out;
12754 octave_value_list *_outp=&_out;
12755 octave_value _outv;
12756
12757 try {
12758 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12759 SWIG_fail;
12760 }
12761 {
12762 if ( _n_dims( args(0) ) > 1 )
12763 {
12764 error( "argument must be a scalar or vector" ); SWIG_fail;
12765 }
12766 temp1 = args(0).matrix_value();
12767 arg1 = &temp1( 0, 0 );
12768 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12769 }
12770 {
12771 if ( _n_dims( args(1) ) > 1 )
12772 {
12773 error( "argument must be a scalar or vector" ); SWIG_fail;
12774 }
12775 temp2 = args(1).matrix_value();
12776 arg2 = &temp2( 0, 0 );
12777 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12778 }
12779 {
12780 if ( _n_dims( args(2) ) > 2 )
12781 {
12782 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12783 }
12784 if ( _dim( args(2), 0 ) != Xlen )
12785 {
12786 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12787 }
12788 if ( _dim( args(2), 1 ) != Ylen )
12789 {
12790 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12791 }
12792 temp3 = args(2).matrix_value();
12793 arg3 = &temp3( 0, 0 );
12794 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12795 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12796 }
12797 ecode6 = SWIG_AsVal_int(args(3), &val6);
12798 if (!SWIG_IsOK(ecode6)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12800 }
12801 arg6 = static_cast< PLINT >(val6);
12802 {
12803 if ( _n_dims( args(4) ) > 1 )
12804 {
12805 error( "argument must be a scalar or vector" ); SWIG_fail;
12806 }
12807 temp7 = args(4).matrix_value();
12808 arg7 = &temp7( 0, 0 );
12809 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12810 }
12811 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12812 _outv = octave_value();
12813 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12814 {
12815
12816 }
12817 {
12818
12819 }
12820 {
12821
12822 }
12823 {
12824
12825 }
12826 return _out;
12827 fail:
12828 {
12829
12830 }
12831 {
12832
12833 }
12834 {
12835
12836 }
12837 {
12838
12839 }
12840 return octave_value_list();
12841 }
12842 catch(...) {
12843 {
12844
12845 }
12846 {
12847
12848 }
12849 {
12850
12851 }
12852 {
12853
12854 }
12855 throw;
12856 }
12857}
12858
12859
12861 PLFLT *arg1 = (PLFLT *) 0 ;
12862 PLFLT *arg2 = (PLFLT *) 0 ;
12863 PLFLT *arg3 = (PLFLT *) 0 ;
12864 PLINT arg4 ;
12865 PLINT arg5 ;
12866 PLINT arg6 ;
12867 PLFLT *arg7 = (PLFLT *) 0 ;
12868 PLINT arg8 ;
12869 PLINT arg9 ;
12870 PLINT arg10 ;
12871 PLINT *arg11 = (PLINT *) 0 ;
12872 PLINT *arg12 = (PLINT *) 0 ;
12873 Matrix temp1 ;
12874 Matrix temp2 ;
12875 Matrix temp3 ;
12876 int val6 ;
12877 int ecode6 = 0 ;
12878 Matrix temp7 ;
12879 int val9 ;
12880 int ecode9 = 0 ;
12881 Matrix temp10 ;
12882 Matrix temp12 ;
12883 octave_value_list _out;
12884 octave_value_list *_outp=&_out;
12885 octave_value _outv;
12886
12887 try {
12888 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12889 SWIG_fail;
12890 }
12891 {
12892 if ( _n_dims( args(0) ) > 1 )
12893 {
12894 error( "argument must be a scalar or vector" ); SWIG_fail;
12895 }
12896 temp1 = args(0).matrix_value();
12897 arg1 = &temp1( 0, 0 );
12898 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12899 }
12900 {
12901 if ( _n_dims( args(1) ) > 1 )
12902 {
12903 error( "argument must be a scalar or vector" ); SWIG_fail;
12904 }
12905 temp2 = args(1).matrix_value();
12906 arg2 = &temp2( 0, 0 );
12907 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12908 }
12909 {
12910 if ( _n_dims( args(2) ) > 2 )
12911 {
12912 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12913 }
12914 if ( _dim( args(2), 0 ) != Xlen )
12915 {
12916 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12917 }
12918 if ( _dim( args(2), 1 ) != Ylen )
12919 {
12920 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12921 }
12922 temp3 = args(2).matrix_value();
12923 arg3 = &temp3( 0, 0 );
12924 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12925 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12926 }
12927 ecode6 = SWIG_AsVal_int(args(3), &val6);
12928 if (!SWIG_IsOK(ecode6)) {
12929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12930 }
12931 arg6 = static_cast< PLINT >(val6);
12932 {
12933 if ( _n_dims( args(4) ) > 1 )
12934 {
12935 error( "argument must be a scalar or vector" ); SWIG_fail;
12936 }
12937 temp7 = args(4).matrix_value();
12938 arg7 = &temp7( 0, 0 );
12939 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12940 }
12941 ecode9 = SWIG_AsVal_int(args(5), &val9);
12942 if (!SWIG_IsOK(ecode9)) {
12943 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12944 }
12945 arg9 = static_cast< PLINT >(val9);
12946 {
12947 if ( _n_dims( args(6) ) > 1 )
12948 {
12949 error( "argument must be a scalar or vector" ); SWIG_fail;
12950 }
12951 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12952 arg11 = new PLINT[Alen];
12953 temp10 = args(6).matrix_value();
12954 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12955 }
12956 {
12957 if ( _n_dims( args(7) ) > 1 )
12958 {
12959 error( "argument must be a scalar or vector" ); SWIG_fail;
12960 }
12961 if ( _dim( args(7), 0 ) != Alen )
12962 {
12963 error( "argument vectors must be same length" ); SWIG_fail;
12964 }
12965 temp12 = args(7).matrix_value();
12966 arg12 = new PLINT[Alen];
12967 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12968 }
12969 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);
12970 _outv = octave_value();
12971 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12972 {
12973
12974 }
12975 {
12976
12977 }
12978 {
12979
12980 }
12981 {
12982
12983 }
12984 {
12985 delete [] arg11;
12986 }
12987 {
12988 delete [] arg12;
12989 }
12990 return _out;
12991 fail:
12992 {
12993
12994 }
12995 {
12996
12997 }
12998 {
12999
13000 }
13001 {
13002
13003 }
13004 {
13005 delete [] arg11;
13006 }
13007 {
13008 delete [] arg12;
13009 }
13010 return octave_value_list();
13011 }
13012 catch(...) {
13013 {
13014
13015 }
13016 {
13017
13018 }
13019 {
13020
13021 }
13022 {
13023
13024 }
13025 {
13026 delete [] arg11;
13027 }
13028 {
13029 delete [] arg12;
13030 }
13031 throw;
13032 }
13033}
13034
13035
13037 PLFLT *arg1 = (PLFLT *) 0 ;
13038 PLFLT *arg2 = (PLFLT *) 0 ;
13039 PLFLT *arg3 = (PLFLT *) 0 ;
13040 PLINT arg4 ;
13041 PLINT arg5 ;
13042 PLINT arg6 ;
13043 PLFLT *arg7 = (PLFLT *) 0 ;
13044 PLINT arg8 ;
13045 Matrix temp1 ;
13046 Matrix temp2 ;
13047 Matrix temp3 ;
13048 int val6 ;
13049 int ecode6 = 0 ;
13050 Matrix temp7 ;
13051 octave_value_list _out;
13052 octave_value_list *_outp=&_out;
13053 octave_value _outv;
13054
13055 try {
13056 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
13057 SWIG_fail;
13058 }
13059 {
13060 if ( _n_dims( args(0) ) > 1 )
13061 {
13062 error( "argument must be a scalar or vector" ); SWIG_fail;
13063 }
13064 temp1 = args(0).matrix_value();
13065 arg1 = &temp1( 0, 0 );
13066 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13067 }
13068 {
13069 if ( _n_dims( args(1) ) > 1 )
13070 {
13071 error( "argument must be a scalar or vector" ); SWIG_fail;
13072 }
13073 temp2 = args(1).matrix_value();
13074 arg2 = &temp2( 0, 0 );
13075 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13076 }
13077 {
13078 if ( _n_dims( args(2) ) > 2 )
13079 {
13080 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13081 }
13082 if ( _dim( args(2), 0 ) != Xlen )
13083 {
13084 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13085 }
13086 if ( _dim( args(2), 1 ) != Ylen )
13087 {
13088 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13089 }
13090 temp3 = args(2).matrix_value();
13091 arg3 = &temp3( 0, 0 );
13092 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13093 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13094 }
13095 ecode6 = SWIG_AsVal_int(args(3), &val6);
13096 if (!SWIG_IsOK(ecode6)) {
13097 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13098 }
13099 arg6 = static_cast< PLINT >(val6);
13100 {
13101 if ( _n_dims( args(4) ) > 1 )
13102 {
13103 error( "argument must be a scalar or vector" ); SWIG_fail;
13104 }
13105 temp7 = args(4).matrix_value();
13106 arg7 = &temp7( 0, 0 );
13107 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13108 }
13109 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13110 _outv = octave_value();
13111 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13112 {
13113
13114 }
13115 {
13116
13117 }
13118 {
13119
13120 }
13121 {
13122
13123 }
13124 return _out;
13125 fail:
13126 {
13127
13128 }
13129 {
13130
13131 }
13132 {
13133
13134 }
13135 {
13136
13137 }
13138 return octave_value_list();
13139 }
13140 catch(...) {
13141 {
13142
13143 }
13144 {
13145
13146 }
13147 {
13148
13149 }
13150 {
13151
13152 }
13153 throw;
13154 }
13155}
13156
13157
13159 PLFLT *arg1 = (PLFLT *) 0 ;
13160 PLFLT *arg2 = (PLFLT *) 0 ;
13161 PLFLT *arg3 = (PLFLT *) 0 ;
13162 PLINT arg4 ;
13163 PLINT arg5 ;
13164 PLINT arg6 ;
13165 PLFLT *arg7 = (PLFLT *) 0 ;
13166 PLINT arg8 ;
13167 PLINT arg9 ;
13168 PLINT arg10 ;
13169 PLINT *arg11 = (PLINT *) 0 ;
13170 PLINT *arg12 = (PLINT *) 0 ;
13171 Matrix temp1 ;
13172 Matrix temp2 ;
13173 Matrix temp3 ;
13174 int val6 ;
13175 int ecode6 = 0 ;
13176 Matrix temp7 ;
13177 int val9 ;
13178 int ecode9 = 0 ;
13179 Matrix temp10 ;
13180 Matrix temp12 ;
13181 octave_value_list _out;
13182 octave_value_list *_outp=&_out;
13183 octave_value _outv;
13184
13185 try {
13186 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13187 SWIG_fail;
13188 }
13189 {
13190 if ( _n_dims( args(0) ) > 1 )
13191 {
13192 error( "argument must be a scalar or vector" ); SWIG_fail;
13193 }
13194 temp1 = args(0).matrix_value();
13195 arg1 = &temp1( 0, 0 );
13196 Xlen = (PLINT) ( _dim( args(0), 0 ) );
13197 }
13198 {
13199 if ( _n_dims( args(1) ) > 1 )
13200 {
13201 error( "argument must be a scalar or vector" ); SWIG_fail;
13202 }
13203 temp2 = args(1).matrix_value();
13204 arg2 = &temp2( 0, 0 );
13205 Ylen = (PLINT) ( _dim( args(1), 0 ) );
13206 }
13207 {
13208 if ( _n_dims( args(2) ) > 2 )
13209 {
13210 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13211 }
13212 if ( _dim( args(2), 0 ) != Xlen )
13213 {
13214 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13215 }
13216 if ( _dim( args(2), 1 ) != Ylen )
13217 {
13218 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13219 }
13220 temp3 = args(2).matrix_value();
13221 arg3 = &temp3( 0, 0 );
13222 arg4 = (PLINT) ( _dim( args(2), 0 ) );
13223 arg5 = (PLINT) ( _dim( args(2), 1 ) );
13224 }
13225 ecode6 = SWIG_AsVal_int(args(3), &val6);
13226 if (!SWIG_IsOK(ecode6)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13228 }
13229 arg6 = static_cast< PLINT >(val6);
13230 {
13231 if ( _n_dims( args(4) ) > 1 )
13232 {
13233 error( "argument must be a scalar or vector" ); SWIG_fail;
13234 }
13235 temp7 = args(4).matrix_value();
13236 arg7 = &temp7( 0, 0 );
13237 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13238 }
13239 ecode9 = SWIG_AsVal_int(args(5), &val9);
13240 if (!SWIG_IsOK(ecode9)) {
13241 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13242 }
13243 arg9 = static_cast< PLINT >(val9);
13244 {
13245 if ( _n_dims( args(6) ) > 1 )
13246 {
13247 error( "argument must be a scalar or vector" ); SWIG_fail;
13248 }
13249 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13250 arg11 = new PLINT[Alen];
13251 temp10 = args(6).matrix_value();
13252 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13253 }
13254 {
13255 if ( _n_dims( args(7) ) > 1 )
13256 {
13257 error( "argument must be a scalar or vector" ); SWIG_fail;
13258 }
13259 if ( _dim( args(7), 0 ) != Alen )
13260 {
13261 error( "argument vectors must be same length" ); SWIG_fail;
13262 }
13263 temp12 = args(7).matrix_value();
13264 arg12 = new PLINT[Alen];
13265 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13266 }
13267 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);
13268 _outv = octave_value();
13269 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13270 {
13271
13272 }
13273 {
13274
13275 }
13276 {
13277
13278 }
13279 {
13280
13281 }
13282 {
13283 delete [] arg11;
13284 }
13285 {
13286 delete [] arg12;
13287 }
13288 return _out;
13289 fail:
13290 {
13291
13292 }
13293 {
13294
13295 }
13296 {
13297
13298 }
13299 {
13300
13301 }
13302 {
13303 delete [] arg11;
13304 }
13305 {
13306 delete [] arg12;
13307 }
13308 return octave_value_list();
13309 }
13310 catch(...) {
13311 {
13312
13313 }
13314 {
13315
13316 }
13317 {
13318
13319 }
13320 {
13321
13322 }
13323 {
13324 delete [] arg11;
13325 }
13326 {
13327 delete [] arg12;
13328 }
13329 throw;
13330 }
13331}
13332
13333
13335 PLFLT *arg1 = (PLFLT *) 0 ;
13336 PLINT arg2 ;
13337 PLINT arg3 ;
13338 PLFLT *arg4 = (PLFLT *) 0 ;
13339 PLFLT arg5 ;
13340 PLFLT arg6 ;
13341 PLFLT arg7 ;
13342 PLFLT arg8 ;
13343 PLFLT arg9 ;
13344 PLFLT arg10 ;
13345 PLINT arg11 ;
13346 PLFLT arg12 ;
13347 PLINT arg13 ;
13348 PLINT arg14 ;
13349 PLINT arg15 ;
13350 PLINT arg16 ;
13351 PLINT arg17 ;
13352 PLBOOL arg18 ;
13353 PLFLT *arg19 = (PLFLT *) 0 ;
13354 Matrix temp1 ;
13355 Matrix temp4 ;
13356 double val5 ;
13357 int ecode5 = 0 ;
13358 double val6 ;
13359 int ecode6 = 0 ;
13360 double val7 ;
13361 int ecode7 = 0 ;
13362 double val8 ;
13363 int ecode8 = 0 ;
13364 double val9 ;
13365 int ecode9 = 0 ;
13366 double val10 ;
13367 int ecode10 = 0 ;
13368 int val11 ;
13369 int ecode11 = 0 ;
13370 double val12 ;
13371 int ecode12 = 0 ;
13372 int val13 ;
13373 int ecode13 = 0 ;
13374 int val14 ;
13375 int ecode14 = 0 ;
13376 int val15 ;
13377 int ecode15 = 0 ;
13378 int val16 ;
13379 int ecode16 = 0 ;
13380 int val17 ;
13381 int ecode17 = 0 ;
13382 int val18 ;
13383 int ecode18 = 0 ;
13384 Matrix temp19 ;
13385 octave_value_list _out;
13386 octave_value_list *_outp=&_out;
13387 octave_value _outv;
13388
13389 try {
13390 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13391 SWIG_fail;
13392 }
13393 {
13394 if ( _n_dims( args(0) ) > 2 )
13395 {
13396 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13397 }
13398 temp1 = args(0).matrix_value();
13399 arg1 = &temp1( 0, 0 );
13400 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13401 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13402 }
13403 {
13404 if ( _n_dims( args(1) ) > 1 )
13405 {
13406 error( "argument must be a scalar or vector" ); SWIG_fail;
13407 }
13408 Alen = (PLINT) ( _dim( args(1), 0 ) );
13409 temp4 = args(1).matrix_value();
13410 arg4 = &temp4( 0, 0 );
13411 }
13412 ecode5 = SWIG_AsVal_double(args(2), &val5);
13413 if (!SWIG_IsOK(ecode5)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13415 }
13416 arg5 = static_cast< PLFLT >(val5);
13417 ecode6 = SWIG_AsVal_double(args(3), &val6);
13418 if (!SWIG_IsOK(ecode6)) {
13419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13420 }
13421 arg6 = static_cast< PLFLT >(val6);
13422 ecode7 = SWIG_AsVal_double(args(4), &val7);
13423 if (!SWIG_IsOK(ecode7)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13425 }
13426 arg7 = static_cast< PLFLT >(val7);
13427 ecode8 = SWIG_AsVal_double(args(5), &val8);
13428 if (!SWIG_IsOK(ecode8)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13430 }
13431 arg8 = static_cast< PLFLT >(val8);
13432 ecode9 = SWIG_AsVal_double(args(6), &val9);
13433 if (!SWIG_IsOK(ecode9)) {
13434 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13435 }
13436 arg9 = static_cast< PLFLT >(val9);
13437 ecode10 = SWIG_AsVal_double(args(7), &val10);
13438 if (!SWIG_IsOK(ecode10)) {
13439 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13440 }
13441 arg10 = static_cast< PLFLT >(val10);
13442 ecode11 = SWIG_AsVal_int(args(8), &val11);
13443 if (!SWIG_IsOK(ecode11)) {
13444 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13445 }
13446 arg11 = static_cast< PLINT >(val11);
13447 ecode12 = SWIG_AsVal_double(args(9), &val12);
13448 if (!SWIG_IsOK(ecode12)) {
13449 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13450 }
13451 arg12 = static_cast< PLFLT >(val12);
13452 ecode13 = SWIG_AsVal_int(args(10), &val13);
13453 if (!SWIG_IsOK(ecode13)) {
13454 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13455 }
13456 arg13 = static_cast< PLINT >(val13);
13457 ecode14 = SWIG_AsVal_int(args(11), &val14);
13458 if (!SWIG_IsOK(ecode14)) {
13459 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13460 }
13461 arg14 = static_cast< PLINT >(val14);
13462 ecode15 = SWIG_AsVal_int(args(12), &val15);
13463 if (!SWIG_IsOK(ecode15)) {
13464 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13465 }
13466 arg15 = static_cast< PLINT >(val15);
13467 ecode16 = SWIG_AsVal_int(args(13), &val16);
13468 if (!SWIG_IsOK(ecode16)) {
13469 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13470 }
13471 arg16 = static_cast< PLINT >(val16);
13472 ecode17 = SWIG_AsVal_int(args(14), &val17);
13473 if (!SWIG_IsOK(ecode17)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13475 }
13476 arg17 = static_cast< PLINT >(val17);
13477 ecode18 = SWIG_AsVal_int(args(15), &val18);
13478 if (!SWIG_IsOK(ecode18)) {
13479 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13480 }
13481 arg18 = static_cast< PLBOOL >(val18);
13482 {
13483 if ( _n_dims( args(16) ) > 1 )
13484 {
13485 error( "argument must be a scalar or vector" ); SWIG_fail;
13486 }
13487 if ( _dim( args(16), 0 ) != 6 )
13488 {
13489 error( "argument vectors must have length of 6" ); SWIG_fail;
13490 }
13491 temp19 = args(16).matrix_value();
13492 arg19 = &temp19( 0, 0 );
13493 }
13494 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);
13495 _outv = octave_value();
13496 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13497 {
13498
13499 }
13500 {
13501
13502 }
13503 {
13504
13505 }
13506 return _out;
13507 fail:
13508 {
13509
13510 }
13511 {
13512
13513 }
13514 {
13515
13516 }
13517 return octave_value_list();
13518 }
13519 catch(...) {
13520 {
13521
13522 }
13523 {
13524
13525 }
13526 {
13527
13528 }
13529 throw;
13530 }
13531}
13532
13533
13534SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13535 PLFLT *arg1 = (PLFLT *) 0 ;
13536 PLINT arg2 ;
13537 PLINT arg3 ;
13538 char *arg4 = (char *) 0 ;
13539 PLFLT arg5 ;
13540 PLFLT arg6 ;
13541 PLFLT arg7 ;
13542 PLFLT arg8 ;
13543 PLFLT arg9 ;
13544 PLFLT arg10 ;
13545 PLINT arg11 ;
13546 PLFLT arg12 ;
13547 PLINT arg13 ;
13548 PLINT arg14 ;
13549 PLINT arg15 ;
13550 PLINT arg16 ;
13551 PLINT arg17 ;
13552 PLBOOL arg18 ;
13553 PLFLT *arg19 = (PLFLT *) 0 ;
13554 PLFLT *arg20 = (PLFLT *) 0 ;
13555 Matrix temp1 ;
13556 int res4 ;
13557 char *buf4 = 0 ;
13558 int alloc4 = 0 ;
13559 double val5 ;
13560 int ecode5 = 0 ;
13561 double val6 ;
13562 int ecode6 = 0 ;
13563 double val7 ;
13564 int ecode7 = 0 ;
13565 double val8 ;
13566 int ecode8 = 0 ;
13567 double val9 ;
13568 int ecode9 = 0 ;
13569 double val10 ;
13570 int ecode10 = 0 ;
13571 int val11 ;
13572 int ecode11 = 0 ;
13573 double val12 ;
13574 int ecode12 = 0 ;
13575 int val13 ;
13576 int ecode13 = 0 ;
13577 int val14 ;
13578 int ecode14 = 0 ;
13579 int val15 ;
13580 int ecode15 = 0 ;
13581 int val16 ;
13582 int ecode16 = 0 ;
13583 int val17 ;
13584 int ecode17 = 0 ;
13585 int val18 ;
13586 int ecode18 = 0 ;
13587 Matrix temp19 ;
13588 Matrix temp20 ;
13589 octave_value_list _out;
13590 octave_value_list *_outp=&_out;
13591 octave_value _outv;
13592
13593 try {
13594 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13595 SWIG_fail;
13596 }
13597 {
13598 if ( _n_dims( args(0) ) > 2 )
13599 {
13600 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13601 }
13602 temp1 = args(0).matrix_value();
13603 arg1 = &temp1( 0, 0 );
13604 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13605 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13606 }
13607 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13608 if (!SWIG_IsOK(res4)) {
13609 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13610 }
13611 arg4 = reinterpret_cast< char * >(buf4);
13612 ecode5 = SWIG_AsVal_double(args(2), &val5);
13613 if (!SWIG_IsOK(ecode5)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13615 }
13616 arg5 = static_cast< PLFLT >(val5);
13617 ecode6 = SWIG_AsVal_double(args(3), &val6);
13618 if (!SWIG_IsOK(ecode6)) {
13619 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13620 }
13621 arg6 = static_cast< PLFLT >(val6);
13622 ecode7 = SWIG_AsVal_double(args(4), &val7);
13623 if (!SWIG_IsOK(ecode7)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13625 }
13626 arg7 = static_cast< PLFLT >(val7);
13627 ecode8 = SWIG_AsVal_double(args(5), &val8);
13628 if (!SWIG_IsOK(ecode8)) {
13629 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13630 }
13631 arg8 = static_cast< PLFLT >(val8);
13632 ecode9 = SWIG_AsVal_double(args(6), &val9);
13633 if (!SWIG_IsOK(ecode9)) {
13634 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13635 }
13636 arg9 = static_cast< PLFLT >(val9);
13637 ecode10 = SWIG_AsVal_double(args(7), &val10);
13638 if (!SWIG_IsOK(ecode10)) {
13639 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13640 }
13641 arg10 = static_cast< PLFLT >(val10);
13642 ecode11 = SWIG_AsVal_int(args(8), &val11);
13643 if (!SWIG_IsOK(ecode11)) {
13644 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13645 }
13646 arg11 = static_cast< PLINT >(val11);
13647 ecode12 = SWIG_AsVal_double(args(9), &val12);
13648 if (!SWIG_IsOK(ecode12)) {
13649 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13650 }
13651 arg12 = static_cast< PLFLT >(val12);
13652 ecode13 = SWIG_AsVal_int(args(10), &val13);
13653 if (!SWIG_IsOK(ecode13)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13655 }
13656 arg13 = static_cast< PLINT >(val13);
13657 ecode14 = SWIG_AsVal_int(args(11), &val14);
13658 if (!SWIG_IsOK(ecode14)) {
13659 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13660 }
13661 arg14 = static_cast< PLINT >(val14);
13662 ecode15 = SWIG_AsVal_int(args(12), &val15);
13663 if (!SWIG_IsOK(ecode15)) {
13664 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13665 }
13666 arg15 = static_cast< PLINT >(val15);
13667 ecode16 = SWIG_AsVal_int(args(13), &val16);
13668 if (!SWIG_IsOK(ecode16)) {
13669 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13670 }
13671 arg16 = static_cast< PLINT >(val16);
13672 ecode17 = SWIG_AsVal_int(args(14), &val17);
13673 if (!SWIG_IsOK(ecode17)) {
13674 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13675 }
13676 arg17 = static_cast< PLINT >(val17);
13677 ecode18 = SWIG_AsVal_int(args(15), &val18);
13678 if (!SWIG_IsOK(ecode18)) {
13679 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13680 }
13681 arg18 = static_cast< PLBOOL >(val18);
13682 {
13683 if ( _n_dims( args(16) ) > 1 )
13684 {
13685 error( "argument must be a scalar or vector" ); SWIG_fail;
13686 }
13687 if ( _dim( args(16), 0 ) != Xlen )
13688 {
13689 error( "argument vectors must be same length" ); SWIG_fail;
13690 }
13691 temp19 = args(16).matrix_value();
13692 arg19 = &temp19( 0, 0 );
13693 }
13694 {
13695 if ( _n_dims( args(17) ) > 1 )
13696 {
13697 error( "argument must be a scalar or vector" ); SWIG_fail;
13698 }
13699 if ( _dim( args(17), 0 ) != Ylen )
13700 {
13701 error( "argument vectors must be same length" ); SWIG_fail;
13702 }
13703 temp20 = args(17).matrix_value();
13704 arg20 = &temp20( 0, 0 );
13705 }
13706 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);
13707 _outv = octave_value();
13708 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13709 {
13710
13711 }
13712 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13713 {
13714
13715 }
13716 {
13717
13718 }
13719 return _out;
13720 fail:
13721 {
13722
13723 }
13724 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13725 {
13726
13727 }
13728 {
13729
13730 }
13731 return octave_value_list();
13732 }
13733 catch(...) {
13734 {
13735
13736 }
13737 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13738 {
13739
13740 }
13741 {
13742
13743 }
13744 throw;
13745 }
13746}
13747
13748
13749SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13750 PLFLT *arg1 = (PLFLT *) 0 ;
13751 PLINT arg2 ;
13752 PLINT arg3 ;
13753 char *arg4 = (char *) 0 ;
13754 PLFLT arg5 ;
13755 PLFLT arg6 ;
13756 PLFLT arg7 ;
13757 PLFLT arg8 ;
13758 PLFLT arg9 ;
13759 PLFLT arg10 ;
13760 PLINT arg11 ;
13761 PLFLT arg12 ;
13762 PLINT arg13 ;
13763 PLINT arg14 ;
13764 PLINT arg15 ;
13765 PLINT arg16 ;
13766 PLINT arg17 ;
13767 PLBOOL arg18 ;
13768 PLFLT *arg19 = (PLFLT *) 0 ;
13769 PLFLT *arg20 = (PLFLT *) 0 ;
13770 Matrix temp1 ;
13771 int res4 ;
13772 char *buf4 = 0 ;
13773 int alloc4 = 0 ;
13774 double val5 ;
13775 int ecode5 = 0 ;
13776 double val6 ;
13777 int ecode6 = 0 ;
13778 double val7 ;
13779 int ecode7 = 0 ;
13780 double val8 ;
13781 int ecode8 = 0 ;
13782 double val9 ;
13783 int ecode9 = 0 ;
13784 double val10 ;
13785 int ecode10 = 0 ;
13786 int val11 ;
13787 int ecode11 = 0 ;
13788 double val12 ;
13789 int ecode12 = 0 ;
13790 int val13 ;
13791 int ecode13 = 0 ;
13792 int val14 ;
13793 int ecode14 = 0 ;
13794 int val15 ;
13795 int ecode15 = 0 ;
13796 int val16 ;
13797 int ecode16 = 0 ;
13798 int val17 ;
13799 int ecode17 = 0 ;
13800 int val18 ;
13801 int ecode18 = 0 ;
13802 Matrix temp19 ;
13803 Matrix temp20 ;
13804 octave_value_list _out;
13805 octave_value_list *_outp=&_out;
13806 octave_value _outv;
13807
13808 try {
13809 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13810 SWIG_fail;
13811 }
13812 {
13813 if ( _n_dims( args(0) ) > 2 )
13814 {
13815 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13816 }
13817 temp1 = args(0).matrix_value();
13818 arg1 = &temp1( 0, 0 );
13819 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13820 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13821 }
13822 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13823 if (!SWIG_IsOK(res4)) {
13824 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13825 }
13826 arg4 = reinterpret_cast< char * >(buf4);
13827 ecode5 = SWIG_AsVal_double(args(2), &val5);
13828 if (!SWIG_IsOK(ecode5)) {
13829 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13830 }
13831 arg5 = static_cast< PLFLT >(val5);
13832 ecode6 = SWIG_AsVal_double(args(3), &val6);
13833 if (!SWIG_IsOK(ecode6)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13835 }
13836 arg6 = static_cast< PLFLT >(val6);
13837 ecode7 = SWIG_AsVal_double(args(4), &val7);
13838 if (!SWIG_IsOK(ecode7)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13840 }
13841 arg7 = static_cast< PLFLT >(val7);
13842 ecode8 = SWIG_AsVal_double(args(5), &val8);
13843 if (!SWIG_IsOK(ecode8)) {
13844 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13845 }
13846 arg8 = static_cast< PLFLT >(val8);
13847 ecode9 = SWIG_AsVal_double(args(6), &val9);
13848 if (!SWIG_IsOK(ecode9)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13850 }
13851 arg9 = static_cast< PLFLT >(val9);
13852 ecode10 = SWIG_AsVal_double(args(7), &val10);
13853 if (!SWIG_IsOK(ecode10)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13855 }
13856 arg10 = static_cast< PLFLT >(val10);
13857 ecode11 = SWIG_AsVal_int(args(8), &val11);
13858 if (!SWIG_IsOK(ecode11)) {
13859 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13860 }
13861 arg11 = static_cast< PLINT >(val11);
13862 ecode12 = SWIG_AsVal_double(args(9), &val12);
13863 if (!SWIG_IsOK(ecode12)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13865 }
13866 arg12 = static_cast< PLFLT >(val12);
13867 ecode13 = SWIG_AsVal_int(args(10), &val13);
13868 if (!SWIG_IsOK(ecode13)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13870 }
13871 arg13 = static_cast< PLINT >(val13);
13872 ecode14 = SWIG_AsVal_int(args(11), &val14);
13873 if (!SWIG_IsOK(ecode14)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13875 }
13876 arg14 = static_cast< PLINT >(val14);
13877 ecode15 = SWIG_AsVal_int(args(12), &val15);
13878 if (!SWIG_IsOK(ecode15)) {
13879 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13880 }
13881 arg15 = static_cast< PLINT >(val15);
13882 ecode16 = SWIG_AsVal_int(args(13), &val16);
13883 if (!SWIG_IsOK(ecode16)) {
13884 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13885 }
13886 arg16 = static_cast< PLINT >(val16);
13887 ecode17 = SWIG_AsVal_int(args(14), &val17);
13888 if (!SWIG_IsOK(ecode17)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13890 }
13891 arg17 = static_cast< PLINT >(val17);
13892 ecode18 = SWIG_AsVal_int(args(15), &val18);
13893 if (!SWIG_IsOK(ecode18)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13895 }
13896 arg18 = static_cast< PLBOOL >(val18);
13897 {
13898 if ( _n_dims( args(16) ) > 2 )
13899 {
13900 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13901 }
13902 temp19 = args(16).matrix_value();
13903 arg19 = &temp19( 0, 0 );
13904 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13905 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13906 }
13907 {
13908 if ( _n_dims( args(17) ) > 2 )
13909 {
13910 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13911 }
13912 temp20 = args(17).matrix_value();
13913 arg20 = &temp20( 0, 0 );
13914 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13915 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13916 }
13917 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);
13918 _outv = octave_value();
13919 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13920 {
13921
13922 }
13923 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13924 {
13925
13926 }
13927 {
13928
13929 }
13930 return _out;
13931 fail:
13932 {
13933
13934 }
13935 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13936 {
13937
13938 }
13939 {
13940
13941 }
13942 return octave_value_list();
13943 }
13944 catch(...) {
13945 {
13946
13947 }
13948 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13949 {
13950
13951 }
13952 {
13953
13954 }
13955 throw;
13956 }
13957}
13958
13959
13961 PLFLT *arg1 = (PLFLT *) 0 ;
13962 PLINT arg2 ;
13963 PLINT arg3 ;
13964 PLFLT arg4 ;
13965 PLFLT arg5 ;
13966 PLFLT arg6 ;
13967 PLFLT arg7 ;
13968 PLFLT *arg8 = (PLFLT *) 0 ;
13969 PLINT arg9 ;
13970 PLINT arg10 ;
13971 PLINT arg11 ;
13972 PLINT arg12 ;
13973 PLBOOL arg13 ;
13974 Matrix temp1 ;
13975 double val4 ;
13976 int ecode4 = 0 ;
13977 double val5 ;
13978 int ecode5 = 0 ;
13979 double val6 ;
13980 int ecode6 = 0 ;
13981 double val7 ;
13982 int ecode7 = 0 ;
13983 Matrix temp8 ;
13984 int val10 ;
13985 int ecode10 = 0 ;
13986 int val11 ;
13987 int ecode11 = 0 ;
13988 int val12 ;
13989 int ecode12 = 0 ;
13990 int val13 ;
13991 int ecode13 = 0 ;
13992 octave_value_list _out;
13993 octave_value_list *_outp=&_out;
13994 octave_value _outv;
13995
13996 try {
13997 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13998 SWIG_fail;
13999 }
14000 {
14001 if ( _n_dims( args(0) ) > 2 )
14002 {
14003 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14004 }
14005 temp1 = args(0).matrix_value();
14006 arg1 = &temp1( 0, 0 );
14007 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14008 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14009 }
14010 ecode4 = SWIG_AsVal_double(args(1), &val4);
14011 if (!SWIG_IsOK(ecode4)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
14013 }
14014 arg4 = static_cast< PLFLT >(val4);
14015 ecode5 = SWIG_AsVal_double(args(2), &val5);
14016 if (!SWIG_IsOK(ecode5)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
14018 }
14019 arg5 = static_cast< PLFLT >(val5);
14020 ecode6 = SWIG_AsVal_double(args(3), &val6);
14021 if (!SWIG_IsOK(ecode6)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
14023 }
14024 arg6 = static_cast< PLFLT >(val6);
14025 ecode7 = SWIG_AsVal_double(args(4), &val7);
14026 if (!SWIG_IsOK(ecode7)) {
14027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
14028 }
14029 arg7 = static_cast< PLFLT >(val7);
14030 {
14031 if ( _n_dims( args(5) ) > 1 )
14032 {
14033 error( "argument must be a scalar or vector" ); SWIG_fail;
14034 }
14035 temp8 = args(5).matrix_value();
14036 arg8 = &temp8( 0, 0 );
14037 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14038 }
14039 ecode10 = SWIG_AsVal_int(args(6), &val10);
14040 if (!SWIG_IsOK(ecode10)) {
14041 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
14042 }
14043 arg10 = static_cast< PLINT >(val10);
14044 ecode11 = SWIG_AsVal_int(args(7), &val11);
14045 if (!SWIG_IsOK(ecode11)) {
14046 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
14047 }
14048 arg11 = static_cast< PLINT >(val11);
14049 ecode12 = SWIG_AsVal_int(args(8), &val12);
14050 if (!SWIG_IsOK(ecode12)) {
14051 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
14052 }
14053 arg12 = static_cast< PLINT >(val12);
14054 ecode13 = SWIG_AsVal_int(args(9), &val13);
14055 if (!SWIG_IsOK(ecode13)) {
14056 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
14057 }
14058 arg13 = static_cast< PLBOOL >(val13);
14059 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14060 _outv = octave_value();
14061 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14062 {
14063
14064 }
14065 {
14066
14067 }
14068 return _out;
14069 fail:
14070 {
14071
14072 }
14073 {
14074
14075 }
14076 return octave_value_list();
14077 }
14078 catch(...) {
14079 {
14080
14081 }
14082 {
14083
14084 }
14085 throw;
14086 }
14087}
14088
14089
14090SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14091 PLFLT *arg1 = (PLFLT *) 0 ;
14092 PLINT arg2 ;
14093 PLINT arg3 ;
14094 PLFLT arg4 ;
14095 PLFLT arg5 ;
14096 PLFLT arg6 ;
14097 PLFLT arg7 ;
14098 PLFLT *arg8 = (PLFLT *) 0 ;
14099 PLINT arg9 ;
14100 PLINT arg10 ;
14101 PLINT arg11 ;
14102 PLINT arg12 ;
14103 PLBOOL arg13 ;
14104 PLFLT *arg14 = (PLFLT *) 0 ;
14105 Matrix temp1 ;
14106 double val4 ;
14107 int ecode4 = 0 ;
14108 double val5 ;
14109 int ecode5 = 0 ;
14110 double val6 ;
14111 int ecode6 = 0 ;
14112 double val7 ;
14113 int ecode7 = 0 ;
14114 Matrix temp8 ;
14115 int val10 ;
14116 int ecode10 = 0 ;
14117 int val11 ;
14118 int ecode11 = 0 ;
14119 int val12 ;
14120 int ecode12 = 0 ;
14121 int val13 ;
14122 int ecode13 = 0 ;
14123 Matrix temp14 ;
14124 octave_value_list _out;
14125 octave_value_list *_outp=&_out;
14126 octave_value _outv;
14127
14128 try {
14129 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14130 SWIG_fail;
14131 }
14132 {
14133 if ( _n_dims( args(0) ) > 2 )
14134 {
14135 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14136 }
14137 temp1 = args(0).matrix_value();
14138 arg1 = &temp1( 0, 0 );
14139 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14140 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14141 }
14142 ecode4 = SWIG_AsVal_double(args(1), &val4);
14143 if (!SWIG_IsOK(ecode4)) {
14144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14145 }
14146 arg4 = static_cast< PLFLT >(val4);
14147 ecode5 = SWIG_AsVal_double(args(2), &val5);
14148 if (!SWIG_IsOK(ecode5)) {
14149 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14150 }
14151 arg5 = static_cast< PLFLT >(val5);
14152 ecode6 = SWIG_AsVal_double(args(3), &val6);
14153 if (!SWIG_IsOK(ecode6)) {
14154 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14155 }
14156 arg6 = static_cast< PLFLT >(val6);
14157 ecode7 = SWIG_AsVal_double(args(4), &val7);
14158 if (!SWIG_IsOK(ecode7)) {
14159 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14160 }
14161 arg7 = static_cast< PLFLT >(val7);
14162 {
14163 if ( _n_dims( args(5) ) > 1 )
14164 {
14165 error( "argument must be a scalar or vector" ); SWIG_fail;
14166 }
14167 temp8 = args(5).matrix_value();
14168 arg8 = &temp8( 0, 0 );
14169 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14170 }
14171 ecode10 = SWIG_AsVal_int(args(6), &val10);
14172 if (!SWIG_IsOK(ecode10)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14174 }
14175 arg10 = static_cast< PLINT >(val10);
14176 ecode11 = SWIG_AsVal_int(args(7), &val11);
14177 if (!SWIG_IsOK(ecode11)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14179 }
14180 arg11 = static_cast< PLINT >(val11);
14181 ecode12 = SWIG_AsVal_int(args(8), &val12);
14182 if (!SWIG_IsOK(ecode12)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14184 }
14185 arg12 = static_cast< PLINT >(val12);
14186 ecode13 = SWIG_AsVal_int(args(9), &val13);
14187 if (!SWIG_IsOK(ecode13)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14189 }
14190 arg13 = static_cast< PLBOOL >(val13);
14191 {
14192 if ( _n_dims( args(10) ) > 1 )
14193 {
14194 error( "argument must be a scalar or vector" ); SWIG_fail;
14195 }
14196 if ( _dim( args(10), 0 ) != 6 )
14197 {
14198 error( "argument vectors must have length of 6" ); SWIG_fail;
14199 }
14200 temp14 = args(10).matrix_value();
14201 arg14 = &temp14( 0, 0 );
14202 }
14203 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14204 _outv = octave_value();
14205 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14206 {
14207
14208 }
14209 {
14210
14211 }
14212 {
14213
14214 }
14215 return _out;
14216 fail:
14217 {
14218
14219 }
14220 {
14221
14222 }
14223 {
14224
14225 }
14226 return octave_value_list();
14227 }
14228 catch(...) {
14229 {
14230
14231 }
14232 {
14233
14234 }
14235 {
14236
14237 }
14238 throw;
14239 }
14240}
14241
14242
14243SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14244 PLFLT *arg1 = (PLFLT *) 0 ;
14245 PLINT arg2 ;
14246 PLINT arg3 ;
14247 PLFLT arg4 ;
14248 PLFLT arg5 ;
14249 PLFLT arg6 ;
14250 PLFLT arg7 ;
14251 PLFLT *arg8 = (PLFLT *) 0 ;
14252 PLINT arg9 ;
14253 PLINT arg10 ;
14254 PLINT arg11 ;
14255 PLINT arg12 ;
14256 PLBOOL arg13 ;
14257 PLFLT *arg14 = (PLFLT *) 0 ;
14258 PLFLT *arg15 = (PLFLT *) 0 ;
14259 Matrix temp1 ;
14260 double val4 ;
14261 int ecode4 = 0 ;
14262 double val5 ;
14263 int ecode5 = 0 ;
14264 double val6 ;
14265 int ecode6 = 0 ;
14266 double val7 ;
14267 int ecode7 = 0 ;
14268 Matrix temp8 ;
14269 int val10 ;
14270 int ecode10 = 0 ;
14271 int val11 ;
14272 int ecode11 = 0 ;
14273 int val12 ;
14274 int ecode12 = 0 ;
14275 int val13 ;
14276 int ecode13 = 0 ;
14277 Matrix temp14 ;
14278 Matrix temp15 ;
14279 octave_value_list _out;
14280 octave_value_list *_outp=&_out;
14281 octave_value _outv;
14282
14283 try {
14284 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14285 SWIG_fail;
14286 }
14287 {
14288 if ( _n_dims( args(0) ) > 2 )
14289 {
14290 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14291 }
14292 temp1 = args(0).matrix_value();
14293 arg1 = &temp1( 0, 0 );
14294 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14295 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14296 }
14297 ecode4 = SWIG_AsVal_double(args(1), &val4);
14298 if (!SWIG_IsOK(ecode4)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14300 }
14301 arg4 = static_cast< PLFLT >(val4);
14302 ecode5 = SWIG_AsVal_double(args(2), &val5);
14303 if (!SWIG_IsOK(ecode5)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14305 }
14306 arg5 = static_cast< PLFLT >(val5);
14307 ecode6 = SWIG_AsVal_double(args(3), &val6);
14308 if (!SWIG_IsOK(ecode6)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14310 }
14311 arg6 = static_cast< PLFLT >(val6);
14312 ecode7 = SWIG_AsVal_double(args(4), &val7);
14313 if (!SWIG_IsOK(ecode7)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14315 }
14316 arg7 = static_cast< PLFLT >(val7);
14317 {
14318 if ( _n_dims( args(5) ) > 1 )
14319 {
14320 error( "argument must be a scalar or vector" ); SWIG_fail;
14321 }
14322 temp8 = args(5).matrix_value();
14323 arg8 = &temp8( 0, 0 );
14324 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14325 }
14326 ecode10 = SWIG_AsVal_int(args(6), &val10);
14327 if (!SWIG_IsOK(ecode10)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14329 }
14330 arg10 = static_cast< PLINT >(val10);
14331 ecode11 = SWIG_AsVal_int(args(7), &val11);
14332 if (!SWIG_IsOK(ecode11)) {
14333 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14334 }
14335 arg11 = static_cast< PLINT >(val11);
14336 ecode12 = SWIG_AsVal_int(args(8), &val12);
14337 if (!SWIG_IsOK(ecode12)) {
14338 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14339 }
14340 arg12 = static_cast< PLINT >(val12);
14341 ecode13 = SWIG_AsVal_int(args(9), &val13);
14342 if (!SWIG_IsOK(ecode13)) {
14343 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14344 }
14345 arg13 = static_cast< PLBOOL >(val13);
14346 {
14347 if ( _n_dims( args(10) ) > 1 )
14348 {
14349 error( "argument must be a scalar or vector" ); SWIG_fail;
14350 }
14351 if ( _dim( args(10), 0 ) != Xlen )
14352 {
14353 error( "argument vectors must be same length" ); SWIG_fail;
14354 }
14355 temp14 = args(10).matrix_value();
14356 arg14 = &temp14( 0, 0 );
14357 }
14358 {
14359 if ( _n_dims( args(11) ) > 1 )
14360 {
14361 error( "argument must be a scalar or vector" ); SWIG_fail;
14362 }
14363 if ( _dim( args(11), 0 ) != Ylen )
14364 {
14365 error( "argument vectors must be same length" ); SWIG_fail;
14366 }
14367 temp15 = args(11).matrix_value();
14368 arg15 = &temp15( 0, 0 );
14369 }
14370 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);
14371 _outv = octave_value();
14372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14373 {
14374
14375 }
14376 {
14377
14378 }
14379 {
14380
14381 }
14382 {
14383
14384 }
14385 return _out;
14386 fail:
14387 {
14388
14389 }
14390 {
14391
14392 }
14393 {
14394
14395 }
14396 {
14397
14398 }
14399 return octave_value_list();
14400 }
14401 catch(...) {
14402 {
14403
14404 }
14405 {
14406
14407 }
14408 {
14409
14410 }
14411 {
14412
14413 }
14414 throw;
14415 }
14416}
14417
14418
14419SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14420 PLFLT *arg1 = (PLFLT *) 0 ;
14421 PLINT arg2 ;
14422 PLINT arg3 ;
14423 PLFLT arg4 ;
14424 PLFLT arg5 ;
14425 PLFLT arg6 ;
14426 PLFLT arg7 ;
14427 PLFLT *arg8 = (PLFLT *) 0 ;
14428 PLINT arg9 ;
14429 PLINT arg10 ;
14430 PLINT arg11 ;
14431 PLINT arg12 ;
14432 PLBOOL arg13 ;
14433 PLFLT *arg14 = (PLFLT *) 0 ;
14434 PLFLT *arg15 = (PLFLT *) 0 ;
14435 Matrix temp1 ;
14436 double val4 ;
14437 int ecode4 = 0 ;
14438 double val5 ;
14439 int ecode5 = 0 ;
14440 double val6 ;
14441 int ecode6 = 0 ;
14442 double val7 ;
14443 int ecode7 = 0 ;
14444 Matrix temp8 ;
14445 int val10 ;
14446 int ecode10 = 0 ;
14447 int val11 ;
14448 int ecode11 = 0 ;
14449 int val12 ;
14450 int ecode12 = 0 ;
14451 int val13 ;
14452 int ecode13 = 0 ;
14453 Matrix temp14 ;
14454 Matrix temp15 ;
14455 octave_value_list _out;
14456 octave_value_list *_outp=&_out;
14457 octave_value _outv;
14458
14459 try {
14460 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14461 SWIG_fail;
14462 }
14463 {
14464 if ( _n_dims( args(0) ) > 2 )
14465 {
14466 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14467 }
14468 temp1 = args(0).matrix_value();
14469 arg1 = &temp1( 0, 0 );
14470 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14471 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14472 }
14473 ecode4 = SWIG_AsVal_double(args(1), &val4);
14474 if (!SWIG_IsOK(ecode4)) {
14475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14476 }
14477 arg4 = static_cast< PLFLT >(val4);
14478 ecode5 = SWIG_AsVal_double(args(2), &val5);
14479 if (!SWIG_IsOK(ecode5)) {
14480 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14481 }
14482 arg5 = static_cast< PLFLT >(val5);
14483 ecode6 = SWIG_AsVal_double(args(3), &val6);
14484 if (!SWIG_IsOK(ecode6)) {
14485 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14486 }
14487 arg6 = static_cast< PLFLT >(val6);
14488 ecode7 = SWIG_AsVal_double(args(4), &val7);
14489 if (!SWIG_IsOK(ecode7)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14491 }
14492 arg7 = static_cast< PLFLT >(val7);
14493 {
14494 if ( _n_dims( args(5) ) > 1 )
14495 {
14496 error( "argument must be a scalar or vector" ); SWIG_fail;
14497 }
14498 temp8 = args(5).matrix_value();
14499 arg8 = &temp8( 0, 0 );
14500 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14501 }
14502 ecode10 = SWIG_AsVal_int(args(6), &val10);
14503 if (!SWIG_IsOK(ecode10)) {
14504 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14505 }
14506 arg10 = static_cast< PLINT >(val10);
14507 ecode11 = SWIG_AsVal_int(args(7), &val11);
14508 if (!SWIG_IsOK(ecode11)) {
14509 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14510 }
14511 arg11 = static_cast< PLINT >(val11);
14512 ecode12 = SWIG_AsVal_int(args(8), &val12);
14513 if (!SWIG_IsOK(ecode12)) {
14514 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14515 }
14516 arg12 = static_cast< PLINT >(val12);
14517 ecode13 = SWIG_AsVal_int(args(9), &val13);
14518 if (!SWIG_IsOK(ecode13)) {
14519 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14520 }
14521 arg13 = static_cast< PLBOOL >(val13);
14522 {
14523 if ( _n_dims( args(10) ) > 2 )
14524 {
14525 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14526 }
14527 temp14 = args(10).matrix_value();
14528 arg14 = &temp14( 0, 0 );
14529 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14530 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14531 }
14532 {
14533 if ( _n_dims( args(11) ) > 2 )
14534 {
14535 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14536 }
14537 temp15 = args(11).matrix_value();
14538 arg15 = &temp15( 0, 0 );
14539 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14540 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14541 }
14542 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);
14543 _outv = octave_value();
14544 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14545 {
14546
14547 }
14548 {
14549
14550 }
14551 {
14552
14553 }
14554 {
14555
14556 }
14557 return _out;
14558 fail:
14559 {
14560
14561 }
14562 {
14563
14564 }
14565 {
14566
14567 }
14568 {
14569
14570 }
14571 return octave_value_list();
14572 }
14573 catch(...) {
14574 {
14575
14576 }
14577 {
14578
14579 }
14580 {
14581
14582 }
14583 {
14584
14585 }
14586 throw;
14587 }
14588}
14589
14590
14592 PLFLT *arg1 = (PLFLT *) 0 ;
14593 PLFLT *arg2 = (PLFLT *) 0 ;
14594 PLINT arg3 ;
14595 PLINT arg4 ;
14596 PLFLT arg5 ;
14597 PLFLT *arg6 = (PLFLT *) 0 ;
14598 Matrix temp1 ;
14599 Matrix temp2 ;
14600 double val5 ;
14601 int ecode5 = 0 ;
14602 Matrix temp6 ;
14603 octave_value_list _out;
14604 octave_value_list *_outp=&_out;
14605 octave_value _outv;
14606
14607 try {
14608 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14609 SWIG_fail;
14610 }
14611 {
14612 if ( _n_dims( args(0) ) > 2 )
14613 {
14614 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14615 }
14616 temp1 = args(0).matrix_value();
14617 arg1 = &temp1( 0, 0 );
14618 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14619 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14620 }
14621 {
14622 if ( _n_dims( args(1) ) > 2 )
14623 {
14624 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14625 }
14626 if ( _dim( args(1), 0 ) != Xlen )
14627 {
14628 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14629 }
14630 if ( _dim( args(1), 1 ) != Ylen )
14631 {
14632 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14633 }
14634 temp2 = args(1).matrix_value();
14635 arg2 = &temp2( 0, 0 );
14636 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14637 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14638 }
14639 ecode5 = SWIG_AsVal_double(args(2), &val5);
14640 if (!SWIG_IsOK(ecode5)) {
14641 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14642 }
14643 arg5 = static_cast< PLFLT >(val5);
14644 {
14645 if ( _n_dims( args(3) ) > 1 )
14646 {
14647 error( "argument must be a scalar or vector" ); SWIG_fail;
14648 }
14649 if ( _dim( args(3), 0 ) != 6 )
14650 {
14651 error( "argument vectors must have length of 6" ); SWIG_fail;
14652 }
14653 temp6 = args(3).matrix_value();
14654 arg6 = &temp6( 0, 0 );
14655 }
14656 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14657 _outv = octave_value();
14658 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14659 {
14660
14661 }
14662 {
14663
14664 }
14665 {
14666
14667 }
14668 return _out;
14669 fail:
14670 {
14671
14672 }
14673 {
14674
14675 }
14676 {
14677
14678 }
14679 return octave_value_list();
14680 }
14681 catch(...) {
14682 {
14683
14684 }
14685 {
14686
14687 }
14688 {
14689
14690 }
14691 throw;
14692 }
14693}
14694
14695
14696SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14697 PLFLT *arg1 = (PLFLT *) 0 ;
14698 PLFLT *arg2 = (PLFLT *) 0 ;
14699 PLINT arg3 ;
14700 PLINT arg4 ;
14701 PLFLT arg5 ;
14702 PLFLT *arg6 = (PLFLT *) 0 ;
14703 PLFLT *arg7 = (PLFLT *) 0 ;
14704 Matrix temp1 ;
14705 Matrix temp2 ;
14706 double val5 ;
14707 int ecode5 = 0 ;
14708 Matrix temp6 ;
14709 Matrix temp7 ;
14710 octave_value_list _out;
14711 octave_value_list *_outp=&_out;
14712 octave_value _outv;
14713
14714 try {
14715 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14716 SWIG_fail;
14717 }
14718 {
14719 if ( _n_dims( args(0) ) > 2 )
14720 {
14721 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14722 }
14723 temp1 = args(0).matrix_value();
14724 arg1 = &temp1( 0, 0 );
14725 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14726 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14727 }
14728 {
14729 if ( _n_dims( args(1) ) > 2 )
14730 {
14731 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14732 }
14733 if ( _dim( args(1), 0 ) != Xlen )
14734 {
14735 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14736 }
14737 if ( _dim( args(1), 1 ) != Ylen )
14738 {
14739 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14740 }
14741 temp2 = args(1).matrix_value();
14742 arg2 = &temp2( 0, 0 );
14743 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14744 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14745 }
14746 ecode5 = SWIG_AsVal_double(args(2), &val5);
14747 if (!SWIG_IsOK(ecode5)) {
14748 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14749 }
14750 arg5 = static_cast< PLFLT >(val5);
14751 {
14752 if ( _n_dims( args(3) ) > 1 )
14753 {
14754 error( "argument must be a scalar or vector" ); SWIG_fail;
14755 }
14756 if ( _dim( args(3), 0 ) != Xlen )
14757 {
14758 error( "argument vectors must be same length" ); SWIG_fail;
14759 }
14760 temp6 = args(3).matrix_value();
14761 arg6 = &temp6( 0, 0 );
14762 }
14763 {
14764 if ( _n_dims( args(4) ) > 1 )
14765 {
14766 error( "argument must be a scalar or vector" ); SWIG_fail;
14767 }
14768 if ( _dim( args(4), 0 ) != Ylen )
14769 {
14770 error( "argument vectors must be same length" ); SWIG_fail;
14771 }
14772 temp7 = args(4).matrix_value();
14773 arg7 = &temp7( 0, 0 );
14774 }
14775 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14776 _outv = octave_value();
14777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14778 {
14779
14780 }
14781 {
14782
14783 }
14784 {
14785
14786 }
14787 {
14788
14789 }
14790 return _out;
14791 fail:
14792 {
14793
14794 }
14795 {
14796
14797 }
14798 {
14799
14800 }
14801 {
14802
14803 }
14804 return octave_value_list();
14805 }
14806 catch(...) {
14807 {
14808
14809 }
14810 {
14811
14812 }
14813 {
14814
14815 }
14816 {
14817
14818 }
14819 throw;
14820 }
14821}
14822
14823
14824SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14825 PLFLT *arg1 = (PLFLT *) 0 ;
14826 PLFLT *arg2 = (PLFLT *) 0 ;
14827 PLINT arg3 ;
14828 PLINT arg4 ;
14829 PLFLT arg5 ;
14830 PLFLT *arg6 = (PLFLT *) 0 ;
14831 PLFLT *arg7 = (PLFLT *) 0 ;
14832 Matrix temp1 ;
14833 Matrix temp2 ;
14834 double val5 ;
14835 int ecode5 = 0 ;
14836 Matrix temp6 ;
14837 Matrix temp7 ;
14838 octave_value_list _out;
14839 octave_value_list *_outp=&_out;
14840 octave_value _outv;
14841
14842 try {
14843 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14844 SWIG_fail;
14845 }
14846 {
14847 if ( _n_dims( args(0) ) > 2 )
14848 {
14849 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14850 }
14851 temp1 = args(0).matrix_value();
14852 arg1 = &temp1( 0, 0 );
14853 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14854 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14855 }
14856 {
14857 if ( _n_dims( args(1) ) > 2 )
14858 {
14859 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14860 }
14861 if ( _dim( args(1), 0 ) != Xlen )
14862 {
14863 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14864 }
14865 if ( _dim( args(1), 1 ) != Ylen )
14866 {
14867 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14868 }
14869 temp2 = args(1).matrix_value();
14870 arg2 = &temp2( 0, 0 );
14871 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14872 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14873 }
14874 ecode5 = SWIG_AsVal_double(args(2), &val5);
14875 if (!SWIG_IsOK(ecode5)) {
14876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14877 }
14878 arg5 = static_cast< PLFLT >(val5);
14879 {
14880 if ( _n_dims( args(3) ) > 2 )
14881 {
14882 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14883 }
14884 temp6 = args(3).matrix_value();
14885 arg6 = &temp6( 0, 0 );
14886 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14887 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14888 }
14889 {
14890 if ( _n_dims( args(4) ) > 2 )
14891 {
14892 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14893 }
14894 temp7 = args(4).matrix_value();
14895 arg7 = &temp7( 0, 0 );
14896 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14897 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14898 }
14899 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14900 _outv = octave_value();
14901 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14902 {
14903
14904 }
14905 {
14906
14907 }
14908 {
14909
14910 }
14911 {
14912
14913 }
14914 return _out;
14915 fail:
14916 {
14917
14918 }
14919 {
14920
14921 }
14922 {
14923
14924 }
14925 {
14926
14927 }
14928 return octave_value_list();
14929 }
14930 catch(...) {
14931 {
14932
14933 }
14934 {
14935
14936 }
14937 {
14938
14939 }
14940 {
14941
14942 }
14943 throw;
14944 }
14945}
14946
14947
14948SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14949 PLFLT *arg1 = (PLFLT *) 0 ;
14950 PLINT arg2 ;
14951 PLINT arg3 ;
14952 PLFLT arg4 ;
14953 PLFLT arg5 ;
14954 PLFLT arg6 ;
14955 PLFLT arg7 ;
14956 PLFLT arg8 ;
14957 PLFLT arg9 ;
14958 PLFLT arg10 ;
14959 PLFLT arg11 ;
14960 PLFLT arg12 ;
14961 PLFLT arg13 ;
14962 Matrix temp1 ;
14963 double val4 ;
14964 int ecode4 = 0 ;
14965 double val5 ;
14966 int ecode5 = 0 ;
14967 double val6 ;
14968 int ecode6 = 0 ;
14969 double val7 ;
14970 int ecode7 = 0 ;
14971 double val8 ;
14972 int ecode8 = 0 ;
14973 double val9 ;
14974 int ecode9 = 0 ;
14975 double val10 ;
14976 int ecode10 = 0 ;
14977 double val11 ;
14978 int ecode11 = 0 ;
14979 double val12 ;
14980 int ecode12 = 0 ;
14981 double val13 ;
14982 int ecode13 = 0 ;
14983 octave_value_list _out;
14984 octave_value_list *_outp=&_out;
14985 octave_value _outv;
14986
14987 try {
14988 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14989 SWIG_fail;
14990 }
14991 {
14992 if ( _n_dims( args(0) ) > 2 )
14993 {
14994 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14995 }
14996 temp1 = args(0).matrix_value();
14997 arg1 = &temp1( 0, 0 );
14998 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14999 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15000 }
15001 ecode4 = SWIG_AsVal_double(args(1), &val4);
15002 if (!SWIG_IsOK(ecode4)) {
15003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
15004 }
15005 arg4 = static_cast< PLFLT >(val4);
15006 ecode5 = SWIG_AsVal_double(args(2), &val5);
15007 if (!SWIG_IsOK(ecode5)) {
15008 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
15009 }
15010 arg5 = static_cast< PLFLT >(val5);
15011 ecode6 = SWIG_AsVal_double(args(3), &val6);
15012 if (!SWIG_IsOK(ecode6)) {
15013 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
15014 }
15015 arg6 = static_cast< PLFLT >(val6);
15016 ecode7 = SWIG_AsVal_double(args(4), &val7);
15017 if (!SWIG_IsOK(ecode7)) {
15018 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
15019 }
15020 arg7 = static_cast< PLFLT >(val7);
15021 ecode8 = SWIG_AsVal_double(args(5), &val8);
15022 if (!SWIG_IsOK(ecode8)) {
15023 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
15024 }
15025 arg8 = static_cast< PLFLT >(val8);
15026 ecode9 = SWIG_AsVal_double(args(6), &val9);
15027 if (!SWIG_IsOK(ecode9)) {
15028 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
15029 }
15030 arg9 = static_cast< PLFLT >(val9);
15031 ecode10 = SWIG_AsVal_double(args(7), &val10);
15032 if (!SWIG_IsOK(ecode10)) {
15033 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
15034 }
15035 arg10 = static_cast< PLFLT >(val10);
15036 ecode11 = SWIG_AsVal_double(args(8), &val11);
15037 if (!SWIG_IsOK(ecode11)) {
15038 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
15039 }
15040 arg11 = static_cast< PLFLT >(val11);
15041 ecode12 = SWIG_AsVal_double(args(9), &val12);
15042 if (!SWIG_IsOK(ecode12)) {
15043 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
15044 }
15045 arg12 = static_cast< PLFLT >(val12);
15046 ecode13 = SWIG_AsVal_double(args(10), &val13);
15047 if (!SWIG_IsOK(ecode13)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
15049 }
15050 arg13 = static_cast< PLFLT >(val13);
15051 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15052 _outv = octave_value();
15053 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15054 {
15055
15056 }
15057 return _out;
15058 fail:
15059 {
15060
15061 }
15062 return octave_value_list();
15063 }
15064 catch(...) {
15065 {
15066
15067 }
15068 throw;
15069 }
15070}
15071
15072
15074 PLFLT *arg1 = (PLFLT *) 0 ;
15075 PLINT arg2 ;
15076 PLINT arg3 ;
15077 PLFLT arg4 ;
15078 PLFLT arg5 ;
15079 PLFLT arg6 ;
15080 PLFLT arg7 ;
15081 PLFLT arg8 ;
15082 PLFLT arg9 ;
15083 PLFLT arg10 ;
15084 PLFLT arg11 ;
15085 Matrix temp1 ;
15086 double val4 ;
15087 int ecode4 = 0 ;
15088 double val5 ;
15089 int ecode5 = 0 ;
15090 double val6 ;
15091 int ecode6 = 0 ;
15092 double val7 ;
15093 int ecode7 = 0 ;
15094 double val8 ;
15095 int ecode8 = 0 ;
15096 double val9 ;
15097 int ecode9 = 0 ;
15098 double val10 ;
15099 int ecode10 = 0 ;
15100 double val11 ;
15101 int ecode11 = 0 ;
15102 octave_value_list _out;
15103 octave_value_list *_outp=&_out;
15104 octave_value _outv;
15105
15106 try {
15107 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15108 SWIG_fail;
15109 }
15110 {
15111 if ( _n_dims( args(0) ) > 2 )
15112 {
15113 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15114 }
15115 temp1 = args(0).matrix_value();
15116 arg1 = &temp1( 0, 0 );
15117 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15118 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15119 }
15120 ecode4 = SWIG_AsVal_double(args(1), &val4);
15121 if (!SWIG_IsOK(ecode4)) {
15122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15123 }
15124 arg4 = static_cast< PLFLT >(val4);
15125 ecode5 = SWIG_AsVal_double(args(2), &val5);
15126 if (!SWIG_IsOK(ecode5)) {
15127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15128 }
15129 arg5 = static_cast< PLFLT >(val5);
15130 ecode6 = SWIG_AsVal_double(args(3), &val6);
15131 if (!SWIG_IsOK(ecode6)) {
15132 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15133 }
15134 arg6 = static_cast< PLFLT >(val6);
15135 ecode7 = SWIG_AsVal_double(args(4), &val7);
15136 if (!SWIG_IsOK(ecode7)) {
15137 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15138 }
15139 arg7 = static_cast< PLFLT >(val7);
15140 ecode8 = SWIG_AsVal_double(args(5), &val8);
15141 if (!SWIG_IsOK(ecode8)) {
15142 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15143 }
15144 arg8 = static_cast< PLFLT >(val8);
15145 ecode9 = SWIG_AsVal_double(args(6), &val9);
15146 if (!SWIG_IsOK(ecode9)) {
15147 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15148 }
15149 arg9 = static_cast< PLFLT >(val9);
15150 ecode10 = SWIG_AsVal_double(args(7), &val10);
15151 if (!SWIG_IsOK(ecode10)) {
15152 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15153 }
15154 arg10 = static_cast< PLFLT >(val10);
15155 ecode11 = SWIG_AsVal_double(args(8), &val11);
15156 if (!SWIG_IsOK(ecode11)) {
15157 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15158 }
15159 arg11 = static_cast< PLFLT >(val11);
15160 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15161 _outv = octave_value();
15162 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15163 {
15164
15165 }
15166 return _out;
15167 fail:
15168 {
15169
15170 }
15171 return octave_value_list();
15172 }
15173 catch(...) {
15174 {
15175
15176 }
15177 throw;
15178 }
15179}
15180
15181
15182SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15183 PLFLT *arg1 = (PLFLT *) 0 ;
15184 PLINT arg2 ;
15185 PLINT arg3 ;
15186 PLFLT arg4 ;
15187 PLFLT arg5 ;
15188 PLFLT arg6 ;
15189 PLFLT arg7 ;
15190 PLFLT arg8 ;
15191 PLFLT arg9 ;
15192 PLFLT arg10 ;
15193 PLFLT arg11 ;
15194 PLFLT *arg12 = (PLFLT *) 0 ;
15195 Matrix temp1 ;
15196 double val4 ;
15197 int ecode4 = 0 ;
15198 double val5 ;
15199 int ecode5 = 0 ;
15200 double val6 ;
15201 int ecode6 = 0 ;
15202 double val7 ;
15203 int ecode7 = 0 ;
15204 double val8 ;
15205 int ecode8 = 0 ;
15206 double val9 ;
15207 int ecode9 = 0 ;
15208 double val10 ;
15209 int ecode10 = 0 ;
15210 double val11 ;
15211 int ecode11 = 0 ;
15212 Matrix temp12 ;
15213 octave_value_list _out;
15214 octave_value_list *_outp=&_out;
15215 octave_value _outv;
15216
15217 try {
15218 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15219 SWIG_fail;
15220 }
15221 {
15222 if ( _n_dims( args(0) ) > 2 )
15223 {
15224 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15225 }
15226 temp1 = args(0).matrix_value();
15227 arg1 = &temp1( 0, 0 );
15228 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15229 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15230 }
15231 ecode4 = SWIG_AsVal_double(args(1), &val4);
15232 if (!SWIG_IsOK(ecode4)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15234 }
15235 arg4 = static_cast< PLFLT >(val4);
15236 ecode5 = SWIG_AsVal_double(args(2), &val5);
15237 if (!SWIG_IsOK(ecode5)) {
15238 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15239 }
15240 arg5 = static_cast< PLFLT >(val5);
15241 ecode6 = SWIG_AsVal_double(args(3), &val6);
15242 if (!SWIG_IsOK(ecode6)) {
15243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15244 }
15245 arg6 = static_cast< PLFLT >(val6);
15246 ecode7 = SWIG_AsVal_double(args(4), &val7);
15247 if (!SWIG_IsOK(ecode7)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15249 }
15250 arg7 = static_cast< PLFLT >(val7);
15251 ecode8 = SWIG_AsVal_double(args(5), &val8);
15252 if (!SWIG_IsOK(ecode8)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15254 }
15255 arg8 = static_cast< PLFLT >(val8);
15256 ecode9 = SWIG_AsVal_double(args(6), &val9);
15257 if (!SWIG_IsOK(ecode9)) {
15258 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15259 }
15260 arg9 = static_cast< PLFLT >(val9);
15261 ecode10 = SWIG_AsVal_double(args(7), &val10);
15262 if (!SWIG_IsOK(ecode10)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15264 }
15265 arg10 = static_cast< PLFLT >(val10);
15266 ecode11 = SWIG_AsVal_double(args(8), &val11);
15267 if (!SWIG_IsOK(ecode11)) {
15268 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15269 }
15270 arg11 = static_cast< PLFLT >(val11);
15271 {
15272 if ( _n_dims( args(9) ) > 1 )
15273 {
15274 error( "argument must be a scalar or vector" ); SWIG_fail;
15275 }
15276 if ( _dim( args(9), 0 ) != 6 )
15277 {
15278 error( "argument vectors must have length of 6" ); SWIG_fail;
15279 }
15280 temp12 = args(9).matrix_value();
15281 arg12 = &temp12( 0, 0 );
15282 }
15283 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15284 _outv = octave_value();
15285 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15286 {
15287
15288 }
15289 {
15290
15291 }
15292 return _out;
15293 fail:
15294 {
15295
15296 }
15297 {
15298
15299 }
15300 return octave_value_list();
15301 }
15302 catch(...) {
15303 {
15304
15305 }
15306 {
15307
15308 }
15309 throw;
15310 }
15311}
15312
15313
15314SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15315 PLFLT *arg1 = (PLFLT *) 0 ;
15316 PLINT arg2 ;
15317 PLINT arg3 ;
15318 PLFLT arg4 ;
15319 PLFLT arg5 ;
15320 PLFLT arg6 ;
15321 PLFLT arg7 ;
15322 PLFLT arg8 ;
15323 PLFLT arg9 ;
15324 PLFLT arg10 ;
15325 PLFLT arg11 ;
15326 PLFLT *arg12 = (PLFLT *) 0 ;
15327 PLFLT *arg13 = (PLFLT *) 0 ;
15328 Matrix temp1 ;
15329 double val4 ;
15330 int ecode4 = 0 ;
15331 double val5 ;
15332 int ecode5 = 0 ;
15333 double val6 ;
15334 int ecode6 = 0 ;
15335 double val7 ;
15336 int ecode7 = 0 ;
15337 double val8 ;
15338 int ecode8 = 0 ;
15339 double val9 ;
15340 int ecode9 = 0 ;
15341 double val10 ;
15342 int ecode10 = 0 ;
15343 double val11 ;
15344 int ecode11 = 0 ;
15345 Matrix temp12 ;
15346 Matrix temp13 ;
15347 octave_value_list _out;
15348 octave_value_list *_outp=&_out;
15349 octave_value _outv;
15350
15351 try {
15352 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15353 SWIG_fail;
15354 }
15355 {
15356 if ( _n_dims( args(0) ) > 2 )
15357 {
15358 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15359 }
15360 temp1 = args(0).matrix_value();
15361 arg1 = &temp1( 0, 0 );
15362 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15363 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15364 }
15365 ecode4 = SWIG_AsVal_double(args(1), &val4);
15366 if (!SWIG_IsOK(ecode4)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15368 }
15369 arg4 = static_cast< PLFLT >(val4);
15370 ecode5 = SWIG_AsVal_double(args(2), &val5);
15371 if (!SWIG_IsOK(ecode5)) {
15372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15373 }
15374 arg5 = static_cast< PLFLT >(val5);
15375 ecode6 = SWIG_AsVal_double(args(3), &val6);
15376 if (!SWIG_IsOK(ecode6)) {
15377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15378 }
15379 arg6 = static_cast< PLFLT >(val6);
15380 ecode7 = SWIG_AsVal_double(args(4), &val7);
15381 if (!SWIG_IsOK(ecode7)) {
15382 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15383 }
15384 arg7 = static_cast< PLFLT >(val7);
15385 ecode8 = SWIG_AsVal_double(args(5), &val8);
15386 if (!SWIG_IsOK(ecode8)) {
15387 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15388 }
15389 arg8 = static_cast< PLFLT >(val8);
15390 ecode9 = SWIG_AsVal_double(args(6), &val9);
15391 if (!SWIG_IsOK(ecode9)) {
15392 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15393 }
15394 arg9 = static_cast< PLFLT >(val9);
15395 ecode10 = SWIG_AsVal_double(args(7), &val10);
15396 if (!SWIG_IsOK(ecode10)) {
15397 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15398 }
15399 arg10 = static_cast< PLFLT >(val10);
15400 ecode11 = SWIG_AsVal_double(args(8), &val11);
15401 if (!SWIG_IsOK(ecode11)) {
15402 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15403 }
15404 arg11 = static_cast< PLFLT >(val11);
15405 {
15406 if ( _n_dims( args(9) ) > 1 )
15407 {
15408 error( "argument must be a scalar or vector" ); SWIG_fail;
15409 }
15410 if ( _dim( args(9), 0 ) != Xlen )
15411 {
15412 error( "argument vectors must be same length" ); SWIG_fail;
15413 }
15414 temp12 = args(9).matrix_value();
15415 arg12 = &temp12( 0, 0 );
15416 }
15417 {
15418 if ( _n_dims( args(10) ) > 1 )
15419 {
15420 error( "argument must be a scalar or vector" ); SWIG_fail;
15421 }
15422 if ( _dim( args(10), 0 ) != Ylen )
15423 {
15424 error( "argument vectors must be same length" ); SWIG_fail;
15425 }
15426 temp13 = args(10).matrix_value();
15427 arg13 = &temp13( 0, 0 );
15428 }
15429 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15430 _outv = octave_value();
15431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15432 {
15433
15434 }
15435 {
15436
15437 }
15438 {
15439
15440 }
15441 return _out;
15442 fail:
15443 {
15444
15445 }
15446 {
15447
15448 }
15449 {
15450
15451 }
15452 return octave_value_list();
15453 }
15454 catch(...) {
15455 {
15456
15457 }
15458 {
15459
15460 }
15461 {
15462
15463 }
15464 throw;
15465 }
15466}
15467
15468
15469SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15470 PLFLT *arg1 = (PLFLT *) 0 ;
15471 PLINT arg2 ;
15472 PLINT arg3 ;
15473 PLFLT arg4 ;
15474 PLFLT arg5 ;
15475 PLFLT arg6 ;
15476 PLFLT arg7 ;
15477 PLFLT arg8 ;
15478 PLFLT arg9 ;
15479 PLFLT arg10 ;
15480 PLFLT arg11 ;
15481 PLFLT *arg12 = (PLFLT *) 0 ;
15482 PLFLT *arg13 = (PLFLT *) 0 ;
15483 Matrix temp1 ;
15484 double val4 ;
15485 int ecode4 = 0 ;
15486 double val5 ;
15487 int ecode5 = 0 ;
15488 double val6 ;
15489 int ecode6 = 0 ;
15490 double val7 ;
15491 int ecode7 = 0 ;
15492 double val8 ;
15493 int ecode8 = 0 ;
15494 double val9 ;
15495 int ecode9 = 0 ;
15496 double val10 ;
15497 int ecode10 = 0 ;
15498 double val11 ;
15499 int ecode11 = 0 ;
15500 Matrix temp12 ;
15501 Matrix temp13 ;
15502 octave_value_list _out;
15503 octave_value_list *_outp=&_out;
15504 octave_value _outv;
15505
15506 try {
15507 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15508 SWIG_fail;
15509 }
15510 {
15511 if ( _n_dims( args(0) ) > 2 )
15512 {
15513 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15514 }
15515 temp1 = args(0).matrix_value();
15516 arg1 = &temp1( 0, 0 );
15517 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15518 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15519 }
15520 ecode4 = SWIG_AsVal_double(args(1), &val4);
15521 if (!SWIG_IsOK(ecode4)) {
15522 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15523 }
15524 arg4 = static_cast< PLFLT >(val4);
15525 ecode5 = SWIG_AsVal_double(args(2), &val5);
15526 if (!SWIG_IsOK(ecode5)) {
15527 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15528 }
15529 arg5 = static_cast< PLFLT >(val5);
15530 ecode6 = SWIG_AsVal_double(args(3), &val6);
15531 if (!SWIG_IsOK(ecode6)) {
15532 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15533 }
15534 arg6 = static_cast< PLFLT >(val6);
15535 ecode7 = SWIG_AsVal_double(args(4), &val7);
15536 if (!SWIG_IsOK(ecode7)) {
15537 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15538 }
15539 arg7 = static_cast< PLFLT >(val7);
15540 ecode8 = SWIG_AsVal_double(args(5), &val8);
15541 if (!SWIG_IsOK(ecode8)) {
15542 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15543 }
15544 arg8 = static_cast< PLFLT >(val8);
15545 ecode9 = SWIG_AsVal_double(args(6), &val9);
15546 if (!SWIG_IsOK(ecode9)) {
15547 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15548 }
15549 arg9 = static_cast< PLFLT >(val9);
15550 ecode10 = SWIG_AsVal_double(args(7), &val10);
15551 if (!SWIG_IsOK(ecode10)) {
15552 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15553 }
15554 arg10 = static_cast< PLFLT >(val10);
15555 ecode11 = SWIG_AsVal_double(args(8), &val11);
15556 if (!SWIG_IsOK(ecode11)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15558 }
15559 arg11 = static_cast< PLFLT >(val11);
15560 {
15561 if ( _n_dims( args(9) ) > 2 )
15562 {
15563 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15564 }
15565 temp12 = args(9).matrix_value();
15566 arg12 = &temp12( 0, 0 );
15567 Xlen = (PLINT) ( _dim( args(9), 0 ) );
15568 Ylen = (PLINT) ( _dim( args(9), 1 ) );
15569 }
15570 {
15571 if ( _n_dims( args(10) ) > 2 )
15572 {
15573 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15574 }
15575 temp13 = args(10).matrix_value();
15576 arg13 = &temp13( 0, 0 );
15577 Xlen = (PLINT) ( _dim( args(10), 0 ) );
15578 Ylen = (PLINT) ( _dim( args(10), 1 ) );
15579 }
15580 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15581 _outv = octave_value();
15582 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15583 {
15584
15585 }
15586 {
15587
15588 }
15589 {
15590
15591 }
15592 return _out;
15593 fail:
15594 {
15595
15596 }
15597 {
15598
15599 }
15600 {
15601
15602 }
15603 return octave_value_list();
15604 }
15605 catch(...) {
15606 {
15607
15608 }
15609 {
15610
15611 }
15612 {
15613
15614 }
15615 throw;
15616 }
15617}
15618
15619
15620SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
15621 PLFLT *arg1 = (PLFLT *) 0 ;
15622 PLFLT *arg2 = (PLFLT *) 0 ;
15623 PLINT arg3 ;
15624 PLINT arg4 ;
15625 PLFLT arg5 ;
15626 PLFLT arg6 ;
15627 PLFLT arg7 ;
15628 PLFLT arg8 ;
15629 PLINT arg9 ;
15630 PLINT arg10 ;
15631 PLINT arg11 ;
15632 PLFLT arg12 ;
15633 PLFLT arg13 ;
15634 PLINT arg14 ;
15635 PLFLT arg15 ;
15636 PLINT arg16 ;
15637 PLINT *arg17 = (PLINT *) 0 ;
15638 char **arg18 = (char **) 0 ;
15639 PLINT arg19 ;
15640 char **arg20 = (char **) 0 ;
15641 PLFLT *arg21 = (PLFLT *) 0 ;
15642 PLINT *arg22 = (PLINT *) 0 ;
15643 PLINT *arg23 = (PLINT *) 0 ;
15644 PLFLT *arg24 = (PLFLT *) 0 ;
15645 PLFLT temp1 ;
15646 int res1 = SWIG_TMPOBJ ;
15647 PLFLT temp2 ;
15648 int res2 = SWIG_TMPOBJ ;
15649 int val3 ;
15650 int ecode3 = 0 ;
15651 int val4 ;
15652 int ecode4 = 0 ;
15653 double val5 ;
15654 int ecode5 = 0 ;
15655 double val6 ;
15656 int ecode6 = 0 ;
15657 double val7 ;
15658 int ecode7 = 0 ;
15659 double val8 ;
15660 int ecode8 = 0 ;
15661 int val9 ;
15662 int ecode9 = 0 ;
15663 int val10 ;
15664 int ecode10 = 0 ;
15665 int val11 ;
15666 int ecode11 = 0 ;
15667 double val12 ;
15668 int ecode12 = 0 ;
15669 double val13 ;
15670 int ecode13 = 0 ;
15671 int val14 ;
15672 int ecode14 = 0 ;
15673 double val15 ;
15674 int ecode15 = 0 ;
15675 Matrix temp16 ;
15676 Matrix temp21 ;
15677 Matrix temp22 ;
15678 Matrix temp23 ;
15679 Matrix temp24 ;
15680 octave_value_list _out;
15681 octave_value_list *_outp=&_out;
15682 octave_value _outv;
15683
15684 try {
15685 arg1 = &temp1;
15686 arg2 = &temp2;
15687 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15688 SWIG_fail;
15689 }
15690 ecode3 = SWIG_AsVal_int(args(0), &val3);
15691 if (!SWIG_IsOK(ecode3)) {
15692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15693 }
15694 arg3 = static_cast< PLINT >(val3);
15695 ecode4 = SWIG_AsVal_int(args(1), &val4);
15696 if (!SWIG_IsOK(ecode4)) {
15697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15698 }
15699 arg4 = static_cast< PLINT >(val4);
15700 ecode5 = SWIG_AsVal_double(args(2), &val5);
15701 if (!SWIG_IsOK(ecode5)) {
15702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15703 }
15704 arg5 = static_cast< PLFLT >(val5);
15705 ecode6 = SWIG_AsVal_double(args(3), &val6);
15706 if (!SWIG_IsOK(ecode6)) {
15707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15708 }
15709 arg6 = static_cast< PLFLT >(val6);
15710 ecode7 = SWIG_AsVal_double(args(4), &val7);
15711 if (!SWIG_IsOK(ecode7)) {
15712 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15713 }
15714 arg7 = static_cast< PLFLT >(val7);
15715 ecode8 = SWIG_AsVal_double(args(5), &val8);
15716 if (!SWIG_IsOK(ecode8)) {
15717 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15718 }
15719 arg8 = static_cast< PLFLT >(val8);
15720 ecode9 = SWIG_AsVal_int(args(6), &val9);
15721 if (!SWIG_IsOK(ecode9)) {
15722 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15723 }
15724 arg9 = static_cast< PLINT >(val9);
15725 ecode10 = SWIG_AsVal_int(args(7), &val10);
15726 if (!SWIG_IsOK(ecode10)) {
15727 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15728 }
15729 arg10 = static_cast< PLINT >(val10);
15730 ecode11 = SWIG_AsVal_int(args(8), &val11);
15731 if (!SWIG_IsOK(ecode11)) {
15732 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15733 }
15734 arg11 = static_cast< PLINT >(val11);
15735 ecode12 = SWIG_AsVal_double(args(9), &val12);
15736 if (!SWIG_IsOK(ecode12)) {
15737 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15738 }
15739 arg12 = static_cast< PLFLT >(val12);
15740 ecode13 = SWIG_AsVal_double(args(10), &val13);
15741 if (!SWIG_IsOK(ecode13)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15743 }
15744 arg13 = static_cast< PLFLT >(val13);
15745 ecode14 = SWIG_AsVal_int(args(11), &val14);
15746 if (!SWIG_IsOK(ecode14)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15748 }
15749 arg14 = static_cast< PLINT >(val14);
15750 ecode15 = SWIG_AsVal_double(args(12), &val15);
15751 if (!SWIG_IsOK(ecode15)) {
15752 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15753 }
15754 arg15 = static_cast< PLFLT >(val15);
15755 {
15756 if ( _n_dims( args(13) ) > 1 )
15757 {
15758 error( "argument must be a scalar or vector" ); SWIG_fail;
15759 }
15760 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15761 arg17 = new PLINT[Alen];
15762 temp16 = args(13).matrix_value();
15763 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15764 }
15765 {
15766 charMatrix temp_matrix;
15767 Cell temp_cell;
15768 char *tmp_cstring;
15769 std::string str;
15770 size_t max_length = 0, non_blank_length;
15771 int i, ifcell;
15772 if ( _n_dims( args(14) ) > 2 )
15773 {
15774 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15775 }
15776#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15777 if ( !args(14).isempty() )
15778#else
15779 if ( !args(14).is_empty() )
15780#endif
15781 {
15782 if ( _dim( args(14), 0 ) != Alen )
15783 {
15784 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15785 }
15786 arg18 = new char*[Alen];
15787#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15788 ifcell = args(14).iscell();
15789#else
15790 ifcell = args(14).is_cell();
15791#endif
15792 if ( ifcell )
15793 {
15794 temp_cell = args(14).cell_value();
15795 }
15796 else
15797 {
15798 temp_matrix = args(14).char_matrix_value();
15799 // Allow one extra space for null termination.
15800 max_length = _dim( args(14), 1 ) + 1;
15801 }
15802
15803 for ( i = 0; i < Alen; i++ )
15804 {
15805 // Must copy string to "permanent" location because the string
15806 // location corresponding to tmp_cstring gets
15807 // overwritten for each iteration of loop.
15808 if ( ifcell )
15809 {
15810 if ( temp_cell.elem( i ).is_string() )
15811 {
15812 str = temp_cell.elem( i ).string_value();
15813 // leave room for null termination.
15814 max_length = str.size() + 1;
15815 tmp_cstring = (char *) str.c_str();
15816 }
15817 else
15818 {
15819 // Use null string if user attempts to pass a cell array
15820 // with a non-string element (likely an empty element
15821 // since that should be allowed by the PLplot interface
15822 // if that element is going to be unused).
15823 // leave room for null termination.
15824 max_length = 1;
15825 tmp_cstring = (char *) "";
15826 }
15827 }
15828 else
15829 {
15830 str = temp_matrix.row_as_string( i );
15831 tmp_cstring = (char *) str.c_str();
15832 }
15833 arg18[i] = new char[max_length];
15834 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15835 arg18[i][max_length - 1] = '\0';
15836 // All the trailing blank crapola should not be needed for
15837 // string cell arrays.
15838 if ( !ifcell )
15839 {
15840 // remove trailing-blank padding that is used by the
15841 // charMatrix class to insure all strings in a given
15842 // charMatrix instance have the same length.
15843 // This transformation also removes legitimate trailing
15844 // blanks but there is nothing we can do about that
15845 // for the charMatrix class.
15846
15847 // Look for trailing nulls first (just in case, although that
15848 // shouldn't happen if charMatrix implemented as documented)
15849 // before looking for trailing blanks.
15850 non_blank_length = max_length - 2;
15851 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15852 {
15853 non_blank_length--;
15854 }
15855 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15856 {
15857 non_blank_length--;
15858 }
15859 arg18[i][non_blank_length + 1] = '\0';
15860 }
15861 }
15862 }
15863 else
15864 {
15865 arg18 = NULL;
15866 }
15867 }
15868 {
15869 charMatrix temp_matrix;
15870 Cell temp_cell;
15871 char *tmp_cstring;
15872 std::string str;
15873 size_t max_length = 0, non_blank_length;
15874 int i, ifcell;
15875 if ( _n_dims( args(15) ) > 2 )
15876 {
15877 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15878 }
15879#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15880 if ( !args(15).isempty() )
15881#else
15882 if ( !args(15).is_empty() )
15883#endif
15884 {
15885 Alen = _dim( args(15), 0 );
15886 arg19 = Alen;
15887 arg20 = new char*[Alen];
15888#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15889 ifcell = args(15).iscell();
15890#else
15891 ifcell = args(15).is_cell();
15892#endif
15893 if ( ifcell )
15894 {
15895 temp_cell = args(15).cell_value();
15896 }
15897 else
15898 {
15899 temp_matrix = args(15).char_matrix_value();
15900 // Allow one extra space for null termination.
15901 max_length = _dim( args(15), 1 ) + 1;
15902 }
15903
15904 for ( i = 0; i < Alen; i++ )
15905 {
15906 // Must copy string to "permanent" location because the string
15907 // location corresponding to tmp_cstring gets
15908 // overwritten for each iteration of loop.
15909 if ( ifcell )
15910 {
15911 if ( temp_cell.elem( i ).is_string() )
15912 {
15913 str = temp_cell.elem( i ).string_value();
15914 // leave room for null termination.
15915 max_length = str.size() + 1;
15916 tmp_cstring = (char *) str.c_str();
15917 }
15918 else
15919 {
15920 // Use null string if user attempts to pass a cell array
15921 // with a non-string element (likely an empty element
15922 // since that should be allowed by the PLplot interface
15923 // if that element is going to be unused).
15924 // leave room for null termination.
15925 max_length = 1;
15926 tmp_cstring = (char *) "";
15927 }
15928 }
15929 else
15930 {
15931 str = temp_matrix.row_as_string( i );
15932 tmp_cstring = (char *) str.c_str();
15933 }
15934 arg20[i] = new char[max_length];
15935 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15936 arg20[i][max_length - 1] = '\0';
15937 // All the trailing blank crapola should not be needed for
15938 // string cell arrays.
15939 if ( !ifcell )
15940 {
15941 // remove trailing-blank padding that is used by the
15942 // charMatrix class to insure all strings in a given
15943 // charMatrix instance have the same length.
15944 // This transformation also removes legitimate trailing
15945 // blanks but there is nothing we can do about that
15946 // for the charMatrix class.
15947
15948 // Look for trailing nulls first (just in case, although that
15949 // shouldn't happen if charMatrix implemented as documented)
15950 // before looking for trailing blanks.
15951 non_blank_length = max_length - 2;
15952 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15953 {
15954 non_blank_length--;
15955 }
15956 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15957 {
15958 non_blank_length--;
15959 }
15960 arg20[i][non_blank_length + 1] = '\0';
15961 }
15962 }
15963 }
15964 else
15965 {
15966 arg19 = 0;
15967 arg20 = NULL;
15968 }
15969 }
15970 {
15971 if ( _n_dims( args(16) ) > 1 )
15972 {
15973 error( "argument must be a scalar or vector" ); SWIG_fail;
15974 }
15975 if ( _dim( args(16), 0 ) != Alen )
15976 {
15977 error( "argument vectors must be same length" ); SWIG_fail;
15978 }
15979 temp21 = args(16).matrix_value();
15980 arg21 = &temp21( 0, 0 );
15981 }
15982 {
15983 if ( _n_dims( args(17) ) > 1 )
15984 {
15985 error( "argument must be a scalar or vector" ); SWIG_fail;
15986 }
15987 if ( _dim( args(17), 0 ) != Alen )
15988 {
15989 error( "argument vectors must be same length" ); SWIG_fail;
15990 }
15991 temp22 = args(17).matrix_value();
15992 arg22 = new PLINT[Alen];
15993 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15994 }
15995 {
15996 int i;
15997 if ( _n_dims( args(18) ) > 1 )
15998 {
15999 error( "argument must be a scalar or vector" ); SWIG_fail;
16000 }
16001 if ( _dim( args(18), 0 ) != Alen )
16002 {
16003 error( "argument vectors must be same length" ); SWIG_fail;
16004 }
16005 Xlen = Alen;
16006 temp23 = args(18).matrix_value();
16007 arg23 = new PLINT[Alen];
16008 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
16009 Ylen = -1;
16010 for ( i = 0; i < Xlen; i++ )
16011 if ( arg23[i] > Ylen )
16012 Ylen = arg23[i];
16013 }
16014 {
16015 if ( _n_dims( args(19) ) > 2 )
16016 {
16017 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
16018 }
16019 if ( _dim( args(19), 0 ) != Xlen )
16020 {
16021 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
16022 }
16023 if ( _dim( args(19), 1 ) != Ylen )
16024 {
16025 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
16026 }
16027 temp24 = args(19).matrix_value();
16028 arg24 = &temp24( 0, 0 );
16029 }
16030 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);
16031 _outv = octave_value();
16032 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16033 if (SWIG_IsTmpObj(res1)) {
16034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16035 } else {
16036 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16038 }
16039 if (SWIG_IsTmpObj(res2)) {
16040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16041 } else {
16042 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16044 }
16045 {
16046 delete [] arg17;
16047 }
16048 {
16049 int i;
16050 if ( arg18 != NULL )
16051 {
16052 for ( i = 0; i < Alen; i++ )
16053 {
16054 delete[] arg18[i];
16055 }
16056 delete[] arg18;
16057 }
16058 }
16059 {
16060 int i;
16061 if ( arg20 != NULL )
16062 {
16063 for ( i = 0; i < Alen; i++ )
16064 {
16065 delete[] arg20[i];
16066 }
16067 delete[] arg20;
16068 }
16069 }
16070 {
16071
16072 }
16073 {
16074 delete [] arg22;
16075 }
16076 {
16077 delete [] arg23;
16078 }
16079 {
16080
16081 }
16082 return _out;
16083 fail:
16084 {
16085 delete [] arg17;
16086 }
16087 {
16088 int i;
16089 if ( arg18 != NULL )
16090 {
16091 for ( i = 0; i < Alen; i++ )
16092 {
16093 delete[] arg18[i];
16094 }
16095 delete[] arg18;
16096 }
16097 }
16098 {
16099 int i;
16100 if ( arg20 != NULL )
16101 {
16102 for ( i = 0; i < Alen; i++ )
16103 {
16104 delete[] arg20[i];
16105 }
16106 delete[] arg20;
16107 }
16108 }
16109 {
16110
16111 }
16112 {
16113 delete [] arg22;
16114 }
16115 {
16116 delete [] arg23;
16117 }
16118 {
16119
16120 }
16121 return octave_value_list();
16122 }
16123 catch(...) {
16124 {
16125 delete [] arg17;
16126 }
16127 {
16128 int i;
16129 if ( arg18 != NULL )
16130 {
16131 for ( i = 0; i < Alen; i++ )
16132 {
16133 delete[] arg18[i];
16134 }
16135 delete[] arg18;
16136 }
16137 }
16138 {
16139 int i;
16140 if ( arg20 != NULL )
16141 {
16142 for ( i = 0; i < Alen; i++ )
16143 {
16144 delete[] arg20[i];
16145 }
16146 delete[] arg20;
16147 }
16148 }
16149 {
16150
16151 }
16152 {
16153 delete [] arg22;
16154 }
16155 {
16156 delete [] arg23;
16157 }
16158 {
16159
16160 }
16161 throw;
16162 }
16163}
16164
16165
16166SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16167 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16168 int arg2 ;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 int val2 ;
16172 int ecode2 = 0 ;
16173 octave_value_list _out;
16174 octave_value_list *_outp=&_out;
16175 octave_value _outv;
16176
16177 try {
16178 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16179 SWIG_fail;
16180 }
16181 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16182 if (!SWIG_IsOK(res1)) {
16183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16184 }
16185 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16186 ecode2 = SWIG_AsVal_int(args(1), &val2);
16187 if (!SWIG_IsOK(ecode2)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16189 }
16190 arg2 = static_cast< int >(val2);
16191 if (arg1) (arg1)->type = arg2;
16192 _outv = octave_value();
16193 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16194 return _out;
16195 fail:
16196 return octave_value_list();
16197 }
16198 catch(...) {
16199 throw;
16200 }
16201}
16202
16203
16204SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16205 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16206 void *argp1 = 0 ;
16207 int res1 = 0 ;
16208 octave_value_list _out;
16209 octave_value_list *_outp=&_out;
16210 octave_value _outv;
16211 int result;
16212
16213 try {
16214 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16215 SWIG_fail;
16216 }
16217 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16218 if (!SWIG_IsOK(res1)) {
16219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16220 }
16221 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16222 result = (int) ((arg1)->type);
16223 _outv = SWIG_From_int(static_cast< int >(result));
16224 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16225 return _out;
16226 fail:
16227 return octave_value_list();
16228 }
16229 catch(...) {
16230 throw;
16231 }
16232}
16233
16234
16235SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16236 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16237 unsigned int arg2 ;
16238 void *argp1 = 0 ;
16239 int res1 = 0 ;
16240 unsigned int val2 ;
16241 int ecode2 = 0 ;
16242 octave_value_list _out;
16243 octave_value_list *_outp=&_out;
16244 octave_value _outv;
16245
16246 try {
16247 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16248 SWIG_fail;
16249 }
16250 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16253 }
16254 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16255 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16256 if (!SWIG_IsOK(ecode2)) {
16257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16258 }
16259 arg2 = static_cast< unsigned int >(val2);
16260 if (arg1) (arg1)->state = arg2;
16261 _outv = octave_value();
16262 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16263 return _out;
16264 fail:
16265 return octave_value_list();
16266 }
16267 catch(...) {
16268 throw;
16269 }
16270}
16271
16272
16273SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16274 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 octave_value_list _out;
16278 octave_value_list *_outp=&_out;
16279 octave_value _outv;
16280 unsigned int result;
16281
16282 try {
16283 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16284 SWIG_fail;
16285 }
16286 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16289 }
16290 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16291 result = (unsigned int) ((arg1)->state);
16292 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16293 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16294 return _out;
16295 fail:
16296 return octave_value_list();
16297 }
16298 catch(...) {
16299 throw;
16300 }
16301}
16302
16303
16304SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16305 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16306 unsigned int arg2 ;
16307 void *argp1 = 0 ;
16308 int res1 = 0 ;
16309 unsigned int val2 ;
16310 int ecode2 = 0 ;
16311 octave_value_list _out;
16312 octave_value_list *_outp=&_out;
16313 octave_value _outv;
16314
16315 try {
16316 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16317 SWIG_fail;
16318 }
16319 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16320 if (!SWIG_IsOK(res1)) {
16321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16322 }
16323 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16324 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16325 if (!SWIG_IsOK(ecode2)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16327 }
16328 arg2 = static_cast< unsigned int >(val2);
16329 if (arg1) (arg1)->keysym = arg2;
16330 _outv = octave_value();
16331 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16332 return _out;
16333 fail:
16334 return octave_value_list();
16335 }
16336 catch(...) {
16337 throw;
16338 }
16339}
16340
16341
16342SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16343 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16344 void *argp1 = 0 ;
16345 int res1 = 0 ;
16346 octave_value_list _out;
16347 octave_value_list *_outp=&_out;
16348 octave_value _outv;
16349 unsigned int result;
16350
16351 try {
16352 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16353 SWIG_fail;
16354 }
16355 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16356 if (!SWIG_IsOK(res1)) {
16357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16358 }
16359 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16360 result = (unsigned int) ((arg1)->keysym);
16361 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16362 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16363 return _out;
16364 fail:
16365 return octave_value_list();
16366 }
16367 catch(...) {
16368 throw;
16369 }
16370}
16371
16372
16373SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16374 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16375 unsigned int arg2 ;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 unsigned int val2 ;
16379 int ecode2 = 0 ;
16380 octave_value_list _out;
16381 octave_value_list *_outp=&_out;
16382 octave_value _outv;
16383
16384 try {
16385 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16386 SWIG_fail;
16387 }
16388 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16389 if (!SWIG_IsOK(res1)) {
16390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16391 }
16392 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16393 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16394 if (!SWIG_IsOK(ecode2)) {
16395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16396 }
16397 arg2 = static_cast< unsigned int >(val2);
16398 if (arg1) (arg1)->button = arg2;
16399 _outv = octave_value();
16400 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16401 return _out;
16402 fail:
16403 return octave_value_list();
16404 }
16405 catch(...) {
16406 throw;
16407 }
16408}
16409
16410
16411SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16412 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 octave_value_list _out;
16416 octave_value_list *_outp=&_out;
16417 octave_value _outv;
16418 unsigned int result;
16419
16420 try {
16421 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16422 SWIG_fail;
16423 }
16424 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16427 }
16428 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16429 result = (unsigned int) ((arg1)->button);
16430 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16431 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16432 return _out;
16433 fail:
16434 return octave_value_list();
16435 }
16436 catch(...) {
16437 throw;
16438 }
16439}
16440
16441
16442SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16443 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16444 PLINT arg2 ;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 int val2 ;
16448 int ecode2 = 0 ;
16449 octave_value_list _out;
16450 octave_value_list *_outp=&_out;
16451 octave_value _outv;
16452
16453 try {
16454 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16455 SWIG_fail;
16456 }
16457 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16458 if (!SWIG_IsOK(res1)) {
16459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16460 }
16461 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16462 ecode2 = SWIG_AsVal_int(args(1), &val2);
16463 if (!SWIG_IsOK(ecode2)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16465 }
16466 arg2 = static_cast< PLINT >(val2);
16467 if (arg1) (arg1)->subwindow = arg2;
16468 _outv = octave_value();
16469 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16470 return _out;
16471 fail:
16472 return octave_value_list();
16473 }
16474 catch(...) {
16475 throw;
16476 }
16477}
16478
16479
16480SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16481 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 octave_value_list _out;
16485 octave_value_list *_outp=&_out;
16486 octave_value _outv;
16487 PLINT result;
16488
16489 try {
16490 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16491 SWIG_fail;
16492 }
16493 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16494 if (!SWIG_IsOK(res1)) {
16495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16496 }
16497 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16498 result = (PLINT) ((arg1)->subwindow);
16499 _outv = SWIG_From_int(static_cast< int >(result));
16500 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16501 return _out;
16502 fail:
16503 return octave_value_list();
16504 }
16505 catch(...) {
16506 throw;
16507 }
16508}
16509
16510
16511SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16512 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16513 char *arg2 ;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 char temp2[16] ;
16517 int res2 ;
16518 octave_value_list _out;
16519 octave_value_list *_outp=&_out;
16520 octave_value _outv;
16521
16522 try {
16523 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16524 SWIG_fail;
16525 }
16526 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16529 }
16530 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16531 res2 = SWIG_AsCharArray(args(1), temp2, 16);
16532 if (!SWIG_IsOK(res2)) {
16533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16534 }
16535 arg2 = reinterpret_cast< char * >(temp2);
16536 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16537 else memset(arg1->string,0,16*sizeof(char));
16538 _outv = octave_value();
16539 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16540 return _out;
16541 fail:
16542 return octave_value_list();
16543 }
16544 catch(...) {
16545 throw;
16546 }
16547}
16548
16549
16550SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16551 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16552 void *argp1 = 0 ;
16553 int res1 = 0 ;
16554 octave_value_list _out;
16555 octave_value_list *_outp=&_out;
16556 octave_value _outv;
16557 char *result = 0 ;
16558
16559 try {
16560 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16561 SWIG_fail;
16562 }
16563 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16566 }
16567 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16568 result = (char *)(char *) ((arg1)->string);
16569 {
16570 size_t size = SWIG_strnlen(result, 16);
16571
16572
16573
16574 _outv = SWIG_FromCharPtrAndSize(result, size);
16575 }
16576 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16577 return _out;
16578 fail:
16579 return octave_value_list();
16580 }
16581 catch(...) {
16582 throw;
16583 }
16584}
16585
16586
16587SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16588 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16589 int arg2 ;
16590 void *argp1 = 0 ;
16591 int res1 = 0 ;
16592 int val2 ;
16593 int ecode2 = 0 ;
16594 octave_value_list _out;
16595 octave_value_list *_outp=&_out;
16596 octave_value _outv;
16597
16598 try {
16599 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16600 SWIG_fail;
16601 }
16602 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16603 if (!SWIG_IsOK(res1)) {
16604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16605 }
16606 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16607 ecode2 = SWIG_AsVal_int(args(1), &val2);
16608 if (!SWIG_IsOK(ecode2)) {
16609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16610 }
16611 arg2 = static_cast< int >(val2);
16612 if (arg1) (arg1)->pX = arg2;
16613 _outv = octave_value();
16614 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16615 return _out;
16616 fail:
16617 return octave_value_list();
16618 }
16619 catch(...) {
16620 throw;
16621 }
16622}
16623
16624
16625SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16626 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16627 void *argp1 = 0 ;
16628 int res1 = 0 ;
16629 octave_value_list _out;
16630 octave_value_list *_outp=&_out;
16631 octave_value _outv;
16632 int result;
16633
16634 try {
16635 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16636 SWIG_fail;
16637 }
16638 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16639 if (!SWIG_IsOK(res1)) {
16640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16641 }
16642 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16643 result = (int) ((arg1)->pX);
16644 _outv = SWIG_From_int(static_cast< int >(result));
16645 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16646 return _out;
16647 fail:
16648 return octave_value_list();
16649 }
16650 catch(...) {
16651 throw;
16652 }
16653}
16654
16655
16656SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16657 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16658 int arg2 ;
16659 void *argp1 = 0 ;
16660 int res1 = 0 ;
16661 int val2 ;
16662 int ecode2 = 0 ;
16663 octave_value_list _out;
16664 octave_value_list *_outp=&_out;
16665 octave_value _outv;
16666
16667 try {
16668 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16669 SWIG_fail;
16670 }
16671 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16672 if (!SWIG_IsOK(res1)) {
16673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16674 }
16675 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16676 ecode2 = SWIG_AsVal_int(args(1), &val2);
16677 if (!SWIG_IsOK(ecode2)) {
16678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16679 }
16680 arg2 = static_cast< int >(val2);
16681 if (arg1) (arg1)->pY = arg2;
16682 _outv = octave_value();
16683 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16684 return _out;
16685 fail:
16686 return octave_value_list();
16687 }
16688 catch(...) {
16689 throw;
16690 }
16691}
16692
16693
16694SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16695 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 octave_value_list _out;
16699 octave_value_list *_outp=&_out;
16700 octave_value _outv;
16701 int result;
16702
16703 try {
16704 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16705 SWIG_fail;
16706 }
16707 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16710 }
16711 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16712 result = (int) ((arg1)->pY);
16713 _outv = SWIG_From_int(static_cast< int >(result));
16714 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16715 return _out;
16716 fail:
16717 return octave_value_list();
16718 }
16719 catch(...) {
16720 throw;
16721 }
16722}
16723
16724
16725SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16726 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16727 PLFLT arg2 ;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 double val2 ;
16731 int ecode2 = 0 ;
16732 octave_value_list _out;
16733 octave_value_list *_outp=&_out;
16734 octave_value _outv;
16735
16736 try {
16737 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16738 SWIG_fail;
16739 }
16740 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16743 }
16744 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16745 ecode2 = SWIG_AsVal_double(args(1), &val2);
16746 if (!SWIG_IsOK(ecode2)) {
16747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16748 }
16749 arg2 = static_cast< PLFLT >(val2);
16750 if (arg1) (arg1)->dX = arg2;
16751 _outv = octave_value();
16752 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16753 return _out;
16754 fail:
16755 return octave_value_list();
16756 }
16757 catch(...) {
16758 throw;
16759 }
16760}
16761
16762
16763SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16764 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 octave_value_list _out;
16768 octave_value_list *_outp=&_out;
16769 octave_value _outv;
16770 PLFLT result;
16771
16772 try {
16773 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16774 SWIG_fail;
16775 }
16776 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16777 if (!SWIG_IsOK(res1)) {
16778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16779 }
16780 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16781 result = (PLFLT) ((arg1)->dX);
16782 _outv = SWIG_From_double(static_cast< double >(result));
16783 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16784 return _out;
16785 fail:
16786 return octave_value_list();
16787 }
16788 catch(...) {
16789 throw;
16790 }
16791}
16792
16793
16794SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16795 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16796 PLFLT arg2 ;
16797 void *argp1 = 0 ;
16798 int res1 = 0 ;
16799 double val2 ;
16800 int ecode2 = 0 ;
16801 octave_value_list _out;
16802 octave_value_list *_outp=&_out;
16803 octave_value _outv;
16804
16805 try {
16806 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16807 SWIG_fail;
16808 }
16809 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16810 if (!SWIG_IsOK(res1)) {
16811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16812 }
16813 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16814 ecode2 = SWIG_AsVal_double(args(1), &val2);
16815 if (!SWIG_IsOK(ecode2)) {
16816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16817 }
16818 arg2 = static_cast< PLFLT >(val2);
16819 if (arg1) (arg1)->dY = arg2;
16820 _outv = octave_value();
16821 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16822 return _out;
16823 fail:
16824 return octave_value_list();
16825 }
16826 catch(...) {
16827 throw;
16828 }
16829}
16830
16831
16832SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16833 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16834 void *argp1 = 0 ;
16835 int res1 = 0 ;
16836 octave_value_list _out;
16837 octave_value_list *_outp=&_out;
16838 octave_value _outv;
16839 PLFLT result;
16840
16841 try {
16842 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16843 SWIG_fail;
16844 }
16845 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16846 if (!SWIG_IsOK(res1)) {
16847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16848 }
16849 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16850 result = (PLFLT) ((arg1)->dY);
16851 _outv = SWIG_From_double(static_cast< double >(result));
16852 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16853 return _out;
16854 fail:
16855 return octave_value_list();
16856 }
16857 catch(...) {
16858 throw;
16859 }
16860}
16861
16862
16863SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16864 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16865 PLFLT arg2 ;
16866 void *argp1 = 0 ;
16867 int res1 = 0 ;
16868 double val2 ;
16869 int ecode2 = 0 ;
16870 octave_value_list _out;
16871 octave_value_list *_outp=&_out;
16872 octave_value _outv;
16873
16874 try {
16875 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16876 SWIG_fail;
16877 }
16878 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16879 if (!SWIG_IsOK(res1)) {
16880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16881 }
16882 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16883 ecode2 = SWIG_AsVal_double(args(1), &val2);
16884 if (!SWIG_IsOK(ecode2)) {
16885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16886 }
16887 arg2 = static_cast< PLFLT >(val2);
16888 if (arg1) (arg1)->wX = arg2;
16889 _outv = octave_value();
16890 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16891 return _out;
16892 fail:
16893 return octave_value_list();
16894 }
16895 catch(...) {
16896 throw;
16897 }
16898}
16899
16900
16901SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16902 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 octave_value_list _out;
16906 octave_value_list *_outp=&_out;
16907 octave_value _outv;
16908 PLFLT result;
16909
16910 try {
16911 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16912 SWIG_fail;
16913 }
16914 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16915 if (!SWIG_IsOK(res1)) {
16916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16917 }
16918 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16919 result = (PLFLT) ((arg1)->wX);
16920 _outv = SWIG_From_double(static_cast< double >(result));
16921 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16922 return _out;
16923 fail:
16924 return octave_value_list();
16925 }
16926 catch(...) {
16927 throw;
16928 }
16929}
16930
16931
16932SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16933 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16934 PLFLT arg2 ;
16935 void *argp1 = 0 ;
16936 int res1 = 0 ;
16937 double val2 ;
16938 int ecode2 = 0 ;
16939 octave_value_list _out;
16940 octave_value_list *_outp=&_out;
16941 octave_value _outv;
16942
16943 try {
16944 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16945 SWIG_fail;
16946 }
16947 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16950 }
16951 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16952 ecode2 = SWIG_AsVal_double(args(1), &val2);
16953 if (!SWIG_IsOK(ecode2)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16955 }
16956 arg2 = static_cast< PLFLT >(val2);
16957 if (arg1) (arg1)->wY = arg2;
16958 _outv = octave_value();
16959 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16960 return _out;
16961 fail:
16962 return octave_value_list();
16963 }
16964 catch(...) {
16965 throw;
16966 }
16967}
16968
16969
16970SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16971 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16972 void *argp1 = 0 ;
16973 int res1 = 0 ;
16974 octave_value_list _out;
16975 octave_value_list *_outp=&_out;
16976 octave_value _outv;
16977 PLFLT result;
16978
16979 try {
16980 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16981 SWIG_fail;
16982 }
16983 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16984 if (!SWIG_IsOK(res1)) {
16985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16986 }
16987 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16988 result = (PLFLT) ((arg1)->wY);
16989 _outv = SWIG_From_double(static_cast< double >(result));
16990 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16991 return _out;
16992 fail:
16993 return octave_value_list();
16994 }
16995 catch(...) {
16996 throw;
16997 }
16998}
16999
17000
17001SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
17002 octave_value_list _out;
17003 octave_value_list *_outp=&_out;
17004 octave_value _outv;
17005 PLGraphicsIn *result = 0 ;
17006
17007 try {
17008 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
17009 SWIG_fail;
17010 }
17011 result = (PLGraphicsIn *)new PLGraphicsIn();
17013 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17014 return _out;
17015 fail:
17016 return octave_value_list();
17017 }
17018 catch(...) {
17019 throw;
17020 }
17021}
17022
17023
17024SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
17025 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
17026 void *argp1 = 0 ;
17027 int res1 = 0 ;
17028 octave_value_list _out;
17029 octave_value_list *_outp=&_out;
17030 octave_value _outv;
17031
17032 try {
17033 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
17034 SWIG_fail;
17035 }
17036 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
17039 }
17040 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
17041 delete arg1;
17042 _outv = octave_value();
17043 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17044 return _out;
17045 fail:
17046 return octave_value_list();
17047 }
17048 catch(...) {
17049 throw;
17050 }
17051}
17052
17053
17067{0,0,0,0,0,0}
17068};
17069static const char *swig_PLGraphicsIn_base_names[] = {0};
17072
17074 PLINT arg1 ;
17075 PLINT arg2 ;
17076 int val1 ;
17077 int ecode1 = 0 ;
17078 int val2 ;
17079 int ecode2 = 0 ;
17080 octave_value_list _out;
17081 octave_value_list *_outp=&_out;
17082 octave_value _outv;
17083
17084 try {
17085 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17086 SWIG_fail;
17087 }
17088 ecode1 = SWIG_AsVal_int(args(0), &val1);
17089 if (!SWIG_IsOK(ecode1)) {
17090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17091 }
17092 arg1 = static_cast< PLINT >(val1);
17093 ecode2 = SWIG_AsVal_int(args(1), &val2);
17094 if (!SWIG_IsOK(ecode2)) {
17095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17096 }
17097 arg2 = static_cast< PLINT >(val2);
17098 pl_setcontlabelformat(arg1,arg2);
17099 _outv = octave_value();
17100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17101 return _out;
17102 fail:
17103 return octave_value_list();
17104 }
17105 catch(...) {
17106 throw;
17107 }
17108}
17109
17110
17112 PLFLT arg1 ;
17113 PLFLT arg2 ;
17114 PLFLT arg3 ;
17115 PLINT arg4 ;
17116 double val1 ;
17117 int ecode1 = 0 ;
17118 double val2 ;
17119 int ecode2 = 0 ;
17120 double val3 ;
17121 int ecode3 = 0 ;
17122 int val4 ;
17123 int ecode4 = 0 ;
17124 octave_value_list _out;
17125 octave_value_list *_outp=&_out;
17126 octave_value _outv;
17127
17128 try {
17129 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17130 SWIG_fail;
17131 }
17132 ecode1 = SWIG_AsVal_double(args(0), &val1);
17133 if (!SWIG_IsOK(ecode1)) {
17134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17135 }
17136 arg1 = static_cast< PLFLT >(val1);
17137 ecode2 = SWIG_AsVal_double(args(1), &val2);
17138 if (!SWIG_IsOK(ecode2)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17140 }
17141 arg2 = static_cast< PLFLT >(val2);
17142 ecode3 = SWIG_AsVal_double(args(2), &val3);
17143 if (!SWIG_IsOK(ecode3)) {
17144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17145 }
17146 arg3 = static_cast< PLFLT >(val3);
17147 ecode4 = SWIG_AsVal_int(args(3), &val4);
17148 if (!SWIG_IsOK(ecode4)) {
17149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17150 }
17151 arg4 = static_cast< PLINT >(val4);
17152 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17153 _outv = octave_value();
17154 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17155 return _out;
17156 fail:
17157 return octave_value_list();
17158 }
17159 catch(...) {
17160 throw;
17161 }
17162}
17163
17164
17166 PLINT arg1 ;
17167 int val1 ;
17168 int ecode1 = 0 ;
17169 octave_value_list _out;
17170 octave_value_list *_outp=&_out;
17171 octave_value _outv;
17172
17173 try {
17174 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17175 SWIG_fail;
17176 }
17177 ecode1 = SWIG_AsVal_int(args(0), &val1);
17178 if (!SWIG_IsOK(ecode1)) {
17179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17180 }
17181 arg1 = static_cast< PLINT >(val1);
17182 pladv(arg1);
17183 _outv = octave_value();
17184 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17185 return _out;
17186 fail:
17187 return octave_value_list();
17188 }
17189 catch(...) {
17190 throw;
17191 }
17192}
17193
17194
17196 PLFLT arg1 ;
17197 PLFLT arg2 ;
17198 PLFLT arg3 ;
17199 PLFLT arg4 ;
17200 PLFLT arg5 ;
17201 PLFLT arg6 ;
17202 PLFLT arg7 ;
17203 PLBOOL arg8 ;
17204 double val1 ;
17205 int ecode1 = 0 ;
17206 double val2 ;
17207 int ecode2 = 0 ;
17208 double val3 ;
17209 int ecode3 = 0 ;
17210 double val4 ;
17211 int ecode4 = 0 ;
17212 double val5 ;
17213 int ecode5 = 0 ;
17214 double val6 ;
17215 int ecode6 = 0 ;
17216 double val7 ;
17217 int ecode7 = 0 ;
17218 int val8 ;
17219 int ecode8 = 0 ;
17220 octave_value_list _out;
17221 octave_value_list *_outp=&_out;
17222 octave_value _outv;
17223
17224 try {
17225 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17226 SWIG_fail;
17227 }
17228 ecode1 = SWIG_AsVal_double(args(0), &val1);
17229 if (!SWIG_IsOK(ecode1)) {
17230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17231 }
17232 arg1 = static_cast< PLFLT >(val1);
17233 ecode2 = SWIG_AsVal_double(args(1), &val2);
17234 if (!SWIG_IsOK(ecode2)) {
17235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17236 }
17237 arg2 = static_cast< PLFLT >(val2);
17238 ecode3 = SWIG_AsVal_double(args(2), &val3);
17239 if (!SWIG_IsOK(ecode3)) {
17240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17241 }
17242 arg3 = static_cast< PLFLT >(val3);
17243 ecode4 = SWIG_AsVal_double(args(3), &val4);
17244 if (!SWIG_IsOK(ecode4)) {
17245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17246 }
17247 arg4 = static_cast< PLFLT >(val4);
17248 ecode5 = SWIG_AsVal_double(args(4), &val5);
17249 if (!SWIG_IsOK(ecode5)) {
17250 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17251 }
17252 arg5 = static_cast< PLFLT >(val5);
17253 ecode6 = SWIG_AsVal_double(args(5), &val6);
17254 if (!SWIG_IsOK(ecode6)) {
17255 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17256 }
17257 arg6 = static_cast< PLFLT >(val6);
17258 ecode7 = SWIG_AsVal_double(args(6), &val7);
17259 if (!SWIG_IsOK(ecode7)) {
17260 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17261 }
17262 arg7 = static_cast< PLFLT >(val7);
17263 ecode8 = SWIG_AsVal_int(args(7), &val8);
17264 if (!SWIG_IsOK(ecode8)) {
17265 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17266 }
17267 arg8 = static_cast< PLBOOL >(val8);
17268 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17269 _outv = octave_value();
17270 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17271 return _out;
17272 fail:
17273 return octave_value_list();
17274 }
17275 catch(...) {
17276 throw;
17277 }
17278}
17279
17280
17282 PLFLT arg1 ;
17283 PLFLT arg2 ;
17284 char *arg3 = (char *) 0 ;
17285 PLFLT arg4 ;
17286 PLINT arg5 ;
17287 char *arg6 = (char *) 0 ;
17288 PLFLT arg7 ;
17289 PLINT arg8 ;
17290 double val1 ;
17291 int ecode1 = 0 ;
17292 double val2 ;
17293 int ecode2 = 0 ;
17294 int res3 ;
17295 char *buf3 = 0 ;
17296 int alloc3 = 0 ;
17297 double val4 ;
17298 int ecode4 = 0 ;
17299 int val5 ;
17300 int ecode5 = 0 ;
17301 int res6 ;
17302 char *buf6 = 0 ;
17303 int alloc6 = 0 ;
17304 double val7 ;
17305 int ecode7 = 0 ;
17306 int val8 ;
17307 int ecode8 = 0 ;
17308 octave_value_list _out;
17309 octave_value_list *_outp=&_out;
17310 octave_value _outv;
17311
17312 try {
17313 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17314 SWIG_fail;
17315 }
17316 ecode1 = SWIG_AsVal_double(args(0), &val1);
17317 if (!SWIG_IsOK(ecode1)) {
17318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17319 }
17320 arg1 = static_cast< PLFLT >(val1);
17321 ecode2 = SWIG_AsVal_double(args(1), &val2);
17322 if (!SWIG_IsOK(ecode2)) {
17323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17324 }
17325 arg2 = static_cast< PLFLT >(val2);
17326 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17327 if (!SWIG_IsOK(res3)) {
17328 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17329 }
17330 arg3 = reinterpret_cast< char * >(buf3);
17331 ecode4 = SWIG_AsVal_double(args(3), &val4);
17332 if (!SWIG_IsOK(ecode4)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17334 }
17335 arg4 = static_cast< PLFLT >(val4);
17336 ecode5 = SWIG_AsVal_int(args(4), &val5);
17337 if (!SWIG_IsOK(ecode5)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17339 }
17340 arg5 = static_cast< PLINT >(val5);
17341 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17342 if (!SWIG_IsOK(res6)) {
17343 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17344 }
17345 arg6 = reinterpret_cast< char * >(buf6);
17346 ecode7 = SWIG_AsVal_double(args(6), &val7);
17347 if (!SWIG_IsOK(ecode7)) {
17348 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17349 }
17350 arg7 = static_cast< PLFLT >(val7);
17351 ecode8 = SWIG_AsVal_int(args(7), &val8);
17352 if (!SWIG_IsOK(ecode8)) {
17353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17354 }
17355 arg8 = static_cast< PLINT >(val8);
17356 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17357 _outv = octave_value();
17358 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17359 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17360 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17361 return _out;
17362 fail:
17363 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17364 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17365 return octave_value_list();
17366 }
17367 catch(...) {
17368 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17369 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17370 throw;
17371 }
17372}
17373
17374
17376 PLINT arg1 ;
17377 PLFLT *arg2 = (PLFLT *) 0 ;
17378 PLFLT *arg3 = (PLFLT *) 0 ;
17379 PLINT arg4 ;
17380 Matrix temp1 ;
17381 Matrix temp3 ;
17382 int val4 ;
17383 int ecode4 = 0 ;
17384 octave_value_list _out;
17385 octave_value_list *_outp=&_out;
17386 octave_value _outv;
17387
17388 try {
17389 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17390 SWIG_fail;
17391 }
17392 {
17393 if ( _n_dims( args(0) ) > 1 )
17394 {
17395 error( "argument must be a scalar or vector" ); SWIG_fail;
17396 }
17397 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17398 temp1 = args(0).matrix_value();
17399 arg2 = &temp1( 0, 0 );
17400 }
17401 {
17402 if ( _n_dims( args(1) ) > 1 )
17403 {
17404 error( "argument must be a scalar or vector" ); SWIG_fail;
17405 }
17406 if ( _dim( args(1), 0 ) != Alen )
17407 {
17408 error( "argument vectors must be same length" ); SWIG_fail;
17409 }
17410 temp3 = args(1).matrix_value();
17411 arg3 = &temp3( 0, 0 );
17412 }
17413 ecode4 = SWIG_AsVal_int(args(2), &val4);
17414 if (!SWIG_IsOK(ecode4)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17416 }
17417 arg4 = static_cast< PLINT >(val4);
17418 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17419 _outv = octave_value();
17420 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17421 {
17422
17423 }
17424 {
17425
17426 }
17427 return _out;
17428 fail:
17429 {
17430
17431 }
17432 {
17433
17434 }
17435 return octave_value_list();
17436 }
17437 catch(...) {
17438 {
17439
17440 }
17441 {
17442
17443 }
17444 throw;
17445 }
17446}
17447
17448
17450 PLINT *arg1 = (PLINT *) 0 ;
17451 PLINT *arg2 = (PLINT *) 0 ;
17452 PLINT *arg3 = (PLINT *) 0 ;
17453 PLINT *arg4 = (PLINT *) 0 ;
17454 PLINT *arg5 = (PLINT *) 0 ;
17455 PLFLT *arg6 = (PLFLT *) 0 ;
17456 PLFLT arg7 ;
17457 PLINT temp1 ;
17458 int res1 = SWIG_TMPOBJ ;
17459 PLINT temp2 ;
17460 int res2 = SWIG_TMPOBJ ;
17461 PLINT temp3 ;
17462 int res3 = SWIG_TMPOBJ ;
17463 PLINT temp4 ;
17464 int res4 = SWIG_TMPOBJ ;
17465 PLINT temp5 ;
17466 int res5 = SWIG_TMPOBJ ;
17467 PLFLT temp6 ;
17468 int res6 = SWIG_TMPOBJ ;
17469 double val7 ;
17470 int ecode7 = 0 ;
17471 octave_value_list _out;
17472 octave_value_list *_outp=&_out;
17473 octave_value _outv;
17474
17475 try {
17476 arg1 = &temp1;
17477 arg2 = &temp2;
17478 arg3 = &temp3;
17479 arg4 = &temp4;
17480 arg5 = &temp5;
17481 arg6 = &temp6;
17482 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17483 SWIG_fail;
17484 }
17485 ecode7 = SWIG_AsVal_double(args(0), &val7);
17486 if (!SWIG_IsOK(ecode7)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17488 }
17489 arg7 = static_cast< PLFLT >(val7);
17490 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17491 _outv = octave_value();
17492 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17493 if (SWIG_IsTmpObj(res1)) {
17494 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17495 } else {
17496 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17497 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17498 }
17499 if (SWIG_IsTmpObj(res2)) {
17500 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17501 } else {
17502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17503 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17504 }
17505 if (SWIG_IsTmpObj(res3)) {
17506 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17507 } else {
17508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17509 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17510 }
17511 if (SWIG_IsTmpObj(res4)) {
17512 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17513 } else {
17514 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17515 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17516 }
17517 if (SWIG_IsTmpObj(res5)) {
17518 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17519 } else {
17520 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17521 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17522 }
17523 if (SWIG_IsTmpObj(res6)) {
17524 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17525 } else {
17526 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17528 }
17529 return _out;
17530 fail:
17531 return octave_value_list();
17532 }
17533 catch(...) {
17534 throw;
17535 }
17536}
17537
17538
17540 octave_value_list _out;
17541 octave_value_list *_outp=&_out;
17542 octave_value _outv;
17543
17544 try {
17545 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17546 SWIG_fail;
17547 }
17548 plbop();
17549 _outv = octave_value();
17550 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17551 return _out;
17552 fail:
17553 return octave_value_list();
17554 }
17555 catch(...) {
17556 throw;
17557 }
17558}
17559
17560
17562 char *arg1 = (char *) 0 ;
17563 PLFLT arg2 ;
17564 PLINT arg3 ;
17565 char *arg4 = (char *) 0 ;
17566 PLFLT arg5 ;
17567 PLINT arg6 ;
17568 int res1 ;
17569 char *buf1 = 0 ;
17570 int alloc1 = 0 ;
17571 double val2 ;
17572 int ecode2 = 0 ;
17573 int val3 ;
17574 int ecode3 = 0 ;
17575 int res4 ;
17576 char *buf4 = 0 ;
17577 int alloc4 = 0 ;
17578 double val5 ;
17579 int ecode5 = 0 ;
17580 int val6 ;
17581 int ecode6 = 0 ;
17582 octave_value_list _out;
17583 octave_value_list *_outp=&_out;
17584 octave_value _outv;
17585
17586 try {
17587 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17588 SWIG_fail;
17589 }
17590 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17591 if (!SWIG_IsOK(res1)) {
17592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17593 }
17594 arg1 = reinterpret_cast< char * >(buf1);
17595 ecode2 = SWIG_AsVal_double(args(1), &val2);
17596 if (!SWIG_IsOK(ecode2)) {
17597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17598 }
17599 arg2 = static_cast< PLFLT >(val2);
17600 ecode3 = SWIG_AsVal_int(args(2), &val3);
17601 if (!SWIG_IsOK(ecode3)) {
17602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17603 }
17604 arg3 = static_cast< PLINT >(val3);
17605 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17606 if (!SWIG_IsOK(res4)) {
17607 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17608 }
17609 arg4 = reinterpret_cast< char * >(buf4);
17610 ecode5 = SWIG_AsVal_double(args(4), &val5);
17611 if (!SWIG_IsOK(ecode5)) {
17612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17613 }
17614 arg5 = static_cast< PLFLT >(val5);
17615 ecode6 = SWIG_AsVal_int(args(5), &val6);
17616 if (!SWIG_IsOK(ecode6)) {
17617 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17618 }
17619 arg6 = static_cast< PLINT >(val6);
17620 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17621 _outv = octave_value();
17622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17623 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17624 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17625 return _out;
17626 fail:
17627 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17628 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17629 return octave_value_list();
17630 }
17631 catch(...) {
17632 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17633 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17634 throw;
17635 }
17636}
17637
17638
17640 char *arg1 = (char *) 0 ;
17641 char *arg2 = (char *) 0 ;
17642 PLFLT arg3 ;
17643 PLINT arg4 ;
17644 char *arg5 = (char *) 0 ;
17645 char *arg6 = (char *) 0 ;
17646 PLFLT arg7 ;
17647 PLINT arg8 ;
17648 char *arg9 = (char *) 0 ;
17649 char *arg10 = (char *) 0 ;
17650 PLFLT arg11 ;
17651 PLINT arg12 ;
17652 int res1 ;
17653 char *buf1 = 0 ;
17654 int alloc1 = 0 ;
17655 int res2 ;
17656 char *buf2 = 0 ;
17657 int alloc2 = 0 ;
17658 double val3 ;
17659 int ecode3 = 0 ;
17660 int val4 ;
17661 int ecode4 = 0 ;
17662 int res5 ;
17663 char *buf5 = 0 ;
17664 int alloc5 = 0 ;
17665 int res6 ;
17666 char *buf6 = 0 ;
17667 int alloc6 = 0 ;
17668 double val7 ;
17669 int ecode7 = 0 ;
17670 int val8 ;
17671 int ecode8 = 0 ;
17672 int res9 ;
17673 char *buf9 = 0 ;
17674 int alloc9 = 0 ;
17675 int res10 ;
17676 char *buf10 = 0 ;
17677 int alloc10 = 0 ;
17678 double val11 ;
17679 int ecode11 = 0 ;
17680 int val12 ;
17681 int ecode12 = 0 ;
17682 octave_value_list _out;
17683 octave_value_list *_outp=&_out;
17684 octave_value _outv;
17685
17686 try {
17687 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17688 SWIG_fail;
17689 }
17690 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17691 if (!SWIG_IsOK(res1)) {
17692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17693 }
17694 arg1 = reinterpret_cast< char * >(buf1);
17695 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17696 if (!SWIG_IsOK(res2)) {
17697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17698 }
17699 arg2 = reinterpret_cast< char * >(buf2);
17700 ecode3 = SWIG_AsVal_double(args(2), &val3);
17701 if (!SWIG_IsOK(ecode3)) {
17702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17703 }
17704 arg3 = static_cast< PLFLT >(val3);
17705 ecode4 = SWIG_AsVal_int(args(3), &val4);
17706 if (!SWIG_IsOK(ecode4)) {
17707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17708 }
17709 arg4 = static_cast< PLINT >(val4);
17710 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17711 if (!SWIG_IsOK(res5)) {
17712 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17713 }
17714 arg5 = reinterpret_cast< char * >(buf5);
17715 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17716 if (!SWIG_IsOK(res6)) {
17717 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17718 }
17719 arg6 = reinterpret_cast< char * >(buf6);
17720 ecode7 = SWIG_AsVal_double(args(6), &val7);
17721 if (!SWIG_IsOK(ecode7)) {
17722 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17723 }
17724 arg7 = static_cast< PLFLT >(val7);
17725 ecode8 = SWIG_AsVal_int(args(7), &val8);
17726 if (!SWIG_IsOK(ecode8)) {
17727 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17728 }
17729 arg8 = static_cast< PLINT >(val8);
17730 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17731 if (!SWIG_IsOK(res9)) {
17732 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17733 }
17734 arg9 = reinterpret_cast< char * >(buf9);
17735 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17736 if (!SWIG_IsOK(res10)) {
17737 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17738 }
17739 arg10 = reinterpret_cast< char * >(buf10);
17740 ecode11 = SWIG_AsVal_double(args(10), &val11);
17741 if (!SWIG_IsOK(ecode11)) {
17742 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17743 }
17744 arg11 = static_cast< PLFLT >(val11);
17745 ecode12 = SWIG_AsVal_int(args(11), &val12);
17746 if (!SWIG_IsOK(ecode12)) {
17747 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17748 }
17749 arg12 = static_cast< PLINT >(val12);
17750 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);
17751 _outv = octave_value();
17752 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17753 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17754 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17755 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17756 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17757 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17758 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17759 return _out;
17760 fail:
17761 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17762 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17763 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17764 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17765 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17766 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17767 return octave_value_list();
17768 }
17769 catch(...) {
17770 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17771 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17772 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17773 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17774 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17775 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17776 throw;
17777 }
17778}
17779
17780
17782 PLFLT arg1 ;
17783 PLFLT arg2 ;
17784 PLFLT *arg3 = (PLFLT *) 0 ;
17785 PLFLT *arg4 = (PLFLT *) 0 ;
17786 PLINT *arg5 = (PLINT *) 0 ;
17787 double val1 ;
17788 int ecode1 = 0 ;
17789 double val2 ;
17790 int ecode2 = 0 ;
17791 PLFLT temp3 ;
17792 int res3 = SWIG_TMPOBJ ;
17793 PLFLT temp4 ;
17794 int res4 = SWIG_TMPOBJ ;
17795 PLINT temp5 ;
17796 int res5 = SWIG_TMPOBJ ;
17797 octave_value_list _out;
17798 octave_value_list *_outp=&_out;
17799 octave_value _outv;
17800
17801 try {
17802 arg3 = &temp3;
17803 arg4 = &temp4;
17804 arg5 = &temp5;
17805 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17806 SWIG_fail;
17807 }
17808 ecode1 = SWIG_AsVal_double(args(0), &val1);
17809 if (!SWIG_IsOK(ecode1)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17811 }
17812 arg1 = static_cast< PLFLT >(val1);
17813 ecode2 = SWIG_AsVal_double(args(1), &val2);
17814 if (!SWIG_IsOK(ecode2)) {
17815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17816 }
17817 arg2 = static_cast< PLFLT >(val2);
17818 plcalc_world(arg1,arg2,arg3,arg4,arg5);
17819 _outv = octave_value();
17820 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17821 if (SWIG_IsTmpObj(res3)) {
17822 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17823 } else {
17824 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17825 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17826 }
17827 if (SWIG_IsTmpObj(res4)) {
17828 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17829 } else {
17830 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17831 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17832 }
17833 if (SWIG_IsTmpObj(res5)) {
17834 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17835 } else {
17836 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17837 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17838 }
17839 return _out;
17840 fail:
17841 return octave_value_list();
17842 }
17843 catch(...) {
17844 throw;
17845 }
17846}
17847
17848
17850 octave_value_list _out;
17851 octave_value_list *_outp=&_out;
17852 octave_value _outv;
17853
17854 try {
17855 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17856 SWIG_fail;
17857 }
17858 plclear();
17859 _outv = octave_value();
17860 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17861 return _out;
17862 fail:
17863 return octave_value_list();
17864 }
17865 catch(...) {
17866 throw;
17867 }
17868}
17869
17870
17872 PLINT arg1 ;
17873 int val1 ;
17874 int ecode1 = 0 ;
17875 octave_value_list _out;
17876 octave_value_list *_outp=&_out;
17877 octave_value _outv;
17878
17879 try {
17880 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17881 SWIG_fail;
17882 }
17883 ecode1 = SWIG_AsVal_int(args(0), &val1);
17884 if (!SWIG_IsOK(ecode1)) {
17885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17886 }
17887 arg1 = static_cast< PLINT >(val1);
17888 plcol0(arg1);
17889 _outv = octave_value();
17890 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17891 return _out;
17892 fail:
17893 return octave_value_list();
17894 }
17895 catch(...) {
17896 throw;
17897 }
17898}
17899
17900
17902 PLFLT arg1 ;
17903 double val1 ;
17904 int ecode1 = 0 ;
17905 octave_value_list _out;
17906 octave_value_list *_outp=&_out;
17907 octave_value _outv;
17908
17909 try {
17910 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17911 SWIG_fail;
17912 }
17913 ecode1 = SWIG_AsVal_double(args(0), &val1);
17914 if (!SWIG_IsOK(ecode1)) {
17915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17916 }
17917 arg1 = static_cast< PLFLT >(val1);
17918 plcol1(arg1);
17919 _outv = octave_value();
17920 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17921 return _out;
17922 fail:
17923 return octave_value_list();
17924 }
17925 catch(...) {
17926 throw;
17927 }
17928}
17929
17930
17932 PLFLT arg1 ;
17933 PLFLT arg2 ;
17934 PLFLT arg3 ;
17935 PLINT arg4 ;
17936 PLBOOL arg5 ;
17937 PLINT arg6 ;
17938 PLINT arg7 ;
17939 PLINT arg8 ;
17940 PLINT arg9 ;
17941 PLINT arg10 ;
17942 PLFLT arg11 ;
17943 double val1 ;
17944 int ecode1 = 0 ;
17945 double val2 ;
17946 int ecode2 = 0 ;
17947 double val3 ;
17948 int ecode3 = 0 ;
17949 int val4 ;
17950 int ecode4 = 0 ;
17951 int val5 ;
17952 int ecode5 = 0 ;
17953 int val6 ;
17954 int ecode6 = 0 ;
17955 int val7 ;
17956 int ecode7 = 0 ;
17957 int val8 ;
17958 int ecode8 = 0 ;
17959 int val9 ;
17960 int ecode9 = 0 ;
17961 int val10 ;
17962 int ecode10 = 0 ;
17963 double val11 ;
17964 int ecode11 = 0 ;
17965 octave_value_list _out;
17966 octave_value_list *_outp=&_out;
17967 octave_value _outv;
17968
17969 try {
17970 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17971 SWIG_fail;
17972 }
17973 ecode1 = SWIG_AsVal_double(args(0), &val1);
17974 if (!SWIG_IsOK(ecode1)) {
17975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17976 }
17977 arg1 = static_cast< PLFLT >(val1);
17978 ecode2 = SWIG_AsVal_double(args(1), &val2);
17979 if (!SWIG_IsOK(ecode2)) {
17980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17981 }
17982 arg2 = static_cast< PLFLT >(val2);
17983 ecode3 = SWIG_AsVal_double(args(2), &val3);
17984 if (!SWIG_IsOK(ecode3)) {
17985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17986 }
17987 arg3 = static_cast< PLFLT >(val3);
17988 ecode4 = SWIG_AsVal_int(args(3), &val4);
17989 if (!SWIG_IsOK(ecode4)) {
17990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17991 }
17992 arg4 = static_cast< PLINT >(val4);
17993 ecode5 = SWIG_AsVal_int(args(4), &val5);
17994 if (!SWIG_IsOK(ecode5)) {
17995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17996 }
17997 arg5 = static_cast< PLBOOL >(val5);
17998 ecode6 = SWIG_AsVal_int(args(5), &val6);
17999 if (!SWIG_IsOK(ecode6)) {
18000 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
18001 }
18002 arg6 = static_cast< PLINT >(val6);
18003 ecode7 = SWIG_AsVal_int(args(6), &val7);
18004 if (!SWIG_IsOK(ecode7)) {
18005 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
18006 }
18007 arg7 = static_cast< PLINT >(val7);
18008 ecode8 = SWIG_AsVal_int(args(7), &val8);
18009 if (!SWIG_IsOK(ecode8)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
18011 }
18012 arg8 = static_cast< PLINT >(val8);
18013 ecode9 = SWIG_AsVal_int(args(8), &val9);
18014 if (!SWIG_IsOK(ecode9)) {
18015 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
18016 }
18017 arg9 = static_cast< PLINT >(val9);
18018 ecode10 = SWIG_AsVal_int(args(9), &val10);
18019 if (!SWIG_IsOK(ecode10)) {
18020 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
18021 }
18022 arg10 = static_cast< PLINT >(val10);
18023 ecode11 = SWIG_AsVal_double(args(10), &val11);
18024 if (!SWIG_IsOK(ecode11)) {
18025 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
18026 }
18027 arg11 = static_cast< PLFLT >(val11);
18028 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18029 _outv = octave_value();
18030 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18031 return _out;
18032 fail:
18033 return octave_value_list();
18034 }
18035 catch(...) {
18036 throw;
18037 }
18038}
18039
18040
18042 PLINT arg1 ;
18043 PLINT arg2 ;
18044 PLINT arg3 ;
18045 PLINT arg4 ;
18046 PLINT arg5 ;
18047 PLFLT arg6 ;
18048 PLFLT *arg7 = (PLFLT *) 0 ;
18049 int val1 ;
18050 int ecode1 = 0 ;
18051 int val2 ;
18052 int ecode2 = 0 ;
18053 int val3 ;
18054 int ecode3 = 0 ;
18055 int val4 ;
18056 int ecode4 = 0 ;
18057 int val5 ;
18058 int ecode5 = 0 ;
18059 double val6 ;
18060 int ecode6 = 0 ;
18061 PLFLT temp7 ;
18062 int res7 = SWIG_TMPOBJ ;
18063 octave_value_list _out;
18064 octave_value_list *_outp=&_out;
18065 octave_value _outv;
18066
18067 try {
18068 arg7 = &temp7;
18069 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18070 SWIG_fail;
18071 }
18072 ecode1 = SWIG_AsVal_int(args(0), &val1);
18073 if (!SWIG_IsOK(ecode1)) {
18074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18075 }
18076 arg1 = static_cast< PLINT >(val1);
18077 ecode2 = SWIG_AsVal_int(args(1), &val2);
18078 if (!SWIG_IsOK(ecode2)) {
18079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18080 }
18081 arg2 = static_cast< PLINT >(val2);
18082 ecode3 = SWIG_AsVal_int(args(2), &val3);
18083 if (!SWIG_IsOK(ecode3)) {
18084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18085 }
18086 arg3 = static_cast< PLINT >(val3);
18087 ecode4 = SWIG_AsVal_int(args(3), &val4);
18088 if (!SWIG_IsOK(ecode4)) {
18089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18090 }
18091 arg4 = static_cast< PLINT >(val4);
18092 ecode5 = SWIG_AsVal_int(args(4), &val5);
18093 if (!SWIG_IsOK(ecode5)) {
18094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18095 }
18096 arg5 = static_cast< PLINT >(val5);
18097 ecode6 = SWIG_AsVal_double(args(5), &val6);
18098 if (!SWIG_IsOK(ecode6)) {
18099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18100 }
18101 arg6 = static_cast< PLFLT >(val6);
18102 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18103 _outv = octave_value();
18104 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18105 if (SWIG_IsTmpObj(res7)) {
18106 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18107 } else {
18108 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18109 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18110 }
18111 return _out;
18112 fail:
18113 return octave_value_list();
18114 }
18115 catch(...) {
18116 throw;
18117 }
18118}
18119
18120
18122 PLINT arg1 ;
18123 PLBOOL arg2 ;
18124 int val1 ;
18125 int ecode1 = 0 ;
18126 int val2 ;
18127 int ecode2 = 0 ;
18128 octave_value_list _out;
18129 octave_value_list *_outp=&_out;
18130 octave_value _outv;
18131
18132 try {
18133 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18134 SWIG_fail;
18135 }
18136 ecode1 = SWIG_AsVal_int(args(0), &val1);
18137 if (!SWIG_IsOK(ecode1)) {
18138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18139 }
18140 arg1 = static_cast< PLINT >(val1);
18141 ecode2 = SWIG_AsVal_int(args(1), &val2);
18142 if (!SWIG_IsOK(ecode2)) {
18143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18144 }
18145 arg2 = static_cast< PLBOOL >(val2);
18146 plcpstrm(arg1,arg2);
18147 _outv = octave_value();
18148 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18149 return _out;
18150 fail:
18151 return octave_value_list();
18152 }
18153 catch(...) {
18154 throw;
18155 }
18156}
18157
18158
18160 octave_value_list _out;
18161 octave_value_list *_outp=&_out;
18162 octave_value _outv;
18163
18164 try {
18165 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18166 SWIG_fail;
18167 }
18168 plend();
18169 _outv = octave_value();
18170 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18171 return _out;
18172 fail:
18173 return octave_value_list();
18174 }
18175 catch(...) {
18176 throw;
18177 }
18178}
18179
18180
18182 octave_value_list _out;
18183 octave_value_list *_outp=&_out;
18184 octave_value _outv;
18185
18186 try {
18187 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18188 SWIG_fail;
18189 }
18190 plend1();
18191 _outv = octave_value();
18192 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18193 return _out;
18194 fail:
18195 return octave_value_list();
18196 }
18197 catch(...) {
18198 throw;
18199 }
18200}
18201
18202
18204 PLFLT arg1 ;
18205 PLFLT arg2 ;
18206 PLFLT arg3 ;
18207 PLFLT arg4 ;
18208 PLINT arg5 ;
18209 PLINT arg6 ;
18210 double val1 ;
18211 int ecode1 = 0 ;
18212 double val2 ;
18213 int ecode2 = 0 ;
18214 double val3 ;
18215 int ecode3 = 0 ;
18216 double val4 ;
18217 int ecode4 = 0 ;
18218 int val5 ;
18219 int ecode5 = 0 ;
18220 int val6 ;
18221 int ecode6 = 0 ;
18222 octave_value_list _out;
18223 octave_value_list *_outp=&_out;
18224 octave_value _outv;
18225
18226 try {
18227 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18228 SWIG_fail;
18229 }
18230 ecode1 = SWIG_AsVal_double(args(0), &val1);
18231 if (!SWIG_IsOK(ecode1)) {
18232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18233 }
18234 arg1 = static_cast< PLFLT >(val1);
18235 ecode2 = SWIG_AsVal_double(args(1), &val2);
18236 if (!SWIG_IsOK(ecode2)) {
18237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18238 }
18239 arg2 = static_cast< PLFLT >(val2);
18240 ecode3 = SWIG_AsVal_double(args(2), &val3);
18241 if (!SWIG_IsOK(ecode3)) {
18242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18243 }
18244 arg3 = static_cast< PLFLT >(val3);
18245 ecode4 = SWIG_AsVal_double(args(3), &val4);
18246 if (!SWIG_IsOK(ecode4)) {
18247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18248 }
18249 arg4 = static_cast< PLFLT >(val4);
18250 ecode5 = SWIG_AsVal_int(args(4), &val5);
18251 if (!SWIG_IsOK(ecode5)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18253 }
18254 arg5 = static_cast< PLINT >(val5);
18255 ecode6 = SWIG_AsVal_int(args(5), &val6);
18256 if (!SWIG_IsOK(ecode6)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18258 }
18259 arg6 = static_cast< PLINT >(val6);
18260 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18261 _outv = octave_value();
18262 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18263 return _out;
18264 fail:
18265 return octave_value_list();
18266 }
18267 catch(...) {
18268 throw;
18269 }
18270}
18271
18272
18274 PLFLT arg1 ;
18275 PLFLT arg2 ;
18276 PLFLT arg3 ;
18277 PLFLT arg4 ;
18278 PLINT arg5 ;
18279 PLINT arg6 ;
18280 double val1 ;
18281 int ecode1 = 0 ;
18282 double val2 ;
18283 int ecode2 = 0 ;
18284 double val3 ;
18285 int ecode3 = 0 ;
18286 double val4 ;
18287 int ecode4 = 0 ;
18288 int val5 ;
18289 int ecode5 = 0 ;
18290 int val6 ;
18291 int ecode6 = 0 ;
18292 octave_value_list _out;
18293 octave_value_list *_outp=&_out;
18294 octave_value _outv;
18295
18296 try {
18297 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18298 SWIG_fail;
18299 }
18300 ecode1 = SWIG_AsVal_double(args(0), &val1);
18301 if (!SWIG_IsOK(ecode1)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18303 }
18304 arg1 = static_cast< PLFLT >(val1);
18305 ecode2 = SWIG_AsVal_double(args(1), &val2);
18306 if (!SWIG_IsOK(ecode2)) {
18307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18308 }
18309 arg2 = static_cast< PLFLT >(val2);
18310 ecode3 = SWIG_AsVal_double(args(2), &val3);
18311 if (!SWIG_IsOK(ecode3)) {
18312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18313 }
18314 arg3 = static_cast< PLFLT >(val3);
18315 ecode4 = SWIG_AsVal_double(args(3), &val4);
18316 if (!SWIG_IsOK(ecode4)) {
18317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18318 }
18319 arg4 = static_cast< PLFLT >(val4);
18320 ecode5 = SWIG_AsVal_int(args(4), &val5);
18321 if (!SWIG_IsOK(ecode5)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18323 }
18324 arg5 = static_cast< PLINT >(val5);
18325 ecode6 = SWIG_AsVal_int(args(5), &val6);
18326 if (!SWIG_IsOK(ecode6)) {
18327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18328 }
18329 arg6 = static_cast< PLINT >(val6);
18330 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18331 _outv = octave_value();
18332 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18333 return _out;
18334 fail:
18335 return octave_value_list();
18336 }
18337 catch(...) {
18338 throw;
18339 }
18340}
18341
18342
18344 octave_value_list _out;
18345 octave_value_list *_outp=&_out;
18346 octave_value _outv;
18347
18348 try {
18349 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18350 SWIG_fail;
18351 }
18352 pleop();
18353 _outv = octave_value();
18354 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18355 return _out;
18356 fail:
18357 return octave_value_list();
18358 }
18359 catch(...) {
18360 throw;
18361 }
18362}
18363
18364
18366 PLINT arg1 ;
18367 PLFLT *arg2 = (PLFLT *) 0 ;
18368 PLFLT *arg3 = (PLFLT *) 0 ;
18369 PLFLT *arg4 = (PLFLT *) 0 ;
18370 Matrix temp1 ;
18371 Matrix temp3 ;
18372 Matrix temp4 ;
18373 octave_value_list _out;
18374 octave_value_list *_outp=&_out;
18375 octave_value _outv;
18376
18377 try {
18378 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18379 SWIG_fail;
18380 }
18381 {
18382 if ( _n_dims( args(0) ) > 1 )
18383 {
18384 error( "argument must be a scalar or vector" ); SWIG_fail;
18385 }
18386 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18387 temp1 = args(0).matrix_value();
18388 arg2 = &temp1( 0, 0 );
18389 }
18390 {
18391 if ( _n_dims( args(1) ) > 1 )
18392 {
18393 error( "argument must be a scalar or vector" ); SWIG_fail;
18394 }
18395 if ( _dim( args(1), 0 ) != Alen )
18396 {
18397 error( "argument vectors must be same length" ); SWIG_fail;
18398 }
18399 temp3 = args(1).matrix_value();
18400 arg3 = &temp3( 0, 0 );
18401 }
18402 {
18403 if ( _n_dims( args(2) ) > 1 )
18404 {
18405 error( "argument must be a scalar or vector" ); SWIG_fail;
18406 }
18407 if ( _dim( args(2), 0 ) != Alen )
18408 {
18409 error( "argument vectors must be same length" ); SWIG_fail;
18410 }
18411 temp4 = args(2).matrix_value();
18412 arg4 = &temp4( 0, 0 );
18413 }
18414 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18415 _outv = octave_value();
18416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18417 {
18418
18419 }
18420 {
18421
18422 }
18423 {
18424
18425 }
18426 return _out;
18427 fail:
18428 {
18429
18430 }
18431 {
18432
18433 }
18434 {
18435
18436 }
18437 return octave_value_list();
18438 }
18439 catch(...) {
18440 {
18441
18442 }
18443 {
18444
18445 }
18446 {
18447
18448 }
18449 throw;
18450 }
18451}
18452
18453
18455 PLINT arg1 ;
18456 PLFLT *arg2 = (PLFLT *) 0 ;
18457 PLFLT *arg3 = (PLFLT *) 0 ;
18458 PLFLT *arg4 = (PLFLT *) 0 ;
18459 Matrix temp1 ;
18460 Matrix temp3 ;
18461 Matrix temp4 ;
18462 octave_value_list _out;
18463 octave_value_list *_outp=&_out;
18464 octave_value _outv;
18465
18466 try {
18467 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18468 SWIG_fail;
18469 }
18470 {
18471 if ( _n_dims( args(0) ) > 1 )
18472 {
18473 error( "argument must be a scalar or vector" ); SWIG_fail;
18474 }
18475 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18476 temp1 = args(0).matrix_value();
18477 arg2 = &temp1( 0, 0 );
18478 }
18479 {
18480 if ( _n_dims( args(1) ) > 1 )
18481 {
18482 error( "argument must be a scalar or vector" ); SWIG_fail;
18483 }
18484 if ( _dim( args(1), 0 ) != Alen )
18485 {
18486 error( "argument vectors must be same length" ); SWIG_fail;
18487 }
18488 temp3 = args(1).matrix_value();
18489 arg3 = &temp3( 0, 0 );
18490 }
18491 {
18492 if ( _n_dims( args(2) ) > 1 )
18493 {
18494 error( "argument must be a scalar or vector" ); SWIG_fail;
18495 }
18496 if ( _dim( args(2), 0 ) != Alen )
18497 {
18498 error( "argument vectors must be same length" ); SWIG_fail;
18499 }
18500 temp4 = args(2).matrix_value();
18501 arg4 = &temp4( 0, 0 );
18502 }
18503 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18504 _outv = octave_value();
18505 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18506 {
18507
18508 }
18509 {
18510
18511 }
18512 {
18513
18514 }
18515 return _out;
18516 fail:
18517 {
18518
18519 }
18520 {
18521
18522 }
18523 {
18524
18525 }
18526 return octave_value_list();
18527 }
18528 catch(...) {
18529 {
18530
18531 }
18532 {
18533
18534 }
18535 {
18536
18537 }
18538 throw;
18539 }
18540}
18541
18542
18544 octave_value_list _out;
18545 octave_value_list *_outp=&_out;
18546 octave_value _outv;
18547
18548 try {
18549 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18550 SWIG_fail;
18551 }
18552 plfamadv();
18553 _outv = octave_value();
18554 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18555 return _out;
18556 fail:
18557 return octave_value_list();
18558 }
18559 catch(...) {
18560 throw;
18561 }
18562}
18563
18564
18566 PLINT arg1 ;
18567 PLFLT *arg2 = (PLFLT *) 0 ;
18568 PLFLT *arg3 = (PLFLT *) 0 ;
18569 Matrix temp1 ;
18570 Matrix temp3 ;
18571 octave_value_list _out;
18572 octave_value_list *_outp=&_out;
18573 octave_value _outv;
18574
18575 try {
18576 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18577 SWIG_fail;
18578 }
18579 {
18580 if ( _n_dims( args(0) ) > 1 )
18581 {
18582 error( "argument must be a scalar or vector" ); SWIG_fail;
18583 }
18584 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18585 temp1 = args(0).matrix_value();
18586 arg2 = &temp1( 0, 0 );
18587 }
18588 {
18589 if ( _n_dims( args(1) ) > 1 )
18590 {
18591 error( "argument must be a scalar or vector" ); SWIG_fail;
18592 }
18593 if ( _dim( args(1), 0 ) != Alen )
18594 {
18595 error( "argument vectors must be same length" ); SWIG_fail;
18596 }
18597 temp3 = args(1).matrix_value();
18598 arg3 = &temp3( 0, 0 );
18599 }
18600 plfill(arg1,(double const *)arg2,(double const *)arg3);
18601 _outv = octave_value();
18602 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18603 {
18604
18605 }
18606 {
18607
18608 }
18609 return _out;
18610 fail:
18611 {
18612
18613 }
18614 {
18615
18616 }
18617 return octave_value_list();
18618 }
18619 catch(...) {
18620 {
18621
18622 }
18623 {
18624
18625 }
18626 throw;
18627 }
18628}
18629
18630
18632 PLINT arg1 ;
18633 PLFLT *arg2 = (PLFLT *) 0 ;
18634 PLFLT *arg3 = (PLFLT *) 0 ;
18635 PLFLT *arg4 = (PLFLT *) 0 ;
18636 Matrix temp1 ;
18637 Matrix temp3 ;
18638 Matrix temp4 ;
18639 octave_value_list _out;
18640 octave_value_list *_outp=&_out;
18641 octave_value _outv;
18642
18643 try {
18644 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18645 SWIG_fail;
18646 }
18647 {
18648 if ( _n_dims( args(0) ) > 1 )
18649 {
18650 error( "argument must be a scalar or vector" ); SWIG_fail;
18651 }
18652 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18653 temp1 = args(0).matrix_value();
18654 arg2 = &temp1( 0, 0 );
18655 }
18656 {
18657 if ( _n_dims( args(1) ) > 1 )
18658 {
18659 error( "argument must be a scalar or vector" ); SWIG_fail;
18660 }
18661 if ( _dim( args(1), 0 ) != Alen )
18662 {
18663 error( "argument vectors must be same length" ); SWIG_fail;
18664 }
18665 temp3 = args(1).matrix_value();
18666 arg3 = &temp3( 0, 0 );
18667 }
18668 {
18669 if ( _n_dims( args(2) ) > 1 )
18670 {
18671 error( "argument must be a scalar or vector" ); SWIG_fail;
18672 }
18673 if ( _dim( args(2), 0 ) != Alen )
18674 {
18675 error( "argument vectors must be same length" ); SWIG_fail;
18676 }
18677 temp4 = args(2).matrix_value();
18678 arg4 = &temp4( 0, 0 );
18679 }
18680 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18681 _outv = octave_value();
18682 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18683 {
18684
18685 }
18686 {
18687
18688 }
18689 {
18690
18691 }
18692 return _out;
18693 fail:
18694 {
18695
18696 }
18697 {
18698
18699 }
18700 {
18701
18702 }
18703 return octave_value_list();
18704 }
18705 catch(...) {
18706 {
18707
18708 }
18709 {
18710
18711 }
18712 {
18713
18714 }
18715 throw;
18716 }
18717}
18718
18719
18721 PLINT arg1 ;
18722 PLFLT *arg2 = (PLFLT *) 0 ;
18723 PLFLT *arg3 = (PLFLT *) 0 ;
18724 PLFLT arg4 ;
18725 Matrix temp1 ;
18726 Matrix temp3 ;
18727 double val4 ;
18728 int ecode4 = 0 ;
18729 octave_value_list _out;
18730 octave_value_list *_outp=&_out;
18731 octave_value _outv;
18732
18733 try {
18734 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18735 SWIG_fail;
18736 }
18737 {
18738 if ( _n_dims( args(0) ) > 1 )
18739 {
18740 error( "argument must be a scalar or vector" ); SWIG_fail;
18741 }
18742 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18743 temp1 = args(0).matrix_value();
18744 arg2 = &temp1( 0, 0 );
18745 }
18746 {
18747 if ( _n_dims( args(1) ) > 1 )
18748 {
18749 error( "argument must be a scalar or vector" ); SWIG_fail;
18750 }
18751 if ( _dim( args(1), 0 ) != Alen )
18752 {
18753 error( "argument vectors must be same length" ); SWIG_fail;
18754 }
18755 temp3 = args(1).matrix_value();
18756 arg3 = &temp3( 0, 0 );
18757 }
18758 ecode4 = SWIG_AsVal_double(args(2), &val4);
18759 if (!SWIG_IsOK(ecode4)) {
18760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18761 }
18762 arg4 = static_cast< PLFLT >(val4);
18763 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18764 _outv = octave_value();
18765 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18766 {
18767
18768 }
18769 {
18770
18771 }
18772 return _out;
18773 fail:
18774 {
18775
18776 }
18777 {
18778
18779 }
18780 return octave_value_list();
18781 }
18782 catch(...) {
18783 {
18784
18785 }
18786 {
18787
18788 }
18789 throw;
18790 }
18791}
18792
18793
18795 octave_value_list _out;
18796 octave_value_list *_outp=&_out;
18797 octave_value _outv;
18798
18799 try {
18800 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18801 SWIG_fail;
18802 }
18803 plflush();
18804 _outv = octave_value();
18805 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18806 return _out;
18807 fail:
18808 return octave_value_list();
18809 }
18810 catch(...) {
18811 throw;
18812 }
18813}
18814
18815
18817 PLINT arg1 ;
18818 int val1 ;
18819 int ecode1 = 0 ;
18820 octave_value_list _out;
18821 octave_value_list *_outp=&_out;
18822 octave_value _outv;
18823
18824 try {
18825 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18826 SWIG_fail;
18827 }
18828 ecode1 = SWIG_AsVal_int(args(0), &val1);
18829 if (!SWIG_IsOK(ecode1)) {
18830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18831 }
18832 arg1 = static_cast< PLINT >(val1);
18833 plfont(arg1);
18834 _outv = octave_value();
18835 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18836 return _out;
18837 fail:
18838 return octave_value_list();
18839 }
18840 catch(...) {
18841 throw;
18842 }
18843}
18844
18845
18847 PLINT arg1 ;
18848 int val1 ;
18849 int ecode1 = 0 ;
18850 octave_value_list _out;
18851 octave_value_list *_outp=&_out;
18852 octave_value _outv;
18853
18854 try {
18855 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18856 SWIG_fail;
18857 }
18858 ecode1 = SWIG_AsVal_int(args(0), &val1);
18859 if (!SWIG_IsOK(ecode1)) {
18860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18861 }
18862 arg1 = static_cast< PLINT >(val1);
18863 plfontld(arg1);
18864 _outv = octave_value();
18865 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18866 return _out;
18867 fail:
18868 return octave_value_list();
18869 }
18870 catch(...) {
18871 throw;
18872 }
18873}
18874
18875
18877 PLFLT *arg1 = (PLFLT *) 0 ;
18878 PLFLT *arg2 = (PLFLT *) 0 ;
18879 PLFLT temp1 ;
18880 int res1 = SWIG_TMPOBJ ;
18881 PLFLT temp2 ;
18882 int res2 = SWIG_TMPOBJ ;
18883 octave_value_list _out;
18884 octave_value_list *_outp=&_out;
18885 octave_value _outv;
18886
18887 try {
18888 arg1 = &temp1;
18889 arg2 = &temp2;
18890 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18891 SWIG_fail;
18892 }
18893 plgchr(arg1,arg2);
18894 _outv = octave_value();
18895 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18896 if (SWIG_IsTmpObj(res1)) {
18897 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18898 } else {
18899 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18900 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18901 }
18902 if (SWIG_IsTmpObj(res2)) {
18903 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18904 } else {
18905 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18906 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18907 }
18908 return _out;
18909 fail:
18910 return octave_value_list();
18911 }
18912 catch(...) {
18913 throw;
18914 }
18915}
18916
18917
18919 PLINT arg1 ;
18920 PLINT *arg2 = (PLINT *) 0 ;
18921 PLINT *arg3 = (PLINT *) 0 ;
18922 PLINT *arg4 = (PLINT *) 0 ;
18923 int val1 ;
18924 int ecode1 = 0 ;
18925 PLINT temp2 ;
18926 int res2 = SWIG_TMPOBJ ;
18927 PLINT temp3 ;
18928 int res3 = SWIG_TMPOBJ ;
18929 PLINT temp4 ;
18930 int res4 = SWIG_TMPOBJ ;
18931 octave_value_list _out;
18932 octave_value_list *_outp=&_out;
18933 octave_value _outv;
18934
18935 try {
18936 arg2 = &temp2;
18937 arg3 = &temp3;
18938 arg4 = &temp4;
18939 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
18940 SWIG_fail;
18941 }
18942 ecode1 = SWIG_AsVal_int(args(0), &val1);
18943 if (!SWIG_IsOK(ecode1)) {
18944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
18945 }
18946 arg1 = static_cast< PLINT >(val1);
18947 plgcol0(arg1,arg2,arg3,arg4);
18948 _outv = octave_value();
18949 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18950 if (SWIG_IsTmpObj(res2)) {
18951 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18952 } else {
18953 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18954 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18955 }
18956 if (SWIG_IsTmpObj(res3)) {
18957 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18958 } else {
18959 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18960 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18961 }
18962 if (SWIG_IsTmpObj(res4)) {
18963 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18964 } else {
18965 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18966 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18967 }
18968 return _out;
18969 fail:
18970 return octave_value_list();
18971 }
18972 catch(...) {
18973 throw;
18974 }
18975}
18976
18977
18979 PLINT arg1 ;
18980 PLINT *arg2 = (PLINT *) 0 ;
18981 PLINT *arg3 = (PLINT *) 0 ;
18982 PLINT *arg4 = (PLINT *) 0 ;
18983 PLFLT *arg5 = (PLFLT *) 0 ;
18984 int val1 ;
18985 int ecode1 = 0 ;
18986 PLINT temp2 ;
18987 int res2 = SWIG_TMPOBJ ;
18988 PLINT temp3 ;
18989 int res3 = SWIG_TMPOBJ ;
18990 PLINT temp4 ;
18991 int res4 = SWIG_TMPOBJ ;
18992 PLFLT temp5 ;
18993 int res5 = SWIG_TMPOBJ ;
18994 octave_value_list _out;
18995 octave_value_list *_outp=&_out;
18996 octave_value _outv;
18997
18998 try {
18999 arg2 = &temp2;
19000 arg3 = &temp3;
19001 arg4 = &temp4;
19002 arg5 = &temp5;
19003 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
19004 SWIG_fail;
19005 }
19006 ecode1 = SWIG_AsVal_int(args(0), &val1);
19007 if (!SWIG_IsOK(ecode1)) {
19008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
19009 }
19010 arg1 = static_cast< PLINT >(val1);
19011 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19012 _outv = octave_value();
19013 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19014 if (SWIG_IsTmpObj(res2)) {
19015 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19016 } else {
19017 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19018 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19019 }
19020 if (SWIG_IsTmpObj(res3)) {
19021 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19022 } else {
19023 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19024 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19025 }
19026 if (SWIG_IsTmpObj(res4)) {
19027 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19028 } else {
19029 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19030 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19031 }
19032 if (SWIG_IsTmpObj(res5)) {
19033 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19034 } else {
19035 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19036 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19037 }
19038 return _out;
19039 fail:
19040 return octave_value_list();
19041 }
19042 catch(...) {
19043 throw;
19044 }
19045}
19046
19047
19049 PLINT *arg1 = (PLINT *) 0 ;
19050 PLINT *arg2 = (PLINT *) 0 ;
19051 PLINT *arg3 = (PLINT *) 0 ;
19052 PLINT temp1 ;
19053 int res1 = SWIG_TMPOBJ ;
19054 PLINT temp2 ;
19055 int res2 = SWIG_TMPOBJ ;
19056 PLINT temp3 ;
19057 int res3 = SWIG_TMPOBJ ;
19058 octave_value_list _out;
19059 octave_value_list *_outp=&_out;
19060 octave_value _outv;
19061
19062 try {
19063 arg1 = &temp1;
19064 arg2 = &temp2;
19065 arg3 = &temp3;
19066 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19067 SWIG_fail;
19068 }
19069 plgcolbg(arg1,arg2,arg3);
19070 _outv = octave_value();
19071 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19072 if (SWIG_IsTmpObj(res1)) {
19073 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19074 } else {
19075 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19076 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19077 }
19078 if (SWIG_IsTmpObj(res2)) {
19079 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19080 } else {
19081 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19082 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19083 }
19084 if (SWIG_IsTmpObj(res3)) {
19085 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19086 } else {
19087 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19088 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19089 }
19090 return _out;
19091 fail:
19092 return octave_value_list();
19093 }
19094 catch(...) {
19095 throw;
19096 }
19097}
19098
19099
19101 PLINT *arg1 = (PLINT *) 0 ;
19102 PLINT *arg2 = (PLINT *) 0 ;
19103 PLINT *arg3 = (PLINT *) 0 ;
19104 PLFLT *arg4 = (PLFLT *) 0 ;
19105 PLINT temp1 ;
19106 int res1 = SWIG_TMPOBJ ;
19107 PLINT temp2 ;
19108 int res2 = SWIG_TMPOBJ ;
19109 PLINT temp3 ;
19110 int res3 = SWIG_TMPOBJ ;
19111 PLFLT temp4 ;
19112 int res4 = SWIG_TMPOBJ ;
19113 octave_value_list _out;
19114 octave_value_list *_outp=&_out;
19115 octave_value _outv;
19116
19117 try {
19118 arg1 = &temp1;
19119 arg2 = &temp2;
19120 arg3 = &temp3;
19121 arg4 = &temp4;
19122 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19123 SWIG_fail;
19124 }
19125 plgcolbga(arg1,arg2,arg3,arg4);
19126 _outv = octave_value();
19127 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19128 if (SWIG_IsTmpObj(res1)) {
19129 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19130 } else {
19131 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19132 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19133 }
19134 if (SWIG_IsTmpObj(res2)) {
19135 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19136 } else {
19137 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19138 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19139 }
19140 if (SWIG_IsTmpObj(res3)) {
19141 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19142 } else {
19143 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19144 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19145 }
19146 if (SWIG_IsTmpObj(res4)) {
19147 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19148 } else {
19149 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19150 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19151 }
19152 return _out;
19153 fail:
19154 return octave_value_list();
19155 }
19156 catch(...) {
19157 throw;
19158 }
19159}
19160
19161
19162SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
19163 PLINT *arg1 = (PLINT *) 0 ;
19164 PLINT temp1 ;
19165 int res1 = SWIG_TMPOBJ ;
19166 octave_value_list _out;
19167 octave_value_list *_outp=&_out;
19168 octave_value _outv;
19169
19170 try {
19171 arg1 = &temp1;
19172 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19173 SWIG_fail;
19174 }
19175 plgcompression(arg1);
19176 _outv = octave_value();
19177 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19178 if (SWIG_IsTmpObj(res1)) {
19179 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19180 } else {
19181 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19182 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19183 }
19184 return _out;
19185 fail:
19186 return octave_value_list();
19187 }
19188 catch(...) {
19189 throw;
19190 }
19191}
19192
19193
19195 char *arg1 = (char *) 0 ;
19196 char local_string1[80] ;
19197 size_t local_string_length1 ;
19198 charMatrix local_charMatrix1 ;
19199 octave_value_list retval1 ;
19200 octave_value_list _out;
19201 octave_value_list *_outp=&_out;
19202 octave_value _outv;
19203
19204 try {
19205 {
19206 arg1 = local_string1;
19207 }
19208 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19209 SWIG_fail;
19210 }
19211 plgdev(arg1);
19212 _outv = octave_value();
19213 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19214 {
19215 local_string_length1 = strlen( local_string1 );
19216 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19217 local_charMatrix1.insert( local_string1, 0, 0 );
19218 retval1( 0 ) = octave_value( local_charMatrix1 );
19219 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19220 }
19221 return _out;
19222 fail:
19223 return octave_value_list();
19224 }
19225 catch(...) {
19226 throw;
19227 }
19228}
19229
19230
19232 PLFLT *arg1 = (PLFLT *) 0 ;
19233 PLFLT *arg2 = (PLFLT *) 0 ;
19234 PLFLT *arg3 = (PLFLT *) 0 ;
19235 PLFLT *arg4 = (PLFLT *) 0 ;
19236 PLFLT temp1 ;
19237 int res1 = SWIG_TMPOBJ ;
19238 PLFLT temp2 ;
19239 int res2 = SWIG_TMPOBJ ;
19240 PLFLT temp3 ;
19241 int res3 = SWIG_TMPOBJ ;
19242 PLFLT temp4 ;
19243 int res4 = SWIG_TMPOBJ ;
19244 octave_value_list _out;
19245 octave_value_list *_outp=&_out;
19246 octave_value _outv;
19247
19248 try {
19249 arg1 = &temp1;
19250 arg2 = &temp2;
19251 arg3 = &temp3;
19252 arg4 = &temp4;
19253 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19254 SWIG_fail;
19255 }
19256 plgdidev(arg1,arg2,arg3,arg4);
19257 _outv = octave_value();
19258 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19259 if (SWIG_IsTmpObj(res1)) {
19260 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19261 } else {
19262 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19263 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19264 }
19265 if (SWIG_IsTmpObj(res2)) {
19266 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19267 } else {
19268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19269 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19270 }
19271 if (SWIG_IsTmpObj(res3)) {
19272 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19273 } else {
19274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19275 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19276 }
19277 if (SWIG_IsTmpObj(res4)) {
19278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19279 } else {
19280 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19282 }
19283 return _out;
19284 fail:
19285 return octave_value_list();
19286 }
19287 catch(...) {
19288 throw;
19289 }
19290}
19291
19292
19294 PLFLT *arg1 = (PLFLT *) 0 ;
19295 PLFLT temp1 ;
19296 int res1 = SWIG_TMPOBJ ;
19297 octave_value_list _out;
19298 octave_value_list *_outp=&_out;
19299 octave_value _outv;
19300
19301 try {
19302 arg1 = &temp1;
19303 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19304 SWIG_fail;
19305 }
19306 plgdiori(arg1);
19307 _outv = octave_value();
19308 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19309 if (SWIG_IsTmpObj(res1)) {
19310 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19311 } else {
19312 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19313 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19314 }
19315 return _out;
19316 fail:
19317 return octave_value_list();
19318 }
19319 catch(...) {
19320 throw;
19321 }
19322}
19323
19324
19326 PLFLT *arg1 = (PLFLT *) 0 ;
19327 PLFLT *arg2 = (PLFLT *) 0 ;
19328 PLFLT *arg3 = (PLFLT *) 0 ;
19329 PLFLT *arg4 = (PLFLT *) 0 ;
19330 PLFLT temp1 ;
19331 int res1 = SWIG_TMPOBJ ;
19332 PLFLT temp2 ;
19333 int res2 = SWIG_TMPOBJ ;
19334 PLFLT temp3 ;
19335 int res3 = SWIG_TMPOBJ ;
19336 PLFLT temp4 ;
19337 int res4 = SWIG_TMPOBJ ;
19338 octave_value_list _out;
19339 octave_value_list *_outp=&_out;
19340 octave_value _outv;
19341
19342 try {
19343 arg1 = &temp1;
19344 arg2 = &temp2;
19345 arg3 = &temp3;
19346 arg4 = &temp4;
19347 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19348 SWIG_fail;
19349 }
19350 plgdiplt(arg1,arg2,arg3,arg4);
19351 _outv = octave_value();
19352 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19353 if (SWIG_IsTmpObj(res1)) {
19354 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19355 } else {
19356 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19357 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19358 }
19359 if (SWIG_IsTmpObj(res2)) {
19360 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19361 } else {
19362 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19363 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19364 }
19365 if (SWIG_IsTmpObj(res3)) {
19366 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19367 } else {
19368 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19369 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19370 }
19371 if (SWIG_IsTmpObj(res4)) {
19372 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19373 } else {
19374 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19375 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19376 }
19377 return _out;
19378 fail:
19379 return octave_value_list();
19380 }
19381 catch(...) {
19382 throw;
19383 }
19384}
19385
19386
19388 PLINT *arg1 = (PLINT *) 0 ;
19389 PLINT *arg2 = (PLINT *) 0 ;
19390 PLINT *arg3 = (PLINT *) 0 ;
19391 PLINT temp1 ;
19392 int res1 = SWIG_TMPOBJ ;
19393 PLINT temp2 ;
19394 int res2 = SWIG_TMPOBJ ;
19395 PLINT temp3 ;
19396 int res3 = SWIG_TMPOBJ ;
19397 octave_value_list _out;
19398 octave_value_list *_outp=&_out;
19399 octave_value _outv;
19400
19401 try {
19402 arg1 = &temp1;
19403 arg2 = &temp2;
19404 arg3 = &temp3;
19405 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19406 SWIG_fail;
19407 }
19408 plgfam(arg1,arg2,arg3);
19409 _outv = octave_value();
19410 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19411 if (SWIG_IsTmpObj(res1)) {
19412 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19413 } else {
19414 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19415 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19416 }
19417 if (SWIG_IsTmpObj(res2)) {
19418 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19419 } else {
19420 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19421 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19422 }
19423 if (SWIG_IsTmpObj(res3)) {
19424 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19425 } else {
19426 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19427 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19428 }
19429 return _out;
19430 fail:
19431 return octave_value_list();
19432 }
19433 catch(...) {
19434 throw;
19435 }
19436}
19437
19438
19440 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19441 PLUNICODE temp1 ;
19442 int res1 = SWIG_TMPOBJ ;
19443 octave_value_list _out;
19444 octave_value_list *_outp=&_out;
19445 octave_value _outv;
19446
19447 try {
19448 arg1 = &temp1;
19449 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19450 SWIG_fail;
19451 }
19452 plgfci(arg1);
19453 _outv = octave_value();
19454 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19455 if (SWIG_IsTmpObj(res1)) {
19456 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19457 } else {
19458 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19459 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19460 }
19461 return _out;
19462 fail:
19463 return octave_value_list();
19464 }
19465 catch(...) {
19466 throw;
19467 }
19468}
19469
19470
19472 char *arg1 = (char *) 0 ;
19473 char local_string1[80] ;
19474 size_t local_string_length1 ;
19475 charMatrix local_charMatrix1 ;
19476 octave_value_list retval1 ;
19477 octave_value_list _out;
19478 octave_value_list *_outp=&_out;
19479 octave_value _outv;
19480
19481 try {
19482 {
19483 arg1 = local_string1;
19484 }
19485 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19486 SWIG_fail;
19487 }
19488 plgfnam(arg1);
19489 _outv = octave_value();
19490 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19491 {
19492 local_string_length1 = strlen( local_string1 );
19493 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19494 local_charMatrix1.insert( local_string1, 0, 0 );
19495 retval1( 0 ) = octave_value( local_charMatrix1 );
19496 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19497 }
19498 return _out;
19499 fail:
19500 return octave_value_list();
19501 }
19502 catch(...) {
19503 throw;
19504 }
19505}
19506
19507
19509 PLINT *arg1 = (PLINT *) 0 ;
19510 PLINT *arg2 = (PLINT *) 0 ;
19511 PLINT *arg3 = (PLINT *) 0 ;
19512 PLINT temp1 ;
19513 int res1 = SWIG_TMPOBJ ;
19514 PLINT temp2 ;
19515 int res2 = SWIG_TMPOBJ ;
19516 PLINT temp3 ;
19517 int res3 = SWIG_TMPOBJ ;
19518 octave_value_list _out;
19519 octave_value_list *_outp=&_out;
19520 octave_value _outv;
19521
19522 try {
19523 arg1 = &temp1;
19524 arg2 = &temp2;
19525 arg3 = &temp3;
19526 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19527 SWIG_fail;
19528 }
19529 plgfont(arg1,arg2,arg3);
19530 _outv = octave_value();
19531 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19532 if (SWIG_IsTmpObj(res1)) {
19533 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19534 } else {
19535 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19536 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19537 }
19538 if (SWIG_IsTmpObj(res2)) {
19539 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19540 } else {
19541 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19542 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19543 }
19544 if (SWIG_IsTmpObj(res3)) {
19545 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19546 } else {
19547 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19548 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19549 }
19550 return _out;
19551 fail:
19552 return octave_value_list();
19553 }
19554 catch(...) {
19555 throw;
19556 }
19557}
19558
19559
19561 PLINT *arg1 = (PLINT *) 0 ;
19562 PLINT temp1 ;
19563 int res1 = SWIG_TMPOBJ ;
19564 octave_value_list _out;
19565 octave_value_list *_outp=&_out;
19566 octave_value _outv;
19567
19568 try {
19569 arg1 = &temp1;
19570 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19571 SWIG_fail;
19572 }
19573 plglevel(arg1);
19574 _outv = octave_value();
19575 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19576 if (SWIG_IsTmpObj(res1)) {
19577 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19578 } else {
19579 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19580 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19581 }
19582 return _out;
19583 fail:
19584 return octave_value_list();
19585 }
19586 catch(...) {
19587 throw;
19588 }
19589}
19590
19591
19593 PLFLT *arg1 = (PLFLT *) 0 ;
19594 PLFLT *arg2 = (PLFLT *) 0 ;
19595 PLINT *arg3 = (PLINT *) 0 ;
19596 PLINT *arg4 = (PLINT *) 0 ;
19597 PLINT *arg5 = (PLINT *) 0 ;
19598 PLINT *arg6 = (PLINT *) 0 ;
19599 PLFLT temp1 ;
19600 int res1 = SWIG_TMPOBJ ;
19601 PLFLT temp2 ;
19602 int res2 = SWIG_TMPOBJ ;
19603 PLINT temp3 ;
19604 int res3 = SWIG_TMPOBJ ;
19605 PLINT temp4 ;
19606 int res4 = SWIG_TMPOBJ ;
19607 PLINT temp5 ;
19608 int res5 = SWIG_TMPOBJ ;
19609 PLINT temp6 ;
19610 int res6 = SWIG_TMPOBJ ;
19611 octave_value_list _out;
19612 octave_value_list *_outp=&_out;
19613 octave_value _outv;
19614
19615 try {
19616 arg1 = &temp1;
19617 arg2 = &temp2;
19618 arg3 = &temp3;
19619 arg4 = &temp4;
19620 arg5 = &temp5;
19621 arg6 = &temp6;
19622 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19623 SWIG_fail;
19624 }
19625 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19626 _outv = octave_value();
19627 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19628 if (SWIG_IsTmpObj(res1)) {
19629 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19630 } else {
19631 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19632 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19633 }
19634 if (SWIG_IsTmpObj(res2)) {
19635 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19636 } else {
19637 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19638 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19639 }
19640 if (SWIG_IsTmpObj(res3)) {
19641 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19642 } else {
19643 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19644 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19645 }
19646 if (SWIG_IsTmpObj(res4)) {
19647 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19648 } else {
19649 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19650 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19651 }
19652 if (SWIG_IsTmpObj(res5)) {
19653 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19654 } else {
19655 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19656 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19657 }
19658 if (SWIG_IsTmpObj(res6)) {
19659 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19660 } else {
19661 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19662 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19663 }
19664 return _out;
19665 fail:
19666 return octave_value_list();
19667 }
19668 catch(...) {
19669 throw;
19670 }
19671}
19672
19673
19675 octave_value_list _out;
19676 octave_value_list *_outp=&_out;
19677 octave_value _outv;
19678
19679 try {
19680 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19681 SWIG_fail;
19682 }
19683 plgra();
19684 _outv = octave_value();
19685 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19686 return _out;
19687 fail:
19688 return octave_value_list();
19689 }
19690 catch(...) {
19691 throw;
19692 }
19693}
19694
19695
19697 PLFLT *arg1 = (PLFLT *) 0 ;
19698 PLFLT *arg2 = (PLFLT *) 0 ;
19699 PLFLT *arg3 = (PLFLT *) 0 ;
19700 PLFLT *arg4 = (PLFLT *) 0 ;
19701 PLFLT temp1 ;
19702 int res1 = SWIG_TMPOBJ ;
19703 PLFLT temp2 ;
19704 int res2 = SWIG_TMPOBJ ;
19705 PLFLT temp3 ;
19706 int res3 = SWIG_TMPOBJ ;
19707 PLFLT temp4 ;
19708 int res4 = SWIG_TMPOBJ ;
19709 octave_value_list _out;
19710 octave_value_list *_outp=&_out;
19711 octave_value _outv;
19712
19713 try {
19714 arg1 = &temp1;
19715 arg2 = &temp2;
19716 arg3 = &temp3;
19717 arg4 = &temp4;
19718 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19719 SWIG_fail;
19720 }
19721 plgspa(arg1,arg2,arg3,arg4);
19722 _outv = octave_value();
19723 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19724 if (SWIG_IsTmpObj(res1)) {
19725 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19726 } else {
19727 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19728 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19729 }
19730 if (SWIG_IsTmpObj(res2)) {
19731 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19732 } else {
19733 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19734 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19735 }
19736 if (SWIG_IsTmpObj(res3)) {
19737 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19738 } else {
19739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19740 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19741 }
19742 if (SWIG_IsTmpObj(res4)) {
19743 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19744 } else {
19745 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19746 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19747 }
19748 return _out;
19749 fail:
19750 return octave_value_list();
19751 }
19752 catch(...) {
19753 throw;
19754 }
19755}
19756
19757
19759 PLINT *arg1 = (PLINT *) 0 ;
19760 PLINT temp1 ;
19761 int res1 = SWIG_TMPOBJ ;
19762 octave_value_list _out;
19763 octave_value_list *_outp=&_out;
19764 octave_value _outv;
19765
19766 try {
19767 arg1 = &temp1;
19768 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19769 SWIG_fail;
19770 }
19771 plgstrm(arg1);
19772 _outv = octave_value();
19773 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19774 if (SWIG_IsTmpObj(res1)) {
19775 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19776 } else {
19777 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19778 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19779 }
19780 return _out;
19781 fail:
19782 return octave_value_list();
19783 }
19784 catch(...) {
19785 throw;
19786 }
19787}
19788
19789
19791 char *arg1 = (char *) 0 ;
19792 char local_string1[80] ;
19793 size_t local_string_length1 ;
19794 charMatrix local_charMatrix1 ;
19795 octave_value_list retval1 ;
19796 octave_value_list _out;
19797 octave_value_list *_outp=&_out;
19798 octave_value _outv;
19799
19800 try {
19801 {
19802 arg1 = local_string1;
19803 }
19804 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19805 SWIG_fail;
19806 }
19807 plgver(arg1);
19808 _outv = octave_value();
19809 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19810 {
19811 local_string_length1 = strlen( local_string1 );
19812 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19813 local_charMatrix1.insert( local_string1, 0, 0 );
19814 retval1( 0 ) = octave_value( local_charMatrix1 );
19815 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19816 }
19817 return _out;
19818 fail:
19819 return octave_value_list();
19820 }
19821 catch(...) {
19822 throw;
19823 }
19824}
19825
19826
19828 PLFLT *arg1 = (PLFLT *) 0 ;
19829 PLFLT *arg2 = (PLFLT *) 0 ;
19830 PLFLT *arg3 = (PLFLT *) 0 ;
19831 PLFLT *arg4 = (PLFLT *) 0 ;
19832 PLFLT temp1 ;
19833 int res1 = SWIG_TMPOBJ ;
19834 PLFLT temp2 ;
19835 int res2 = SWIG_TMPOBJ ;
19836 PLFLT temp3 ;
19837 int res3 = SWIG_TMPOBJ ;
19838 PLFLT temp4 ;
19839 int res4 = SWIG_TMPOBJ ;
19840 octave_value_list _out;
19841 octave_value_list *_outp=&_out;
19842 octave_value _outv;
19843
19844 try {
19845 arg1 = &temp1;
19846 arg2 = &temp2;
19847 arg3 = &temp3;
19848 arg4 = &temp4;
19849 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19850 SWIG_fail;
19851 }
19852 plgvpd(arg1,arg2,arg3,arg4);
19853 _outv = octave_value();
19854 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19855 if (SWIG_IsTmpObj(res1)) {
19856 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19857 } else {
19858 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19859 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19860 }
19861 if (SWIG_IsTmpObj(res2)) {
19862 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19863 } else {
19864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19865 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19866 }
19867 if (SWIG_IsTmpObj(res3)) {
19868 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19869 } else {
19870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19871 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19872 }
19873 if (SWIG_IsTmpObj(res4)) {
19874 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19875 } else {
19876 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19877 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19878 }
19879 return _out;
19880 fail:
19881 return octave_value_list();
19882 }
19883 catch(...) {
19884 throw;
19885 }
19886}
19887
19888
19890 PLFLT *arg1 = (PLFLT *) 0 ;
19891 PLFLT *arg2 = (PLFLT *) 0 ;
19892 PLFLT *arg3 = (PLFLT *) 0 ;
19893 PLFLT *arg4 = (PLFLT *) 0 ;
19894 PLFLT temp1 ;
19895 int res1 = SWIG_TMPOBJ ;
19896 PLFLT temp2 ;
19897 int res2 = SWIG_TMPOBJ ;
19898 PLFLT temp3 ;
19899 int res3 = SWIG_TMPOBJ ;
19900 PLFLT temp4 ;
19901 int res4 = SWIG_TMPOBJ ;
19902 octave_value_list _out;
19903 octave_value_list *_outp=&_out;
19904 octave_value _outv;
19905
19906 try {
19907 arg1 = &temp1;
19908 arg2 = &temp2;
19909 arg3 = &temp3;
19910 arg4 = &temp4;
19911 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19912 SWIG_fail;
19913 }
19914 plgvpw(arg1,arg2,arg3,arg4);
19915 _outv = octave_value();
19916 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19917 if (SWIG_IsTmpObj(res1)) {
19918 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19919 } else {
19920 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19921 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19922 }
19923 if (SWIG_IsTmpObj(res2)) {
19924 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19925 } else {
19926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19927 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19928 }
19929 if (SWIG_IsTmpObj(res3)) {
19930 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19931 } else {
19932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19933 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19934 }
19935 if (SWIG_IsTmpObj(res4)) {
19936 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19937 } else {
19938 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19939 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19940 }
19941 return _out;
19942 fail:
19943 return octave_value_list();
19944 }
19945 catch(...) {
19946 throw;
19947 }
19948}
19949
19950
19952 PLINT *arg1 = (PLINT *) 0 ;
19953 PLINT *arg2 = (PLINT *) 0 ;
19954 PLINT temp1 ;
19955 int res1 = SWIG_TMPOBJ ;
19956 PLINT temp2 ;
19957 int res2 = SWIG_TMPOBJ ;
19958 octave_value_list _out;
19959 octave_value_list *_outp=&_out;
19960 octave_value _outv;
19961
19962 try {
19963 arg1 = &temp1;
19964 arg2 = &temp2;
19965 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
19966 SWIG_fail;
19967 }
19968 plgxax(arg1,arg2);
19969 _outv = octave_value();
19970 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19971 if (SWIG_IsTmpObj(res1)) {
19972 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19973 } else {
19974 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19975 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19976 }
19977 if (SWIG_IsTmpObj(res2)) {
19978 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19979 } else {
19980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19981 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19982 }
19983 return _out;
19984 fail:
19985 return octave_value_list();
19986 }
19987 catch(...) {
19988 throw;
19989 }
19990}
19991
19992
19994 PLINT *arg1 = (PLINT *) 0 ;
19995 PLINT *arg2 = (PLINT *) 0 ;
19996 PLINT temp1 ;
19997 int res1 = SWIG_TMPOBJ ;
19998 PLINT temp2 ;
19999 int res2 = SWIG_TMPOBJ ;
20000 octave_value_list _out;
20001 octave_value_list *_outp=&_out;
20002 octave_value _outv;
20003
20004 try {
20005 arg1 = &temp1;
20006 arg2 = &temp2;
20007 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
20008 SWIG_fail;
20009 }
20010 plgyax(arg1,arg2);
20011 _outv = octave_value();
20012 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20013 if (SWIG_IsTmpObj(res1)) {
20014 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20015 } else {
20016 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20017 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20018 }
20019 if (SWIG_IsTmpObj(res2)) {
20020 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20021 } else {
20022 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20023 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20024 }
20025 return _out;
20026 fail:
20027 return octave_value_list();
20028 }
20029 catch(...) {
20030 throw;
20031 }
20032}
20033
20034
20036 PLINT *arg1 = (PLINT *) 0 ;
20037 PLINT *arg2 = (PLINT *) 0 ;
20038 PLINT temp1 ;
20039 int res1 = SWIG_TMPOBJ ;
20040 PLINT temp2 ;
20041 int res2 = SWIG_TMPOBJ ;
20042 octave_value_list _out;
20043 octave_value_list *_outp=&_out;
20044 octave_value _outv;
20045
20046 try {
20047 arg1 = &temp1;
20048 arg2 = &temp2;
20049 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
20050 SWIG_fail;
20051 }
20052 plgzax(arg1,arg2);
20053 _outv = octave_value();
20054 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20055 if (SWIG_IsTmpObj(res1)) {
20056 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20057 } else {
20058 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20059 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20060 }
20061 if (SWIG_IsTmpObj(res2)) {
20062 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20063 } else {
20064 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20065 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20066 }
20067 return _out;
20068 fail:
20069 return octave_value_list();
20070 }
20071 catch(...) {
20072 throw;
20073 }
20074}
20075
20076
20078 PLINT arg1 ;
20079 PLFLT *arg2 = (PLFLT *) 0 ;
20080 PLFLT arg3 ;
20081 PLFLT arg4 ;
20082 PLINT arg5 ;
20083 PLINT arg6 ;
20084 Matrix temp1 ;
20085 double val3 ;
20086 int ecode3 = 0 ;
20087 double val4 ;
20088 int ecode4 = 0 ;
20089 int val5 ;
20090 int ecode5 = 0 ;
20091 int val6 ;
20092 int ecode6 = 0 ;
20093 octave_value_list _out;
20094 octave_value_list *_outp=&_out;
20095 octave_value _outv;
20096
20097 try {
20098 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20099 SWIG_fail;
20100 }
20101 {
20102 if ( _n_dims( args(0) ) > 1 )
20103 {
20104 error( "argument must be a scalar or vector" ); SWIG_fail;
20105 }
20106 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20107 temp1 = args(0).matrix_value();
20108 arg2 = &temp1( 0, 0 );
20109 }
20110 ecode3 = SWIG_AsVal_double(args(1), &val3);
20111 if (!SWIG_IsOK(ecode3)) {
20112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20113 }
20114 arg3 = static_cast< PLFLT >(val3);
20115 ecode4 = SWIG_AsVal_double(args(2), &val4);
20116 if (!SWIG_IsOK(ecode4)) {
20117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20118 }
20119 arg4 = static_cast< PLFLT >(val4);
20120 ecode5 = SWIG_AsVal_int(args(3), &val5);
20121 if (!SWIG_IsOK(ecode5)) {
20122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20123 }
20124 arg5 = static_cast< PLINT >(val5);
20125 ecode6 = SWIG_AsVal_int(args(4), &val6);
20126 if (!SWIG_IsOK(ecode6)) {
20127 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20128 }
20129 arg6 = static_cast< PLINT >(val6);
20130 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20131 _outv = octave_value();
20132 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20133 {
20134
20135 }
20136 return _out;
20137 fail:
20138 {
20139
20140 }
20141 return octave_value_list();
20142 }
20143 catch(...) {
20144 {
20145
20146 }
20147 throw;
20148 }
20149}
20150
20151
20153 PLFLT arg1 ;
20154 PLFLT arg2 ;
20155 PLFLT arg3 ;
20156 PLFLT *arg4 = (PLFLT *) 0 ;
20157 PLFLT *arg5 = (PLFLT *) 0 ;
20158 PLFLT *arg6 = (PLFLT *) 0 ;
20159 double val1 ;
20160 int ecode1 = 0 ;
20161 double val2 ;
20162 int ecode2 = 0 ;
20163 double val3 ;
20164 int ecode3 = 0 ;
20165 PLFLT temp4 ;
20166 int res4 = SWIG_TMPOBJ ;
20167 PLFLT temp5 ;
20168 int res5 = SWIG_TMPOBJ ;
20169 PLFLT temp6 ;
20170 int res6 = SWIG_TMPOBJ ;
20171 octave_value_list _out;
20172 octave_value_list *_outp=&_out;
20173 octave_value _outv;
20174
20175 try {
20176 arg4 = &temp4;
20177 arg5 = &temp5;
20178 arg6 = &temp6;
20179 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20180 SWIG_fail;
20181 }
20182 ecode1 = SWIG_AsVal_double(args(0), &val1);
20183 if (!SWIG_IsOK(ecode1)) {
20184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20185 }
20186 arg1 = static_cast< PLFLT >(val1);
20187 ecode2 = SWIG_AsVal_double(args(1), &val2);
20188 if (!SWIG_IsOK(ecode2)) {
20189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20190 }
20191 arg2 = static_cast< PLFLT >(val2);
20192 ecode3 = SWIG_AsVal_double(args(2), &val3);
20193 if (!SWIG_IsOK(ecode3)) {
20194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20195 }
20196 arg3 = static_cast< PLFLT >(val3);
20197 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20198 _outv = octave_value();
20199 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20200 if (SWIG_IsTmpObj(res4)) {
20201 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20202 } else {
20203 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20204 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20205 }
20206 if (SWIG_IsTmpObj(res5)) {
20207 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20208 } else {
20209 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20210 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20211 }
20212 if (SWIG_IsTmpObj(res6)) {
20213 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20214 } else {
20215 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20216 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20217 }
20218 return _out;
20219 fail:
20220 return octave_value_list();
20221 }
20222 catch(...) {
20223 throw;
20224 }
20225}
20226
20227
20229 octave_value_list _out;
20230 octave_value_list *_outp=&_out;
20231 octave_value _outv;
20232
20233 try {
20234 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20235 SWIG_fail;
20236 }
20237 plinit();
20238 _outv = octave_value();
20239 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20240 return _out;
20241 fail:
20242 return octave_value_list();
20243 }
20244 catch(...) {
20245 throw;
20246 }
20247}
20248
20249
20251 PLFLT arg1 ;
20252 PLFLT arg2 ;
20253 PLFLT arg3 ;
20254 PLFLT arg4 ;
20255 double val1 ;
20256 int ecode1 = 0 ;
20257 double val2 ;
20258 int ecode2 = 0 ;
20259 double val3 ;
20260 int ecode3 = 0 ;
20261 double val4 ;
20262 int ecode4 = 0 ;
20263 octave_value_list _out;
20264 octave_value_list *_outp=&_out;
20265 octave_value _outv;
20266
20267 try {
20268 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20269 SWIG_fail;
20270 }
20271 ecode1 = SWIG_AsVal_double(args(0), &val1);
20272 if (!SWIG_IsOK(ecode1)) {
20273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20274 }
20275 arg1 = static_cast< PLFLT >(val1);
20276 ecode2 = SWIG_AsVal_double(args(1), &val2);
20277 if (!SWIG_IsOK(ecode2)) {
20278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20279 }
20280 arg2 = static_cast< PLFLT >(val2);
20281 ecode3 = SWIG_AsVal_double(args(2), &val3);
20282 if (!SWIG_IsOK(ecode3)) {
20283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20284 }
20285 arg3 = static_cast< PLFLT >(val3);
20286 ecode4 = SWIG_AsVal_double(args(3), &val4);
20287 if (!SWIG_IsOK(ecode4)) {
20288 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20289 }
20290 arg4 = static_cast< PLFLT >(val4);
20291 pljoin(arg1,arg2,arg3,arg4);
20292 _outv = octave_value();
20293 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20294 return _out;
20295 fail:
20296 return octave_value_list();
20297 }
20298 catch(...) {
20299 throw;
20300 }
20301}
20302
20303
20305 char *arg1 = (char *) 0 ;
20306 char *arg2 = (char *) 0 ;
20307 char *arg3 = (char *) 0 ;
20308 int res1 ;
20309 char *buf1 = 0 ;
20310 int alloc1 = 0 ;
20311 int res2 ;
20312 char *buf2 = 0 ;
20313 int alloc2 = 0 ;
20314 int res3 ;
20315 char *buf3 = 0 ;
20316 int alloc3 = 0 ;
20317 octave_value_list _out;
20318 octave_value_list *_outp=&_out;
20319 octave_value _outv;
20320
20321 try {
20322 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20323 SWIG_fail;
20324 }
20325 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20326 if (!SWIG_IsOK(res1)) {
20327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20328 }
20329 arg1 = reinterpret_cast< char * >(buf1);
20330 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20331 if (!SWIG_IsOK(res2)) {
20332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20333 }
20334 arg2 = reinterpret_cast< char * >(buf2);
20335 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20336 if (!SWIG_IsOK(res3)) {
20337 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20338 }
20339 arg3 = reinterpret_cast< char * >(buf3);
20340 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20341 _outv = octave_value();
20342 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20343 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20344 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20345 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20346 return _out;
20347 fail:
20348 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20349 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20350 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20351 return octave_value_list();
20352 }
20353 catch(...) {
20354 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20355 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20356 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20357 throw;
20358 }
20359}
20360
20361
20363 PLFLT *arg1 = (PLFLT *) 0 ;
20364 PLFLT *arg2 = (PLFLT *) 0 ;
20365 PLINT arg3 ;
20366 PLINT arg4 ;
20367 PLFLT arg5 ;
20368 PLFLT arg6 ;
20369 PLFLT arg7 ;
20370 PLINT arg8 ;
20371 PLINT arg9 ;
20372 PLINT arg10 ;
20373 PLINT arg11 ;
20374 PLINT arg12 ;
20375 PLINT arg13 ;
20376 PLINT *arg14 = (PLINT *) 0 ;
20377 PLFLT arg15 ;
20378 PLFLT arg16 ;
20379 PLFLT arg17 ;
20380 PLFLT arg18 ;
20381 PLINT *arg19 = (PLINT *) 0 ;
20382 char **arg20 = (char **) 0 ;
20383 PLINT *arg21 = (PLINT *) 0 ;
20384 PLINT *arg22 = (PLINT *) 0 ;
20385 PLFLT *arg23 = (PLFLT *) 0 ;
20386 PLFLT *arg24 = (PLFLT *) 0 ;
20387 PLINT *arg25 = (PLINT *) 0 ;
20388 PLINT *arg26 = (PLINT *) 0 ;
20389 PLFLT *arg27 = (PLFLT *) 0 ;
20390 PLINT *arg28 = (PLINT *) 0 ;
20391 PLFLT *arg29 = (PLFLT *) 0 ;
20392 PLINT *arg30 = (PLINT *) 0 ;
20393 char **arg31 = (char **) 0 ;
20394 PLFLT temp1 ;
20395 int res1 = SWIG_TMPOBJ ;
20396 PLFLT temp2 ;
20397 int res2 = SWIG_TMPOBJ ;
20398 int val3 ;
20399 int ecode3 = 0 ;
20400 int val4 ;
20401 int ecode4 = 0 ;
20402 double val5 ;
20403 int ecode5 = 0 ;
20404 double val6 ;
20405 int ecode6 = 0 ;
20406 double val7 ;
20407 int ecode7 = 0 ;
20408 int val8 ;
20409 int ecode8 = 0 ;
20410 int val9 ;
20411 int ecode9 = 0 ;
20412 int val10 ;
20413 int ecode10 = 0 ;
20414 int val11 ;
20415 int ecode11 = 0 ;
20416 int val12 ;
20417 int ecode12 = 0 ;
20418 Matrix temp13 ;
20419 double val15 ;
20420 int ecode15 = 0 ;
20421 double val16 ;
20422 int ecode16 = 0 ;
20423 double val17 ;
20424 int ecode17 = 0 ;
20425 double val18 ;
20426 int ecode18 = 0 ;
20427 Matrix temp19 ;
20428 Matrix temp21 ;
20429 Matrix temp22 ;
20430 Matrix temp23 ;
20431 Matrix temp24 ;
20432 Matrix temp25 ;
20433 Matrix temp26 ;
20434 Matrix temp27 ;
20435 Matrix temp28 ;
20436 Matrix temp29 ;
20437 Matrix temp30 ;
20438 octave_value_list _out;
20439 octave_value_list *_outp=&_out;
20440 octave_value _outv;
20441
20442 try {
20443 arg1 = &temp1;
20444 arg2 = &temp2;
20445 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20446 SWIG_fail;
20447 }
20448 ecode3 = SWIG_AsVal_int(args(0), &val3);
20449 if (!SWIG_IsOK(ecode3)) {
20450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20451 }
20452 arg3 = static_cast< PLINT >(val3);
20453 ecode4 = SWIG_AsVal_int(args(1), &val4);
20454 if (!SWIG_IsOK(ecode4)) {
20455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20456 }
20457 arg4 = static_cast< PLINT >(val4);
20458 ecode5 = SWIG_AsVal_double(args(2), &val5);
20459 if (!SWIG_IsOK(ecode5)) {
20460 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20461 }
20462 arg5 = static_cast< PLFLT >(val5);
20463 ecode6 = SWIG_AsVal_double(args(3), &val6);
20464 if (!SWIG_IsOK(ecode6)) {
20465 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20466 }
20467 arg6 = static_cast< PLFLT >(val6);
20468 ecode7 = SWIG_AsVal_double(args(4), &val7);
20469 if (!SWIG_IsOK(ecode7)) {
20470 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20471 }
20472 arg7 = static_cast< PLFLT >(val7);
20473 ecode8 = SWIG_AsVal_int(args(5), &val8);
20474 if (!SWIG_IsOK(ecode8)) {
20475 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20476 }
20477 arg8 = static_cast< PLINT >(val8);
20478 ecode9 = SWIG_AsVal_int(args(6), &val9);
20479 if (!SWIG_IsOK(ecode9)) {
20480 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20481 }
20482 arg9 = static_cast< PLINT >(val9);
20483 ecode10 = SWIG_AsVal_int(args(7), &val10);
20484 if (!SWIG_IsOK(ecode10)) {
20485 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20486 }
20487 arg10 = static_cast< PLINT >(val10);
20488 ecode11 = SWIG_AsVal_int(args(8), &val11);
20489 if (!SWIG_IsOK(ecode11)) {
20490 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20491 }
20492 arg11 = static_cast< PLINT >(val11);
20493 ecode12 = SWIG_AsVal_int(args(9), &val12);
20494 if (!SWIG_IsOK(ecode12)) {
20495 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20496 }
20497 arg12 = static_cast< PLINT >(val12);
20498 {
20499 if ( _n_dims( args(10) ) > 1 )
20500 {
20501 error( "argument must be a scalar or vector" ); SWIG_fail;
20502 }
20503 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20504 arg14 = new PLINT[Alen];
20505 temp13 = args(10).matrix_value();
20506 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20507 }
20508 ecode15 = SWIG_AsVal_double(args(11), &val15);
20509 if (!SWIG_IsOK(ecode15)) {
20510 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20511 }
20512 arg15 = static_cast< PLFLT >(val15);
20513 ecode16 = SWIG_AsVal_double(args(12), &val16);
20514 if (!SWIG_IsOK(ecode16)) {
20515 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20516 }
20517 arg16 = static_cast< PLFLT >(val16);
20518 ecode17 = SWIG_AsVal_double(args(13), &val17);
20519 if (!SWIG_IsOK(ecode17)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20521 }
20522 arg17 = static_cast< PLFLT >(val17);
20523 ecode18 = SWIG_AsVal_double(args(14), &val18);
20524 if (!SWIG_IsOK(ecode18)) {
20525 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20526 }
20527 arg18 = static_cast< PLFLT >(val18);
20528 {
20529 if ( _n_dims( args(15) ) > 1 )
20530 {
20531 error( "argument must be a scalar or vector" ); SWIG_fail;
20532 }
20533 if ( _dim( args(15), 0 ) != Alen )
20534 {
20535 error( "argument vectors must be same length" ); SWIG_fail;
20536 }
20537 temp19 = args(15).matrix_value();
20538 arg19 = new PLINT[Alen];
20539 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20540 }
20541 {
20542 charMatrix temp_matrix;
20543 Cell temp_cell;
20544 char *tmp_cstring;
20545 std::string str;
20546 size_t max_length = 0, non_blank_length;
20547 int i, ifcell;
20548 if ( _n_dims( args(16) ) > 2 )
20549 {
20550 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20551 }
20552#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20553 if ( !args(16).isempty() )
20554#else
20555 if ( !args(16).is_empty() )
20556#endif
20557 {
20558 if ( _dim( args(16), 0 ) != Alen )
20559 {
20560 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20561 }
20562 arg20 = new char*[Alen];
20563#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20564 ifcell = args(16).iscell();
20565#else
20566 ifcell = args(16).is_cell();
20567#endif
20568 if ( ifcell )
20569 {
20570 temp_cell = args(16).cell_value();
20571 }
20572 else
20573 {
20574 temp_matrix = args(16).char_matrix_value();
20575 // Allow one extra space for null termination.
20576 max_length = _dim( args(16), 1 ) + 1;
20577 }
20578
20579 for ( i = 0; i < Alen; i++ )
20580 {
20581 // Must copy string to "permanent" location because the string
20582 // location corresponding to tmp_cstring gets
20583 // overwritten for each iteration of loop.
20584 if ( ifcell )
20585 {
20586 if ( temp_cell.elem( i ).is_string() )
20587 {
20588 str = temp_cell.elem( i ).string_value();
20589 // leave room for null termination.
20590 max_length = str.size() + 1;
20591 tmp_cstring = (char *) str.c_str();
20592 }
20593 else
20594 {
20595 // Use null string if user attempts to pass a cell array
20596 // with a non-string element (likely an empty element
20597 // since that should be allowed by the PLplot interface
20598 // if that element is going to be unused).
20599 // leave room for null termination.
20600 max_length = 1;
20601 tmp_cstring = (char *) "";
20602 }
20603 }
20604 else
20605 {
20606 str = temp_matrix.row_as_string( i );
20607 tmp_cstring = (char *) str.c_str();
20608 }
20609 arg20[i] = new char[max_length];
20610 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20611 arg20[i][max_length - 1] = '\0';
20612 // All the trailing blank crapola should not be needed for
20613 // string cell arrays.
20614 if ( !ifcell )
20615 {
20616 // remove trailing-blank padding that is used by the
20617 // charMatrix class to insure all strings in a given
20618 // charMatrix instance have the same length.
20619 // This transformation also removes legitimate trailing
20620 // blanks but there is nothing we can do about that
20621 // for the charMatrix class.
20622
20623 // Look for trailing nulls first (just in case, although that
20624 // shouldn't happen if charMatrix implemented as documented)
20625 // before looking for trailing blanks.
20626 non_blank_length = max_length - 2;
20627 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20628 {
20629 non_blank_length--;
20630 }
20631 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20632 {
20633 non_blank_length--;
20634 }
20635 arg20[i][non_blank_length + 1] = '\0';
20636 }
20637 }
20638 }
20639 else
20640 {
20641 arg20 = NULL;
20642 }
20643 }
20644 {
20645 if ( _n_dims( args(17) ) > 1 )
20646 {
20647 error( "argument must be a scalar or vector" ); SWIG_fail;
20648 }
20649#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20650 if ( !args(17).isempty() )
20651#else
20652 if ( !args(17).is_empty() )
20653#endif
20654 {
20655 if ( _dim( args(17), 0 ) != Alen )
20656 {
20657 error( "argument vectors must be same length" ); SWIG_fail;
20658 }
20659 temp21 = args(17).matrix_value();
20660 arg21 = new PLINT[Alen];
20661 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20662 }
20663 else
20664 {
20665 arg21 = NULL;
20666 }
20667 }
20668 {
20669 if ( _n_dims( args(18) ) > 1 )
20670 {
20671 error( "argument must be a scalar or vector" ); SWIG_fail;
20672 }
20673#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20674 if ( !args(18).isempty() )
20675#else
20676 if ( !args(18).is_empty() )
20677#endif
20678 {
20679 if ( _dim( args(18), 0 ) != Alen )
20680 {
20681 error( "argument vectors must be same length" ); SWIG_fail;
20682 }
20683 temp22 = args(18).matrix_value();
20684 arg22 = new PLINT[Alen];
20685 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20686 }
20687 else
20688 {
20689 arg22 = NULL;
20690 }
20691 }
20692 {
20693 if ( _n_dims( args(19) ) > 1 )
20694 {
20695 error( "argument must be a scalar or vector" ); SWIG_fail;
20696 }
20697#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20698 if ( !args(19).isempty() )
20699#else
20700 if ( !args(19).is_empty() )
20701#endif
20702 {
20703 if ( _dim( args(19), 0 ) != Alen )
20704 {
20705 error( "argument vectors must be same length" ); SWIG_fail;
20706 }
20707 temp23 = args(19).matrix_value();
20708 arg23 = &temp23( 0, 0 );
20709 }
20710 else
20711 {
20712 arg23 = NULL;
20713 }
20714 }
20715 {
20716 if ( _n_dims( args(20) ) > 1 )
20717 {
20718 error( "argument must be a scalar or vector" ); SWIG_fail;
20719 }
20720#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20721 if ( !args(20).isempty() )
20722#else
20723 if ( !args(20).is_empty() )
20724#endif
20725 {
20726 if ( _dim( args(20), 0 ) != Alen )
20727 {
20728 error( "argument vectors must be same length" ); SWIG_fail;
20729 }
20730 temp24 = args(20).matrix_value();
20731 arg24 = &temp24( 0, 0 );
20732 }
20733 else
20734 {
20735 arg24 = NULL;
20736 }
20737 }
20738 {
20739 if ( _n_dims( args(21) ) > 1 )
20740 {
20741 error( "argument must be a scalar or vector" ); SWIG_fail;
20742 }
20743#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20744 if ( !args(21).isempty() )
20745#else
20746 if ( !args(21).is_empty() )
20747#endif
20748 {
20749 if ( _dim( args(21), 0 ) != Alen )
20750 {
20751 error( "argument vectors must be same length" ); SWIG_fail;
20752 }
20753 temp25 = args(21).matrix_value();
20754 arg25 = new PLINT[Alen];
20755 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20756 }
20757 else
20758 {
20759 arg25 = NULL;
20760 }
20761 }
20762 {
20763 if ( _n_dims( args(22) ) > 1 )
20764 {
20765 error( "argument must be a scalar or vector" ); SWIG_fail;
20766 }
20767#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20768 if ( !args(22).isempty() )
20769#else
20770 if ( !args(22).is_empty() )
20771#endif
20772 {
20773 if ( _dim( args(22), 0 ) != Alen )
20774 {
20775 error( "argument vectors must be same length" ); SWIG_fail;
20776 }
20777 temp26 = args(22).matrix_value();
20778 arg26 = new PLINT[Alen];
20779 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20780 }
20781 else
20782 {
20783 arg26 = NULL;
20784 }
20785 }
20786 {
20787 if ( _n_dims( args(23) ) > 1 )
20788 {
20789 error( "argument must be a scalar or vector" ); SWIG_fail;
20790 }
20791#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20792 if ( !args(23).isempty() )
20793#else
20794 if ( !args(23).is_empty() )
20795#endif
20796 {
20797 if ( _dim( args(23), 0 ) != Alen )
20798 {
20799 error( "argument vectors must be same length" ); SWIG_fail;
20800 }
20801 temp27 = args(23).matrix_value();
20802 arg27 = &temp27( 0, 0 );
20803 }
20804 else
20805 {
20806 arg27 = NULL;
20807 }
20808 }
20809 {
20810 if ( _n_dims( args(24) ) > 1 )
20811 {
20812 error( "argument must be a scalar or vector" ); SWIG_fail;
20813 }
20814#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20815 if ( !args(24).isempty() )
20816#else
20817 if ( !args(24).is_empty() )
20818#endif
20819 {
20820 if ( _dim( args(24), 0 ) != Alen )
20821 {
20822 error( "argument vectors must be same length" ); SWIG_fail;
20823 }
20824 temp28 = args(24).matrix_value();
20825 arg28 = new PLINT[Alen];
20826 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20827 }
20828 else
20829 {
20830 arg28 = NULL;
20831 }
20832 }
20833 {
20834 if ( _n_dims( args(25) ) > 1 )
20835 {
20836 error( "argument must be a scalar or vector" ); SWIG_fail;
20837 }
20838#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20839 if ( !args(25).isempty() )
20840#else
20841 if ( !args(25).is_empty() )
20842#endif
20843 {
20844 if ( _dim( args(25), 0 ) != Alen )
20845 {
20846 error( "argument vectors must be same length" ); SWIG_fail;
20847 }
20848 temp29 = args(25).matrix_value();
20849 arg29 = &temp29( 0, 0 );
20850 }
20851 else
20852 {
20853 arg29 = NULL;
20854 }
20855 }
20856 {
20857 if ( _n_dims( args(26) ) > 1 )
20858 {
20859 error( "argument must be a scalar or vector" ); SWIG_fail;
20860 }
20861#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20862 if ( !args(26).isempty() )
20863#else
20864 if ( !args(26).is_empty() )
20865#endif
20866 {
20867 if ( _dim( args(26), 0 ) != Alen )
20868 {
20869 error( "argument vectors must be same length" ); SWIG_fail;
20870 }
20871 temp30 = args(26).matrix_value();
20872 arg30 = new PLINT[Alen];
20873 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20874 }
20875 else
20876 {
20877 arg30 = NULL;
20878 }
20879 }
20880 {
20881 charMatrix temp_matrix;
20882 Cell temp_cell;
20883 char *tmp_cstring;
20884 std::string str;
20885 size_t max_length = 0, non_blank_length;
20886 int i, ifcell;
20887 if ( _n_dims( args(27) ) > 2 )
20888 {
20889 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20890 }
20891#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20892 if ( !args(27).isempty() )
20893#else
20894 if ( !args(27).is_empty() )
20895#endif
20896 {
20897 if ( _dim( args(27), 0 ) != Alen )
20898 {
20899 error( "first dimension must be same length as previous vector" ); SWIG_fail;
20900 }
20901 arg31 = new char*[Alen];
20902#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20903 ifcell = args(27).iscell();
20904#else
20905 ifcell = args(27).is_cell();
20906#endif
20907 if ( ifcell )
20908 {
20909 temp_cell = args(27).cell_value();
20910 }
20911 else
20912 {
20913 temp_matrix = args(27).char_matrix_value();
20914 // Allow one extra space for null termination.
20915 max_length = _dim( args(27), 1 ) + 1;
20916 }
20917
20918 for ( i = 0; i < Alen; i++ )
20919 {
20920 // Must copy string to "permanent" location because the string
20921 // location corresponding to tmp_cstring gets
20922 // overwritten for each iteration of loop.
20923 if ( ifcell )
20924 {
20925 if ( temp_cell.elem( i ).is_string() )
20926 {
20927 str = temp_cell.elem( i ).string_value();
20928 // leave room for null termination.
20929 max_length = str.size() + 1;
20930 tmp_cstring = (char *) str.c_str();
20931 }
20932 else
20933 {
20934 // Use null string if user attempts to pass a cell array
20935 // with a non-string element (likely an empty element
20936 // since that should be allowed by the PLplot interface
20937 // if that element is going to be unused).
20938 // leave room for null termination.
20939 max_length = 1;
20940 tmp_cstring = (char *) "";
20941 }
20942 }
20943 else
20944 {
20945 str = temp_matrix.row_as_string( i );
20946 tmp_cstring = (char *) str.c_str();
20947 }
20948 arg31[i] = new char[max_length];
20949 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20950 arg31[i][max_length - 1] = '\0';
20951 // All the trailing blank crapola should not be needed for
20952 // string cell arrays.
20953 if ( !ifcell )
20954 {
20955 // remove trailing-blank padding that is used by the
20956 // charMatrix class to insure all strings in a given
20957 // charMatrix instance have the same length.
20958 // This transformation also removes legitimate trailing
20959 // blanks but there is nothing we can do about that
20960 // for the charMatrix class.
20961
20962 // Look for trailing nulls first (just in case, although that
20963 // shouldn't happen if charMatrix implemented as documented)
20964 // before looking for trailing blanks.
20965 non_blank_length = max_length - 2;
20966 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
20967 {
20968 non_blank_length--;
20969 }
20970 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
20971 {
20972 non_blank_length--;
20973 }
20974 arg31[i][non_blank_length + 1] = '\0';
20975 }
20976 }
20977 }
20978 else
20979 {
20980 arg31 = NULL;
20981 }
20982 }
20983 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);
20984 _outv = octave_value();
20985 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20986 if (SWIG_IsTmpObj(res1)) {
20987 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20988 } else {
20989 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20990 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20991 }
20992 if (SWIG_IsTmpObj(res2)) {
20993 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20994 } else {
20995 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20996 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20997 }
20998 {
20999 delete [] arg14;
21000 }
21001 {
21002 delete [] arg19;
21003 }
21004 {
21005 int i;
21006 if ( arg20 != NULL )
21007 {
21008 for ( i = 0; i < Alen; i++ )
21009 {
21010 delete[] arg20[i];
21011 }
21012 delete[] arg20;
21013 }
21014 }
21015 {
21016 if ( arg21 != NULL )
21017 delete [] arg21;
21018 }
21019 {
21020 if ( arg22 != NULL )
21021 delete [] arg22;
21022 }
21023 {
21024
21025 }
21026 {
21027
21028 }
21029 {
21030 if ( arg25 != NULL )
21031 delete [] arg25;
21032 }
21033 {
21034 if ( arg26 != NULL )
21035 delete [] arg26;
21036 }
21037 {
21038
21039 }
21040 {
21041 if ( arg28 != NULL )
21042 delete [] arg28;
21043 }
21044 {
21045
21046 }
21047 {
21048 if ( arg30 != NULL )
21049 delete [] arg30;
21050 }
21051 {
21052 int i;
21053 if ( arg31 != NULL )
21054 {
21055 for ( i = 0; i < Alen; i++ )
21056 {
21057 delete[] arg31[i];
21058 }
21059 delete[] arg31;
21060 }
21061 }
21062 return _out;
21063 fail:
21064 {
21065 delete [] arg14;
21066 }
21067 {
21068 delete [] arg19;
21069 }
21070 {
21071 int i;
21072 if ( arg20 != NULL )
21073 {
21074 for ( i = 0; i < Alen; i++ )
21075 {
21076 delete[] arg20[i];
21077 }
21078 delete[] arg20;
21079 }
21080 }
21081 {
21082 if ( arg21 != NULL )
21083 delete [] arg21;
21084 }
21085 {
21086 if ( arg22 != NULL )
21087 delete [] arg22;
21088 }
21089 {
21090
21091 }
21092 {
21093
21094 }
21095 {
21096 if ( arg25 != NULL )
21097 delete [] arg25;
21098 }
21099 {
21100 if ( arg26 != NULL )
21101 delete [] arg26;
21102 }
21103 {
21104
21105 }
21106 {
21107 if ( arg28 != NULL )
21108 delete [] arg28;
21109 }
21110 {
21111
21112 }
21113 {
21114 if ( arg30 != NULL )
21115 delete [] arg30;
21116 }
21117 {
21118 int i;
21119 if ( arg31 != NULL )
21120 {
21121 for ( i = 0; i < Alen; i++ )
21122 {
21123 delete[] arg31[i];
21124 }
21125 delete[] arg31;
21126 }
21127 }
21128 return octave_value_list();
21129 }
21130 catch(...) {
21131 {
21132 delete [] arg14;
21133 }
21134 {
21135 delete [] arg19;
21136 }
21137 {
21138 int i;
21139 if ( arg20 != NULL )
21140 {
21141 for ( i = 0; i < Alen; i++ )
21142 {
21143 delete[] arg20[i];
21144 }
21145 delete[] arg20;
21146 }
21147 }
21148 {
21149 if ( arg21 != NULL )
21150 delete [] arg21;
21151 }
21152 {
21153 if ( arg22 != NULL )
21154 delete [] arg22;
21155 }
21156 {
21157
21158 }
21159 {
21160
21161 }
21162 {
21163 if ( arg25 != NULL )
21164 delete [] arg25;
21165 }
21166 {
21167 if ( arg26 != NULL )
21168 delete [] arg26;
21169 }
21170 {
21171
21172 }
21173 {
21174 if ( arg28 != NULL )
21175 delete [] arg28;
21176 }
21177 {
21178
21179 }
21180 {
21181 if ( arg30 != NULL )
21182 delete [] arg30;
21183 }
21184 {
21185 int i;
21186 if ( arg31 != NULL )
21187 {
21188 for ( i = 0; i < Alen; i++ )
21189 {
21190 delete[] arg31[i];
21191 }
21192 delete[] arg31;
21193 }
21194 }
21195 throw;
21196 }
21197}
21198
21199
21201 PLFLT arg1 ;
21202 PLFLT arg2 ;
21203 PLFLT arg3 ;
21204 double val1 ;
21205 int ecode1 = 0 ;
21206 double val2 ;
21207 int ecode2 = 0 ;
21208 double val3 ;
21209 int ecode3 = 0 ;
21210 octave_value_list _out;
21211 octave_value_list *_outp=&_out;
21212 octave_value _outv;
21213
21214 try {
21215 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21216 SWIG_fail;
21217 }
21218 ecode1 = SWIG_AsVal_double(args(0), &val1);
21219 if (!SWIG_IsOK(ecode1)) {
21220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21221 }
21222 arg1 = static_cast< PLFLT >(val1);
21223 ecode2 = SWIG_AsVal_double(args(1), &val2);
21224 if (!SWIG_IsOK(ecode2)) {
21225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21226 }
21227 arg2 = static_cast< PLFLT >(val2);
21228 ecode3 = SWIG_AsVal_double(args(2), &val3);
21229 if (!SWIG_IsOK(ecode3)) {
21230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21231 }
21232 arg3 = static_cast< PLFLT >(val3);
21233 pllightsource(arg1,arg2,arg3);
21234 _outv = octave_value();
21235 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21236 return _out;
21237 fail:
21238 return octave_value_list();
21239 }
21240 catch(...) {
21241 throw;
21242 }
21243}
21244
21245
21247 PLINT arg1 ;
21248 PLFLT *arg2 = (PLFLT *) 0 ;
21249 PLFLT *arg3 = (PLFLT *) 0 ;
21250 Matrix temp1 ;
21251 Matrix temp3 ;
21252 octave_value_list _out;
21253 octave_value_list *_outp=&_out;
21254 octave_value _outv;
21255
21256 try {
21257 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21258 SWIG_fail;
21259 }
21260 {
21261 if ( _n_dims( args(0) ) > 1 )
21262 {
21263 error( "argument must be a scalar or vector" ); SWIG_fail;
21264 }
21265 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21266 temp1 = args(0).matrix_value();
21267 arg2 = &temp1( 0, 0 );
21268 }
21269 {
21270 if ( _n_dims( args(1) ) > 1 )
21271 {
21272 error( "argument must be a scalar or vector" ); SWIG_fail;
21273 }
21274 if ( _dim( args(1), 0 ) != Alen )
21275 {
21276 error( "argument vectors must be same length" ); SWIG_fail;
21277 }
21278 temp3 = args(1).matrix_value();
21279 arg3 = &temp3( 0, 0 );
21280 }
21281 plline(arg1,(double const *)arg2,(double const *)arg3);
21282 _outv = octave_value();
21283 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21284 {
21285
21286 }
21287 {
21288
21289 }
21290 return _out;
21291 fail:
21292 {
21293
21294 }
21295 {
21296
21297 }
21298 return octave_value_list();
21299 }
21300 catch(...) {
21301 {
21302
21303 }
21304 {
21305
21306 }
21307 throw;
21308 }
21309}
21310
21311
21313 PLINT arg1 ;
21314 PLFLT *arg2 = (PLFLT *) 0 ;
21315 PLFLT *arg3 = (PLFLT *) 0 ;
21316 PLFLT *arg4 = (PLFLT *) 0 ;
21317 Matrix temp1 ;
21318 Matrix temp3 ;
21319 Matrix temp4 ;
21320 octave_value_list _out;
21321 octave_value_list *_outp=&_out;
21322 octave_value _outv;
21323
21324 try {
21325 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21326 SWIG_fail;
21327 }
21328 {
21329 if ( _n_dims( args(0) ) > 1 )
21330 {
21331 error( "argument must be a scalar or vector" ); SWIG_fail;
21332 }
21333 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21334 temp1 = args(0).matrix_value();
21335 arg2 = &temp1( 0, 0 );
21336 }
21337 {
21338 if ( _n_dims( args(1) ) > 1 )
21339 {
21340 error( "argument must be a scalar or vector" ); SWIG_fail;
21341 }
21342 if ( _dim( args(1), 0 ) != Alen )
21343 {
21344 error( "argument vectors must be same length" ); SWIG_fail;
21345 }
21346 temp3 = args(1).matrix_value();
21347 arg3 = &temp3( 0, 0 );
21348 }
21349 {
21350 if ( _n_dims( args(2) ) > 1 )
21351 {
21352 error( "argument must be a scalar or vector" ); SWIG_fail;
21353 }
21354 if ( _dim( args(2), 0 ) != Alen )
21355 {
21356 error( "argument vectors must be same length" ); SWIG_fail;
21357 }
21358 temp4 = args(2).matrix_value();
21359 arg4 = &temp4( 0, 0 );
21360 }
21361 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21362 _outv = octave_value();
21363 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21364 {
21365
21366 }
21367 {
21368
21369 }
21370 {
21371
21372 }
21373 return _out;
21374 fail:
21375 {
21376
21377 }
21378 {
21379
21380 }
21381 {
21382
21383 }
21384 return octave_value_list();
21385 }
21386 catch(...) {
21387 {
21388
21389 }
21390 {
21391
21392 }
21393 {
21394
21395 }
21396 throw;
21397 }
21398}
21399
21400
21402 PLINT arg1 ;
21403 int val1 ;
21404 int ecode1 = 0 ;
21405 octave_value_list _out;
21406 octave_value_list *_outp=&_out;
21407 octave_value _outv;
21408
21409 try {
21410 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21411 SWIG_fail;
21412 }
21413 ecode1 = SWIG_AsVal_int(args(0), &val1);
21414 if (!SWIG_IsOK(ecode1)) {
21415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21416 }
21417 arg1 = static_cast< PLINT >(val1);
21418 pllsty(arg1);
21419 _outv = octave_value();
21420 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21421 return _out;
21422 fail:
21423 return octave_value_list();
21424 }
21425 catch(...) {
21426 throw;
21427 }
21428}
21429
21430
21432 PLINT *arg1 = (PLINT *) 0 ;
21433 PLINT temp1 ;
21434 int res1 = SWIG_TMPOBJ ;
21435 octave_value_list _out;
21436 octave_value_list *_outp=&_out;
21437 octave_value _outv;
21438
21439 try {
21440 arg1 = &temp1;
21441 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21442 SWIG_fail;
21443 }
21444 plmkstrm(arg1);
21445 _outv = octave_value();
21446 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21447 if (SWIG_IsTmpObj(res1)) {
21448 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21449 } else {
21450 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21451 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21452 }
21453 return _out;
21454 fail:
21455 return octave_value_list();
21456 }
21457 catch(...) {
21458 throw;
21459 }
21460}
21461
21462
21464 char *arg1 = (char *) 0 ;
21465 PLFLT arg2 ;
21466 PLFLT arg3 ;
21467 PLFLT arg4 ;
21468 char *arg5 = (char *) 0 ;
21469 int res1 ;
21470 char *buf1 = 0 ;
21471 int alloc1 = 0 ;
21472 double val2 ;
21473 int ecode2 = 0 ;
21474 double val3 ;
21475 int ecode3 = 0 ;
21476 double val4 ;
21477 int ecode4 = 0 ;
21478 int res5 ;
21479 char *buf5 = 0 ;
21480 int alloc5 = 0 ;
21481 octave_value_list _out;
21482 octave_value_list *_outp=&_out;
21483 octave_value _outv;
21484
21485 try {
21486 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21487 SWIG_fail;
21488 }
21489 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21492 }
21493 arg1 = reinterpret_cast< char * >(buf1);
21494 ecode2 = SWIG_AsVal_double(args(1), &val2);
21495 if (!SWIG_IsOK(ecode2)) {
21496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21497 }
21498 arg2 = static_cast< PLFLT >(val2);
21499 ecode3 = SWIG_AsVal_double(args(2), &val3);
21500 if (!SWIG_IsOK(ecode3)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21502 }
21503 arg3 = static_cast< PLFLT >(val3);
21504 ecode4 = SWIG_AsVal_double(args(3), &val4);
21505 if (!SWIG_IsOK(ecode4)) {
21506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21507 }
21508 arg4 = static_cast< PLFLT >(val4);
21509 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21510 if (!SWIG_IsOK(res5)) {
21511 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21512 }
21513 arg5 = reinterpret_cast< char * >(buf5);
21514 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21515 _outv = octave_value();
21516 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21517 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21518 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21519 return _out;
21520 fail:
21521 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21522 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21523 return octave_value_list();
21524 }
21525 catch(...) {
21526 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21527 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21528 throw;
21529 }
21530}
21531
21532
21534 char *arg1 = (char *) 0 ;
21535 PLFLT arg2 ;
21536 PLFLT arg3 ;
21537 PLFLT arg4 ;
21538 char *arg5 = (char *) 0 ;
21539 int res1 ;
21540 char *buf1 = 0 ;
21541 int alloc1 = 0 ;
21542 double val2 ;
21543 int ecode2 = 0 ;
21544 double val3 ;
21545 int ecode3 = 0 ;
21546 double val4 ;
21547 int ecode4 = 0 ;
21548 int res5 ;
21549 char *buf5 = 0 ;
21550 int alloc5 = 0 ;
21551 octave_value_list _out;
21552 octave_value_list *_outp=&_out;
21553 octave_value _outv;
21554
21555 try {
21556 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21557 SWIG_fail;
21558 }
21559 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21560 if (!SWIG_IsOK(res1)) {
21561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21562 }
21563 arg1 = reinterpret_cast< char * >(buf1);
21564 ecode2 = SWIG_AsVal_double(args(1), &val2);
21565 if (!SWIG_IsOK(ecode2)) {
21566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21567 }
21568 arg2 = static_cast< PLFLT >(val2);
21569 ecode3 = SWIG_AsVal_double(args(2), &val3);
21570 if (!SWIG_IsOK(ecode3)) {
21571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21572 }
21573 arg3 = static_cast< PLFLT >(val3);
21574 ecode4 = SWIG_AsVal_double(args(3), &val4);
21575 if (!SWIG_IsOK(ecode4)) {
21576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21577 }
21578 arg4 = static_cast< PLFLT >(val4);
21579 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21580 if (!SWIG_IsOK(res5)) {
21581 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21582 }
21583 arg5 = reinterpret_cast< char * >(buf5);
21584 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21585 _outv = octave_value();
21586 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21587 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21588 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21589 return _out;
21590 fail:
21591 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21592 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21593 return octave_value_list();
21594 }
21595 catch(...) {
21596 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21597 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21598 throw;
21599 }
21600}
21601
21602
21604 int *arg1 = (int *) 0 ;
21605 char **arg2 = (char **) 0 ;
21606 PLINT arg3 ;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 void *argp2 = 0 ;
21610 int res2 = 0 ;
21611 int val3 ;
21612 int ecode3 = 0 ;
21613 octave_value_list _out;
21614 octave_value_list *_outp=&_out;
21615 octave_value _outv;
21616 PLINT result;
21617
21618 try {
21619 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21620 SWIG_fail;
21621 }
21622 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21625 }
21626 arg1 = reinterpret_cast< int * >(argp1);
21627 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21628 if (!SWIG_IsOK(res2)) {
21629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21630 }
21631 arg2 = reinterpret_cast< char ** >(argp2);
21632 ecode3 = SWIG_AsVal_int(args(2), &val3);
21633 if (!SWIG_IsOK(ecode3)) {
21634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21635 }
21636 arg3 = static_cast< PLINT >(val3);
21637 result = (PLINT)plparseopts(arg1,arg2,arg3);
21638 _outv = SWIG_From_int(static_cast< int >(result));
21639 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21640 return _out;
21641 fail:
21642 return octave_value_list();
21643 }
21644 catch(...) {
21645 throw;
21646 }
21647}
21648
21649
21651 PLINT arg1 ;
21652 PLINT *arg2 = (PLINT *) 0 ;
21653 PLINT *arg3 = (PLINT *) 0 ;
21654 Matrix temp1 ;
21655 Matrix temp3 ;
21656 octave_value_list _out;
21657 octave_value_list *_outp=&_out;
21658 octave_value _outv;
21659
21660 try {
21661 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21662 SWIG_fail;
21663 }
21664 {
21665 if ( _n_dims( args(0) ) > 1 )
21666 {
21667 error( "argument must be a scalar or vector" ); SWIG_fail;
21668 }
21669 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21670 arg2 = new PLINT[Alen];
21671 temp1 = args(0).matrix_value();
21672 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21673 }
21674 {
21675 if ( _n_dims( args(1) ) > 1 )
21676 {
21677 error( "argument must be a scalar or vector" ); SWIG_fail;
21678 }
21679 if ( _dim( args(1), 0 ) != Alen )
21680 {
21681 error( "argument vectors must be same length" ); SWIG_fail;
21682 }
21683 temp3 = args(1).matrix_value();
21684 arg3 = new PLINT[Alen];
21685 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21686 }
21687 plpat(arg1,(int const *)arg2,(int const *)arg3);
21688 _outv = octave_value();
21689 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21690 {
21691 delete [] arg2;
21692 }
21693 {
21694 delete [] arg3;
21695 }
21696 return _out;
21697 fail:
21698 {
21699 delete [] arg2;
21700 }
21701 {
21702 delete [] arg3;
21703 }
21704 return octave_value_list();
21705 }
21706 catch(...) {
21707 {
21708 delete [] arg2;
21709 }
21710 {
21711 delete [] arg3;
21712 }
21713 throw;
21714 }
21715}
21716
21717
21719 PLINT arg1 ;
21720 PLFLT arg2 ;
21721 PLFLT arg3 ;
21722 PLFLT arg4 ;
21723 PLFLT arg5 ;
21724 int val1 ;
21725 int ecode1 = 0 ;
21726 double val2 ;
21727 int ecode2 = 0 ;
21728 double val3 ;
21729 int ecode3 = 0 ;
21730 double val4 ;
21731 int ecode4 = 0 ;
21732 double val5 ;
21733 int ecode5 = 0 ;
21734 octave_value_list _out;
21735 octave_value_list *_outp=&_out;
21736 octave_value _outv;
21737
21738 try {
21739 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21740 SWIG_fail;
21741 }
21742 ecode1 = SWIG_AsVal_int(args(0), &val1);
21743 if (!SWIG_IsOK(ecode1)) {
21744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21745 }
21746 arg1 = static_cast< PLINT >(val1);
21747 ecode2 = SWIG_AsVal_double(args(1), &val2);
21748 if (!SWIG_IsOK(ecode2)) {
21749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21750 }
21751 arg2 = static_cast< PLFLT >(val2);
21752 ecode3 = SWIG_AsVal_double(args(2), &val3);
21753 if (!SWIG_IsOK(ecode3)) {
21754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21755 }
21756 arg3 = static_cast< PLFLT >(val3);
21757 ecode4 = SWIG_AsVal_double(args(3), &val4);
21758 if (!SWIG_IsOK(ecode4)) {
21759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21760 }
21761 arg4 = static_cast< PLFLT >(val4);
21762 ecode5 = SWIG_AsVal_double(args(4), &val5);
21763 if (!SWIG_IsOK(ecode5)) {
21764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21765 }
21766 arg5 = static_cast< PLFLT >(val5);
21767 plpath(arg1,arg2,arg3,arg4,arg5);
21768 _outv = octave_value();
21769 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21770 return _out;
21771 fail:
21772 return octave_value_list();
21773 }
21774 catch(...) {
21775 throw;
21776 }
21777}
21778
21779
21781 PLINT arg1 ;
21782 PLFLT *arg2 = (PLFLT *) 0 ;
21783 PLFLT *arg3 = (PLFLT *) 0 ;
21784 PLINT arg4 ;
21785 Matrix temp1 ;
21786 Matrix temp3 ;
21787 int val4 ;
21788 int ecode4 = 0 ;
21789 octave_value_list _out;
21790 octave_value_list *_outp=&_out;
21791 octave_value _outv;
21792
21793 try {
21794 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21795 SWIG_fail;
21796 }
21797 {
21798 if ( _n_dims( args(0) ) > 1 )
21799 {
21800 error( "argument must be a scalar or vector" ); SWIG_fail;
21801 }
21802 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21803 temp1 = args(0).matrix_value();
21804 arg2 = &temp1( 0, 0 );
21805 }
21806 {
21807 if ( _n_dims( args(1) ) > 1 )
21808 {
21809 error( "argument must be a scalar or vector" ); SWIG_fail;
21810 }
21811 if ( _dim( args(1), 0 ) != Alen )
21812 {
21813 error( "argument vectors must be same length" ); SWIG_fail;
21814 }
21815 temp3 = args(1).matrix_value();
21816 arg3 = &temp3( 0, 0 );
21817 }
21818 ecode4 = SWIG_AsVal_int(args(2), &val4);
21819 if (!SWIG_IsOK(ecode4)) {
21820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21821 }
21822 arg4 = static_cast< PLINT >(val4);
21823 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21824 _outv = octave_value();
21825 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21826 {
21827
21828 }
21829 {
21830
21831 }
21832 return _out;
21833 fail:
21834 {
21835
21836 }
21837 {
21838
21839 }
21840 return octave_value_list();
21841 }
21842 catch(...) {
21843 {
21844
21845 }
21846 {
21847
21848 }
21849 throw;
21850 }
21851}
21852
21853
21855 PLINT arg1 ;
21856 PLFLT *arg2 = (PLFLT *) 0 ;
21857 PLFLT *arg3 = (PLFLT *) 0 ;
21858 PLFLT *arg4 = (PLFLT *) 0 ;
21859 PLINT arg5 ;
21860 Matrix temp1 ;
21861 Matrix temp3 ;
21862 Matrix temp4 ;
21863 int val5 ;
21864 int ecode5 = 0 ;
21865 octave_value_list _out;
21866 octave_value_list *_outp=&_out;
21867 octave_value _outv;
21868
21869 try {
21870 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21871 SWIG_fail;
21872 }
21873 {
21874 if ( _n_dims( args(0) ) > 1 )
21875 {
21876 error( "argument must be a scalar or vector" ); SWIG_fail;
21877 }
21878 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21879 temp1 = args(0).matrix_value();
21880 arg2 = &temp1( 0, 0 );
21881 }
21882 {
21883 if ( _n_dims( args(1) ) > 1 )
21884 {
21885 error( "argument must be a scalar or vector" ); SWIG_fail;
21886 }
21887 if ( _dim( args(1), 0 ) != Alen )
21888 {
21889 error( "argument vectors must be same length" ); SWIG_fail;
21890 }
21891 temp3 = args(1).matrix_value();
21892 arg3 = &temp3( 0, 0 );
21893 }
21894 {
21895 if ( _n_dims( args(2) ) > 1 )
21896 {
21897 error( "argument must be a scalar or vector" ); SWIG_fail;
21898 }
21899 if ( _dim( args(2), 0 ) != Alen )
21900 {
21901 error( "argument vectors must be same length" ); SWIG_fail;
21902 }
21903 temp4 = args(2).matrix_value();
21904 arg4 = &temp4( 0, 0 );
21905 }
21906 ecode5 = SWIG_AsVal_int(args(3), &val5);
21907 if (!SWIG_IsOK(ecode5)) {
21908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21909 }
21910 arg5 = static_cast< PLINT >(val5);
21911 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21912 _outv = octave_value();
21913 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21914 {
21915
21916 }
21917 {
21918
21919 }
21920 {
21921
21922 }
21923 return _out;
21924 fail:
21925 {
21926
21927 }
21928 {
21929
21930 }
21931 {
21932
21933 }
21934 return octave_value_list();
21935 }
21936 catch(...) {
21937 {
21938
21939 }
21940 {
21941
21942 }
21943 {
21944
21945 }
21946 throw;
21947 }
21948}
21949
21950
21952 PLINT arg1 ;
21953 PLFLT *arg2 = (PLFLT *) 0 ;
21954 PLFLT *arg3 = (PLFLT *) 0 ;
21955 PLFLT *arg4 = (PLFLT *) 0 ;
21956 PLBOOL *arg5 = (PLBOOL *) 0 ;
21957 PLBOOL arg6 ;
21958 Matrix temp1 ;
21959 Matrix temp3 ;
21960 Matrix temp4 ;
21961 Matrix temp5 ;
21962 int val6 ;
21963 int ecode6 = 0 ;
21964 octave_value_list _out;
21965 octave_value_list *_outp=&_out;
21966 octave_value _outv;
21967
21968 try {
21969 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
21970 SWIG_fail;
21971 }
21972 {
21973 if ( _n_dims( args(0) ) > 1 )
21974 {
21975 error( "argument must be a scalar or vector" ); SWIG_fail;
21976 }
21977 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21978 temp1 = args(0).matrix_value();
21979 arg2 = &temp1( 0, 0 );
21980 }
21981 {
21982 if ( _n_dims( args(1) ) > 1 )
21983 {
21984 error( "argument must be a scalar or vector" ); SWIG_fail;
21985 }
21986 if ( _dim( args(1), 0 ) != Alen )
21987 {
21988 error( "argument vectors must be same length" ); SWIG_fail;
21989 }
21990 temp3 = args(1).matrix_value();
21991 arg3 = &temp3( 0, 0 );
21992 }
21993 {
21994 if ( _n_dims( args(2) ) > 1 )
21995 {
21996 error( "argument must be a scalar or vector" ); SWIG_fail;
21997 }
21998 if ( _dim( args(2), 0 ) != Alen )
21999 {
22000 error( "argument vectors must be same length" ); SWIG_fail;
22001 }
22002 temp4 = args(2).matrix_value();
22003 arg4 = &temp4( 0, 0 );
22004 }
22005 {
22006 if ( _n_dims( args(3) ) > 1 )
22007 {
22008 error( "argument must be a scalar or vector" ); SWIG_fail;
22009 }
22010 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
22011 {
22012 error( "argument vector must be same length or one less" ); SWIG_fail;
22013 }
22014 temp5 = args(3).matrix_value();
22015 arg5 = new PLINT[Alen];
22016 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
22017 }
22018 ecode6 = SWIG_AsVal_int(args(4), &val6);
22019 if (!SWIG_IsOK(ecode6)) {
22020 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
22021 }
22022 arg6 = static_cast< PLBOOL >(val6);
22023 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
22024 _outv = octave_value();
22025 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22026 {
22027
22028 }
22029 {
22030
22031 }
22032 {
22033
22034 }
22035 {
22036 delete [] arg5;
22037 }
22038 return _out;
22039 fail:
22040 {
22041
22042 }
22043 {
22044
22045 }
22046 {
22047
22048 }
22049 {
22050 delete [] arg5;
22051 }
22052 return octave_value_list();
22053 }
22054 catch(...) {
22055 {
22056
22057 }
22058 {
22059
22060 }
22061 {
22062
22063 }
22064 {
22065 delete [] arg5;
22066 }
22067 throw;
22068 }
22069}
22070
22071
22073 PLINT arg1 ;
22074 PLINT arg2 ;
22075 int val1 ;
22076 int ecode1 = 0 ;
22077 int val2 ;
22078 int ecode2 = 0 ;
22079 octave_value_list _out;
22080 octave_value_list *_outp=&_out;
22081 octave_value _outv;
22082
22083 try {
22084 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22085 SWIG_fail;
22086 }
22087 ecode1 = SWIG_AsVal_int(args(0), &val1);
22088 if (!SWIG_IsOK(ecode1)) {
22089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22090 }
22091 arg1 = static_cast< PLINT >(val1);
22092 ecode2 = SWIG_AsVal_int(args(1), &val2);
22093 if (!SWIG_IsOK(ecode2)) {
22094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22095 }
22096 arg2 = static_cast< PLINT >(val2);
22097 plprec(arg1,arg2);
22098 _outv = octave_value();
22099 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22100 return _out;
22101 fail:
22102 return octave_value_list();
22103 }
22104 catch(...) {
22105 throw;
22106 }
22107}
22108
22109
22111 PLINT arg1 ;
22112 int val1 ;
22113 int ecode1 = 0 ;
22114 octave_value_list _out;
22115 octave_value_list *_outp=&_out;
22116 octave_value _outv;
22117
22118 try {
22119 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22120 SWIG_fail;
22121 }
22122 ecode1 = SWIG_AsVal_int(args(0), &val1);
22123 if (!SWIG_IsOK(ecode1)) {
22124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22125 }
22126 arg1 = static_cast< PLINT >(val1);
22127 plpsty(arg1);
22128 _outv = octave_value();
22129 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22130 return _out;
22131 fail:
22132 return octave_value_list();
22133 }
22134 catch(...) {
22135 throw;
22136 }
22137}
22138
22139
22141 PLFLT arg1 ;
22142 PLFLT arg2 ;
22143 PLFLT arg3 ;
22144 PLFLT arg4 ;
22145 PLFLT arg5 ;
22146 char *arg6 = (char *) 0 ;
22147 double val1 ;
22148 int ecode1 = 0 ;
22149 double val2 ;
22150 int ecode2 = 0 ;
22151 double val3 ;
22152 int ecode3 = 0 ;
22153 double val4 ;
22154 int ecode4 = 0 ;
22155 double val5 ;
22156 int ecode5 = 0 ;
22157 int res6 ;
22158 char *buf6 = 0 ;
22159 int alloc6 = 0 ;
22160 octave_value_list _out;
22161 octave_value_list *_outp=&_out;
22162 octave_value _outv;
22163
22164 try {
22165 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22166 SWIG_fail;
22167 }
22168 ecode1 = SWIG_AsVal_double(args(0), &val1);
22169 if (!SWIG_IsOK(ecode1)) {
22170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22171 }
22172 arg1 = static_cast< PLFLT >(val1);
22173 ecode2 = SWIG_AsVal_double(args(1), &val2);
22174 if (!SWIG_IsOK(ecode2)) {
22175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22176 }
22177 arg2 = static_cast< PLFLT >(val2);
22178 ecode3 = SWIG_AsVal_double(args(2), &val3);
22179 if (!SWIG_IsOK(ecode3)) {
22180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22181 }
22182 arg3 = static_cast< PLFLT >(val3);
22183 ecode4 = SWIG_AsVal_double(args(3), &val4);
22184 if (!SWIG_IsOK(ecode4)) {
22185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22186 }
22187 arg4 = static_cast< PLFLT >(val4);
22188 ecode5 = SWIG_AsVal_double(args(4), &val5);
22189 if (!SWIG_IsOK(ecode5)) {
22190 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22191 }
22192 arg5 = static_cast< PLFLT >(val5);
22193 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22194 if (!SWIG_IsOK(res6)) {
22195 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22196 }
22197 arg6 = reinterpret_cast< char * >(buf6);
22198 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22199 _outv = octave_value();
22200 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22201 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22202 return _out;
22203 fail:
22204 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22205 return octave_value_list();
22206 }
22207 catch(...) {
22208 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22209 throw;
22210 }
22211}
22212
22213
22215 PLFLT arg1 ;
22216 PLFLT arg2 ;
22217 PLFLT arg3 ;
22218 PLFLT arg4 ;
22219 PLFLT arg5 ;
22220 PLFLT arg6 ;
22221 PLFLT arg7 ;
22222 PLFLT arg8 ;
22223 PLFLT arg9 ;
22224 PLFLT arg10 ;
22225 char *arg11 = (char *) 0 ;
22226 double val1 ;
22227 int ecode1 = 0 ;
22228 double val2 ;
22229 int ecode2 = 0 ;
22230 double val3 ;
22231 int ecode3 = 0 ;
22232 double val4 ;
22233 int ecode4 = 0 ;
22234 double val5 ;
22235 int ecode5 = 0 ;
22236 double val6 ;
22237 int ecode6 = 0 ;
22238 double val7 ;
22239 int ecode7 = 0 ;
22240 double val8 ;
22241 int ecode8 = 0 ;
22242 double val9 ;
22243 int ecode9 = 0 ;
22244 double val10 ;
22245 int ecode10 = 0 ;
22246 int res11 ;
22247 char *buf11 = 0 ;
22248 int alloc11 = 0 ;
22249 octave_value_list _out;
22250 octave_value_list *_outp=&_out;
22251 octave_value _outv;
22252
22253 try {
22254 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22255 SWIG_fail;
22256 }
22257 ecode1 = SWIG_AsVal_double(args(0), &val1);
22258 if (!SWIG_IsOK(ecode1)) {
22259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22260 }
22261 arg1 = static_cast< PLFLT >(val1);
22262 ecode2 = SWIG_AsVal_double(args(1), &val2);
22263 if (!SWIG_IsOK(ecode2)) {
22264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22265 }
22266 arg2 = static_cast< PLFLT >(val2);
22267 ecode3 = SWIG_AsVal_double(args(2), &val3);
22268 if (!SWIG_IsOK(ecode3)) {
22269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22270 }
22271 arg3 = static_cast< PLFLT >(val3);
22272 ecode4 = SWIG_AsVal_double(args(3), &val4);
22273 if (!SWIG_IsOK(ecode4)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22275 }
22276 arg4 = static_cast< PLFLT >(val4);
22277 ecode5 = SWIG_AsVal_double(args(4), &val5);
22278 if (!SWIG_IsOK(ecode5)) {
22279 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22280 }
22281 arg5 = static_cast< PLFLT >(val5);
22282 ecode6 = SWIG_AsVal_double(args(5), &val6);
22283 if (!SWIG_IsOK(ecode6)) {
22284 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22285 }
22286 arg6 = static_cast< PLFLT >(val6);
22287 ecode7 = SWIG_AsVal_double(args(6), &val7);
22288 if (!SWIG_IsOK(ecode7)) {
22289 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22290 }
22291 arg7 = static_cast< PLFLT >(val7);
22292 ecode8 = SWIG_AsVal_double(args(7), &val8);
22293 if (!SWIG_IsOK(ecode8)) {
22294 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22295 }
22296 arg8 = static_cast< PLFLT >(val8);
22297 ecode9 = SWIG_AsVal_double(args(8), &val9);
22298 if (!SWIG_IsOK(ecode9)) {
22299 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22300 }
22301 arg9 = static_cast< PLFLT >(val9);
22302 ecode10 = SWIG_AsVal_double(args(9), &val10);
22303 if (!SWIG_IsOK(ecode10)) {
22304 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22305 }
22306 arg10 = static_cast< PLFLT >(val10);
22307 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22308 if (!SWIG_IsOK(res11)) {
22309 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22310 }
22311 arg11 = reinterpret_cast< char * >(buf11);
22312 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22313 _outv = octave_value();
22314 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22315 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22316 return _out;
22317 fail:
22318 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22319 return octave_value_list();
22320 }
22321 catch(...) {
22322 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22323 throw;
22324 }
22325}
22326
22327
22329 octave_value_list _out;
22330 octave_value_list *_outp=&_out;
22331 octave_value _outv;
22332 PLFLT result;
22333
22334 try {
22335 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22336 SWIG_fail;
22337 }
22338 result = (PLFLT)plrandd();
22339 _outv = SWIG_From_double(static_cast< double >(result));
22340 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22341 return _out;
22342 fail:
22343 return octave_value_list();
22344 }
22345 catch(...) {
22346 throw;
22347 }
22348}
22349
22350
22352 octave_value_list _out;
22353 octave_value_list *_outp=&_out;
22354 octave_value _outv;
22355
22356 try {
22357 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22358 SWIG_fail;
22359 }
22360 plreplot();
22361 _outv = octave_value();
22362 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22363 return _out;
22364 fail:
22365 return octave_value_list();
22366 }
22367 catch(...) {
22368 throw;
22369 }
22370}
22371
22372
22374 PLFLT arg1 ;
22375 PLFLT arg2 ;
22376 PLFLT arg3 ;
22377 PLFLT *arg4 = (PLFLT *) 0 ;
22378 PLFLT *arg5 = (PLFLT *) 0 ;
22379 PLFLT *arg6 = (PLFLT *) 0 ;
22380 double val1 ;
22381 int ecode1 = 0 ;
22382 double val2 ;
22383 int ecode2 = 0 ;
22384 double val3 ;
22385 int ecode3 = 0 ;
22386 PLFLT temp4 ;
22387 int res4 = SWIG_TMPOBJ ;
22388 PLFLT temp5 ;
22389 int res5 = SWIG_TMPOBJ ;
22390 PLFLT temp6 ;
22391 int res6 = SWIG_TMPOBJ ;
22392 octave_value_list _out;
22393 octave_value_list *_outp=&_out;
22394 octave_value _outv;
22395
22396 try {
22397 arg4 = &temp4;
22398 arg5 = &temp5;
22399 arg6 = &temp6;
22400 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22401 SWIG_fail;
22402 }
22403 ecode1 = SWIG_AsVal_double(args(0), &val1);
22404 if (!SWIG_IsOK(ecode1)) {
22405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22406 }
22407 arg1 = static_cast< PLFLT >(val1);
22408 ecode2 = SWIG_AsVal_double(args(1), &val2);
22409 if (!SWIG_IsOK(ecode2)) {
22410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22411 }
22412 arg2 = static_cast< PLFLT >(val2);
22413 ecode3 = SWIG_AsVal_double(args(2), &val3);
22414 if (!SWIG_IsOK(ecode3)) {
22415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22416 }
22417 arg3 = static_cast< PLFLT >(val3);
22418 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22419 _outv = octave_value();
22420 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22421 if (SWIG_IsTmpObj(res4)) {
22422 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22423 } else {
22424 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22425 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22426 }
22427 if (SWIG_IsTmpObj(res5)) {
22428 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22429 } else {
22430 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22431 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22432 }
22433 if (SWIG_IsTmpObj(res6)) {
22434 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22435 } else {
22436 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22437 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22438 }
22439 return _out;
22440 fail:
22441 return octave_value_list();
22442 }
22443 catch(...) {
22444 throw;
22445 }
22446}
22447
22448
22450 PLFLT arg1 ;
22451 PLFLT arg2 ;
22452 double val1 ;
22453 int ecode1 = 0 ;
22454 double val2 ;
22455 int ecode2 = 0 ;
22456 octave_value_list _out;
22457 octave_value_list *_outp=&_out;
22458 octave_value _outv;
22459
22460 try {
22461 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22462 SWIG_fail;
22463 }
22464 ecode1 = SWIG_AsVal_double(args(0), &val1);
22465 if (!SWIG_IsOK(ecode1)) {
22466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22467 }
22468 arg1 = static_cast< PLFLT >(val1);
22469 ecode2 = SWIG_AsVal_double(args(1), &val2);
22470 if (!SWIG_IsOK(ecode2)) {
22471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22472 }
22473 arg2 = static_cast< PLFLT >(val2);
22474 plschr(arg1,arg2);
22475 _outv = octave_value();
22476 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22477 return _out;
22478 fail:
22479 return octave_value_list();
22480 }
22481 catch(...) {
22482 throw;
22483 }
22484}
22485
22486
22488 PLINT *arg1 = (PLINT *) 0 ;
22489 PLINT *arg2 = (PLINT *) 0 ;
22490 PLINT *arg3 = (PLINT *) 0 ;
22491 PLINT arg4 ;
22492 Matrix temp1 ;
22493 Matrix temp2 ;
22494 Matrix temp3 ;
22495 octave_value_list _out;
22496 octave_value_list *_outp=&_out;
22497 octave_value _outv;
22498
22499 try {
22500 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22501 SWIG_fail;
22502 }
22503 {
22504 if ( _n_dims( args(0) ) > 1 )
22505 {
22506 error( "argument must be a scalar or vector" ); SWIG_fail;
22507 }
22508 Alen = (PLINT) ( _dim( args(0), 0 ) );
22509 temp1 = args(0).matrix_value();
22510 arg1 = new PLINT[Alen];
22511 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22512 }
22513 {
22514 if ( _n_dims( args(1) ) > 1 )
22515 {
22516 error( "argument must be a scalar or vector" ); SWIG_fail;
22517 }
22518 if ( _dim( args(1), 0 ) != Alen )
22519 {
22520 error( "argument vectors must be same length" ); SWIG_fail;
22521 }
22522 temp2 = args(1).matrix_value();
22523 arg2 = new PLINT[Alen];
22524 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22525 }
22526 {
22527 if ( _n_dims( args(2) ) > 1 )
22528 {
22529 error( "argument must be a scalar or vector" ); SWIG_fail;
22530 }
22531 if ( _dim( args(2), 0 ) != Alen )
22532 {
22533 error( "argument vectors must be same length" ); SWIG_fail;
22534 }
22535 temp3 = args(2).matrix_value();
22536 arg3 = new PLINT[Alen];
22537 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22538 arg4 = Alen;
22539 }
22540 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22541 _outv = octave_value();
22542 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22543 {
22544 delete [] arg1;
22545 }
22546 {
22547 delete [] arg2;
22548 }
22549 {
22550 delete [] arg3;
22551 }
22552 return _out;
22553 fail:
22554 {
22555 delete [] arg1;
22556 }
22557 {
22558 delete [] arg2;
22559 }
22560 {
22561 delete [] arg3;
22562 }
22563 return octave_value_list();
22564 }
22565 catch(...) {
22566 {
22567 delete [] arg1;
22568 }
22569 {
22570 delete [] arg2;
22571 }
22572 {
22573 delete [] arg3;
22574 }
22575 throw;
22576 }
22577}
22578
22579
22581 PLINT *arg1 = (PLINT *) 0 ;
22582 PLINT *arg2 = (PLINT *) 0 ;
22583 PLINT *arg3 = (PLINT *) 0 ;
22584 PLFLT *arg4 = (PLFLT *) 0 ;
22585 PLINT arg5 ;
22586 Matrix temp1 ;
22587 Matrix temp2 ;
22588 Matrix temp3 ;
22589 Matrix temp4 ;
22590 octave_value_list _out;
22591 octave_value_list *_outp=&_out;
22592 octave_value _outv;
22593
22594 try {
22595 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22596 SWIG_fail;
22597 }
22598 {
22599 if ( _n_dims( args(0) ) > 1 )
22600 {
22601 error( "argument must be a scalar or vector" ); SWIG_fail;
22602 }
22603 Alen = (PLINT) ( _dim( args(0), 0 ) );
22604 temp1 = args(0).matrix_value();
22605 arg1 = new PLINT[Alen];
22606 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22607 }
22608 {
22609 if ( _n_dims( args(1) ) > 1 )
22610 {
22611 error( "argument must be a scalar or vector" ); SWIG_fail;
22612 }
22613 if ( _dim( args(1), 0 ) != Alen )
22614 {
22615 error( "argument vectors must be same length" ); SWIG_fail;
22616 }
22617 temp2 = args(1).matrix_value();
22618 arg2 = new PLINT[Alen];
22619 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22620 }
22621 {
22622 if ( _n_dims( args(2) ) > 1 )
22623 {
22624 error( "argument must be a scalar or vector" ); SWIG_fail;
22625 }
22626 if ( _dim( args(2), 0 ) != Alen )
22627 {
22628 error( "argument vectors must be same length" ); SWIG_fail;
22629 }
22630 temp3 = args(2).matrix_value();
22631 arg3 = new PLINT[Alen];
22632 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22633 }
22634 {
22635 if ( _n_dims( args(3) ) > 1 )
22636 {
22637 error( "argument must be a scalar or vector" ); SWIG_fail;
22638 }
22639 if ( _dim( args(3), 0 ) != Alen )
22640 {
22641 error( "argument vectors must be same length" ); SWIG_fail;
22642 }
22643 temp4 = args(3).matrix_value();
22644 arg4 = &temp4( 0, 0 );
22645 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22646 }
22647 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22648 _outv = octave_value();
22649 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22650 {
22651 delete [] arg1;
22652 }
22653 {
22654 delete [] arg2;
22655 }
22656 {
22657 delete [] arg3;
22658 }
22659 {
22660
22661 }
22662 return _out;
22663 fail:
22664 {
22665 delete [] arg1;
22666 }
22667 {
22668 delete [] arg2;
22669 }
22670 {
22671 delete [] arg3;
22672 }
22673 {
22674
22675 }
22676 return octave_value_list();
22677 }
22678 catch(...) {
22679 {
22680 delete [] arg1;
22681 }
22682 {
22683 delete [] arg2;
22684 }
22685 {
22686 delete [] arg3;
22687 }
22688 {
22689
22690 }
22691 throw;
22692 }
22693}
22694
22695
22697 PLINT arg1 ;
22698 int val1 ;
22699 int ecode1 = 0 ;
22700 octave_value_list _out;
22701 octave_value_list *_outp=&_out;
22702 octave_value _outv;
22703
22704 try {
22705 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22706 SWIG_fail;
22707 }
22708 ecode1 = SWIG_AsVal_int(args(0), &val1);
22709 if (!SWIG_IsOK(ecode1)) {
22710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22711 }
22712 arg1 = static_cast< PLINT >(val1);
22713 plscmap0n(arg1);
22714 _outv = octave_value();
22715 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22716 return _out;
22717 fail:
22718 return octave_value_list();
22719 }
22720 catch(...) {
22721 throw;
22722 }
22723}
22724
22725
22727 PLINT *arg1 = (PLINT *) 0 ;
22728 PLINT *arg2 = (PLINT *) 0 ;
22729 PLINT *arg3 = (PLINT *) 0 ;
22730 PLINT arg4 ;
22731 Matrix temp1 ;
22732 Matrix temp2 ;
22733 Matrix temp3 ;
22734 octave_value_list _out;
22735 octave_value_list *_outp=&_out;
22736 octave_value _outv;
22737
22738 try {
22739 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22740 SWIG_fail;
22741 }
22742 {
22743 if ( _n_dims( args(0) ) > 1 )
22744 {
22745 error( "argument must be a scalar or vector" ); SWIG_fail;
22746 }
22747 Alen = (PLINT) ( _dim( args(0), 0 ) );
22748 temp1 = args(0).matrix_value();
22749 arg1 = new PLINT[Alen];
22750 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22751 }
22752 {
22753 if ( _n_dims( args(1) ) > 1 )
22754 {
22755 error( "argument must be a scalar or vector" ); SWIG_fail;
22756 }
22757 if ( _dim( args(1), 0 ) != Alen )
22758 {
22759 error( "argument vectors must be same length" ); SWIG_fail;
22760 }
22761 temp2 = args(1).matrix_value();
22762 arg2 = new PLINT[Alen];
22763 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22764 }
22765 {
22766 if ( _n_dims( args(2) ) > 1 )
22767 {
22768 error( "argument must be a scalar or vector" ); SWIG_fail;
22769 }
22770 if ( _dim( args(2), 0 ) != Alen )
22771 {
22772 error( "argument vectors must be same length" ); SWIG_fail;
22773 }
22774 temp3 = args(2).matrix_value();
22775 arg3 = new PLINT[Alen];
22776 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22777 arg4 = Alen;
22778 }
22779 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22780 _outv = octave_value();
22781 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22782 {
22783 delete [] arg1;
22784 }
22785 {
22786 delete [] arg2;
22787 }
22788 {
22789 delete [] arg3;
22790 }
22791 return _out;
22792 fail:
22793 {
22794 delete [] arg1;
22795 }
22796 {
22797 delete [] arg2;
22798 }
22799 {
22800 delete [] arg3;
22801 }
22802 return octave_value_list();
22803 }
22804 catch(...) {
22805 {
22806 delete [] arg1;
22807 }
22808 {
22809 delete [] arg2;
22810 }
22811 {
22812 delete [] arg3;
22813 }
22814 throw;
22815 }
22816}
22817
22818
22820 PLINT *arg1 = (PLINT *) 0 ;
22821 PLINT *arg2 = (PLINT *) 0 ;
22822 PLINT *arg3 = (PLINT *) 0 ;
22823 PLFLT *arg4 = (PLFLT *) 0 ;
22824 PLINT arg5 ;
22825 Matrix temp1 ;
22826 Matrix temp2 ;
22827 Matrix temp3 ;
22828 Matrix temp4 ;
22829 octave_value_list _out;
22830 octave_value_list *_outp=&_out;
22831 octave_value _outv;
22832
22833 try {
22834 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22835 SWIG_fail;
22836 }
22837 {
22838 if ( _n_dims( args(0) ) > 1 )
22839 {
22840 error( "argument must be a scalar or vector" ); SWIG_fail;
22841 }
22842 Alen = (PLINT) ( _dim( args(0), 0 ) );
22843 temp1 = args(0).matrix_value();
22844 arg1 = new PLINT[Alen];
22845 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22846 }
22847 {
22848 if ( _n_dims( args(1) ) > 1 )
22849 {
22850 error( "argument must be a scalar or vector" ); SWIG_fail;
22851 }
22852 if ( _dim( args(1), 0 ) != Alen )
22853 {
22854 error( "argument vectors must be same length" ); SWIG_fail;
22855 }
22856 temp2 = args(1).matrix_value();
22857 arg2 = new PLINT[Alen];
22858 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22859 }
22860 {
22861 if ( _n_dims( args(2) ) > 1 )
22862 {
22863 error( "argument must be a scalar or vector" ); SWIG_fail;
22864 }
22865 if ( _dim( args(2), 0 ) != Alen )
22866 {
22867 error( "argument vectors must be same length" ); SWIG_fail;
22868 }
22869 temp3 = args(2).matrix_value();
22870 arg3 = new PLINT[Alen];
22871 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22872 }
22873 {
22874 if ( _n_dims( args(3) ) > 1 )
22875 {
22876 error( "argument must be a scalar or vector" ); SWIG_fail;
22877 }
22878 if ( _dim( args(3), 0 ) != Alen )
22879 {
22880 error( "argument vectors must be same length" ); SWIG_fail;
22881 }
22882 temp4 = args(3).matrix_value();
22883 arg4 = &temp4( 0, 0 );
22884 arg5 = (PLINT) ( _dim( args(3), 0 ) );
22885 }
22886 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22887 _outv = octave_value();
22888 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22889 {
22890 delete [] arg1;
22891 }
22892 {
22893 delete [] arg2;
22894 }
22895 {
22896 delete [] arg3;
22897 }
22898 {
22899
22900 }
22901 return _out;
22902 fail:
22903 {
22904 delete [] arg1;
22905 }
22906 {
22907 delete [] arg2;
22908 }
22909 {
22910 delete [] arg3;
22911 }
22912 {
22913
22914 }
22915 return octave_value_list();
22916 }
22917 catch(...) {
22918 {
22919 delete [] arg1;
22920 }
22921 {
22922 delete [] arg2;
22923 }
22924 {
22925 delete [] arg3;
22926 }
22927 {
22928
22929 }
22930 throw;
22931 }
22932}
22933
22934
22936 PLBOOL arg1 ;
22937 PLINT arg2 ;
22938 PLFLT *arg3 = (PLFLT *) 0 ;
22939 PLFLT *arg4 = (PLFLT *) 0 ;
22940 PLFLT *arg5 = (PLFLT *) 0 ;
22941 PLFLT *arg6 = (PLFLT *) 0 ;
22942 PLBOOL *arg7 = (PLBOOL *) 0 ;
22943 int val1 ;
22944 int ecode1 = 0 ;
22945 Matrix temp2 ;
22946 Matrix temp4 ;
22947 Matrix temp5 ;
22948 Matrix temp6 ;
22949 Matrix temp7 ;
22950 octave_value_list _out;
22951 octave_value_list *_outp=&_out;
22952 octave_value _outv;
22953
22954 try {
22955 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
22956 SWIG_fail;
22957 }
22958 ecode1 = SWIG_AsVal_int(args(0), &val1);
22959 if (!SWIG_IsOK(ecode1)) {
22960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
22961 }
22962 arg1 = static_cast< PLBOOL >(val1);
22963 {
22964 if ( _n_dims( args(1) ) > 1 )
22965 {
22966 error( "argument must be a scalar or vector" ); SWIG_fail;
22967 }
22968 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22969 temp2 = args(1).matrix_value();
22970 arg3 = &temp2( 0, 0 );
22971 }
22972 {
22973 if ( _n_dims( args(2) ) > 1 )
22974 {
22975 error( "argument must be a scalar or vector" ); SWIG_fail;
22976 }
22977 if ( _dim( args(2), 0 ) != Alen )
22978 {
22979 error( "argument vectors must be same length" ); SWIG_fail;
22980 }
22981 temp4 = args(2).matrix_value();
22982 arg4 = &temp4( 0, 0 );
22983 }
22984 {
22985 if ( _n_dims( args(3) ) > 1 )
22986 {
22987 error( "argument must be a scalar or vector" ); SWIG_fail;
22988 }
22989 if ( _dim( args(3), 0 ) != Alen )
22990 {
22991 error( "argument vectors must be same length" ); SWIG_fail;
22992 }
22993 temp5 = args(3).matrix_value();
22994 arg5 = &temp5( 0, 0 );
22995 }
22996 {
22997 if ( _n_dims( args(4) ) > 1 )
22998 {
22999 error( "argument must be a scalar or vector" ); SWIG_fail;
23000 }
23001 if ( _dim( args(4), 0 ) != Alen )
23002 {
23003 error( "argument vectors must be same length" ); SWIG_fail;
23004 }
23005 temp6 = args(4).matrix_value();
23006 arg6 = &temp6( 0, 0 );
23007 }
23008 {
23009 if ( _n_dims( args(5) ) > 1 )
23010 {
23011 error( "argument must be a scalar or vector" ); SWIG_fail;
23012 }
23013 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
23014 {
23015 error( "argument vector must be same length or one less" ); SWIG_fail;
23016 }
23017 temp7 = args(5).matrix_value();
23018 arg7 = new PLINT[Alen];
23019 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
23020 }
23021 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
23022 _outv = octave_value();
23023 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23024 {
23025
23026 }
23027 {
23028
23029 }
23030 {
23031
23032 }
23033 {
23034
23035 }
23036 {
23037 delete [] arg7;
23038 }
23039 return _out;
23040 fail:
23041 {
23042
23043 }
23044 {
23045
23046 }
23047 {
23048
23049 }
23050 {
23051
23052 }
23053 {
23054 delete [] arg7;
23055 }
23056 return octave_value_list();
23057 }
23058 catch(...) {
23059 {
23060
23061 }
23062 {
23063
23064 }
23065 {
23066
23067 }
23068 {
23069
23070 }
23071 {
23072 delete [] arg7;
23073 }
23074 throw;
23075 }
23076}
23077
23078
23080 PLBOOL arg1 ;
23081 PLINT arg2 ;
23082 PLFLT *arg3 = (PLFLT *) 0 ;
23083 PLFLT *arg4 = (PLFLT *) 0 ;
23084 PLFLT *arg5 = (PLFLT *) 0 ;
23085 PLFLT *arg6 = (PLFLT *) 0 ;
23086 PLFLT *arg7 = (PLFLT *) 0 ;
23087 PLBOOL *arg8 = (PLBOOL *) 0 ;
23088 int val1 ;
23089 int ecode1 = 0 ;
23090 Matrix temp2 ;
23091 Matrix temp4 ;
23092 Matrix temp5 ;
23093 Matrix temp6 ;
23094 Matrix temp7 ;
23095 Matrix temp8 ;
23096 octave_value_list _out;
23097 octave_value_list *_outp=&_out;
23098 octave_value _outv;
23099
23100 try {
23101 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23102 SWIG_fail;
23103 }
23104 ecode1 = SWIG_AsVal_int(args(0), &val1);
23105 if (!SWIG_IsOK(ecode1)) {
23106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23107 }
23108 arg1 = static_cast< PLBOOL >(val1);
23109 {
23110 if ( _n_dims( args(1) ) > 1 )
23111 {
23112 error( "argument must be a scalar or vector" ); SWIG_fail;
23113 }
23114 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23115 temp2 = args(1).matrix_value();
23116 arg3 = &temp2( 0, 0 );
23117 }
23118 {
23119 if ( _n_dims( args(2) ) > 1 )
23120 {
23121 error( "argument must be a scalar or vector" ); SWIG_fail;
23122 }
23123 if ( _dim( args(2), 0 ) != Alen )
23124 {
23125 error( "argument vectors must be same length" ); SWIG_fail;
23126 }
23127 temp4 = args(2).matrix_value();
23128 arg4 = &temp4( 0, 0 );
23129 }
23130 {
23131 if ( _n_dims( args(3) ) > 1 )
23132 {
23133 error( "argument must be a scalar or vector" ); SWIG_fail;
23134 }
23135 if ( _dim( args(3), 0 ) != Alen )
23136 {
23137 error( "argument vectors must be same length" ); SWIG_fail;
23138 }
23139 temp5 = args(3).matrix_value();
23140 arg5 = &temp5( 0, 0 );
23141 }
23142 {
23143 if ( _n_dims( args(4) ) > 1 )
23144 {
23145 error( "argument must be a scalar or vector" ); SWIG_fail;
23146 }
23147 if ( _dim( args(4), 0 ) != Alen )
23148 {
23149 error( "argument vectors must be same length" ); SWIG_fail;
23150 }
23151 temp6 = args(4).matrix_value();
23152 arg6 = &temp6( 0, 0 );
23153 }
23154 {
23155 if ( _n_dims( args(5) ) > 1 )
23156 {
23157 error( "argument must be a scalar or vector" ); SWIG_fail;
23158 }
23159 if ( _dim( args(5), 0 ) != Alen )
23160 {
23161 error( "argument vectors must be same length" ); SWIG_fail;
23162 }
23163 temp7 = args(5).matrix_value();
23164 arg7 = &temp7( 0, 0 );
23165 }
23166 {
23167 if ( _n_dims( args(6) ) > 1 )
23168 {
23169 error( "argument must be a scalar or vector" ); SWIG_fail;
23170 }
23171 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23172 {
23173 error( "argument vector must be same length or one less" ); SWIG_fail;
23174 }
23175 temp8 = args(6).matrix_value();
23176 arg8 = new PLINT[Alen];
23177 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23178 }
23179 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23180 _outv = octave_value();
23181 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23182 {
23183
23184 }
23185 {
23186
23187 }
23188 {
23189
23190 }
23191 {
23192
23193 }
23194 {
23195
23196 }
23197 {
23198 delete [] arg8;
23199 }
23200 return _out;
23201 fail:
23202 {
23203
23204 }
23205 {
23206
23207 }
23208 {
23209
23210 }
23211 {
23212
23213 }
23214 {
23215
23216 }
23217 {
23218 delete [] arg8;
23219 }
23220 return octave_value_list();
23221 }
23222 catch(...) {
23223 {
23224
23225 }
23226 {
23227
23228 }
23229 {
23230
23231 }
23232 {
23233
23234 }
23235 {
23236
23237 }
23238 {
23239 delete [] arg8;
23240 }
23241 throw;
23242 }
23243}
23244
23245
23247 PLINT arg1 ;
23248 int val1 ;
23249 int ecode1 = 0 ;
23250 octave_value_list _out;
23251 octave_value_list *_outp=&_out;
23252 octave_value _outv;
23253
23254 try {
23255 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23256 SWIG_fail;
23257 }
23258 ecode1 = SWIG_AsVal_int(args(0), &val1);
23259 if (!SWIG_IsOK(ecode1)) {
23260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23261 }
23262 arg1 = static_cast< PLINT >(val1);
23263 plscmap1n(arg1);
23264 _outv = octave_value();
23265 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23266 return _out;
23267 fail:
23268 return octave_value_list();
23269 }
23270 catch(...) {
23271 throw;
23272 }
23273}
23274
23275
23277 PLFLT arg1 ;
23278 PLFLT arg2 ;
23279 double val1 ;
23280 int ecode1 = 0 ;
23281 double val2 ;
23282 int ecode2 = 0 ;
23283 octave_value_list _out;
23284 octave_value_list *_outp=&_out;
23285 octave_value _outv;
23286
23287 try {
23288 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23289 SWIG_fail;
23290 }
23291 ecode1 = SWIG_AsVal_double(args(0), &val1);
23292 if (!SWIG_IsOK(ecode1)) {
23293 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23294 }
23295 arg1 = static_cast< PLFLT >(val1);
23296 ecode2 = SWIG_AsVal_double(args(1), &val2);
23297 if (!SWIG_IsOK(ecode2)) {
23298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23299 }
23300 arg2 = static_cast< PLFLT >(val2);
23301 plscmap1_range(arg1,arg2);
23302 _outv = octave_value();
23303 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23304 return _out;
23305 fail:
23306 return octave_value_list();
23307 }
23308 catch(...) {
23309 throw;
23310 }
23311}
23312
23313
23315 PLFLT *arg1 = (PLFLT *) 0 ;
23316 PLFLT *arg2 = (PLFLT *) 0 ;
23317 PLFLT temp1 ;
23318 int res1 = SWIG_TMPOBJ ;
23319 PLFLT temp2 ;
23320 int res2 = SWIG_TMPOBJ ;
23321 octave_value_list _out;
23322 octave_value_list *_outp=&_out;
23323 octave_value _outv;
23324
23325 try {
23326 arg1 = &temp1;
23327 arg2 = &temp2;
23328 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23329 SWIG_fail;
23330 }
23331 plgcmap1_range(arg1,arg2);
23332 _outv = octave_value();
23333 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23334 if (SWIG_IsTmpObj(res1)) {
23335 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23336 } else {
23337 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23338 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23339 }
23340 if (SWIG_IsTmpObj(res2)) {
23341 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23342 } else {
23343 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23344 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23345 }
23346 return _out;
23347 fail:
23348 return octave_value_list();
23349 }
23350 catch(...) {
23351 throw;
23352 }
23353}
23354
23355
23357 PLINT arg1 ;
23358 PLINT arg2 ;
23359 PLINT arg3 ;
23360 PLINT arg4 ;
23361 int val1 ;
23362 int ecode1 = 0 ;
23363 int val2 ;
23364 int ecode2 = 0 ;
23365 int val3 ;
23366 int ecode3 = 0 ;
23367 int val4 ;
23368 int ecode4 = 0 ;
23369 octave_value_list _out;
23370 octave_value_list *_outp=&_out;
23371 octave_value _outv;
23372
23373 try {
23374 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23375 SWIG_fail;
23376 }
23377 ecode1 = SWIG_AsVal_int(args(0), &val1);
23378 if (!SWIG_IsOK(ecode1)) {
23379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23380 }
23381 arg1 = static_cast< PLINT >(val1);
23382 ecode2 = SWIG_AsVal_int(args(1), &val2);
23383 if (!SWIG_IsOK(ecode2)) {
23384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23385 }
23386 arg2 = static_cast< PLINT >(val2);
23387 ecode3 = SWIG_AsVal_int(args(2), &val3);
23388 if (!SWIG_IsOK(ecode3)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23390 }
23391 arg3 = static_cast< PLINT >(val3);
23392 ecode4 = SWIG_AsVal_int(args(3), &val4);
23393 if (!SWIG_IsOK(ecode4)) {
23394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23395 }
23396 arg4 = static_cast< PLINT >(val4);
23397 plscol0(arg1,arg2,arg3,arg4);
23398 _outv = octave_value();
23399 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23400 return _out;
23401 fail:
23402 return octave_value_list();
23403 }
23404 catch(...) {
23405 throw;
23406 }
23407}
23408
23409
23411 PLINT arg1 ;
23412 PLINT arg2 ;
23413 PLINT arg3 ;
23414 PLINT arg4 ;
23415 PLFLT arg5 ;
23416 int val1 ;
23417 int ecode1 = 0 ;
23418 int val2 ;
23419 int ecode2 = 0 ;
23420 int val3 ;
23421 int ecode3 = 0 ;
23422 int val4 ;
23423 int ecode4 = 0 ;
23424 double val5 ;
23425 int ecode5 = 0 ;
23426 octave_value_list _out;
23427 octave_value_list *_outp=&_out;
23428 octave_value _outv;
23429
23430 try {
23431 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23432 SWIG_fail;
23433 }
23434 ecode1 = SWIG_AsVal_int(args(0), &val1);
23435 if (!SWIG_IsOK(ecode1)) {
23436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23437 }
23438 arg1 = static_cast< PLINT >(val1);
23439 ecode2 = SWIG_AsVal_int(args(1), &val2);
23440 if (!SWIG_IsOK(ecode2)) {
23441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23442 }
23443 arg2 = static_cast< PLINT >(val2);
23444 ecode3 = SWIG_AsVal_int(args(2), &val3);
23445 if (!SWIG_IsOK(ecode3)) {
23446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23447 }
23448 arg3 = static_cast< PLINT >(val3);
23449 ecode4 = SWIG_AsVal_int(args(3), &val4);
23450 if (!SWIG_IsOK(ecode4)) {
23451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23452 }
23453 arg4 = static_cast< PLINT >(val4);
23454 ecode5 = SWIG_AsVal_double(args(4), &val5);
23455 if (!SWIG_IsOK(ecode5)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23457 }
23458 arg5 = static_cast< PLFLT >(val5);
23459 plscol0a(arg1,arg2,arg3,arg4,arg5);
23460 _outv = octave_value();
23461 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23462 return _out;
23463 fail:
23464 return octave_value_list();
23465 }
23466 catch(...) {
23467 throw;
23468 }
23469}
23470
23471
23473 PLINT arg1 ;
23474 PLINT arg2 ;
23475 PLINT arg3 ;
23476 int val1 ;
23477 int ecode1 = 0 ;
23478 int val2 ;
23479 int ecode2 = 0 ;
23480 int val3 ;
23481 int ecode3 = 0 ;
23482 octave_value_list _out;
23483 octave_value_list *_outp=&_out;
23484 octave_value _outv;
23485
23486 try {
23487 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23488 SWIG_fail;
23489 }
23490 ecode1 = SWIG_AsVal_int(args(0), &val1);
23491 if (!SWIG_IsOK(ecode1)) {
23492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23493 }
23494 arg1 = static_cast< PLINT >(val1);
23495 ecode2 = SWIG_AsVal_int(args(1), &val2);
23496 if (!SWIG_IsOK(ecode2)) {
23497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23498 }
23499 arg2 = static_cast< PLINT >(val2);
23500 ecode3 = SWIG_AsVal_int(args(2), &val3);
23501 if (!SWIG_IsOK(ecode3)) {
23502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23503 }
23504 arg3 = static_cast< PLINT >(val3);
23505 plscolbg(arg1,arg2,arg3);
23506 _outv = octave_value();
23507 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23508 return _out;
23509 fail:
23510 return octave_value_list();
23511 }
23512 catch(...) {
23513 throw;
23514 }
23515}
23516
23517
23519 PLINT arg1 ;
23520 PLINT arg2 ;
23521 PLINT arg3 ;
23522 PLFLT arg4 ;
23523 int val1 ;
23524 int ecode1 = 0 ;
23525 int val2 ;
23526 int ecode2 = 0 ;
23527 int val3 ;
23528 int ecode3 = 0 ;
23529 double val4 ;
23530 int ecode4 = 0 ;
23531 octave_value_list _out;
23532 octave_value_list *_outp=&_out;
23533 octave_value _outv;
23534
23535 try {
23536 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23537 SWIG_fail;
23538 }
23539 ecode1 = SWIG_AsVal_int(args(0), &val1);
23540 if (!SWIG_IsOK(ecode1)) {
23541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23542 }
23543 arg1 = static_cast< PLINT >(val1);
23544 ecode2 = SWIG_AsVal_int(args(1), &val2);
23545 if (!SWIG_IsOK(ecode2)) {
23546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23547 }
23548 arg2 = static_cast< PLINT >(val2);
23549 ecode3 = SWIG_AsVal_int(args(2), &val3);
23550 if (!SWIG_IsOK(ecode3)) {
23551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23552 }
23553 arg3 = static_cast< PLINT >(val3);
23554 ecode4 = SWIG_AsVal_double(args(3), &val4);
23555 if (!SWIG_IsOK(ecode4)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23557 }
23558 arg4 = static_cast< PLFLT >(val4);
23559 plscolbga(arg1,arg2,arg3,arg4);
23560 _outv = octave_value();
23561 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23562 return _out;
23563 fail:
23564 return octave_value_list();
23565 }
23566 catch(...) {
23567 throw;
23568 }
23569}
23570
23571
23573 PLINT arg1 ;
23574 int val1 ;
23575 int ecode1 = 0 ;
23576 octave_value_list _out;
23577 octave_value_list *_outp=&_out;
23578 octave_value _outv;
23579
23580 try {
23581 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23582 SWIG_fail;
23583 }
23584 ecode1 = SWIG_AsVal_int(args(0), &val1);
23585 if (!SWIG_IsOK(ecode1)) {
23586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23587 }
23588 arg1 = static_cast< PLINT >(val1);
23589 plscolor(arg1);
23590 _outv = octave_value();
23591 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23592 return _out;
23593 fail:
23594 return octave_value_list();
23595 }
23596 catch(...) {
23597 throw;
23598 }
23599}
23600
23601
23603 PLINT arg1 ;
23604 int val1 ;
23605 int ecode1 = 0 ;
23606 octave_value_list _out;
23607 octave_value_list *_outp=&_out;
23608 octave_value _outv;
23609
23610 try {
23611 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23612 SWIG_fail;
23613 }
23614 ecode1 = SWIG_AsVal_int(args(0), &val1);
23615 if (!SWIG_IsOK(ecode1)) {
23616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23617 }
23618 arg1 = static_cast< PLINT >(val1);
23619 plscompression(arg1);
23620 _outv = octave_value();
23621 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23622 return _out;
23623 fail:
23624 return octave_value_list();
23625 }
23626 catch(...) {
23627 throw;
23628 }
23629}
23630
23631
23633 char *arg1 = (char *) 0 ;
23634 int res1 ;
23635 char *buf1 = 0 ;
23636 int alloc1 = 0 ;
23637 octave_value_list _out;
23638 octave_value_list *_outp=&_out;
23639 octave_value _outv;
23640
23641 try {
23642 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23643 SWIG_fail;
23644 }
23645 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23646 if (!SWIG_IsOK(res1)) {
23647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23648 }
23649 arg1 = reinterpret_cast< char * >(buf1);
23650 plsdev((char const *)arg1);
23651 _outv = octave_value();
23652 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23653 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23654 return _out;
23655 fail:
23656 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23657 return octave_value_list();
23658 }
23659 catch(...) {
23660 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23661 throw;
23662 }
23663}
23664
23665
23667 PLFLT arg1 ;
23668 PLFLT arg2 ;
23669 PLFLT arg3 ;
23670 PLFLT arg4 ;
23671 double val1 ;
23672 int ecode1 = 0 ;
23673 double val2 ;
23674 int ecode2 = 0 ;
23675 double val3 ;
23676 int ecode3 = 0 ;
23677 double val4 ;
23678 int ecode4 = 0 ;
23679 octave_value_list _out;
23680 octave_value_list *_outp=&_out;
23681 octave_value _outv;
23682
23683 try {
23684 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23685 SWIG_fail;
23686 }
23687 ecode1 = SWIG_AsVal_double(args(0), &val1);
23688 if (!SWIG_IsOK(ecode1)) {
23689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23690 }
23691 arg1 = static_cast< PLFLT >(val1);
23692 ecode2 = SWIG_AsVal_double(args(1), &val2);
23693 if (!SWIG_IsOK(ecode2)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23695 }
23696 arg2 = static_cast< PLFLT >(val2);
23697 ecode3 = SWIG_AsVal_double(args(2), &val3);
23698 if (!SWIG_IsOK(ecode3)) {
23699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23700 }
23701 arg3 = static_cast< PLFLT >(val3);
23702 ecode4 = SWIG_AsVal_double(args(3), &val4);
23703 if (!SWIG_IsOK(ecode4)) {
23704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23705 }
23706 arg4 = static_cast< PLFLT >(val4);
23707 plsdidev(arg1,arg2,arg3,arg4);
23708 _outv = octave_value();
23709 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23710 return _out;
23711 fail:
23712 return octave_value_list();
23713 }
23714 catch(...) {
23715 throw;
23716 }
23717}
23718
23719
23721 PLINT arg1 ;
23722 PLINT arg2 ;
23723 PLINT arg3 ;
23724 PLINT arg4 ;
23725 PLFLT arg5 ;
23726 PLFLT arg6 ;
23727 int val1 ;
23728 int ecode1 = 0 ;
23729 int val2 ;
23730 int ecode2 = 0 ;
23731 int val3 ;
23732 int ecode3 = 0 ;
23733 int val4 ;
23734 int ecode4 = 0 ;
23735 double val5 ;
23736 int ecode5 = 0 ;
23737 double val6 ;
23738 int ecode6 = 0 ;
23739 octave_value_list _out;
23740 octave_value_list *_outp=&_out;
23741 octave_value _outv;
23742
23743 try {
23744 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23745 SWIG_fail;
23746 }
23747 ecode1 = SWIG_AsVal_int(args(0), &val1);
23748 if (!SWIG_IsOK(ecode1)) {
23749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23750 }
23751 arg1 = static_cast< PLINT >(val1);
23752 ecode2 = SWIG_AsVal_int(args(1), &val2);
23753 if (!SWIG_IsOK(ecode2)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23755 }
23756 arg2 = static_cast< PLINT >(val2);
23757 ecode3 = SWIG_AsVal_int(args(2), &val3);
23758 if (!SWIG_IsOK(ecode3)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23760 }
23761 arg3 = static_cast< PLINT >(val3);
23762 ecode4 = SWIG_AsVal_int(args(3), &val4);
23763 if (!SWIG_IsOK(ecode4)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23765 }
23766 arg4 = static_cast< PLINT >(val4);
23767 ecode5 = SWIG_AsVal_double(args(4), &val5);
23768 if (!SWIG_IsOK(ecode5)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23770 }
23771 arg5 = static_cast< PLFLT >(val5);
23772 ecode6 = SWIG_AsVal_double(args(5), &val6);
23773 if (!SWIG_IsOK(ecode6)) {
23774 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23775 }
23776 arg6 = static_cast< PLFLT >(val6);
23777 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23778 _outv = octave_value();
23779 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23780 return _out;
23781 fail:
23782 return octave_value_list();
23783 }
23784 catch(...) {
23785 throw;
23786 }
23787}
23788
23789
23791 PLFLT arg1 ;
23792 double val1 ;
23793 int ecode1 = 0 ;
23794 octave_value_list _out;
23795 octave_value_list *_outp=&_out;
23796 octave_value _outv;
23797
23798 try {
23799 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23800 SWIG_fail;
23801 }
23802 ecode1 = SWIG_AsVal_double(args(0), &val1);
23803 if (!SWIG_IsOK(ecode1)) {
23804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23805 }
23806 arg1 = static_cast< PLFLT >(val1);
23807 plsdiori(arg1);
23808 _outv = octave_value();
23809 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23810 return _out;
23811 fail:
23812 return octave_value_list();
23813 }
23814 catch(...) {
23815 throw;
23816 }
23817}
23818
23819
23821 PLFLT arg1 ;
23822 PLFLT arg2 ;
23823 PLFLT arg3 ;
23824 PLFLT arg4 ;
23825 double val1 ;
23826 int ecode1 = 0 ;
23827 double val2 ;
23828 int ecode2 = 0 ;
23829 double val3 ;
23830 int ecode3 = 0 ;
23831 double val4 ;
23832 int ecode4 = 0 ;
23833 octave_value_list _out;
23834 octave_value_list *_outp=&_out;
23835 octave_value _outv;
23836
23837 try {
23838 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23839 SWIG_fail;
23840 }
23841 ecode1 = SWIG_AsVal_double(args(0), &val1);
23842 if (!SWIG_IsOK(ecode1)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23844 }
23845 arg1 = static_cast< PLFLT >(val1);
23846 ecode2 = SWIG_AsVal_double(args(1), &val2);
23847 if (!SWIG_IsOK(ecode2)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23849 }
23850 arg2 = static_cast< PLFLT >(val2);
23851 ecode3 = SWIG_AsVal_double(args(2), &val3);
23852 if (!SWIG_IsOK(ecode3)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23854 }
23855 arg3 = static_cast< PLFLT >(val3);
23856 ecode4 = SWIG_AsVal_double(args(3), &val4);
23857 if (!SWIG_IsOK(ecode4)) {
23858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23859 }
23860 arg4 = static_cast< PLFLT >(val4);
23861 plsdiplt(arg1,arg2,arg3,arg4);
23862 _outv = octave_value();
23863 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23864 return _out;
23865 fail:
23866 return octave_value_list();
23867 }
23868 catch(...) {
23869 throw;
23870 }
23871}
23872
23873
23875 PLFLT arg1 ;
23876 PLFLT arg2 ;
23877 PLFLT arg3 ;
23878 PLFLT arg4 ;
23879 double val1 ;
23880 int ecode1 = 0 ;
23881 double val2 ;
23882 int ecode2 = 0 ;
23883 double val3 ;
23884 int ecode3 = 0 ;
23885 double val4 ;
23886 int ecode4 = 0 ;
23887 octave_value_list _out;
23888 octave_value_list *_outp=&_out;
23889 octave_value _outv;
23890
23891 try {
23892 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23893 SWIG_fail;
23894 }
23895 ecode1 = SWIG_AsVal_double(args(0), &val1);
23896 if (!SWIG_IsOK(ecode1)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23898 }
23899 arg1 = static_cast< PLFLT >(val1);
23900 ecode2 = SWIG_AsVal_double(args(1), &val2);
23901 if (!SWIG_IsOK(ecode2)) {
23902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23903 }
23904 arg2 = static_cast< PLFLT >(val2);
23905 ecode3 = SWIG_AsVal_double(args(2), &val3);
23906 if (!SWIG_IsOK(ecode3)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23908 }
23909 arg3 = static_cast< PLFLT >(val3);
23910 ecode4 = SWIG_AsVal_double(args(3), &val4);
23911 if (!SWIG_IsOK(ecode4)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23913 }
23914 arg4 = static_cast< PLFLT >(val4);
23915 plsdiplz(arg1,arg2,arg3,arg4);
23916 _outv = octave_value();
23917 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23918 return _out;
23919 fail:
23920 return octave_value_list();
23921 }
23922 catch(...) {
23923 throw;
23924 }
23925}
23926
23927
23929 unsigned int arg1 ;
23930 unsigned int val1 ;
23931 int ecode1 = 0 ;
23932 octave_value_list _out;
23933 octave_value_list *_outp=&_out;
23934 octave_value _outv;
23935
23936 try {
23937 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
23938 SWIG_fail;
23939 }
23940 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23941 if (!SWIG_IsOK(ecode1)) {
23942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
23943 }
23944 arg1 = static_cast< unsigned int >(val1);
23945 plseed(arg1);
23946 _outv = octave_value();
23947 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23948 return _out;
23949 fail:
23950 return octave_value_list();
23951 }
23952 catch(...) {
23953 throw;
23954 }
23955}
23956
23957
23959 char arg1 ;
23960 char val1 ;
23961 int ecode1 = 0 ;
23962 octave_value_list _out;
23963 octave_value_list *_outp=&_out;
23964 octave_value _outv;
23965
23966 try {
23967 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
23968 SWIG_fail;
23969 }
23970 ecode1 = SWIG_AsVal_char(args(0), &val1);
23971 if (!SWIG_IsOK(ecode1)) {
23972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
23973 }
23974 arg1 = static_cast< char >(val1);
23975 plsesc(arg1);
23976 _outv = octave_value();
23977 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23978 return _out;
23979 fail:
23980 return octave_value_list();
23981 }
23982 catch(...) {
23983 throw;
23984 }
23985}
23986
23987
23988SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
23989 char *arg1 = (char *) 0 ;
23990 char *arg2 = (char *) 0 ;
23991 int res1 ;
23992 char *buf1 = 0 ;
23993 int alloc1 = 0 ;
23994 int res2 ;
23995 char *buf2 = 0 ;
23996 int alloc2 = 0 ;
23997 octave_value_list _out;
23998 octave_value_list *_outp=&_out;
23999 octave_value _outv;
24000 PLINT result;
24001
24002 try {
24003 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
24004 SWIG_fail;
24005 }
24006 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24007 if (!SWIG_IsOK(res1)) {
24008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
24009 }
24010 arg1 = reinterpret_cast< char * >(buf1);
24011 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24012 if (!SWIG_IsOK(res2)) {
24013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
24014 }
24015 arg2 = reinterpret_cast< char * >(buf2);
24016 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
24017 _outv = SWIG_From_int(static_cast< int >(result));
24018 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24019 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24020 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24021 return _out;
24022 fail:
24023 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24024 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24025 return octave_value_list();
24026 }
24027 catch(...) {
24028 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24029 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24030 throw;
24031 }
24032}
24033
24034
24036 PLINT arg1 ;
24037 PLINT arg2 ;
24038 PLINT arg3 ;
24039 int val1 ;
24040 int ecode1 = 0 ;
24041 int val2 ;
24042 int ecode2 = 0 ;
24043 int val3 ;
24044 int ecode3 = 0 ;
24045 octave_value_list _out;
24046 octave_value_list *_outp=&_out;
24047 octave_value _outv;
24048
24049 try {
24050 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
24051 SWIG_fail;
24052 }
24053 ecode1 = SWIG_AsVal_int(args(0), &val1);
24054 if (!SWIG_IsOK(ecode1)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
24056 }
24057 arg1 = static_cast< PLINT >(val1);
24058 ecode2 = SWIG_AsVal_int(args(1), &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24061 }
24062 arg2 = static_cast< PLINT >(val2);
24063 ecode3 = SWIG_AsVal_int(args(2), &val3);
24064 if (!SWIG_IsOK(ecode3)) {
24065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24066 }
24067 arg3 = static_cast< PLINT >(val3);
24068 plsfam(arg1,arg2,arg3);
24069 _outv = octave_value();
24070 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24071 return _out;
24072 fail:
24073 return octave_value_list();
24074 }
24075 catch(...) {
24076 throw;
24077 }
24078}
24079
24080
24082 PLUNICODE arg1 ;
24083 unsigned int val1 ;
24084 int ecode1 = 0 ;
24085 octave_value_list _out;
24086 octave_value_list *_outp=&_out;
24087 octave_value _outv;
24088
24089 try {
24090 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24091 SWIG_fail;
24092 }
24093 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24094 if (!SWIG_IsOK(ecode1)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24096 }
24097 arg1 = static_cast< PLUNICODE >(val1);
24098 plsfci(arg1);
24099 _outv = octave_value();
24100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24101 return _out;
24102 fail:
24103 return octave_value_list();
24104 }
24105 catch(...) {
24106 throw;
24107 }
24108}
24109
24110
24112 char *arg1 = (char *) 0 ;
24113 int res1 ;
24114 char *buf1 = 0 ;
24115 int alloc1 = 0 ;
24116 octave_value_list _out;
24117 octave_value_list *_outp=&_out;
24118 octave_value _outv;
24119
24120 try {
24121 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24122 SWIG_fail;
24123 }
24124 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24127 }
24128 arg1 = reinterpret_cast< char * >(buf1);
24129 plsfnam((char const *)arg1);
24130 _outv = octave_value();
24131 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24132 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24133 return _out;
24134 fail:
24135 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24136 return octave_value_list();
24137 }
24138 catch(...) {
24139 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24140 throw;
24141 }
24142}
24143
24144
24146 PLINT arg1 ;
24147 PLINT arg2 ;
24148 PLINT arg3 ;
24149 int val1 ;
24150 int ecode1 = 0 ;
24151 int val2 ;
24152 int ecode2 = 0 ;
24153 int val3 ;
24154 int ecode3 = 0 ;
24155 octave_value_list _out;
24156 octave_value_list *_outp=&_out;
24157 octave_value _outv;
24158
24159 try {
24160 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24161 SWIG_fail;
24162 }
24163 ecode1 = SWIG_AsVal_int(args(0), &val1);
24164 if (!SWIG_IsOK(ecode1)) {
24165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24166 }
24167 arg1 = static_cast< PLINT >(val1);
24168 ecode2 = SWIG_AsVal_int(args(1), &val2);
24169 if (!SWIG_IsOK(ecode2)) {
24170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24171 }
24172 arg2 = static_cast< PLINT >(val2);
24173 ecode3 = SWIG_AsVal_int(args(2), &val3);
24174 if (!SWIG_IsOK(ecode3)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24176 }
24177 arg3 = static_cast< PLINT >(val3);
24178 plsfont(arg1,arg2,arg3);
24179 _outv = octave_value();
24180 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24181 return _out;
24182 fail:
24183 return octave_value_list();
24184 }
24185 catch(...) {
24186 throw;
24187 }
24188}
24189
24190
24192 label_func arg1 = (label_func) 0 ;
24193 PLPointer arg2 = (PLPointer) 0 ;
24194 int res2 ;
24195 octave_value_list _out;
24196 octave_value_list *_outp=&_out;
24197 octave_value _outv;
24198
24199 try {
24200 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24201 SWIG_fail;
24202 }
24203 {
24204 octave_value obj = args(0);
24205#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24206 if ( !obj.isempty() )
24207#else
24208 if ( !obj.is_empty() )
24209#endif
24210 {
24211 if ( obj.is_function_handle() || obj.is_inline_function() )
24212 {
24213 fcnLabelFunc = obj.function_value();
24214 }
24215 else if ( obj.is_string() )
24216 {
24217 nameLabelFunc = obj.string_value();
24218 fcnLabelFunc = NULL;
24219 }
24220 arg1 = labelfunc_octave;
24221 }
24222 else
24223 {
24224 arg1 = NULL;
24225 }
24226 }
24227 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24228 if (!SWIG_IsOK(res2)) {
24229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24230 }
24231 plslabelfunc(arg1,arg2);
24232 _outv = octave_value();
24233 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24234 return _out;
24235 fail:
24236 return octave_value_list();
24237 }
24238 catch(...) {
24239 throw;
24240 }
24241}
24242
24243
24245 PLFLT arg1 ;
24246 PLFLT arg2 ;
24247 double val1 ;
24248 int ecode1 = 0 ;
24249 double val2 ;
24250 int ecode2 = 0 ;
24251 octave_value_list _out;
24252 octave_value_list *_outp=&_out;
24253 octave_value _outv;
24254
24255 try {
24256 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24257 SWIG_fail;
24258 }
24259 ecode1 = SWIG_AsVal_double(args(0), &val1);
24260 if (!SWIG_IsOK(ecode1)) {
24261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24262 }
24263 arg1 = static_cast< PLFLT >(val1);
24264 ecode2 = SWIG_AsVal_double(args(1), &val2);
24265 if (!SWIG_IsOK(ecode2)) {
24266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24267 }
24268 arg2 = static_cast< PLFLT >(val2);
24269 plsmaj(arg1,arg2);
24270 _outv = octave_value();
24271 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24272 return _out;
24273 fail:
24274 return octave_value_list();
24275 }
24276 catch(...) {
24277 throw;
24278 }
24279}
24280
24281
24283 PLFLT arg1 ;
24284 PLFLT arg2 ;
24285 double val1 ;
24286 int ecode1 = 0 ;
24287 double val2 ;
24288 int ecode2 = 0 ;
24289 octave_value_list _out;
24290 octave_value_list *_outp=&_out;
24291 octave_value _outv;
24292
24293 try {
24294 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24295 SWIG_fail;
24296 }
24297 ecode1 = SWIG_AsVal_double(args(0), &val1);
24298 if (!SWIG_IsOK(ecode1)) {
24299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24300 }
24301 arg1 = static_cast< PLFLT >(val1);
24302 ecode2 = SWIG_AsVal_double(args(1), &val2);
24303 if (!SWIG_IsOK(ecode2)) {
24304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24305 }
24306 arg2 = static_cast< PLFLT >(val2);
24307 plsmin(arg1,arg2);
24308 _outv = octave_value();
24309 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24310 return _out;
24311 fail:
24312 return octave_value_list();
24313 }
24314 catch(...) {
24315 throw;
24316 }
24317}
24318
24319
24321 PLINT arg1 ;
24322 int val1 ;
24323 int ecode1 = 0 ;
24324 octave_value_list _out;
24325 octave_value_list *_outp=&_out;
24326 octave_value _outv;
24327
24328 try {
24329 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24330 SWIG_fail;
24331 }
24332 ecode1 = SWIG_AsVal_int(args(0), &val1);
24333 if (!SWIG_IsOK(ecode1)) {
24334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24335 }
24336 arg1 = static_cast< PLINT >(val1);
24337 plsori(arg1);
24338 _outv = octave_value();
24339 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24340 return _out;
24341 fail:
24342 return octave_value_list();
24343 }
24344 catch(...) {
24345 throw;
24346 }
24347}
24348
24349
24351 PLFLT arg1 ;
24352 PLFLT arg2 ;
24353 PLINT arg3 ;
24354 PLINT arg4 ;
24355 PLINT arg5 ;
24356 PLINT arg6 ;
24357 double val1 ;
24358 int ecode1 = 0 ;
24359 double val2 ;
24360 int ecode2 = 0 ;
24361 int val3 ;
24362 int ecode3 = 0 ;
24363 int val4 ;
24364 int ecode4 = 0 ;
24365 int val5 ;
24366 int ecode5 = 0 ;
24367 int val6 ;
24368 int ecode6 = 0 ;
24369 octave_value_list _out;
24370 octave_value_list *_outp=&_out;
24371 octave_value _outv;
24372
24373 try {
24374 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24375 SWIG_fail;
24376 }
24377 ecode1 = SWIG_AsVal_double(args(0), &val1);
24378 if (!SWIG_IsOK(ecode1)) {
24379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24380 }
24381 arg1 = static_cast< PLFLT >(val1);
24382 ecode2 = SWIG_AsVal_double(args(1), &val2);
24383 if (!SWIG_IsOK(ecode2)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24385 }
24386 arg2 = static_cast< PLFLT >(val2);
24387 ecode3 = SWIG_AsVal_int(args(2), &val3);
24388 if (!SWIG_IsOK(ecode3)) {
24389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24390 }
24391 arg3 = static_cast< PLINT >(val3);
24392 ecode4 = SWIG_AsVal_int(args(3), &val4);
24393 if (!SWIG_IsOK(ecode4)) {
24394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24395 }
24396 arg4 = static_cast< PLINT >(val4);
24397 ecode5 = SWIG_AsVal_int(args(4), &val5);
24398 if (!SWIG_IsOK(ecode5)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24400 }
24401 arg5 = static_cast< PLINT >(val5);
24402 ecode6 = SWIG_AsVal_int(args(5), &val6);
24403 if (!SWIG_IsOK(ecode6)) {
24404 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24405 }
24406 arg6 = static_cast< PLINT >(val6);
24407 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24408 _outv = octave_value();
24409 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24410 return _out;
24411 fail:
24412 return octave_value_list();
24413 }
24414 catch(...) {
24415 throw;
24416 }
24417}
24418
24419
24421 char *arg1 = (char *) 0 ;
24422 int res1 ;
24423 char *buf1 = 0 ;
24424 int alloc1 = 0 ;
24425 octave_value_list _out;
24426 octave_value_list *_outp=&_out;
24427 octave_value _outv;
24428
24429 try {
24430 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24431 SWIG_fail;
24432 }
24433 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24434 if (!SWIG_IsOK(res1)) {
24435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24436 }
24437 arg1 = reinterpret_cast< char * >(buf1);
24438 plspal0((char const *)arg1);
24439 _outv = octave_value();
24440 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24441 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24442 return _out;
24443 fail:
24444 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24445 return octave_value_list();
24446 }
24447 catch(...) {
24448 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24449 throw;
24450 }
24451}
24452
24453
24455 char *arg1 = (char *) 0 ;
24456 PLBOOL arg2 ;
24457 int res1 ;
24458 char *buf1 = 0 ;
24459 int alloc1 = 0 ;
24460 int val2 ;
24461 int ecode2 = 0 ;
24462 octave_value_list _out;
24463 octave_value_list *_outp=&_out;
24464 octave_value _outv;
24465
24466 try {
24467 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24468 SWIG_fail;
24469 }
24470 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24473 }
24474 arg1 = reinterpret_cast< char * >(buf1);
24475 ecode2 = SWIG_AsVal_int(args(1), &val2);
24476 if (!SWIG_IsOK(ecode2)) {
24477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24478 }
24479 arg2 = static_cast< PLBOOL >(val2);
24480 plspal1((char const *)arg1,arg2);
24481 _outv = octave_value();
24482 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24483 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24484 return _out;
24485 fail:
24486 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24487 return octave_value_list();
24488 }
24489 catch(...) {
24490 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24491 throw;
24492 }
24493}
24494
24495
24497 PLBOOL arg1 ;
24498 int val1 ;
24499 int ecode1 = 0 ;
24500 octave_value_list _out;
24501 octave_value_list *_outp=&_out;
24502 octave_value _outv;
24503
24504 try {
24505 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24506 SWIG_fail;
24507 }
24508 ecode1 = SWIG_AsVal_int(args(0), &val1);
24509 if (!SWIG_IsOK(ecode1)) {
24510 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24511 }
24512 arg1 = static_cast< PLBOOL >(val1);
24513 plspause(arg1);
24514 _outv = octave_value();
24515 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24516 return _out;
24517 fail:
24518 return octave_value_list();
24519 }
24520 catch(...) {
24521 throw;
24522 }
24523}
24524
24525
24526SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
24527 PLINT arg1 ;
24528 int val1 ;
24529 int ecode1 = 0 ;
24530 octave_value_list _out;
24531 octave_value_list *_outp=&_out;
24532 octave_value _outv;
24533
24534 try {
24535 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24536 SWIG_fail;
24537 }
24538 ecode1 = SWIG_AsVal_int(args(0), &val1);
24539 if (!SWIG_IsOK(ecode1)) {
24540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24541 }
24542 arg1 = static_cast< PLINT >(val1);
24543 plsstrm(arg1);
24544 _outv = octave_value();
24545 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24546 return _out;
24547 fail:
24548 return octave_value_list();
24549 }
24550 catch(...) {
24551 throw;
24552 }
24553}
24554
24555
24557 PLINT arg1 ;
24558 PLINT arg2 ;
24559 int val1 ;
24560 int ecode1 = 0 ;
24561 int val2 ;
24562 int ecode2 = 0 ;
24563 octave_value_list _out;
24564 octave_value_list *_outp=&_out;
24565 octave_value _outv;
24566
24567 try {
24568 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24569 SWIG_fail;
24570 }
24571 ecode1 = SWIG_AsVal_int(args(0), &val1);
24572 if (!SWIG_IsOK(ecode1)) {
24573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24574 }
24575 arg1 = static_cast< PLINT >(val1);
24576 ecode2 = SWIG_AsVal_int(args(1), &val2);
24577 if (!SWIG_IsOK(ecode2)) {
24578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24579 }
24580 arg2 = static_cast< PLINT >(val2);
24581 plssub(arg1,arg2);
24582 _outv = octave_value();
24583 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24584 return _out;
24585 fail:
24586 return octave_value_list();
24587 }
24588 catch(...) {
24589 throw;
24590 }
24591}
24592
24593
24595 PLFLT arg1 ;
24596 PLFLT arg2 ;
24597 double val1 ;
24598 int ecode1 = 0 ;
24599 double val2 ;
24600 int ecode2 = 0 ;
24601 octave_value_list _out;
24602 octave_value_list *_outp=&_out;
24603 octave_value _outv;
24604
24605 try {
24606 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24607 SWIG_fail;
24608 }
24609 ecode1 = SWIG_AsVal_double(args(0), &val1);
24610 if (!SWIG_IsOK(ecode1)) {
24611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24612 }
24613 arg1 = static_cast< PLFLT >(val1);
24614 ecode2 = SWIG_AsVal_double(args(1), &val2);
24615 if (!SWIG_IsOK(ecode2)) {
24616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24617 }
24618 arg2 = static_cast< PLFLT >(val2);
24619 plssym(arg1,arg2);
24620 _outv = octave_value();
24621 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24622 return _out;
24623 fail:
24624 return octave_value_list();
24625 }
24626 catch(...) {
24627 throw;
24628 }
24629}
24630
24631
24633 PLINT arg1 ;
24634 PLINT arg2 ;
24635 int val1 ;
24636 int ecode1 = 0 ;
24637 int val2 ;
24638 int ecode2 = 0 ;
24639 octave_value_list _out;
24640 octave_value_list *_outp=&_out;
24641 octave_value _outv;
24642
24643 try {
24644 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24645 SWIG_fail;
24646 }
24647 ecode1 = SWIG_AsVal_int(args(0), &val1);
24648 if (!SWIG_IsOK(ecode1)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24650 }
24651 arg1 = static_cast< PLINT >(val1);
24652 ecode2 = SWIG_AsVal_int(args(1), &val2);
24653 if (!SWIG_IsOK(ecode2)) {
24654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24655 }
24656 arg2 = static_cast< PLINT >(val2);
24657 plstar(arg1,arg2);
24658 _outv = octave_value();
24659 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24660 return _out;
24661 fail:
24662 return octave_value_list();
24663 }
24664 catch(...) {
24665 throw;
24666 }
24667}
24668
24669
24671 char *arg1 = (char *) 0 ;
24672 PLINT arg2 ;
24673 PLINT arg3 ;
24674 int res1 ;
24675 char *buf1 = 0 ;
24676 int alloc1 = 0 ;
24677 int val2 ;
24678 int ecode2 = 0 ;
24679 int val3 ;
24680 int ecode3 = 0 ;
24681 octave_value_list _out;
24682 octave_value_list *_outp=&_out;
24683 octave_value _outv;
24684
24685 try {
24686 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24687 SWIG_fail;
24688 }
24689 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24692 }
24693 arg1 = reinterpret_cast< char * >(buf1);
24694 ecode2 = SWIG_AsVal_int(args(1), &val2);
24695 if (!SWIG_IsOK(ecode2)) {
24696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24697 }
24698 arg2 = static_cast< PLINT >(val2);
24699 ecode3 = SWIG_AsVal_int(args(2), &val3);
24700 if (!SWIG_IsOK(ecode3)) {
24701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24702 }
24703 arg3 = static_cast< PLINT >(val3);
24704 plstart((char const *)arg1,arg2,arg3);
24705 _outv = octave_value();
24706 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24707 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24708 return _out;
24709 fail:
24710 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24711 return octave_value_list();
24712 }
24713 catch(...) {
24714 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24715 throw;
24716 }
24717}
24718
24719
24721 ct_func arg1 = (ct_func) 0 ;
24722 PLPointer arg2 = (PLPointer) 0 ;
24723 int res2 ;
24724 octave_value_list _out;
24725 octave_value_list *_outp=&_out;
24726 octave_value _outv;
24727
24728 try {
24729 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24730 SWIG_fail;
24731 }
24732 {
24733 octave_value obj = args(0);
24734#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24735 if ( !obj.isempty() )
24736#else
24737 if ( !obj.is_empty() )
24738#endif
24739 {
24740 if ( obj.is_function_handle() || obj.is_inline_function() )
24741 {
24742 fcnCoordTrans = obj.function_value();
24743 }
24744 else if ( obj.is_string() )
24745 {
24746 nameCoordTrans = obj.string_value();
24747 fcnCoordTrans = NULL;
24748 }
24749 arg1 = ct_octave;
24750 }
24751 else
24752 {
24753 arg1 = NULL;
24754 }
24755 }
24756 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24757 if (!SWIG_IsOK(res2)) {
24758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24759 }
24760 plstransform(arg1,arg2);
24761 _outv = octave_value();
24762 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24763 return _out;
24764 fail:
24765 return octave_value_list();
24766 }
24767 catch(...) {
24768 throw;
24769 }
24770}
24771
24772
24774 PLINT arg1 ;
24775 PLFLT *arg2 = (PLFLT *) 0 ;
24776 PLFLT *arg3 = (PLFLT *) 0 ;
24777 char *arg4 = (char *) 0 ;
24778 Matrix temp1 ;
24779 Matrix temp3 ;
24780 int res4 ;
24781 char *buf4 = 0 ;
24782 int alloc4 = 0 ;
24783 octave_value_list _out;
24784 octave_value_list *_outp=&_out;
24785 octave_value _outv;
24786
24787 try {
24788 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24789 SWIG_fail;
24790 }
24791 {
24792 if ( _n_dims( args(0) ) > 1 )
24793 {
24794 error( "argument must be a scalar or vector" ); SWIG_fail;
24795 }
24796 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24797 temp1 = args(0).matrix_value();
24798 arg2 = &temp1( 0, 0 );
24799 }
24800 {
24801 if ( _n_dims( args(1) ) > 1 )
24802 {
24803 error( "argument must be a scalar or vector" ); SWIG_fail;
24804 }
24805 if ( _dim( args(1), 0 ) != Alen )
24806 {
24807 error( "argument vectors must be same length" ); SWIG_fail;
24808 }
24809 temp3 = args(1).matrix_value();
24810 arg3 = &temp3( 0, 0 );
24811 }
24812 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24813 if (!SWIG_IsOK(res4)) {
24814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24815 }
24816 arg4 = reinterpret_cast< char * >(buf4);
24817 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24818 _outv = octave_value();
24819 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24820 {
24821
24822 }
24823 {
24824
24825 }
24826 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24827 return _out;
24828 fail:
24829 {
24830
24831 }
24832 {
24833
24834 }
24835 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24836 return octave_value_list();
24837 }
24838 catch(...) {
24839 {
24840
24841 }
24842 {
24843
24844 }
24845 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24846 throw;
24847 }
24848}
24849
24850
24852 PLINT arg1 ;
24853 PLFLT *arg2 = (PLFLT *) 0 ;
24854 PLFLT *arg3 = (PLFLT *) 0 ;
24855 PLFLT *arg4 = (PLFLT *) 0 ;
24856 char *arg5 = (char *) 0 ;
24857 Matrix temp1 ;
24858 Matrix temp3 ;
24859 Matrix temp4 ;
24860 int res5 ;
24861 char *buf5 = 0 ;
24862 int alloc5 = 0 ;
24863 octave_value_list _out;
24864 octave_value_list *_outp=&_out;
24865 octave_value _outv;
24866
24867 try {
24868 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24869 SWIG_fail;
24870 }
24871 {
24872 if ( _n_dims( args(0) ) > 1 )
24873 {
24874 error( "argument must be a scalar or vector" ); SWIG_fail;
24875 }
24876 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24877 temp1 = args(0).matrix_value();
24878 arg2 = &temp1( 0, 0 );
24879 }
24880 {
24881 if ( _n_dims( args(1) ) > 1 )
24882 {
24883 error( "argument must be a scalar or vector" ); SWIG_fail;
24884 }
24885 if ( _dim( args(1), 0 ) != Alen )
24886 {
24887 error( "argument vectors must be same length" ); SWIG_fail;
24888 }
24889 temp3 = args(1).matrix_value();
24890 arg3 = &temp3( 0, 0 );
24891 }
24892 {
24893 if ( _n_dims( args(2) ) > 1 )
24894 {
24895 error( "argument must be a scalar or vector" ); SWIG_fail;
24896 }
24897 if ( _dim( args(2), 0 ) != Alen )
24898 {
24899 error( "argument vectors must be same length" ); SWIG_fail;
24900 }
24901 temp4 = args(2).matrix_value();
24902 arg4 = &temp4( 0, 0 );
24903 }
24904 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24905 if (!SWIG_IsOK(res5)) {
24906 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24907 }
24908 arg5 = reinterpret_cast< char * >(buf5);
24909 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24910 _outv = octave_value();
24911 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24912 {
24913
24914 }
24915 {
24916
24917 }
24918 {
24919
24920 }
24921 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24922 return _out;
24923 fail:
24924 {
24925
24926 }
24927 {
24928
24929 }
24930 {
24931
24932 }
24933 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24934 return octave_value_list();
24935 }
24936 catch(...) {
24937 {
24938
24939 }
24940 {
24941
24942 }
24943 {
24944
24945 }
24946 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24947 throw;
24948 }
24949}
24950
24951
24953 PLINT arg1 ;
24954 PLINT arg2 ;
24955 PLFLT arg3 ;
24956 PLFLT arg4 ;
24957 int val1 ;
24958 int ecode1 = 0 ;
24959 int val2 ;
24960 int ecode2 = 0 ;
24961 double val3 ;
24962 int ecode3 = 0 ;
24963 double val4 ;
24964 int ecode4 = 0 ;
24965 octave_value_list _out;
24966 octave_value_list *_outp=&_out;
24967 octave_value _outv;
24968
24969 try {
24970 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
24971 SWIG_fail;
24972 }
24973 ecode1 = SWIG_AsVal_int(args(0), &val1);
24974 if (!SWIG_IsOK(ecode1)) {
24975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
24976 }
24977 arg1 = static_cast< PLINT >(val1);
24978 ecode2 = SWIG_AsVal_int(args(1), &val2);
24979 if (!SWIG_IsOK(ecode2)) {
24980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
24981 }
24982 arg2 = static_cast< PLINT >(val2);
24983 ecode3 = SWIG_AsVal_double(args(2), &val3);
24984 if (!SWIG_IsOK(ecode3)) {
24985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
24986 }
24987 arg3 = static_cast< PLFLT >(val3);
24988 ecode4 = SWIG_AsVal_double(args(3), &val4);
24989 if (!SWIG_IsOK(ecode4)) {
24990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
24991 }
24992 arg4 = static_cast< PLFLT >(val4);
24993 plstripa(arg1,arg2,arg3,arg4);
24994 _outv = octave_value();
24995 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24996 return _out;
24997 fail:
24998 return octave_value_list();
24999 }
25000 catch(...) {
25001 throw;
25002 }
25003}
25004
25005
25007 PLINT arg1 ;
25008 int val1 ;
25009 int ecode1 = 0 ;
25010 octave_value_list _out;
25011 octave_value_list *_outp=&_out;
25012 octave_value _outv;
25013
25014 try {
25015 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
25016 SWIG_fail;
25017 }
25018 ecode1 = SWIG_AsVal_int(args(0), &val1);
25019 if (!SWIG_IsOK(ecode1)) {
25020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
25021 }
25022 arg1 = static_cast< PLINT >(val1);
25023 plstripd(arg1);
25024 _outv = octave_value();
25025 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25026 return _out;
25027 fail:
25028 return octave_value_list();
25029 }
25030 catch(...) {
25031 throw;
25032 }
25033}
25034
25035
25037 PLINT arg1 ;
25038 PLINT *arg2 = (PLINT *) 0 ;
25039 PLINT *arg3 = (PLINT *) 0 ;
25040 Matrix temp1 ;
25041 Matrix temp3 ;
25042 octave_value_list _out;
25043 octave_value_list *_outp=&_out;
25044 octave_value _outv;
25045
25046 try {
25047 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
25048 SWIG_fail;
25049 }
25050 {
25051 if ( _n_dims( args(0) ) > 1 )
25052 {
25053 error( "argument must be a scalar or vector" ); SWIG_fail;
25054 }
25055 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25056 arg2 = new PLINT[Alen];
25057 temp1 = args(0).matrix_value();
25058 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25059 }
25060 {
25061 if ( _n_dims( args(1) ) > 1 )
25062 {
25063 error( "argument must be a scalar or vector" ); SWIG_fail;
25064 }
25065 if ( _dim( args(1), 0 ) != Alen )
25066 {
25067 error( "argument vectors must be same length" ); SWIG_fail;
25068 }
25069 temp3 = args(1).matrix_value();
25070 arg3 = new PLINT[Alen];
25071 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25072 }
25073 plstyl(arg1,(int const *)arg2,(int const *)arg3);
25074 _outv = octave_value();
25075 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25076 {
25077 delete [] arg2;
25078 }
25079 {
25080 delete [] arg3;
25081 }
25082 return _out;
25083 fail:
25084 {
25085 delete [] arg2;
25086 }
25087 {
25088 delete [] arg3;
25089 }
25090 return octave_value_list();
25091 }
25092 catch(...) {
25093 {
25094 delete [] arg2;
25095 }
25096 {
25097 delete [] arg3;
25098 }
25099 throw;
25100 }
25101}
25102
25103
25105 PLFLT *arg1 = (PLFLT *) 0 ;
25106 PLFLT *arg2 = (PLFLT *) 0 ;
25107 PLINT arg3 ;
25108 PLBOOL arg4 ;
25109 Matrix temp1 ;
25110 Matrix temp2 ;
25111 int val4 ;
25112 int ecode4 = 0 ;
25113 octave_value_list _out;
25114 octave_value_list *_outp=&_out;
25115 octave_value _outv;
25116
25117 try {
25118 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25119 SWIG_fail;
25120 }
25121 {
25122 if ( _n_dims( args(0) ) > 1 )
25123 {
25124 error( "argument must be a scalar or vector" ); SWIG_fail;
25125 }
25126#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25127 if ( !args(0).isempty() )
25128#else
25129 if ( !args(0).is_empty() )
25130#endif
25131 {
25132 Alen = (PLINT) ( _dim( args(0), 0 ) );
25133 temp1 = args(0).matrix_value();
25134 arg1 = &temp1( 0, 0 );
25135 }
25136 else
25137 {
25138 arg1 = NULL;
25139 Alen = 0;
25140 }
25141 }
25142 {
25143 if ( _n_dims( args(1) ) > 1 )
25144 {
25145 error( "argument must be a scalar or vector" ); SWIG_fail;
25146 }
25147#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25148 if ( !args(1).isempty() )
25149#else
25150 if ( !args(1).is_empty() )
25151#endif
25152 {
25153 if ( _dim( args(1), 0 ) != Alen )
25154 {
25155 error( "argument vectors must be same length" ); SWIG_fail;
25156 }
25157 temp2 = args(1).matrix_value();
25158 arg2 = &temp2( 0, 0 );
25159 arg3 = (PLINT) ( _dim( args(1), 0 ) );
25160 }
25161 else
25162 {
25163 arg2 = NULL;
25164 arg3 = 0;
25165 }
25166 }
25167 ecode4 = SWIG_AsVal_int(args(2), &val4);
25168 if (!SWIG_IsOK(ecode4)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25170 }
25171 arg4 = static_cast< PLBOOL >(val4);
25172 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25173 _outv = octave_value();
25174 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25175 {
25176
25177 }
25178 {
25179
25180 }
25181 return _out;
25182 fail:
25183 {
25184
25185 }
25186 {
25187
25188 }
25189 return octave_value_list();
25190 }
25191 catch(...) {
25192 {
25193
25194 }
25195 {
25196
25197 }
25198 throw;
25199 }
25200}
25201
25202
25204 PLFLT arg1 ;
25205 PLFLT arg2 ;
25206 PLFLT arg3 ;
25207 PLFLT arg4 ;
25208 double val1 ;
25209 int ecode1 = 0 ;
25210 double val2 ;
25211 int ecode2 = 0 ;
25212 double val3 ;
25213 int ecode3 = 0 ;
25214 double val4 ;
25215 int ecode4 = 0 ;
25216 octave_value_list _out;
25217 octave_value_list *_outp=&_out;
25218 octave_value _outv;
25219
25220 try {
25221 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25222 SWIG_fail;
25223 }
25224 ecode1 = SWIG_AsVal_double(args(0), &val1);
25225 if (!SWIG_IsOK(ecode1)) {
25226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25227 }
25228 arg1 = static_cast< PLFLT >(val1);
25229 ecode2 = SWIG_AsVal_double(args(1), &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25232 }
25233 arg2 = static_cast< PLFLT >(val2);
25234 ecode3 = SWIG_AsVal_double(args(2), &val3);
25235 if (!SWIG_IsOK(ecode3)) {
25236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25237 }
25238 arg3 = static_cast< PLFLT >(val3);
25239 ecode4 = SWIG_AsVal_double(args(3), &val4);
25240 if (!SWIG_IsOK(ecode4)) {
25241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25242 }
25243 arg4 = static_cast< PLFLT >(val4);
25244 plsvpa(arg1,arg2,arg3,arg4);
25245 _outv = octave_value();
25246 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25247 return _out;
25248 fail:
25249 return octave_value_list();
25250 }
25251 catch(...) {
25252 throw;
25253 }
25254}
25255
25256
25258 PLINT arg1 ;
25259 PLINT arg2 ;
25260 int val1 ;
25261 int ecode1 = 0 ;
25262 int val2 ;
25263 int ecode2 = 0 ;
25264 octave_value_list _out;
25265 octave_value_list *_outp=&_out;
25266 octave_value _outv;
25267
25268 try {
25269 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25270 SWIG_fail;
25271 }
25272 ecode1 = SWIG_AsVal_int(args(0), &val1);
25273 if (!SWIG_IsOK(ecode1)) {
25274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25275 }
25276 arg1 = static_cast< PLINT >(val1);
25277 ecode2 = SWIG_AsVal_int(args(1), &val2);
25278 if (!SWIG_IsOK(ecode2)) {
25279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25280 }
25281 arg2 = static_cast< PLINT >(val2);
25282 plsxax(arg1,arg2);
25283 _outv = octave_value();
25284 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25285 return _out;
25286 fail:
25287 return octave_value_list();
25288 }
25289 catch(...) {
25290 throw;
25291 }
25292}
25293
25294
25296 PLINT arg1 ;
25297 PLINT arg2 ;
25298 int val1 ;
25299 int ecode1 = 0 ;
25300 int val2 ;
25301 int ecode2 = 0 ;
25302 octave_value_list _out;
25303 octave_value_list *_outp=&_out;
25304 octave_value _outv;
25305
25306 try {
25307 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25308 SWIG_fail;
25309 }
25310 ecode1 = SWIG_AsVal_int(args(0), &val1);
25311 if (!SWIG_IsOK(ecode1)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25313 }
25314 arg1 = static_cast< PLINT >(val1);
25315 ecode2 = SWIG_AsVal_int(args(1), &val2);
25316 if (!SWIG_IsOK(ecode2)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25318 }
25319 arg2 = static_cast< PLINT >(val2);
25320 plsyax(arg1,arg2);
25321 _outv = octave_value();
25322 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25323 return _out;
25324 fail:
25325 return octave_value_list();
25326 }
25327 catch(...) {
25328 throw;
25329 }
25330}
25331
25332
25334 PLINT arg1 ;
25335 PLFLT *arg2 = (PLFLT *) 0 ;
25336 PLFLT *arg3 = (PLFLT *) 0 ;
25337 PLINT arg4 ;
25338 Matrix temp1 ;
25339 Matrix temp3 ;
25340 int val4 ;
25341 int ecode4 = 0 ;
25342 octave_value_list _out;
25343 octave_value_list *_outp=&_out;
25344 octave_value _outv;
25345
25346 try {
25347 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25348 SWIG_fail;
25349 }
25350 {
25351 if ( _n_dims( args(0) ) > 1 )
25352 {
25353 error( "argument must be a scalar or vector" ); SWIG_fail;
25354 }
25355 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25356 temp1 = args(0).matrix_value();
25357 arg2 = &temp1( 0, 0 );
25358 }
25359 {
25360 if ( _n_dims( args(1) ) > 1 )
25361 {
25362 error( "argument must be a scalar or vector" ); SWIG_fail;
25363 }
25364 if ( _dim( args(1), 0 ) != Alen )
25365 {
25366 error( "argument vectors must be same length" ); SWIG_fail;
25367 }
25368 temp3 = args(1).matrix_value();
25369 arg3 = &temp3( 0, 0 );
25370 }
25371 ecode4 = SWIG_AsVal_int(args(2), &val4);
25372 if (!SWIG_IsOK(ecode4)) {
25373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25374 }
25375 arg4 = static_cast< PLINT >(val4);
25376 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25377 _outv = octave_value();
25378 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25379 {
25380
25381 }
25382 {
25383
25384 }
25385 return _out;
25386 fail:
25387 {
25388
25389 }
25390 {
25391
25392 }
25393 return octave_value_list();
25394 }
25395 catch(...) {
25396 {
25397
25398 }
25399 {
25400
25401 }
25402 throw;
25403 }
25404}
25405
25406
25408 PLINT arg1 ;
25409 PLINT arg2 ;
25410 int val1 ;
25411 int ecode1 = 0 ;
25412 int val2 ;
25413 int ecode2 = 0 ;
25414 octave_value_list _out;
25415 octave_value_list *_outp=&_out;
25416 octave_value _outv;
25417
25418 try {
25419 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25420 SWIG_fail;
25421 }
25422 ecode1 = SWIG_AsVal_int(args(0), &val1);
25423 if (!SWIG_IsOK(ecode1)) {
25424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25425 }
25426 arg1 = static_cast< PLINT >(val1);
25427 ecode2 = SWIG_AsVal_int(args(1), &val2);
25428 if (!SWIG_IsOK(ecode2)) {
25429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25430 }
25431 arg2 = static_cast< PLINT >(val2);
25432 plszax(arg1,arg2);
25433 _outv = octave_value();
25434 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25435 return _out;
25436 fail:
25437 return octave_value_list();
25438 }
25439 catch(...) {
25440 throw;
25441 }
25442}
25443
25444
25446 octave_value_list _out;
25447 octave_value_list *_outp=&_out;
25448 octave_value _outv;
25449
25450 try {
25451 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25452 SWIG_fail;
25453 }
25454 pltext();
25455 _outv = octave_value();
25456 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25457 return _out;
25458 fail:
25459 return octave_value_list();
25460 }
25461 catch(...) {
25462 throw;
25463 }
25464}
25465
25466
25468 char *arg1 = (char *) 0 ;
25469 int res1 ;
25470 char *buf1 = 0 ;
25471 int alloc1 = 0 ;
25472 octave_value_list _out;
25473 octave_value_list *_outp=&_out;
25474 octave_value _outv;
25475
25476 try {
25477 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25478 SWIG_fail;
25479 }
25480 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25481 if (!SWIG_IsOK(res1)) {
25482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25483 }
25484 arg1 = reinterpret_cast< char * >(buf1);
25485 pltimefmt((char const *)arg1);
25486 _outv = octave_value();
25487 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25488 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25489 return _out;
25490 fail:
25491 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25492 return octave_value_list();
25493 }
25494 catch(...) {
25495 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25496 throw;
25497 }
25498}
25499
25500
25502 PLFLT arg1 ;
25503 double val1 ;
25504 int ecode1 = 0 ;
25505 octave_value_list _out;
25506 octave_value_list *_outp=&_out;
25507 octave_value _outv;
25508
25509 try {
25510 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25511 SWIG_fail;
25512 }
25513 ecode1 = SWIG_AsVal_double(args(0), &val1);
25514 if (!SWIG_IsOK(ecode1)) {
25515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25516 }
25517 arg1 = static_cast< PLFLT >(val1);
25518 plvasp(arg1);
25519 _outv = octave_value();
25520 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25521 return _out;
25522 fail:
25523 return octave_value_list();
25524 }
25525 catch(...) {
25526 throw;
25527 }
25528}
25529
25530
25532 PLFLT arg1 ;
25533 PLFLT arg2 ;
25534 PLFLT arg3 ;
25535 PLFLT arg4 ;
25536 PLFLT arg5 ;
25537 double val1 ;
25538 int ecode1 = 0 ;
25539 double val2 ;
25540 int ecode2 = 0 ;
25541 double val3 ;
25542 int ecode3 = 0 ;
25543 double val4 ;
25544 int ecode4 = 0 ;
25545 double val5 ;
25546 int ecode5 = 0 ;
25547 octave_value_list _out;
25548 octave_value_list *_outp=&_out;
25549 octave_value _outv;
25550
25551 try {
25552 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25553 SWIG_fail;
25554 }
25555 ecode1 = SWIG_AsVal_double(args(0), &val1);
25556 if (!SWIG_IsOK(ecode1)) {
25557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25558 }
25559 arg1 = static_cast< PLFLT >(val1);
25560 ecode2 = SWIG_AsVal_double(args(1), &val2);
25561 if (!SWIG_IsOK(ecode2)) {
25562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25563 }
25564 arg2 = static_cast< PLFLT >(val2);
25565 ecode3 = SWIG_AsVal_double(args(2), &val3);
25566 if (!SWIG_IsOK(ecode3)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25568 }
25569 arg3 = static_cast< PLFLT >(val3);
25570 ecode4 = SWIG_AsVal_double(args(3), &val4);
25571 if (!SWIG_IsOK(ecode4)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25573 }
25574 arg4 = static_cast< PLFLT >(val4);
25575 ecode5 = SWIG_AsVal_double(args(4), &val5);
25576 if (!SWIG_IsOK(ecode5)) {
25577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25578 }
25579 arg5 = static_cast< PLFLT >(val5);
25580 plvpas(arg1,arg2,arg3,arg4,arg5);
25581 _outv = octave_value();
25582 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25583 return _out;
25584 fail:
25585 return octave_value_list();
25586 }
25587 catch(...) {
25588 throw;
25589 }
25590}
25591
25592
25594 PLFLT arg1 ;
25595 PLFLT arg2 ;
25596 PLFLT arg3 ;
25597 PLFLT arg4 ;
25598 double val1 ;
25599 int ecode1 = 0 ;
25600 double val2 ;
25601 int ecode2 = 0 ;
25602 double val3 ;
25603 int ecode3 = 0 ;
25604 double val4 ;
25605 int ecode4 = 0 ;
25606 octave_value_list _out;
25607 octave_value_list *_outp=&_out;
25608 octave_value _outv;
25609
25610 try {
25611 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25612 SWIG_fail;
25613 }
25614 ecode1 = SWIG_AsVal_double(args(0), &val1);
25615 if (!SWIG_IsOK(ecode1)) {
25616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25617 }
25618 arg1 = static_cast< PLFLT >(val1);
25619 ecode2 = SWIG_AsVal_double(args(1), &val2);
25620 if (!SWIG_IsOK(ecode2)) {
25621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25622 }
25623 arg2 = static_cast< PLFLT >(val2);
25624 ecode3 = SWIG_AsVal_double(args(2), &val3);
25625 if (!SWIG_IsOK(ecode3)) {
25626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25627 }
25628 arg3 = static_cast< PLFLT >(val3);
25629 ecode4 = SWIG_AsVal_double(args(3), &val4);
25630 if (!SWIG_IsOK(ecode4)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25632 }
25633 arg4 = static_cast< PLFLT >(val4);
25634 plvpor(arg1,arg2,arg3,arg4);
25635 _outv = octave_value();
25636 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25637 return _out;
25638 fail:
25639 return octave_value_list();
25640 }
25641 catch(...) {
25642 throw;
25643 }
25644}
25645
25646
25648 octave_value_list _out;
25649 octave_value_list *_outp=&_out;
25650 octave_value _outv;
25651
25652 try {
25653 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25654 SWIG_fail;
25655 }
25656 plvsta();
25657 _outv = octave_value();
25658 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25659 return _out;
25660 fail:
25661 return octave_value_list();
25662 }
25663 catch(...) {
25664 throw;
25665 }
25666}
25667
25668
25670 PLFLT arg1 ;
25671 PLFLT arg2 ;
25672 PLFLT arg3 ;
25673 PLFLT arg4 ;
25674 PLFLT arg5 ;
25675 PLFLT arg6 ;
25676 PLFLT arg7 ;
25677 PLFLT arg8 ;
25678 PLFLT arg9 ;
25679 PLFLT arg10 ;
25680 PLFLT arg11 ;
25681 double val1 ;
25682 int ecode1 = 0 ;
25683 double val2 ;
25684 int ecode2 = 0 ;
25685 double val3 ;
25686 int ecode3 = 0 ;
25687 double val4 ;
25688 int ecode4 = 0 ;
25689 double val5 ;
25690 int ecode5 = 0 ;
25691 double val6 ;
25692 int ecode6 = 0 ;
25693 double val7 ;
25694 int ecode7 = 0 ;
25695 double val8 ;
25696 int ecode8 = 0 ;
25697 double val9 ;
25698 int ecode9 = 0 ;
25699 double val10 ;
25700 int ecode10 = 0 ;
25701 double val11 ;
25702 int ecode11 = 0 ;
25703 octave_value_list _out;
25704 octave_value_list *_outp=&_out;
25705 octave_value _outv;
25706
25707 try {
25708 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25709 SWIG_fail;
25710 }
25711 ecode1 = SWIG_AsVal_double(args(0), &val1);
25712 if (!SWIG_IsOK(ecode1)) {
25713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25714 }
25715 arg1 = static_cast< PLFLT >(val1);
25716 ecode2 = SWIG_AsVal_double(args(1), &val2);
25717 if (!SWIG_IsOK(ecode2)) {
25718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25719 }
25720 arg2 = static_cast< PLFLT >(val2);
25721 ecode3 = SWIG_AsVal_double(args(2), &val3);
25722 if (!SWIG_IsOK(ecode3)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25724 }
25725 arg3 = static_cast< PLFLT >(val3);
25726 ecode4 = SWIG_AsVal_double(args(3), &val4);
25727 if (!SWIG_IsOK(ecode4)) {
25728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25729 }
25730 arg4 = static_cast< PLFLT >(val4);
25731 ecode5 = SWIG_AsVal_double(args(4), &val5);
25732 if (!SWIG_IsOK(ecode5)) {
25733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25734 }
25735 arg5 = static_cast< PLFLT >(val5);
25736 ecode6 = SWIG_AsVal_double(args(5), &val6);
25737 if (!SWIG_IsOK(ecode6)) {
25738 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25739 }
25740 arg6 = static_cast< PLFLT >(val6);
25741 ecode7 = SWIG_AsVal_double(args(6), &val7);
25742 if (!SWIG_IsOK(ecode7)) {
25743 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25744 }
25745 arg7 = static_cast< PLFLT >(val7);
25746 ecode8 = SWIG_AsVal_double(args(7), &val8);
25747 if (!SWIG_IsOK(ecode8)) {
25748 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25749 }
25750 arg8 = static_cast< PLFLT >(val8);
25751 ecode9 = SWIG_AsVal_double(args(8), &val9);
25752 if (!SWIG_IsOK(ecode9)) {
25753 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25754 }
25755 arg9 = static_cast< PLFLT >(val9);
25756 ecode10 = SWIG_AsVal_double(args(9), &val10);
25757 if (!SWIG_IsOK(ecode10)) {
25758 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25759 }
25760 arg10 = static_cast< PLFLT >(val10);
25761 ecode11 = SWIG_AsVal_double(args(10), &val11);
25762 if (!SWIG_IsOK(ecode11)) {
25763 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25764 }
25765 arg11 = static_cast< PLFLT >(val11);
25766 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25767 _outv = octave_value();
25768 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25769 return _out;
25770 fail:
25771 return octave_value_list();
25772 }
25773 catch(...) {
25774 throw;
25775 }
25776}
25777
25778
25780 PLFLT arg1 ;
25781 double val1 ;
25782 int ecode1 = 0 ;
25783 octave_value_list _out;
25784 octave_value_list *_outp=&_out;
25785 octave_value _outv;
25786
25787 try {
25788 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25789 SWIG_fail;
25790 }
25791 ecode1 = SWIG_AsVal_double(args(0), &val1);
25792 if (!SWIG_IsOK(ecode1)) {
25793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25794 }
25795 arg1 = static_cast< PLFLT >(val1);
25796 plwidth(arg1);
25797 _outv = octave_value();
25798 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25799 return _out;
25800 fail:
25801 return octave_value_list();
25802 }
25803 catch(...) {
25804 throw;
25805 }
25806}
25807
25808
25810 PLFLT arg1 ;
25811 PLFLT arg2 ;
25812 PLFLT arg3 ;
25813 PLFLT arg4 ;
25814 double val1 ;
25815 int ecode1 = 0 ;
25816 double val2 ;
25817 int ecode2 = 0 ;
25818 double val3 ;
25819 int ecode3 = 0 ;
25820 double val4 ;
25821 int ecode4 = 0 ;
25822 octave_value_list _out;
25823 octave_value_list *_outp=&_out;
25824 octave_value _outv;
25825
25826 try {
25827 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25828 SWIG_fail;
25829 }
25830 ecode1 = SWIG_AsVal_double(args(0), &val1);
25831 if (!SWIG_IsOK(ecode1)) {
25832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25833 }
25834 arg1 = static_cast< PLFLT >(val1);
25835 ecode2 = SWIG_AsVal_double(args(1), &val2);
25836 if (!SWIG_IsOK(ecode2)) {
25837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25838 }
25839 arg2 = static_cast< PLFLT >(val2);
25840 ecode3 = SWIG_AsVal_double(args(2), &val3);
25841 if (!SWIG_IsOK(ecode3)) {
25842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25843 }
25844 arg3 = static_cast< PLFLT >(val3);
25845 ecode4 = SWIG_AsVal_double(args(3), &val4);
25846 if (!SWIG_IsOK(ecode4)) {
25847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25848 }
25849 arg4 = static_cast< PLFLT >(val4);
25850 plwind(arg1,arg2,arg3,arg4);
25851 _outv = octave_value();
25852 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25853 return _out;
25854 fail:
25855 return octave_value_list();
25856 }
25857 catch(...) {
25858 throw;
25859 }
25860}
25861
25862
25864 PLBOOL arg1 ;
25865 PLBOOL *arg2 = (PLBOOL *) 0 ;
25866 int val1 ;
25867 int ecode1 = 0 ;
25868 PLBOOL temp2 ;
25869 int res2 = SWIG_TMPOBJ ;
25870 octave_value_list _out;
25871 octave_value_list *_outp=&_out;
25872 octave_value _outv;
25873
25874 try {
25875 arg2 = &temp2;
25876 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25877 SWIG_fail;
25878 }
25879 ecode1 = SWIG_AsVal_int(args(0), &val1);
25880 if (!SWIG_IsOK(ecode1)) {
25881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25882 }
25883 arg1 = static_cast< PLBOOL >(val1);
25884 plxormod(arg1,arg2);
25885 _outv = octave_value();
25886 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25887 if (SWIG_IsTmpObj(res2)) {
25888 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25889 } else {
25890 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25891 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25892 }
25893 return _out;
25894 fail:
25895 return octave_value_list();
25896 }
25897 catch(...) {
25898 throw;
25899 }
25900}
25901
25902
25904 mapform_func arg1 = (mapform_func) 0 ;
25905 char *arg2 = (char *) 0 ;
25906 PLFLT arg3 ;
25907 PLFLT arg4 ;
25908 PLFLT arg5 ;
25909 PLFLT arg6 ;
25910 int res2 ;
25911 char *buf2 = 0 ;
25912 int alloc2 = 0 ;
25913 double val3 ;
25914 int ecode3 = 0 ;
25915 double val4 ;
25916 int ecode4 = 0 ;
25917 double val5 ;
25918 int ecode5 = 0 ;
25919 double val6 ;
25920 int ecode6 = 0 ;
25921 octave_value_list _out;
25922 octave_value_list *_outp=&_out;
25923 octave_value _outv;
25924
25925 try {
25926 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25927 SWIG_fail;
25928 }
25929 {
25930 octave_value obj = args(0);
25931#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25932 if ( !obj.isempty() )
25933#else
25934 if ( !obj.is_empty() )
25935#endif
25936 {
25937 if ( obj.is_function_handle() || obj.is_inline_function() )
25938 {
25939 fcnMapForm = obj.function_value();
25940 }
25941 else if ( obj.is_string() )
25942 {
25943 nameMapForm = obj.string_value();
25944 fcnMapForm = NULL;
25945 }
25946 arg1 = mapform_octave;
25947 }
25948 else
25949 {
25950 arg1 = NULL;
25951 }
25952 }
25953 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25954 if (!SWIG_IsOK(res2)) {
25955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
25956 }
25957 arg2 = reinterpret_cast< char * >(buf2);
25958 ecode3 = SWIG_AsVal_double(args(2), &val3);
25959 if (!SWIG_IsOK(ecode3)) {
25960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
25961 }
25962 arg3 = static_cast< PLFLT >(val3);
25963 ecode4 = SWIG_AsVal_double(args(3), &val4);
25964 if (!SWIG_IsOK(ecode4)) {
25965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
25966 }
25967 arg4 = static_cast< PLFLT >(val4);
25968 ecode5 = SWIG_AsVal_double(args(4), &val5);
25969 if (!SWIG_IsOK(ecode5)) {
25970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
25971 }
25972 arg5 = static_cast< PLFLT >(val5);
25973 ecode6 = SWIG_AsVal_double(args(5), &val6);
25974 if (!SWIG_IsOK(ecode6)) {
25975 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
25976 }
25977 arg6 = static_cast< PLFLT >(val6);
25978 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
25979 _outv = octave_value();
25980 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25981 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25982 return _out;
25983 fail:
25984 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25985 return octave_value_list();
25986 }
25987 catch(...) {
25988 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25989 throw;
25990 }
25991}
25992
25993
25995 mapform_func arg1 = (mapform_func) 0 ;
25996 char *arg2 = (char *) 0 ;
25997 PLFLT arg3 ;
25998 PLFLT arg4 ;
25999 PLFLT arg5 ;
26000 PLFLT arg6 ;
26001 PLINT *arg7 = (PLINT *) 0 ;
26002 PLINT arg8 ;
26003 int res2 ;
26004 char *buf2 = 0 ;
26005 int alloc2 = 0 ;
26006 double val3 ;
26007 int ecode3 = 0 ;
26008 double val4 ;
26009 int ecode4 = 0 ;
26010 double val5 ;
26011 int ecode5 = 0 ;
26012 double val6 ;
26013 int ecode6 = 0 ;
26014 Matrix temp7 ;
26015 octave_value_list _out;
26016 octave_value_list *_outp=&_out;
26017 octave_value _outv;
26018
26019 try {
26020 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
26021 SWIG_fail;
26022 }
26023 {
26024 octave_value obj = args(0);
26025#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26026 if ( !obj.isempty() )
26027#else
26028 if ( !obj.is_empty() )
26029#endif
26030 {
26031 if ( obj.is_function_handle() || obj.is_inline_function() )
26032 {
26033 fcnMapForm = obj.function_value();
26034 }
26035 else if ( obj.is_string() )
26036 {
26037 nameMapForm = obj.string_value();
26038 fcnMapForm = NULL;
26039 }
26040 arg1 = mapform_octave;
26041 }
26042 else
26043 {
26044 arg1 = NULL;
26045 }
26046 }
26047 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26048 if (!SWIG_IsOK(res2)) {
26049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
26050 }
26051 arg2 = reinterpret_cast< char * >(buf2);
26052 ecode3 = SWIG_AsVal_double(args(2), &val3);
26053 if (!SWIG_IsOK(ecode3)) {
26054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
26055 }
26056 arg3 = static_cast< PLFLT >(val3);
26057 ecode4 = SWIG_AsVal_double(args(3), &val4);
26058 if (!SWIG_IsOK(ecode4)) {
26059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26060 }
26061 arg4 = static_cast< PLFLT >(val4);
26062 ecode5 = SWIG_AsVal_double(args(4), &val5);
26063 if (!SWIG_IsOK(ecode5)) {
26064 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26065 }
26066 arg5 = static_cast< PLFLT >(val5);
26067 ecode6 = SWIG_AsVal_double(args(5), &val6);
26068 if (!SWIG_IsOK(ecode6)) {
26069 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26070 }
26071 arg6 = static_cast< PLFLT >(val6);
26072 {
26073 if ( _n_dims( args(6) ) > 1 )
26074 {
26075 error( "argument must be a scalar or vector" ); SWIG_fail;
26076 }
26077#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26078 if ( !args(6).isempty() )
26079#else
26080 if ( !args(6).is_empty() )
26081#endif
26082 {
26083 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26084 temp7 = args(6).matrix_value();
26085 arg7 = new PLINT[arg8];
26086 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26087 }
26088 else
26089 {
26090 arg7 = NULL;
26091 arg8 = 0;
26092 }
26093 }
26094 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26095 _outv = octave_value();
26096 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26097 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26098 {
26099 delete [] arg7;
26100 }
26101 return _out;
26102 fail:
26103 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26104 {
26105 delete [] arg7;
26106 }
26107 return octave_value_list();
26108 }
26109 catch(...) {
26110 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26111 {
26112 delete [] arg7;
26113 }
26114 throw;
26115 }
26116}
26117
26118
26120 mapform_func arg1 = (mapform_func) 0 ;
26121 char *arg2 = (char *) 0 ;
26122 char *arg3 = (char *) 0 ;
26123 PLFLT arg4 ;
26124 PLFLT arg5 ;
26125 PLFLT arg6 ;
26126 PLFLT arg7 ;
26127 PLINT *arg8 = (PLINT *) 0 ;
26128 PLINT arg9 ;
26129 int res2 ;
26130 char *buf2 = 0 ;
26131 int alloc2 = 0 ;
26132 int res3 ;
26133 char *buf3 = 0 ;
26134 int alloc3 = 0 ;
26135 double val4 ;
26136 int ecode4 = 0 ;
26137 double val5 ;
26138 int ecode5 = 0 ;
26139 double val6 ;
26140 int ecode6 = 0 ;
26141 double val7 ;
26142 int ecode7 = 0 ;
26143 Matrix temp8 ;
26144 octave_value_list _out;
26145 octave_value_list *_outp=&_out;
26146 octave_value _outv;
26147
26148 try {
26149 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26150 SWIG_fail;
26151 }
26152 {
26153 octave_value obj = args(0);
26154#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26155 if ( !obj.isempty() )
26156#else
26157 if ( !obj.is_empty() )
26158#endif
26159 {
26160 if ( obj.is_function_handle() || obj.is_inline_function() )
26161 {
26162 fcnMapForm = obj.function_value();
26163 }
26164 else if ( obj.is_string() )
26165 {
26166 nameMapForm = obj.string_value();
26167 fcnMapForm = NULL;
26168 }
26169 arg1 = mapform_octave;
26170 }
26171 else
26172 {
26173 arg1 = NULL;
26174 }
26175 }
26176 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26177 if (!SWIG_IsOK(res2)) {
26178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26179 }
26180 arg2 = reinterpret_cast< char * >(buf2);
26181 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26182 if (!SWIG_IsOK(res3)) {
26183 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26184 }
26185 arg3 = reinterpret_cast< char * >(buf3);
26186 ecode4 = SWIG_AsVal_double(args(3), &val4);
26187 if (!SWIG_IsOK(ecode4)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26189 }
26190 arg4 = static_cast< PLFLT >(val4);
26191 ecode5 = SWIG_AsVal_double(args(4), &val5);
26192 if (!SWIG_IsOK(ecode5)) {
26193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26194 }
26195 arg5 = static_cast< PLFLT >(val5);
26196 ecode6 = SWIG_AsVal_double(args(5), &val6);
26197 if (!SWIG_IsOK(ecode6)) {
26198 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26199 }
26200 arg6 = static_cast< PLFLT >(val6);
26201 ecode7 = SWIG_AsVal_double(args(6), &val7);
26202 if (!SWIG_IsOK(ecode7)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26204 }
26205 arg7 = static_cast< PLFLT >(val7);
26206 {
26207 if ( _n_dims( args(7) ) > 1 )
26208 {
26209 error( "argument must be a scalar or vector" ); SWIG_fail;
26210 }
26211#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26212 if ( !args(7).isempty() )
26213#else
26214 if ( !args(7).is_empty() )
26215#endif
26216 {
26217 arg9 = (PLINT) ( _dim( args(7), 0 ) );
26218 temp8 = args(7).matrix_value();
26219 arg8 = new PLINT[arg9];
26220 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26221 }
26222 else
26223 {
26224 arg8 = NULL;
26225 arg9 = 0;
26226 }
26227 }
26228 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26229 _outv = octave_value();
26230 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26231 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26232 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26233 {
26234 delete [] arg8;
26235 }
26236 return _out;
26237 fail:
26238 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26239 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26240 {
26241 delete [] arg8;
26242 }
26243 return octave_value_list();
26244 }
26245 catch(...) {
26246 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26247 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26248 {
26249 delete [] arg8;
26250 }
26251 throw;
26252 }
26253}
26254
26255
26257 mapform_func arg1 = (mapform_func) 0 ;
26258 char *arg2 = (char *) 0 ;
26259 PLFLT arg3 ;
26260 PLFLT arg4 ;
26261 PLFLT arg5 ;
26262 char *arg6 = (char *) 0 ;
26263 PLFLT arg7 ;
26264 PLFLT arg8 ;
26265 PLFLT arg9 ;
26266 PLFLT arg10 ;
26267 PLINT arg11 ;
26268 int res2 ;
26269 char *buf2 = 0 ;
26270 int alloc2 = 0 ;
26271 double val3 ;
26272 int ecode3 = 0 ;
26273 double val4 ;
26274 int ecode4 = 0 ;
26275 double val5 ;
26276 int ecode5 = 0 ;
26277 int res6 ;
26278 char *buf6 = 0 ;
26279 int alloc6 = 0 ;
26280 double val7 ;
26281 int ecode7 = 0 ;
26282 double val8 ;
26283 int ecode8 = 0 ;
26284 double val9 ;
26285 int ecode9 = 0 ;
26286 double val10 ;
26287 int ecode10 = 0 ;
26288 int val11 ;
26289 int ecode11 = 0 ;
26290 octave_value_list _out;
26291 octave_value_list *_outp=&_out;
26292 octave_value _outv;
26293
26294 try {
26295 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26296 SWIG_fail;
26297 }
26298 {
26299 octave_value obj = args(0);
26300#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26301 if ( !obj.isempty() )
26302#else
26303 if ( !obj.is_empty() )
26304#endif
26305 {
26306 if ( obj.is_function_handle() || obj.is_inline_function() )
26307 {
26308 fcnMapForm = obj.function_value();
26309 }
26310 else if ( obj.is_string() )
26311 {
26312 nameMapForm = obj.string_value();
26313 fcnMapForm = NULL;
26314 }
26315 arg1 = mapform_octave;
26316 }
26317 else
26318 {
26319 arg1 = NULL;
26320 }
26321 }
26322 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26323 if (!SWIG_IsOK(res2)) {
26324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26325 }
26326 arg2 = reinterpret_cast< char * >(buf2);
26327 ecode3 = SWIG_AsVal_double(args(2), &val3);
26328 if (!SWIG_IsOK(ecode3)) {
26329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26330 }
26331 arg3 = static_cast< PLFLT >(val3);
26332 ecode4 = SWIG_AsVal_double(args(3), &val4);
26333 if (!SWIG_IsOK(ecode4)) {
26334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26335 }
26336 arg4 = static_cast< PLFLT >(val4);
26337 ecode5 = SWIG_AsVal_double(args(4), &val5);
26338 if (!SWIG_IsOK(ecode5)) {
26339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26340 }
26341 arg5 = static_cast< PLFLT >(val5);
26342 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26343 if (!SWIG_IsOK(res6)) {
26344 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26345 }
26346 arg6 = reinterpret_cast< char * >(buf6);
26347 ecode7 = SWIG_AsVal_double(args(6), &val7);
26348 if (!SWIG_IsOK(ecode7)) {
26349 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26350 }
26351 arg7 = static_cast< PLFLT >(val7);
26352 ecode8 = SWIG_AsVal_double(args(7), &val8);
26353 if (!SWIG_IsOK(ecode8)) {
26354 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26355 }
26356 arg8 = static_cast< PLFLT >(val8);
26357 ecode9 = SWIG_AsVal_double(args(8), &val9);
26358 if (!SWIG_IsOK(ecode9)) {
26359 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26360 }
26361 arg9 = static_cast< PLFLT >(val9);
26362 ecode10 = SWIG_AsVal_double(args(9), &val10);
26363 if (!SWIG_IsOK(ecode10)) {
26364 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26365 }
26366 arg10 = static_cast< PLFLT >(val10);
26367 ecode11 = SWIG_AsVal_int(args(10), &val11);
26368 if (!SWIG_IsOK(ecode11)) {
26369 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26370 }
26371 arg11 = static_cast< PLINT >(val11);
26372 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26373 _outv = octave_value();
26374 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26375 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26376 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26377 return _out;
26378 fail:
26379 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26380 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26381 return octave_value_list();
26382 }
26383 catch(...) {
26384 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26385 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26386 throw;
26387 }
26388}
26389
26390
26392 mapform_func arg1 = (mapform_func) 0 ;
26393 char *arg2 = (char *) 0 ;
26394 PLFLT arg3 ;
26395 PLFLT arg4 ;
26396 PLFLT arg5 ;
26397 PLFLT arg6 ;
26398 PLINT *arg7 = (PLINT *) 0 ;
26399 PLINT arg8 ;
26400 int res2 ;
26401 char *buf2 = 0 ;
26402 int alloc2 = 0 ;
26403 double val3 ;
26404 int ecode3 = 0 ;
26405 double val4 ;
26406 int ecode4 = 0 ;
26407 double val5 ;
26408 int ecode5 = 0 ;
26409 double val6 ;
26410 int ecode6 = 0 ;
26411 Matrix temp7 ;
26412 octave_value_list _out;
26413 octave_value_list *_outp=&_out;
26414 octave_value _outv;
26415
26416 try {
26417 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26418 SWIG_fail;
26419 }
26420 {
26421 octave_value obj = args(0);
26422#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26423 if ( !obj.isempty() )
26424#else
26425 if ( !obj.is_empty() )
26426#endif
26427 {
26428 if ( obj.is_function_handle() || obj.is_inline_function() )
26429 {
26430 fcnMapForm = obj.function_value();
26431 }
26432 else if ( obj.is_string() )
26433 {
26434 nameMapForm = obj.string_value();
26435 fcnMapForm = NULL;
26436 }
26437 arg1 = mapform_octave;
26438 }
26439 else
26440 {
26441 arg1 = NULL;
26442 }
26443 }
26444 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26445 if (!SWIG_IsOK(res2)) {
26446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26447 }
26448 arg2 = reinterpret_cast< char * >(buf2);
26449 ecode3 = SWIG_AsVal_double(args(2), &val3);
26450 if (!SWIG_IsOK(ecode3)) {
26451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26452 }
26453 arg3 = static_cast< PLFLT >(val3);
26454 ecode4 = SWIG_AsVal_double(args(3), &val4);
26455 if (!SWIG_IsOK(ecode4)) {
26456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26457 }
26458 arg4 = static_cast< PLFLT >(val4);
26459 ecode5 = SWIG_AsVal_double(args(4), &val5);
26460 if (!SWIG_IsOK(ecode5)) {
26461 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26462 }
26463 arg5 = static_cast< PLFLT >(val5);
26464 ecode6 = SWIG_AsVal_double(args(5), &val6);
26465 if (!SWIG_IsOK(ecode6)) {
26466 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26467 }
26468 arg6 = static_cast< PLFLT >(val6);
26469 {
26470 if ( _n_dims( args(6) ) > 1 )
26471 {
26472 error( "argument must be a scalar or vector" ); SWIG_fail;
26473 }
26474#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26475 if ( !args(6).isempty() )
26476#else
26477 if ( !args(6).is_empty() )
26478#endif
26479 {
26480 arg8 = (PLINT) ( _dim( args(6), 0 ) );
26481 temp7 = args(6).matrix_value();
26482 arg7 = new PLINT[arg8];
26483 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26484 }
26485 else
26486 {
26487 arg7 = NULL;
26488 arg8 = 0;
26489 }
26490 }
26491 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26492 _outv = octave_value();
26493 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26494 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26495 {
26496 delete [] arg7;
26497 }
26498 return _out;
26499 fail:
26500 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26501 {
26502 delete [] arg7;
26503 }
26504 return octave_value_list();
26505 }
26506 catch(...) {
26507 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26508 {
26509 delete [] arg7;
26510 }
26511 throw;
26512 }
26513}
26514
26515
26517 mapform_func arg1 = (mapform_func) 0 ;
26518 PLFLT arg2 ;
26519 PLFLT arg3 ;
26520 PLFLT arg4 ;
26521 PLFLT arg5 ;
26522 PLFLT arg6 ;
26523 PLFLT arg7 ;
26524 double val2 ;
26525 int ecode2 = 0 ;
26526 double val3 ;
26527 int ecode3 = 0 ;
26528 double val4 ;
26529 int ecode4 = 0 ;
26530 double val5 ;
26531 int ecode5 = 0 ;
26532 double val6 ;
26533 int ecode6 = 0 ;
26534 double val7 ;
26535 int ecode7 = 0 ;
26536 octave_value_list _out;
26537 octave_value_list *_outp=&_out;
26538 octave_value _outv;
26539
26540 try {
26541 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26542 SWIG_fail;
26543 }
26544 {
26545 octave_value obj = args(0);
26546#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26547 if ( !obj.isempty() )
26548#else
26549 if ( !obj.is_empty() )
26550#endif
26551 {
26552 if ( obj.is_function_handle() || obj.is_inline_function() )
26553 {
26554 fcnMapForm = obj.function_value();
26555 }
26556 else if ( obj.is_string() )
26557 {
26558 nameMapForm = obj.string_value();
26559 fcnMapForm = NULL;
26560 }
26561 arg1 = mapform_octave;
26562 }
26563 else
26564 {
26565 arg1 = NULL;
26566 }
26567 }
26568 ecode2 = SWIG_AsVal_double(args(1), &val2);
26569 if (!SWIG_IsOK(ecode2)) {
26570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26571 }
26572 arg2 = static_cast< PLFLT >(val2);
26573 ecode3 = SWIG_AsVal_double(args(2), &val3);
26574 if (!SWIG_IsOK(ecode3)) {
26575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26576 }
26577 arg3 = static_cast< PLFLT >(val3);
26578 ecode4 = SWIG_AsVal_double(args(3), &val4);
26579 if (!SWIG_IsOK(ecode4)) {
26580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26581 }
26582 arg4 = static_cast< PLFLT >(val4);
26583 ecode5 = SWIG_AsVal_double(args(4), &val5);
26584 if (!SWIG_IsOK(ecode5)) {
26585 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26586 }
26587 arg5 = static_cast< PLFLT >(val5);
26588 ecode6 = SWIG_AsVal_double(args(5), &val6);
26589 if (!SWIG_IsOK(ecode6)) {
26590 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26591 }
26592 arg6 = static_cast< PLFLT >(val6);
26593 ecode7 = SWIG_AsVal_double(args(6), &val7);
26594 if (!SWIG_IsOK(ecode7)) {
26595 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26596 }
26597 arg7 = static_cast< PLFLT >(val7);
26598 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26599 _outv = octave_value();
26600 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26601 return _out;
26602 fail:
26603 return octave_value_list();
26604 }
26605 catch(...) {
26606 throw;
26607 }
26608}
26609
26610
26612 octave_value_list _out;
26613 octave_value_list *_outp=&_out;
26614 octave_value _outv;
26615
26616 try {
26617 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26618 SWIG_fail;
26619 }
26620 plClearOpts();
26621 _outv = octave_value();
26622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26623 return _out;
26624 fail:
26625 return octave_value_list();
26626 }
26627 catch(...) {
26628 throw;
26629 }
26630}
26631
26632
26634 octave_value_list _out;
26635 octave_value_list *_outp=&_out;
26636 octave_value _outv;
26637
26638 try {
26639 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26640 SWIG_fail;
26641 }
26642 plResetOpts();
26643 _outv = octave_value();
26644 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26645 return _out;
26646 fail:
26647 return octave_value_list();
26648 }
26649 catch(...) {
26650 throw;
26651 }
26652}
26653
26654
26656 char *arg1 = (char *) 0 ;
26657 char *arg2 = (char *) 0 ;
26658 int res1 ;
26659 char *buf1 = 0 ;
26660 int alloc1 = 0 ;
26661 int res2 ;
26662 char *buf2 = 0 ;
26663 int alloc2 = 0 ;
26664 octave_value_list _out;
26665 octave_value_list *_outp=&_out;
26666 octave_value _outv;
26667
26668 try {
26669 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26670 SWIG_fail;
26671 }
26672 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26673 if (!SWIG_IsOK(res1)) {
26674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26675 }
26676 arg1 = reinterpret_cast< char * >(buf1);
26677 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26678 if (!SWIG_IsOK(res2)) {
26679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26680 }
26681 arg2 = reinterpret_cast< char * >(buf2);
26682 plSetUsage((char const *)arg1,(char const *)arg2);
26683 _outv = octave_value();
26684 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26685 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26686 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26687 return _out;
26688 fail:
26689 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26690 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26691 return octave_value_list();
26692 }
26693 catch(...) {
26694 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26695 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26696 throw;
26697 }
26698}
26699
26700
26702 octave_value_list _out;
26703 octave_value_list *_outp=&_out;
26704 octave_value _outv;
26705
26706 try {
26707 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26708 SWIG_fail;
26709 }
26710 plOptUsage();
26711 _outv = octave_value();
26712 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26713 return _out;
26714 fail:
26715 return octave_value_list();
26716 }
26717 catch(...) {
26718 throw;
26719 }
26720}
26721
26722
26723
26724static const struct swig_octave_member swig_globals[] = {
26725{"testppchar",_wrap_testppchar,0,0,2,0},
26726{"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26727{"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26728{"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26729{"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26730{"plcont0",_wrap_plcont0,0,0,2,0},
26731{"plcont1",_wrap_plcont1,0,0,2,0},
26732{"plcont2",_wrap_plcont2,0,0,2,0},
26733{"plcont2p",_wrap_plcont2p,0,0,2,0},
26734{"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26735{"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26736{"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26737{"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26738{"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26739{"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26740{"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26741{"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26742{"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26743{"plshade1",_wrap_plshade1,0,0,2,0},
26744{"plshade2",_wrap_plshade2,0,0,2,0},
26745{"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26746{"plshadesx",_wrap_plshadesx,0,0,2,0},
26747{"plshades1",_wrap_plshades1,0,0,2,0},
26748{"plshades2",_wrap_plshades2,0,0,2,0},
26749{"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26750{"plvect1",_wrap_plvect1,0,0,2,0},
26751{"plvect2",_wrap_plvect2,0,0,2,0},
26752{"pplimage",_wrap_pplimage,0,0,2,0},
26753{"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26754{"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26755{"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26756{"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26757{"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26758{"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26759{"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26760{"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26761{"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26762{"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26763{"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26764{"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26765{"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26766{"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26767{"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26768{"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26769{"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26770{"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26771{"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26772{"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26773{"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26774{"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26775{"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26776{"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26777{"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26778{"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26779{"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26780{"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26781{"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26782{"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26783{"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26786{"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26787{"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26788{"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26789{"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26790{"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26791{"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26792{"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26793{"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26794{"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26795{"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26796{"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26797{"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26798{"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26799{"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26800{"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26801{"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26802{"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26803{"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26804{"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26805{"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26806{"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26807{"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26808{"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26809{"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26810{"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26811{"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26812{"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26813{"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26814{"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26815{"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26816{"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26817{"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26818{"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26819{"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26820{"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26821{"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26822{"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26823{"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26824{"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26825{"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26826{"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26827{"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26828{"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26829{"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26830{"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26831{"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26832{"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26833{"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26834{"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26835{"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26836{"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26837{"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26838{"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26839{"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26840{"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26841{"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26842{"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26843{"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26844{"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26845{"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26846{"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26847{"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26848{"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26849{"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26850{"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26851{"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26852{"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26853{"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26854{"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26855{"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26856{"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26857{"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26858{"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26859{"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26860{"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26861{"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26862{"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26863{"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26864{"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26865{"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26866{"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26867{"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26868{"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26869{"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26870{"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26871{"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26872{"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26873{"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26874{"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26875{"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26876{"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26877{"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26878{"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26879{"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26880{"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26881{"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26882{"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26883{"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26884{"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26885{"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26886{"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26887{"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26888{"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26889{"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26890{"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26891{"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26892{"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26893{"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26894{"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26895{"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26896{"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26897{"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26898{"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26899{"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26900{"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26901{"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26902{"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26903{"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26904{"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26905{"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26906{"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26907{"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26908{"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26909{"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26910{"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26911{"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26912{"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26913{"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26914{"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26915{"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26916{"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26917{"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26918{"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26919{"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26920{"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26921{"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26922{"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26923{"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26924{"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26925{"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26926{"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26927{"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26928{"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26929{"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26930{"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26931{"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
26932{"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
26933{"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
26934{"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
26935{"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
26936{"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
26937{"plClearOpts",_wrap_plClearOpts,0,0,2,0},
26938{"plResetOpts",_wrap_plResetOpts,0,0,2,0},
26939{"plSetUsage",_wrap_plSetUsage,0,0,2,0},
26940{"plOptUsage",_wrap_plOptUsage,0,0,2,0},
26941{0,0,0,0,0,0}
26942};
26943
26944/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26945
26946static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
26947static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26948static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
26949static 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};
26950static 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};
26951static 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};
26952static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
26953static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26954static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
26955
26966};
26967
26968static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
26969static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26970static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26974static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26975static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26976static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26977
26988};
26989
26990
26991/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26992
26993/* -----------------------------------------------------------------------------
26994 * Type initialization:
26995 * This problem is tough by the requirement that no dynamic
26996 * memory is used. Also, since swig_type_info structures store pointers to
26997 * swig_cast_info structures and swig_cast_info structures store pointers back
26998 * to swig_type_info structures, we need some lookup code at initialization.
26999 * The idea is that swig generates all the structures that are needed.
27000 * The runtime then collects these partially filled structures.
27001 * The SWIG_InitializeModule function takes these initial arrays out of
27002 * swig_module, and does all the lookup, filling in the swig_module.types
27003 * array with the correct data and linking the correct swig_cast_info
27004 * structures together.
27005 *
27006 * The generated swig_type_info structures are assigned statically to an initial
27007 * array. We just loop through that array, and handle each type individually.
27008 * First we lookup if this type has been already loaded, and if so, use the
27009 * loaded structure instead of the generated one. Then we have to fill in the
27010 * cast linked list. The cast data is initially stored in something like a
27011 * two-dimensional array. Each row corresponds to a type (there are the same
27012 * number of rows as there are in the swig_type_initial array). Each entry in
27013 * a column is one of the swig_cast_info structures for that type.
27014 * The cast_initial array is actually an array of arrays, because each row has
27015 * a variable number of columns. So to actually build the cast linked list,
27016 * we find the array of casts associated with the type, and loop through it
27017 * adding the casts to the list. The one last trick we need to do is making
27018 * sure the type pointer in the swig_cast_info struct is correct.
27019 *
27020 * First off, we lookup the cast->type name to see if it is already loaded.
27021 * There are three cases to handle:
27022 * 1) If the cast->type has already been loaded AND the type we are adding
27023 * casting info to has not been loaded (it is in this module), THEN we
27024 * replace the cast->type pointer with the type pointer that has already
27025 * been loaded.
27026 * 2) If BOTH types (the one we are adding casting info to, and the
27027 * cast->type) are loaded, THEN the cast info has already been loaded by
27028 * the previous module so we just ignore it.
27029 * 3) Finally, if cast->type has not already been loaded, then we add that
27030 * swig_cast_info to the linked list (because the cast->type) pointer will
27031 * be correct.
27032 * ----------------------------------------------------------------------------- */
27033
27034#ifdef __cplusplus
27035extern "C" {
27036#if 0
27037} /* c-mode */
27038#endif
27039#endif
27040
27041#if 0
27042#define SWIGRUNTIME_DEBUG
27043#endif
27044
27045#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27046#define SWIG_INIT_CLIENT_DATA_TYPE void *
27047#endif
27048
27049SWIGRUNTIME void
27051 size_t i;
27052 swig_module_info *module_head, *iter;
27053 int init;
27054
27055 /* check to see if the circular list has been setup, if not, set it up */
27056 if (swig_module.next==0) {
27057 /* Initialize the swig_module */
27061 init = 1;
27062 } else {
27063 init = 0;
27064 }
27065
27066 /* Try and load any already created modules */
27067 module_head = SWIG_GetModule(clientdata);
27068 if (!module_head) {
27069 /* This is the first module loaded for this interpreter */
27070 /* so set the swig module into the interpreter */
27071 SWIG_SetModule(clientdata, &swig_module);
27072 } else {
27073 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27074 iter=module_head;
27075 do {
27076 if (iter==&swig_module) {
27077 /* Our module is already in the list, so there's nothing more to do. */
27078 return;
27079 }
27080 iter=iter->next;
27081 } while (iter!= module_head);
27082
27083 /* otherwise we must add our module into the list */
27084 swig_module.next = module_head->next;
27085 module_head->next = &swig_module;
27086 }
27087
27088 /* When multiple interpreters are used, a module could have already been initialized in
27089 a different interpreter, but not yet have a pointer in this interpreter.
27090 In this case, we do not want to continue adding types... everything should be
27091 set up already */
27092 if (init == 0) return;
27093
27094 /* Now work on filling in swig_module.types */
27095#ifdef SWIGRUNTIME_DEBUG
27096 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27097#endif
27098 for (i = 0; i < swig_module.size; ++i) {
27099 swig_type_info *type = 0;
27100 swig_type_info *ret;
27101 swig_cast_info *cast;
27102
27103#ifdef SWIGRUNTIME_DEBUG
27104 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27105#endif
27106
27107 /* if there is another module already loaded */
27108 if (swig_module.next != &swig_module) {
27110 }
27111 if (type) {
27112 /* Overwrite clientdata field */
27113#ifdef SWIGRUNTIME_DEBUG
27114 printf("SWIG_InitializeModule: found type %s\n", type->name);
27115#endif
27118#ifdef SWIGRUNTIME_DEBUG
27119 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27120#endif
27121 }
27122 } else {
27123 type = swig_module.type_initial[i];
27124 }
27125
27126 /* Insert casting types */
27127 cast = swig_module.cast_initial[i];
27128 while (cast->type) {
27129
27130 /* Don't need to add information already in the list */
27131 ret = 0;
27132#ifdef SWIGRUNTIME_DEBUG
27133 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27134#endif
27135 if (swig_module.next != &swig_module) {
27137#ifdef SWIGRUNTIME_DEBUG
27138 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27139#endif
27140 }
27141 if (ret) {
27142 if (type == swig_module.type_initial[i]) {
27143#ifdef SWIGRUNTIME_DEBUG
27144 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27145#endif
27146 cast->type = ret;
27147 ret = 0;
27148 } else {
27149 /* Check for casting already in the list */
27150 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27151#ifdef SWIGRUNTIME_DEBUG
27152 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27153#endif
27154 if (!ocast) ret = 0;
27155 }
27156 }
27157
27158 if (!ret) {
27159#ifdef SWIGRUNTIME_DEBUG
27160 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27161#endif
27162 if (type->cast) {
27163 type->cast->prev = cast;
27164 cast->next = type->cast;
27165 }
27166 type->cast = cast;
27167 }
27168 cast++;
27169 }
27170 /* Set entry in modules->types array equal to the type */
27171 swig_module.types[i] = type;
27172 }
27173 swig_module.types[i] = 0;
27174
27175#ifdef SWIGRUNTIME_DEBUG
27176 printf("**** SWIG_InitializeModule: Cast List ******\n");
27177 for (i = 0; i < swig_module.size; ++i) {
27178 int j = 0;
27180 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27181 while (cast->type) {
27182 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27183 cast++;
27184 ++j;
27185 }
27186 printf("---- Total casts: %d\n",j);
27187 }
27188 printf("**** SWIG_InitializeModule: Cast List ******\n");
27189#endif
27190}
27191
27192/* This function will propagate the clientdata field of type to
27193* any new swig_type_info structures that have been added into the list
27194* of equivalent types. It is like calling
27195* SWIG_TypeClientData(type, clientdata) a second time.
27196*/
27197SWIGRUNTIME void
27199 size_t i;
27200 swig_cast_info *equiv;
27201 static int init_run = 0;
27202
27203 if (init_run) return;
27204 init_run = 1;
27205
27206 for (i = 0; i < swig_module.size; i++) {
27207 if (swig_module.types[i]->clientdata) {
27208 equiv = swig_module.types[i]->cast;
27209 while (equiv) {
27210 if (!equiv->converter) {
27211 if (equiv->type && !equiv->type->clientdata)
27213 }
27214 equiv = equiv->next;
27215 }
27216 }
27217 }
27218}
27219
27220#ifdef __cplusplus
27221#if 0
27222{ /* c-mode */
27223#endif
27224}
27225#endif
27226
27227
27228
27229static bool SWIG_init_user(octave_swig_type* module_ns);
27230
27232 bool retn = false;
27233 {
27234#if SWIG_OCTAVE_PREREQ(6,0,0)
27235#elif SWIG_OCTAVE_PREREQ(4,2,0)
27236 octave::unwind_protect frame;
27237 frame.protect_var(discard_error_messages); discard_error_messages = true;
27238 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27239#elif SWIG_OCTAVE_PREREQ(3,3,50)
27240 unwind_protect frame;
27241 frame.protect_var(error_state); error_state = 0;
27242 frame.protect_var(warning_state); warning_state = 0;
27243 frame.protect_var(discard_error_messages); discard_error_messages = true;
27244 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27245#else
27246 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27247 unwind_protect_int(error_state); error_state = 0;
27248 unwind_protect_int(warning_state); warning_state = 0;
27249 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27250 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27251#endif
27252#if SWIG_OCTAVE_PREREQ(4,2,0)
27253 try {
27254#if SWIG_OCTAVE_PREREQ(4,4,0)
27255 octave::feval(name, octave_value_list(), 0);
27256#else
27257 feval(name, octave_value_list(), 0);
27258#endif
27259 retn = true;
27260 } catch (octave::execution_exception&) { }
27261#else
27262 feval(name, octave_value_list(), 0);
27263 retn = (error_state == 0);
27264#endif
27265#if !SWIG_OCTAVE_PREREQ(3,3,50)
27266 unwind_protect::run_frame("SWIG_Octave_LoadModule");
27267#endif
27268 }
27269 if (!retn) {
27270 error(SWIG_name_d ": could not load module `%s'", name.c_str());
27271 }
27272 return retn;
27273}
27274
27275SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27276 bool retn = false;
27277 {
27278#if SWIG_OCTAVE_PREREQ(6,0,0)
27279#elif SWIG_OCTAVE_PREREQ(4,2,0)
27280 octave::unwind_protect frame;
27281 frame.protect_var(discard_error_messages); discard_error_messages = true;
27282 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27283#elif SWIG_OCTAVE_PREREQ(3,3,50)
27284 unwind_protect frame;
27285 frame.protect_var(error_state); error_state = 0;
27286 frame.protect_var(warning_state); warning_state = 0;
27287 frame.protect_var(discard_error_messages); discard_error_messages = true;
27288 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27289#else
27290 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27291 unwind_protect_int(error_state); error_state = 0;
27292 unwind_protect_int(warning_state); warning_state = 0;
27293 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27294 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27295#endif
27296 octave_value_list args;
27297 args.append(name);
27298 args.append(octloadfcn->fcn_file_name());
27299#if SWIG_OCTAVE_PREREQ(4,2,0)
27300 try {
27301#if SWIG_OCTAVE_PREREQ(4,4,0)
27302 octave::feval("autoload", args, 0);
27303#else
27304 feval("autoload", args, 0);
27305#endif
27306 retn = true;
27307 } catch (octave::execution_exception&) { }
27308#else
27309 feval("autoload", args, 0);
27310 retn = (error_state == 0);
27311#endif
27312#if !SWIG_OCTAVE_PREREQ(3,3,50)
27313 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27314#endif
27315 }
27316 if (!retn) {
27317 error(SWIG_name_d ": could not load function `%s'", name.c_str());
27318 }
27319 return retn;
27320}
27321
27322static const char *const subclass_usage = "-*- texinfo -*- \n\
27323@deftypefn {Loadable Function} {} subclass()\n\
27324@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27325Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27326\n\
27327See the SWIG manual for usage examples.\n\
27328@end deftypefn";
27329
27330DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27332 for (int j = 0; j < args.length(); ++j) {
27333 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27334 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27335 octave_swig_type *ost = osr->get_ptr();
27336 if (!ost->is_owned()) {
27337 error("subclass: cannot subclass object not constructed on octave side");
27338 return octave_value_list();
27339 }
27340 top->merge(*ost);
27341 } else if (args(j).is_function_handle()) {
27342 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27343 } else if (args(j).is_string()) {
27344 if (j + 1 >= args.length()) {
27345 error("subclass: member assignments must be of string,value form");
27346 return octave_value_list();
27347 }
27348 top->assign(args(j).string_value(), args(j + 1));
27349 ++j;
27350 } else {
27351 error("subclass: invalid arguments to subclass()");
27352 return octave_value_list();
27353 }
27354 }
27355 return octave_value(Swig::swig_value_ref(top));
27356}
27357
27358static const char *const swig_type_usage = "-*- texinfo -*- \n\
27359@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27360Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27361@end deftypefn";
27362
27363DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27364 if (args.length() != 1) {
27365 error("swig_type: must be called with only a single object");
27366 return octave_value_list();
27367 }
27369 if (!ost) {
27370 error("swig_type: object is not a swig_ref");
27371 return octave_value_list();
27372 }
27373 return octave_value(ost->swig_type_name());
27374}
27375
27376static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27377@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27378Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27379otherwise return `<unknown>'.\n\
27380@end deftypefn";
27381
27382DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27383 if (args.length() != 1 || !args(0).is_string()) {
27384 error("swig_typequery: must be called with single string argument");
27385 return octave_value_list();
27386 }
27387 swig_module_info *module = SWIG_GetModule(0);
27388 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27389 if (!type)
27390 return octave_value("<unknown>");
27391 return octave_value(type->name);
27392}
27393
27394static const char *const swig_this_usage = "-*- texinfo -*- \n\
27395@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27396Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27397@end deftypefn";
27398
27399DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27400 if (args.length() != 1) {
27401 error("swig_this: must be called with only a single object");
27402 return octave_value_list();
27403 }
27404 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27405 return octave_value(octave_uint64(0));
27407 if (!ost) {
27408 error("swig_this: object is not a swig_ref");
27409 return octave_value_list();
27410 }
27411 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27412}
27413
27414static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27415@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27416Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27417@end deftypefn";
27418
27419DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27420 if (args.length() != 3) {
27421 error("swig_octave_prereq: must be called with 3 arguments");
27422 return octave_value_list();
27423 }
27424 const int major = args(0).int_value();
27425 const int minor = args(1).int_value();
27426 const int patch = args(2).int_value();
27427 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27428 return octave_value(prereq);
27429}
27430
27431static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27432@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27433Exit Octave without performing any memory cleanup.\n\
27434@end deftypefn";
27435
27436DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27437 if (args.length() > 1) {
27438 error("swig_exit: must be called with at most one arguments");
27439 return octave_value_list();
27440 }
27441 int exit_status = 0;
27442 if (args.length() == 1) {
27443 exit_status = args(0).int_value();
27444 }
27445 ::_Exit(exit_status);
27446 return octave_value();
27447}
27448
27449static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27450@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27451Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27452@end deftypefn";
27453
27455
27456 static octave_swig_type* module_ns = 0;
27457
27458 // workaround to prevent octave seg-faulting on exit: set Octave exit function
27459 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27460 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27461 // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27462 // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27463 // can be turned off with macro definition.
27464#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27465#if !SWIG_OCTAVE_PREREQ(4,4,0)
27466#if SWIG_OCTAVE_PREREQ(3,2,0)
27467 octave_exit = ::_Exit;
27468#endif
27469#endif
27470#endif
27471
27472 // check for no input and output args
27473 if (args.length() != 0 || nargout != 0) {
27474 print_usage();
27475 return octave_value_list();
27476 }
27477
27478 // create module on first function call
27479 if (!module_ns) {
27480
27481 // workaround bug in octave where installing global variable of custom type and then
27482 // exiting without explicitly clearing the variable causes octave to segfault.
27483#if SWIG_OCTAVE_PREREQ(3,2,0)
27484 octave_value_list eval_args;
27485 eval_args.append("base");
27486 eval_args.append("function __swig_atexit__; "
27487 " if mislocked() "
27488 " clear -all; "
27489 " else "
27490 " mlock(); "
27491 " endif; "
27492 "endfunction; "
27493 "__swig_atexit__; "
27494 "atexit(\"__swig_atexit__\", false); "
27495 "atexit(\"__swig_atexit__\")");
27496#if SWIG_OCTAVE_PREREQ(4,4,0)
27497 octave::feval("evalin", eval_args, 0);
27498#else
27499 feval("evalin", eval_args, 0);
27500#endif
27501#endif
27502
27503#if SWIG_OCTAVE_PREREQ(4,4,0)
27504 {
27505 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27506 string_vector types = typeinfo.installed_type_names();
27507 bool register_octave_swig_ref = true;
27508 bool register_octave_swig_packed = true;
27509 for (int i = 0; i < types.numel(); ++i) {
27510 if (types(i) == octave_swig_ref::static_type_name()) {
27511 register_octave_swig_ref = false;
27512 octave_swig_ref::set_type_id(i);
27513 }
27514 if (types(i) == octave_swig_packed::static_type_name()) {
27515 register_octave_swig_packed = false;
27516 octave_swig_packed::set_type_id(i);
27517 }
27518 }
27519 if (register_octave_swig_ref) {
27520 octave_swig_ref::register_type();
27521 }
27522 if (register_octave_swig_packed) {
27523 octave_swig_packed::register_type();
27524 }
27525 }
27526#else
27527 octave_swig_ref::register_type();
27528 octave_swig_packed::register_type();
27529#endif
27532
27533#if SWIG_OCTAVE_PREREQ(8,0,0)
27534 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27535 octave_function *me = tree_eval.current_function();
27536#elif SWIG_OCTAVE_PREREQ(6,0,0)
27537 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27538 octave::call_stack& stack = tree_eval.get_call_stack();
27539 octave_function *me = stack.current_function();
27540#elif SWIG_OCTAVE_PREREQ(4,4,0)
27541 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27542 octave_function *me = stack.current();
27543#else
27544 octave_function *me = octave_call_stack::current();
27545#endif
27546
27547 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27548 return octave_value_list();
27549 }
27550 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27551 return octave_value_list();
27552 }
27553 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27554 return octave_value_list();
27555 }
27556 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27557 return octave_value_list();
27558 }
27559 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27560 return octave_value_list();
27561 }
27562 if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27563 return octave_value_list();
27564 }
27565
27566 octave_swig_type* cvar_ns=0;
27567 if (std::string(SWIG_global_name) != ".") {
27568 cvar_ns=new octave_swig_type;
27569 for (int j=0;swig_globals[j].name;++j)
27570 if (swig_globals[j].get_method)
27571 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27572 }
27573
27574 module_ns=new octave_swig_type(0, 0, 0, true);
27575 if (std::string(SWIG_global_name) != ".") {
27576 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27577 }
27578 else {
27579 for (int j=0;swig_globals[j].name;++j)
27580 if (swig_globals[j].get_method)
27581 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27582 }
27583 for (int j=0;swig_globals[j].name;++j)
27584 if (swig_globals[j].method)
27585 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27586
27587 // * need better solution here; swig_type -> octave_class mapping is
27588 // * really n-to-1, in some cases such as template partial spec, etc.
27589 // * see failing tests.
27590 for (int j=0;swig_types[j];++j)
27591 if (swig_types[j]->clientdata) {
27593 module_ns->assign(c->name,
27595 (new octave_swig_type(0,swig_types[j])));
27596 }
27597
27598 if (!SWIG_init_user(module_ns)) {
27599 delete module_ns;
27600 module_ns=0;
27601 return octave_value_list();
27602 }
27603
27604 SWIG_InstallOps(octave_swig_ref::static_type_id());
27605
27607 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27608 if (mb->second.first && mb->second.first->method) {
27609 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27610 return octave_value_list();
27611 }
27612 }
27613 }
27614
27615#if SWIG_OCTAVE_PREREQ(4,4,0)
27616 octave::interpreter::the_interpreter()->mlock();
27617#elif SWIG_OCTAVE_PREREQ(3,2,0)
27618 mlock();
27619#else
27620 mlock(me->name());
27621#endif
27622
27623 }
27624
27626 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27627 if (mb->second.second.is_defined()) {
27628 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27629 SWIG_Octave_LinkGlobalValue(mb->first);
27630 }
27631 }
27632
27635
27636 return octave_value_list();
27637
27638}
27639
27640
27641static bool SWIG_init_user(octave_swig_type* module_ns)
27642{
27643 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27644 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27645 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27646 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27647 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27648 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27649 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27650 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27651 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27652 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27653 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27654 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27655 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27656 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27657 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27658 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27659 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27660 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27661 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27662 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27663 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27664 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27665 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27666 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27667 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27668 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27669 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27670 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27671 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27672 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27673 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27674 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27675 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27676 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27677 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27678 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27679 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27680 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27681 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27682 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27683 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27684 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27685 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27686 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27687 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27688 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27689 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27690 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27691 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27692 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27693 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27694 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27695 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27696 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27697 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27698 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27699 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27700 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27701 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27702 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27703 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27704 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27705 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27706 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27707 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27708 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27709 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27710 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27711 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27712 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27713 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27714 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27715 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27716 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27717 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27718 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27719 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27720 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27721 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27722 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27723 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27724 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27725 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27726 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27727 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27728 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27729 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27730 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27731 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27732 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27733 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27734 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27735 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27736 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27737 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27738 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27739 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27740 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27741 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27742 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27743 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27744 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27745 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27746 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27747 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27748 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27749 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27750 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27751 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27752 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27753 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27754 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27755 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27756 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27757 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27758 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27759 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27760 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27761 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27762 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27763 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27764 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27765 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27766 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27767 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27768 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27769 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27770 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27771 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27772 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27773 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27774 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27775 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27776 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27777 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27778 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27779 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27780 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27781 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27782 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27783 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27784 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27785 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27786 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27787 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27788 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27789 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27790 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27791 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27792 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27793 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27794 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27795 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27796 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27797 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27798 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27799 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27800 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27801 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27802 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27803 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27804 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27805 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27806 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27807 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27808 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27809 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27810 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27811 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27812 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27813 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27814 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27815 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27816 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27817 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27818 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27819 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27820 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27821 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27822 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27823 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27824 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27825 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27826 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27827 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27828 return true;
27829}
27830
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