10#define SWIG_VERSION 0x040300
12#define SWIG_name_d "plplot_octave"
13#define SWIG_name plplot_octave
15#define SWIG_global_name "cvar"
16#define SWIG_op_prefix "op_"
24#ifndef SWIGTEMPLATEDISAMBIGUATOR
25# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# elif defined(__HP_aCC)
30# define SWIGTEMPLATEDISAMBIGUATOR template
32# define SWIGTEMPLATEDISAMBIGUATOR
38# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39# define SWIGINLINE inline
48# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49# define SWIGUNUSED __attribute__ ((__unused__))
54# define SWIGUNUSED __attribute__ ((__unused__))
60#ifndef SWIG_MSC_UNSUPPRESS_4505
62# pragma warning(disable : 4505)
68# define SWIGUNUSEDPARM(p)
70# define SWIGUNUSEDPARM(p) p SWIGUNUSED
76# define SWIGINTERN static SWIGUNUSED
80#ifndef SWIGINTERNINLINE
81# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
86# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87# ifndef GCC_HASCLASSVISIBILITY
88# define GCC_HASCLASSVISIBILITY
94# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95# if defined(STATIC_LINKED)
98# define SWIGEXPORT __declspec(dllexport)
101# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102# define SWIGEXPORT __attribute__ ((visibility("default")))
111# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112# define SWIGSTDCALL __stdcall
119#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120# define _CRT_SECURE_NO_DEPRECATE
124#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125# define _SCL_SECURE_NO_DEPRECATE
129#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
138#ifdef __INTEL_COMPILER
139# pragma warning disable 592
142#if defined(__cplusplus) && __cplusplus >=201103L
143# define SWIG_NULLPTR nullptr
145# define SWIG_NULLPTR NULL
161#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
162 (defined __cplusplus && __cplusplus >= 201103L) || \
163 defined SWIG_HAVE_SNPRINTF) && \
164 !defined SWIG_NO_SNPRINTF
165# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
166# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
172# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
173# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
187#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
188#define SWIG_OCTAVE_OCTHEADERS_HPP
202#include <octave/oct.h>
203#include <octave/version.h>
207#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
208 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
211#if !defined(OCTAVE_MAJOR_VERSION)
213# if !defined(OCTAVE_API_VERSION_NUMBER)
217# include <octave/ov.h>
218# if defined(octave_ov_h)
219# define OCTAVE_MAJOR_VERSION 3
220# define OCTAVE_MINOR_VERSION 8
221# define OCTAVE_PATCH_VERSION 0
225# define ComplexLU __ignore
226# include <octave/CmplxLU.h>
228# if defined(octave_Complex_LU_h)
231# define OCTAVE_MAJOR_VERSION 3
232# define OCTAVE_MINOR_VERSION 1
233# define OCTAVE_PATCH_VERSION 99
238# define OCTAVE_MAJOR_VERSION 3
239# define OCTAVE_MINOR_VERSION 2
240# define OCTAVE_PATCH_VERSION 0
248# elif OCTAVE_API_VERSION_NUMBER >= 48
249# define OCTAVE_MAJOR_VERSION 3
250# define OCTAVE_MINOR_VERSION 6
251# define OCTAVE_PATCH_VERSION 0
253# elif OCTAVE_API_VERSION_NUMBER >= 45
254# define OCTAVE_MAJOR_VERSION 3
255# define OCTAVE_MINOR_VERSION 4
256# define OCTAVE_PATCH_VERSION 1
258# elif OCTAVE_API_VERSION_NUMBER >= 42
259# define OCTAVE_MAJOR_VERSION 3
260# define OCTAVE_MINOR_VERSION 3
261# define OCTAVE_PATCH_VERSION 54
263# elif OCTAVE_API_VERSION_NUMBER >= 41
264# define OCTAVE_MAJOR_VERSION 3
265# define OCTAVE_MINOR_VERSION 3
266# define OCTAVE_PATCH_VERSION 53
268# elif OCTAVE_API_VERSION_NUMBER >= 40
269# define OCTAVE_MAJOR_VERSION 3
270# define OCTAVE_MINOR_VERSION 3
271# define OCTAVE_PATCH_VERSION 52
273# elif OCTAVE_API_VERSION_NUMBER >= 39
274# define OCTAVE_MAJOR_VERSION 3
275# define OCTAVE_MINOR_VERSION 3
276# define OCTAVE_PATCH_VERSION 51
279# define OCTAVE_MAJOR_VERSION 3
280# define OCTAVE_MINOR_VERSION 3
281# define OCTAVE_PATCH_VERSION 50
288#include <octave/Cell.h>
289#include <octave/dynamic-ld.h>
290#include <octave/oct-env.h>
291#include <octave/oct-map.h>
292#include <octave/ov-scalar.h>
293#include <octave/ov-fcn-handle.h>
294#include <octave/parse.h>
295#if SWIG_OCTAVE_PREREQ(4,2,0)
296#include <octave/interpreter.h>
298#include <octave/toplev.h>
300#include <octave/unwind-prot.h>
301#if SWIG_OCTAVE_PREREQ(4,2,0)
302#include <octave/call-stack.h>
316#define SWIG_RUNTIME_VERSION "4"
319#ifdef SWIG_TYPE_TABLE
320# define SWIG_QUOTE_STRING(x) #x
321# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
322# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
324# define SWIG_TYPE_TABLE_NAME
337# define SWIGRUNTIME SWIGINTERN
340#ifndef SWIGRUNTIMEINLINE
341# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
345#ifndef SWIG_BUFFER_SIZE
346# define SWIG_BUFFER_SIZE 1024
350#define SWIG_POINTER_DISOWN 0x1
351#define SWIG_CAST_NEW_MEMORY 0x2
352#define SWIG_POINTER_NO_NULL 0x4
353#define SWIG_POINTER_CLEAR 0x8
354#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
357#define SWIG_POINTER_OWN 0x1
441#define SWIG_ERROR (-1)
445#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
447#define SWIG_IsOK(r) (r >= 0)
448#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
451#define SWIG_CASTRANKLIMIT (1 << 8)
453#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
455#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
457#define SWIG_BADOBJ (SWIG_ERROR)
458#define SWIG_OLDOBJ (SWIG_OK)
459#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
460#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
462#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
463#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
464#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
465#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
466#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
467#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
470#if defined(SWIG_CASTRANK_MODE)
471# ifndef SWIG_TypeRank
472# define SWIG_TypeRank unsigned long
474# ifndef SWIG_MAXCASTRANK
475# define SWIG_MAXCASTRANK (2)
477# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
478# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
483 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
486# define SWIG_AddCast(r) (r)
487# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
497typedef void *(*swig_converter_func)(
void *,
int *);
539 const char *f2,
const char *l2) {
540 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
541 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
542 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
543 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
545 return (
int)((l1 - f1) - (l2 - f2));
555 const char* te = tb + strlen(tb);
557 while (equiv != 0 && *ne) {
558 for (nb = ne; *ne; ++ne) {
559 if (*ne ==
'|')
break;
584 if (strcmp(iter->
type->
name, c) == 0) {
585 if (iter == ty->
cast)
611 if (iter->
type == from) {
612 if (iter == ty->
cast)
644 if (!ty || !ty->
dcast)
return ty;
645 while (ty && (ty->
dcast)) {
646 ty = (*ty->
dcast)(ptr);
670 if (!type)
return NULL;
671 if (type->str != NULL) {
672 const char *last_name = type->str;
674 for (s = type->str; *s; s++)
675 if (*s ==
'|') last_name = s+1;
723 size_t r = iter->
size - 1;
726 size_t i = (l + r) >> 1;
727 const char *iname = iter->
types[i]->
name;
729 int compare = strcmp(
name, iname);
731 return iter->
types[i];
732 }
else if (compare < 0) {
738 }
else if (compare > 0) {
747 }
while (iter != end);
774 for (; i < iter->
size; ++i) {
776 return iter->
types[i];
779 }
while (iter != end);
791 static const char hex[17] =
"0123456789abcdef";
792 const unsigned char *u = (
unsigned char *) ptr;
793 const unsigned char *eu = u + sz;
794 for (; u != eu; ++u) {
795 unsigned char uu = *u;
796 *(c++) = hex[(uu & 0xf0) >> 4];
797 *(c++) = hex[uu & 0xf];
807 unsigned char *u = (
unsigned char *) ptr;
808 const unsigned char *eu = u + sz;
809 for (; u != eu; ++u) {
812 if ((d >=
'0') && (d <=
'9'))
813 uu = (
unsigned char)((d -
'0') << 4);
814 else if ((d >=
'a') && (d <=
'f'))
815 uu = (
unsigned char)((d - (
'a'-10)) << 4);
819 if ((d >=
'0') && (d <=
'9'))
820 uu |= (
unsigned char)(d -
'0');
821 else if ((d >=
'a') && (d <=
'f'))
822 uu |= (
unsigned char)(d - (
'a'-10));
836 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
839 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
847 if (strcmp(c,
"NULL") == 0) {
860 size_t lname = (
name ? strlen(
name) : 0);
861 if ((2*sz + 2 + lname) > bsz)
return 0;
865 strncpy(r,
name,lname+1);
875 if (strcmp(c,
"NULL") == 0) {
890#define SWIG_UnknownError -1
891#define SWIG_IOError -2
892#define SWIG_RuntimeError -3
893#define SWIG_IndexError -4
894#define SWIG_TypeError -5
895#define SWIG_DivisionByZero -6
896#define SWIG_OverflowError -7
897#define SWIG_SyntaxError -8
898#define SWIG_ValueError -9
899#define SWIG_SystemError -10
900#define SWIG_AttributeError -11
901#define SWIG_MemoryError -12
902#define SWIG_NullReferenceError -13
905#if !SWIG_OCTAVE_PREREQ(3,2,0)
906#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
908#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
912 if (num_args > max_args && !varargs)
913 error(
"function %s takes at most %i arguments", func_name, max_args);
914 else if (num_args < min_args)
915 error(
"function %s requires at least %i arguments", func_name, min_args);
929 return "SWIG_MemoryError";
931 return "SWIG_IOError";
933 return "SWIG_RuntimeError";
935 return "SWIG_IndexError";
937 return "SWIG_TypeError";
939 return "SWIG_DivisionByZero";
941 return "SWIG_OverflowError";
943 return "SWIG_SyntaxError";
945 return "SWIG_ValueError";
947 return "SWIG_SystemError";
949 return "SWIG_AttributeError";
951 return "SWIG_NullReferenceError";
953 return "SWIG unknown error";
959 r +=
" (" + type.string_value() +
")";
960 error(
"%s", r.c_str());
961 return octave_value(r);
964#define SWIG_fail goto fail
966#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
967#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
968#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
969#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
970#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
971#define swig_owntype int
973#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
974#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
976#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
977#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
979#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
980#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
982#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
983#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
984#define SWIG_MODULE_CLIENTDATA_TYPE void*
986#define Octave_Error_Occurred() 0
987#define SWIG_Octave_AddErrorMsg(msg) {;}
993#define SWIG_POINTER_EXCEPTION 0
994#define SWIG_arg_fail(arg) 0
998typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
1003#ifdef SWIG_DIRECTORS
1007 typedef std::map < void *, Director * > rtdir_map;
1024#ifdef SWIG_DIRECTORS
1025SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
1026SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
1027SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1056#if SWIG_OCTAVE_PREREQ(4,4,0)
1059#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1060 class octave_swig_bound_func :
public octave_function {
1063 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1066 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1067 : octave_function(
"",
""), method(_method), first_args(_first_args)
1070 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1072 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1074 ~octave_swig_bound_func(
void) =
default;
1076 bool is_function(
void)
const {
return true; }
1078 octave_function* function_value(
bool =
false) {
return this; }
1080#if SWIG_OCTAVE_PREREQ(6,0,0)
1081 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1082 return execute(tw,nargout,args);
1085#if SWIG_OCTAVE_PREREQ(6,0,0)
1086 octave_value_list execute(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1088 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1090 octave_value_list all_args;
1091 all_args.append(first_args);
1092 all_args.append(args);
1093 return method->call(tw, nargout, all_args);
1096 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1097 octave_value_list ovl = subsref(ops, idx, 1);
1098 return ovl.length() ? ovl(0) : octave_value();
1101 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1102 assert(ops.size() > 0);
1103 assert(ops.size() == idx.size());
1105 error(
"invalid function call");
1106 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1107 return call(tw, nargout, *idx.begin());
1112 octave_function* method;
1113 octave_value_list first_args;
1115 std::set<std::string> dispatch_classes;
1119#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1149 if (!type->clientdata)
1159 module = SWIG_GetModule(0);
1176 for (
unsigned int j = 0; j <
types.size(); ++j)
1178 return &
members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1179 if (!insert_if_not_found)
1186 for (
unsigned int j = 0; j <
types.size(); ++j) {
1187 assert(
types[j].first->clientdata);
1190 return types[j].first;
1199 module = SWIG_GetModule(0);
1215 if (out.find(m->name) == out.end())
1216 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1221 module = SWIG_GetModule(0);
1236 for (
unsigned int j = 0; j <
types.size(); ++j)
1237 if (
types[j].first->clientdata)
1242 if (m->second.is_defined())
1243 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1244 else if (m->first && m->first->method)
1245 return m->first->method(args, nargout);
1246 error(
"member not defined or not invocable");
1247 return octave_value_list();
1253 if (!m || m->first->is_static() || m->first->is_global())
1255 octave_value_list args;
1257 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1258 if (argout.length() < 1)
1264 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1267 if (!m || m->first->is_static() || m->first->is_global())
1269 octave_value_list args;
1272 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1273 if (argout.length() < 1)
1279 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1282 if (!m || m->first->is_static() || m->first->is_global())
1284 octave_value_list args;
1287 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1288 if (argout.length() >= 1)
1294 if (m->second.is_defined()) {
1295 if (m->second.is_function() || m->second.is_function_handle()) {
1300 }
else if (m->first) {
1301 if (m->first->get_method)
1302 return m->first->get_method(args, 1);
1303 else if (m->first->method)
1306 error(
"undefined member");
1307 return octave_value_list();
1311#if SWIG_OCTAVE_PREREQ(9,0,0)
1316 return octave_value((octave_base_value *) &x);
1324 bool _always_static =
false)
1328 types.push_back(std::make_pair(_type, _ptr));
1329#ifdef SWIG_DIRECTORS
1331 Swig::Director *d = Swig::get_rtdir(_ptr);
1333 Swig::swig_director_set_self(d,
this);
1340#if SWIG_OCTAVE_PREREQ(9,0,0)
1345 for (
unsigned int j = 0; j <
types.size(); ++j) {
1346 if (!
types[j].first || !
types[j].first->clientdata)
1354#ifdef SWIG_DIRECTORS
1355 for (
unsigned int j = 0; j <
types.size(); ++j)
1356 Swig::erase_rtdir(
types[j].second.ptr);
1363 return dim_vector(1,1);
1366#if SWIG_OCTAVE_PREREQ(4,4,0)
1369 if (out.is_cell()) {
1371 const Cell & c=out.cell_value();
1372 int ndim = c.rows();
1373 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1376 d.resize(ndim < 2 ? 2 : ndim);
1380 for (
int k=0;k<ndim;k++) {
1381 const octave_value& obj = c(k);
1382#if SWIG_OCTAVE_PREREQ(6,0,0)
1384 d.elem(k) = obj.int_value();
1386 catch (octave::execution_exception& oee) {
1388 return dim_vector(1,1);
1391 d.elem(k) = obj.int_value();
1394 if (error_state)
return dim_vector(1,1);
1398#if SWIG_OCTAVE_PREREQ(4,4,0)
1399 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1401 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1403 if (out.rows()==1 || out.columns()==1) {
1404#if SWIG_OCTAVE_PREREQ(6,0,0)
1407 a = out.int_vector_value();
1409 catch (octave::execution_exception& oee) {
1410 return dim_vector(1,1);
1413 Array<int> a = out.int_vector_value();
1414 if (error_state)
return dim_vector(1,1);
1417 d.resize(a.numel() < 2 ? 2 : a.numel());
1419 for (
int k=0;k<a.numel();k++) {
1424 return dim_vector(1,1);
1427 return dim_vector(1,1);
1432#if SWIG_OCTAVE_PREREQ(9,0,0)
1441#if SWIG_OCTAVE_PREREQ(9,0,0)
1449#if SWIG_OCTAVE_PREREQ(9,0,0)
1459 return (
size_t)
this;
1460 return (
size_t)
types[0].second.ptr;
1465 if (!
types[0].first->clientdata)
1475 for (
unsigned int j = 0; j <
types.size(); ++j) {
1478 if (
types[j].first->clientdata) {
1482 ret +=
types[j].first->name;
1489 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1490 assert(!rhs.
types[j].second.destroyed);
1491#ifdef SWIG_DIRECTORS
1492 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1494 Swig::swig_director_set_self(d,
this);
1499#if SWIG_OCTAVE_PREREQ(4,4,0)
1513 int clear_pointer = 0;
1530 if (!type &&
types.size()) {
1532 *vptr =
types[0].second.ptr;
1534 types[0].second.ptr = 0;
1538 for (
unsigned int j = 0; j <
types.size(); ++j)
1539 if (type ==
types[j].first) {
1541 *vptr =
types[j].second.ptr;
1543 types[j].second.ptr = 0;
1547 for (
unsigned int j = 0; j <
types.size(); ++j) {
1560 types[j].second.ptr = 0;
1572#ifdef SWIG_DIRECTORS
1573 void director_destroyed(Swig::Director *d) {
1575 for (
unsigned int j = 0; j < types.size(); ++j) {
1576 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1578 types[j].second.destroyed =
true;
1591 members[
name] = std::make_pair(m, octave_value());
1610#if SWIG_OCTAVE_PREREQ(6,0,0)
1611 virtual bool isstruct()
const {
1618 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1619 octave_value_list ovl =
subsref(ops, idx, 1);
1620 return ovl.length()? ovl(0) : octave_value();
1623 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1624 assert(ops.size() > 0);
1625 assert(ops.size() == idx.size());
1627 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1629 octave_value_list sub_ovl;
1636 error(
"cannot create instance");
1637 return octave_value_list();
1639 octave_value_list args;
1642 args.append(*idx_it++);
1647 else if (ops[skip] ==
'.') {
1648 std::string subname;
1651 octave_value_list subname_ovl(*idx_it++);
1653 assert(subname_ovl.length() == 1 && subname_ovl(0).
is_string());
1654 subname = subname_ovl(0).string_value();
1657 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1663 if (!base || !(m->first =
find_member(base, subname)))
1666 error(
"member not found");
1667 return octave_value_list();
1670 octave_value_list args;
1672 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1674 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1675 ((m->first && m->first->method) || m->second.is_function() ||
1676 m->second.is_function_handle())) {
1677 args.append(*idx_it++);
1686 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1687 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1688 octave_value_list args;
1689 args.append(*idx_it++);
1692 error(
"error evaluating index operator");
1693 return octave_value_list();
1696 error(
"unsupported subsref");
1697 return octave_value_list();
1701 if (skip >= (
int) ops.size())
1703 if (sub_ovl.length() < 1) {
1704 error(
"bad subs ref");
1705 return octave_value_list();
1707 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1710 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1711 assert(ops.size() > 0);
1712 assert(ops.size() == idx.size());
1714 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1717 if (ops.size() > 1) {
1718 std::list < octave_value_list >::const_iterator last = idx.end();
1720 std::list < octave_value_list > next_idx(idx.begin(), last);
1721 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1722 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1725 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1726 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1729 octave_value_list args;
1731 args.append(*idx_it);
1735 error(
"%s member not found", op_name);
1738 else if (ops[skip] ==
'.') {
1739 octave_value_list subname_ovl(*idx_it++);
1741 assert(subname_ovl.length() == 1 &&subname_ovl(0).
is_string());
1742 std::string subname = subname_ovl(0).string_value();
1745 if (!m->first || !m->first->set_method) {
1748 }
else if (m->first->set_method) {
1749 octave_value_list args;
1750 if (!m->first->is_static() && !m->first->is_global())
1753 m->first->set_method(args, 1);
1755 error(
"member not assignable");
1757 error(
"unsupported subsasgn");
1762#if SWIG_OCTAVE_PREREQ(4,4,0)
1763 virtual bool isobject()
const {
1778 error(
"__str__ method not defined");
1779 return std::string();
1781 if (!ret.is_string()) {
1782 error(
"__str__ method did not return a string");
1783 return std::string();
1785 return ret.string_value();
1791 error(
"__float__ method not defined");
1793 return ret.scalar_value();
1796#if SWIG_OCTAVE_PREREQ(4,2,0)
1797 virtual octave_value as_double(
void)
const {
1799 if (!dispatch_unary_op(
"__float__", ret)) {
1800 error(
"__float__ method not defined");
1802 return ret.as_double();
1805 virtual octave_value as_single(
void)
const {
1807 if (!dispatch_unary_op(
"__float__", ret)) {
1808 error(
"__float__ method not defined");
1810 return ret.as_single();
1814#if SWIG_OCTAVE_PREREQ(3,8,0)
1815 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1816 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1818 if (!dispatch_unary_op(opname, ret)) {
1819 error(
"%s", (opname + std::string(
" method not found")).c_str());
1820 return octave_value();
1826#if SWIG_OCTAVE_PREREQ(3,3,52)
1827 virtual octave_map map_value()
const {
1828 return octave_map();
1832 return Octave_map();
1840 string_vector keys(tmp.size());
1842 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1843 keys(k++) = it->first;
1862 octave::mach_info::float_format fmt) {
1864 oct_mach_info::float_format fmt) {
1869#if defined (HAVE_HDF5)
1870# if SWIG_OCTAVE_PREREQ(4,0,0)
1872 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1877 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1882 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1887 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1893 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1901 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1905 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1908#if SWIG_OCTAVE_PREREQ(4,4,0)
1909 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1910 octave_value_list retval = fcn->call(tw, 1, args);
1911 if (retval.length() == 1)
1914 ret = fcn->do_multi_index_op(1, args)(0);
1924 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1927 octave_value_list args;
1932 error(
"could not dispatch unary operator");
1933 return octave_value();
1936 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1941 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1944 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1945 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1947 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1950 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1955 octave_value_list args;
1986 error(
"could not dispatch binary operator");
1987 return octave_value();
1990#if SWIG_OCTAVE_PREREQ(4,0,0)
1991 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1993 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2005 os <<
"{"; newline(os);
2006 increment_indent_level();
2007 for (
unsigned int j = 0; j <
types.size(); ++j) {
2009 if (
types[j].first->clientdata) {
2011 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
2013 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
2016 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2018 if (it->second.first) {
2019 const char *objtype = it->second.first->method ?
"method" :
"variable";
2020 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
2021 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
2022 assert(it->second.first->name == it->first);
2024 os << it->first; newline(os);
2027 decrement_indent_level();
2029 os <<
"}"; newline(os);
2052#if SWIG_OCTAVE_PREREQ(9,0,0)
2054 s_t_id = octave_swig_ref::static_type_id();
2057 t_id = octave_swig_ref::static_type_id();
2063 {
if (
ptr)
ptr->decref(); }
2075 {
return ptr->dims(); }
2078 {
return ptr->is_defined(); }
2080#if SWIG_OCTAVE_PREREQ(6,0,0)
2081 virtual bool isstruct()
const
2082 {
return ptr->isstruct(); }
2085 {
return ptr->is_map(); }
2088 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
2089 {
return ptr->subsref(ops, idx); }
2091 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
2092 {
return ptr->subsref(ops, idx, nargout); }
2094 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
2095 {
return ptr->subsasgn(ops, idx, rhs); }
2097#if SWIG_OCTAVE_PREREQ(4,4,0)
2098 virtual bool isobject()
const
2099 {
return ptr->isobject(); }
2102 {
return ptr->is_object(); }
2106 {
return ptr->is_string(); }
2109 {
return ptr->string_value(force); }
2112 {
return ptr->scalar_value(frc_str_conv); }
2114#if SWIG_OCTAVE_PREREQ(4,2,0)
2115 virtual octave_value as_double(
void)
const
2116 {
return ptr->as_double(); }
2118 virtual octave_value as_single(
void)
const
2119 {
return ptr->as_single(); }
2122#if SWIG_OCTAVE_PREREQ(3,8,0)
2123 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
2124 {
return ptr->map(umap); }
2127#if SWIG_OCTAVE_PREREQ(3,3,52)
2128 virtual octave_map map_value()
const
2132 {
return ptr->map_value(); }
2136 {
return ptr->map_keys(); }
2139 {
return ptr->save_ascii(os); }
2142 {
return ptr->load_ascii(is); }
2145 {
return ptr->save_binary(os, save_as_floats); }
2149 octave::mach_info::float_format fmt)
2151 oct_mach_info::float_format fmt)
2153 {
return ptr->load_binary(is, swap, fmt); }
2155#if defined (HAVE_HDF5)
2156# if SWIG_OCTAVE_PREREQ(4,0,0)
2158 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2159 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2162 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2163 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2166 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2167 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2170 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2171 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2175 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2176 {
return ptr->convert_to_str(pad, force, type); }
2179 {
return ptr->convert_to_str_internal(pad, force, type); }
2181#if SWIG_OCTAVE_PREREQ(4,0,0)
2182 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2184 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2186 {
return ptr->print(os, pr_as_read_syntax); }
2188#if SWIG_OCTAVE_PREREQ(9,0,0)
2189 static void set_type_id(
int type_id) { s_t_id=type_id; }
2191# if SWIG_OCTAVE_PREREQ(4,4,0)
2192 static void set_type_id(
int type_id) { t_id=type_id; }
2198 octave_scalar::static_type_id ());
2207#if !SWIG_OCTAVE_PREREQ(4,0,0)
2212#if !SWIG_OCTAVE_PREREQ(4,0,0)
2223 :
type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len)
2226#if SWIG_OCTAVE_PREREQ(9,0,0)
2228 s_t_id = octave_swig_packed::static_type_id();
2231 t_id = octave_swig_packed::static_type_id();
2237 if (outtype && outtype !=
type)
2239 assert(sz <=
buf.size());
2240 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2256#if SWIG_OCTAVE_PREREQ(4,0,0)
2257 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2259 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2263 os <<
"swig packed type: name = " << (
type ?
type->name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2281 octave::mach_info::float_format fmt) {
2283 oct_mach_info::float_format fmt) {
2288#if defined (HAVE_HDF5)
2289# if SWIG_OCTAVE_PREREQ(4,0,0)
2291 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2296 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2301 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2306 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2312#if SWIG_OCTAVE_PREREQ(9,0,0)
2313 static void set_type_id(
int type_id) { s_t_id=type_id; }
2315# if SWIG_OCTAVE_PREREQ(4,4,0)
2316 static void set_type_id(
int type_id) { t_id=type_id; }
2321#if !SWIG_OCTAVE_PREREQ(4,0,0)
2326#if !SWIG_OCTAVE_PREREQ(4,0,0)
2332 error(
"attempt to set immutable member variable");
2333 return octave_value_list();
2341 :
ovl(_ovl),
j(_j) { }
2343 operator octave_value()
const {
2366 && ov.rows() == 1 && ov.columns() == 1)
2367 ov = ov.cell_value()(0);
2372 if (ov.type_id() != octave_swig_ref::static_type_id())
2381#define swig_unary_op(name) \
2382SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2383 return octave_swig_type::dispatch_unary_op(x,#name); \
2385#define swig_binary_op(name) \
2386SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2387 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2389#if SWIG_OCTAVE_PREREQ(4,4,0)
2390#define swigreg_unary_op(name) \
2391if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2392typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2394#define swigreg_unary_op(name) \
2395if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2396octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2398#if SWIG_OCTAVE_PREREQ(4,4,0)
2399#define swigreg_binary_op(name) \
2400if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2401typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2403#define swigreg_binary_op(name) \
2404if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2405octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2422#if !SWIG_OCTAVE_PREREQ(4,2,0)
2440#if SWIG_OCTAVE_PREREQ(4,4,0)
2441 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2452#if SWIG_OCTAVE_PREREQ(4,4,0)
2453 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2461#if !SWIG_OCTAVE_PREREQ(4,2,0)
2485 for (
int j = 0; j < tid; ++j) {
2495#ifdef SWIG_DIRECTORS
2496 Swig::Director *d = Swig::get_rtdir(ptr);
2497 if (d && Swig::swig_director_get_self(d))
2498 return Swig::swig_director_get_self(d)->as_value();
2502 return octave_value(Matrix());
2512 && ov.rows() == 1 && ov.columns() == 1)
2513 ov = ov.cell_value()(0);
2514 if (!ov.is_defined() ||
2515 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2520 if (ov.type_id() != octave_swig_ref::static_type_id())
2524 return ost->
cast(ptr, type, own, flags);
2532 if (!ov.is_defined())
2534 if (ov.type_id() != octave_swig_packed::static_type_id())
2545#if SWIG_OCTAVE_PREREQ(6,0,0)
2546 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2549#if SWIG_OCTAVE_PREREQ(4,4,0)
2550 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2551 return symtab.global_varval(
name);
2553 return get_global_value(
name,
true);
2559#if SWIG_OCTAVE_PREREQ(6,0,0)
2560 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2562#elif SWIG_OCTAVE_PREREQ(4,4,0)
2563 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2571#if SWIG_OCTAVE_PREREQ(4,4,0)
2572 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2573#if SWIG_OCTAVE_PREREQ(6,0,0)
2574 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2576 octave::tree_evaluator& tree_eval =
interp->get_evaluator();
2577#if SWIG_OCTAVE_PREREQ(8,0,0)
2578 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2580 octave::call_stack& callStack = tree_eval.get_call_stack();
2581 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2583 octave::symbol_record sym=symscope.lookup_symbol(
name);
2584 stackFrame->mark_global(sym);
2586 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2587 symscope.assign(
name, symtab.global_varval(
name));
2588 symscope.mark_global(
name);
2591#if !SWIG_OCTAVE_PREREQ(3,2,0)
2592 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2594#if !SWIG_OCTAVE_PREREQ(3,8,0)
2595 symbol_table::varref(
name);
2597 symbol_table::mark_global(
name);
2604 if (!ov.is_defined() ||
2605 ov.type_id() != octave_swig_packed::static_type_id())
2621 if (obj.is_string())
2622 error(
"%s", obj.string_value().c_str());
2624 error(
"C++ side threw an exception of type %s", type);
2629#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2631#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2637#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2638#define SWIGTYPE_p_char swig_types[1]
2639#define SWIGTYPE_p_double swig_types[2]
2640#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2641#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2642#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2643#define SWIGTYPE_p_int swig_types[6]
2644#define SWIGTYPE_p_p_char swig_types[7]
2645#define SWIGTYPE_p_unsigned_int swig_types[8]
2648#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2649#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2657template<
typename T>
class SwigValueWrapper {
2658 struct SwigSmartPointer {
2660 SwigSmartPointer(T *p) : ptr(p) { }
2661 ~SwigSmartPointer() {
delete ptr; }
2662 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
2663 void reset(T *p) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
2665 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
2666 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
2668 SwigValueWrapper() : pointer(0) { }
2669 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
2670#if __cplusplus >=201103L
2671 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
2672 operator T&&()
const {
return std::move(*pointer.ptr); }
2674 operator T&()
const {
return *pointer.ptr; }
2676 T *operator&()
const {
return pointer.ptr; }
2677 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2689template <
typename T> T SwigValueInit() {
2693#if __cplusplus >=201103L
2694# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2696# define SWIG_STD_MOVE(OBJ) OBJ
2702#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2703#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2717 #if defined ( __GNUC__ ) && __GNUC__ > 3
2718 #undef OCTAVE_EXPORT
2719 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2737 inline int max(
int a,
int b )
2739 return a >= b ? a : b;
2741 inline int min(
int a,
int b )
2743 return a >= b ? a : b;
2757 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2769 if (
max( o_obj.columns(), 1 ) > 1 )
2774 else if (
max( o_obj.rows(), 1 ) > 1 )
2784 _dim(
const octave_value &o_obj,
int dim_idx )
2787 return max( o_obj.rows(), 0 );
2791 else if ( dim_idx == 1 )
2792 return max( o_obj.columns(), 0 );
2805 template <
class FLOAT>
2809 while ( n_el-- > 0 )
2810 *out_arr++ = (FLOAT) ( *in_arr++ );
2829 template <
class FLOAT>
2833 while ( n_el-- > 0 )
2834 *d_arr++ = double(*arr++);
2865 octave_value_list functionArguments;
2866 octave_value_list retval;
2873 for ( i = 0; i < n; i++ )
2879 functionArguments( 0 ) = xin;
2880 functionArguments( 1 ) = yin;
2883#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2884 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2886 retval = feval(
fcnMapForm, functionArguments, 1 );
2889#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2890 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2892 retval = feval(
nameMapForm, functionArguments, 1 );
2895 if ( retval.length() >= 2 )
2897 xout = retval( 0 ).matrix_value();
2898 yout = retval( 1 ).matrix_value();
2900 for ( i = 0; i < n; i++ )
2902 x[i] = xout( i, 0 );
2903 y[i] = yout( i, 0 );
2915 octave_value_list functionArguments;
2916 octave_value_list retval;
2918 Matrix inAxis( 1, 1 );
2919 Matrix inValue( 1, 1 );
2920 inAxis( 0, 0 ) = axis;
2921 inValue( 0, 0 ) =
value;
2923 functionArguments( 0 ) = inAxis;
2924 functionArguments( 1 ) = inValue;
2927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2928 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2933#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2934 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2939 strncpy( label, retval( 0 ).string_value().c_str(), length );
2949 octave_value_list functionArguments;
2950 octave_value_list retval;
2960 functionArguments( 0 ) = xin;
2961 functionArguments( 1 ) = yin;
2964#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2965 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2976 if ( retval.length() >= 2 )
2978 xout = retval( 0 ).matrix_value();
2979 yout = retval( 1 ).matrix_value();
2990 printf(
"nlegend =%d\n", nlegend );
2991 for ( i = 0; i < nlegend; i++ )
2993 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2994 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2995 printf(
"text[%d] =%s\n", i,
text[i] );
3001#if !defined(SWIG_NO_LLONG_MAX)
3002# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3003# define LLONG_MAX __LONG_LONG_MAX__
3004# define LLONG_MIN (-LLONG_MAX - 1LL)
3005# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3012 if (!ov.is_scalar_type())
3014 if (ov.is_complex_scalar())
3016 if (ov.is_double_type()||ov.is_single_type()) {
3017 double v=ov.double_value();
3022 *val = ov.long_value();
3033 if ((v < INT_MIN || v > INT_MAX)) {
3036 if (val) *val =
static_cast< int >(v);
3043 static int my_plGetCursor(
int *state,
int *keysym,
int *button,
char *
string,
int *pX,
int *pY,
PLFLT *dX,
PLFLT *dY,
PLFLT *wX,
PLFLT *wY,
int *subwin )
3051 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
3065 && ov.rows() == 1 && ov.columns() == 1)
3066 ov = ov.cell_value()(0);
3068 if (ov.is_string()) {
3069 std::string str=ov.string_value();
3070 size_t len=str.size();
3071 char* cstr=(
char*)str.c_str();
3073 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
3079 }
else if (!ov.is_defined() || (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
3094 return octave_value(
value);
3107 return octave_value(
value);
3116 gin.
dX = x_in; gin.
dY = y_in;
3118 *x = gin.
wX; *y = gin.
wY;
3125 if (!ov.is_scalar_type())
3127 if (ov.is_complex_scalar())
3130 *val = ov.double_value();
3143 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3144 const char *labx,
const char *laby,
const char *labtop )
3146 const char *legline[4];
3147 legline[0] = legline1; legline[1] = legline2;
3148 legline[2] = legline3; legline[3] = legline4;
3149 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3150 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3151 labx, laby, labtop );
3169 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3170 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3175#define f2c( f, ff, nx, ny ) \
3177 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3178 for ( int i = 0; i < nx; i++ ) { \
3179 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3180 for ( int j = 0; j < ny; j++ ) \
3181 *( ff[i] + j ) = *( f + nx * j + i );}
3188 f2c( f, ff, nx, ny );
3189 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3197 f2c( f, ff, nx, ny );
3198 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3207 grid1.
nx = nx; grid1.
ny = ny;
3209 f2c( f, ff, nx, ny );
3210 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3218 f2c( xg, xgg, nx, ny );
3219 f2c(
yg, ygg, nx, ny );
3220 grid2.
nx = nx; grid2.
ny = ny;
3221 grid2.
xg = xgg; grid2.
yg = ygg;
3222 f2c( f, ff, nx, ny );
3223 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3232 f2c( xg, xgg, nx, ny );
3233 f2c(
yg, ygg, nx, ny );
3234 grid2.
nx = nx; grid2.
ny = ny;
3235 grid2.
xg = xgg; grid2.
yg = ygg;
3236 f2c( f, ff, nx, ny );
3237 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3242 const PLFLT *xg,
int nptsx,
const PLFLT *
yg,
int nptsy,
3245 f2c(
zg, zgg, nptsx, nptsy );
3246 plgriddata( x, y, z, npts, xg, nptsx,
yg, nptsy, zgg, type, data );
3247 for (
int i = 0; i < nptsx; i++ )
3248 for (
int j = 0; j < nptsy; j++ )
3249 *(
zg + nptsx * j + i ) = zgg[i][j];
3257 f2c( z, zz, nx, ny );
3265 f2c( z, zz, nx, ny );
3266 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3274 f2c( z, zz, nx, ny );
3283 f2c( z, zz, nx, ny );
3284 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3293 f2c( z, zz, nx, ny );
3295 indexxmin, indexxmax, indexymin, indexymax );
3302 f2c( z, zz, nx, ny );
3310 f2c( z, zz, nx, ny );
3312 indexxmin, indexxmax, indexymin, indexymax );
3330 f2c( a, aa, nx, ny );
3331 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3332 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3333 min_color, min_width, max_color, max_width,
3347 grid1.
nx = nx; grid1.
ny = ny;
3349 f2c( a, aa, nx, ny );
3350 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3351 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3352 min_color, min_width, max_color, max_width,
3366 f2c( xg, xgg, nx, ny );
3367 f2c(
yg, ygg, nx, ny );
3368 grid2.
nx = nx; grid2.
ny = ny;
3369 grid2.
xg = xgg; grid2.
yg = ygg;
3370 f2c( a, aa, nx, ny );
3371 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3372 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3373 min_color, min_width, max_color, max_width,
3385 f2c( a, aa, nx, ny );
3386 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3387 clevel, nlevel, fill_width, cont_color, cont_width,
3388 plfill, rectangular, NULL, NULL );
3397 f2c( a, aa, nx, ny );
3398 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3399 clevel, nlevel, fill_width, cont_color, cont_width,
3410 grid1.
nx = nx; grid1.
ny = ny;
3413 f2c( a, aa, nx, ny );
3414 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3415 clevel, nlevel, fill_width, cont_color, cont_width,
3426 f2c( xg, xgg, nx, ny );
3427 f2c(
yg, ygg, nx, ny );
3428 grid2.
nx = nx; grid2.
ny = ny;
3429 grid2.
xg = xgg; grid2.
yg = ygg;
3430 f2c( a, aa, nx, ny );
3431 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3432 clevel, nlevel, fill_width, cont_color, cont_width,
3442 f2c( u, uu, nx, ny );
3443 f2c( v, vv, nx, ny );
3451 grid1.
nx = nx; grid1.
ny = ny;
3453 f2c( u, uu, nx, ny );
3454 f2c( v, vv, nx, ny );
3462 f2c( xg, xgg, nx, ny );
3463 f2c(
yg, ygg, nx, ny );
3464 grid2.
nx = nx; grid2.
ny = ny;
3465 grid2.
xg = xgg; grid2.
yg = ygg;
3466 f2c( u, uu, nx, ny );
3467 f2c( v, vv, nx, ny );
3478 f2c( a, aa, nx, ny );
3479 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3489 f2c( a, aa, nx, ny );
3490 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3498 f2c( a, aa, nx, ny );
3499 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3509 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3511 f2c( a, aa, nx, ny );
3512 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3522 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3523 f2c(
yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3524 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3525 grid2.
xg = xgg; grid2.
yg = ygg;
3526 f2c( a, aa, nx, ny );
3527 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3538 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3539 PLINT n_axes,
const char ** axis_opts,
3546 for ( i = 0; i < nx; i++ )
3547 if ( n_values[i] > ny )
3549 f2c( a, aa, nx, ny );
3551 opt, position, x, y,
3553 bg_color, bb_color, bb_style,
3554 low_cap_color, high_cap_color,
3555 cont_color, cont_width,
3556 n_labels, label_opts, label,
3566 if (!ov.is_scalar_type())
3568 if (ov.is_complex_scalar())
3570 if (ov.is_double_type()||ov.is_single_type()) {
3571 double v=ov.double_value();
3577 if (ov.is_int8_type()||ov.is_int16_type()||
3578 ov.is_int32_type()) {
3579 long v=ov.long_value();
3583 if (ov.is_int64_type()) {
3584 long long v=ov.int64_scalar_value().value();
3589 *val = ov.ulong_value();
3600 if ((v > UINT_MAX)) {
3603 if (val) *val =
static_cast< unsigned int >(v);
3612 return octave_value(
value);
3626 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3630 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3631 if (csize <= size) {
3633 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3634 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3662 return std::string(carray,carray+size);
3670 for (p = s; maxlen-- && *p; p++)
3684 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3685 if (val) *val =
static_cast< char >(v);
3695Set up transformation from metafile coordinates\n\
3699 Set up transformation from metafile coordinates. The size of the plot\n\
3700 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3701 general-purpose facility just yet (not sure why the user would need\n\
3704 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3707 This function is not used in any examples.\n\
3713plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3717 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3719 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3721 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3723 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3725 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3727 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3730Set the cmap0 palette using the specified cmap0*.pal format file\n\
3734 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3736 Redacted form: plspal0(filename)\n\
3738 This function is in example 16.\n\
3748 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3749 containing the name of the cmap0*.pal file. If this string is\n\
3750 empty, use the default cmap0*.pal file.\n\
3753Set the cmap1 palette using the specified cmap1*.pal format file\n\
3757 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3759 Redacted form: plspal1(filename, interpolate)\n\
3761 This function is used in example 16.\n\
3767plspal1(filename, interpolate)\n\
3771 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3772 containing the name of the cmap1*.pal file. If this string is\n\
3773 empty, use the default cmap1*.pal file.\n\
3775 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3776 columns containing the intensity index, r, g, b, alpha and\n\
3777 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3778 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3779 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3780 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3781 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3782 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3783 are used instead to set the cmap1 palette directly with a call to\n\
3787Draw a line in 3 space\n\
3791 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3792 first set up the viewport, the 2d viewing window (in world\n\
3793 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3796 Redacted form: plline3(x, y, z)\n\
3798 This function is used in example 18.\n\
3804plline3(n, x, y, z)\n\
3808 n (PLINT, input) : Number of points defining line.\n\
3810 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3813 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3816 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3820Magnitude colored plot surface mesh with contour\n\
3824 A more powerful form of plmesh: the surface mesh can be colored\n\
3825 accordingly to the current z value being plotted, a contour plot can\n\
3826 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3827 plotted function border and the base XY plane.\n\
3829 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3831 This function is used in example 11.\n\
3837plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3841 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3842 which the function is evaluated.\n\
3844 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3845 which the function is evaluated.\n\
3847 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3848 plot. Should have dimensions of\n\
3852 nx (PLINT, input) : Number of x values at which function is\n\
3855 ny (PLINT, input) : Number of y values at which function is\n\
3858 opt (PLINT, input) : Determines the way in which the surface is\n\
3859 represented. To specify more than one option just add the options,\n\
3860 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3861 showing z as a function of x for each value of y[j] .\n\
3862 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3863 for each value of x[i] .\n\
3864 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3865 at which function is defined.\n\
3866 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3867 the z value being plotted. The color is used from the current\n\
3869 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3873 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3874 the borders of the plotted function.\n\
3877 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3880 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3883Draw a line between two points, accounting for coordinate transforms\n\
3887 Joins the point (\n\
3891 y2) . If a global coordinate transform is defined then the line is\n\
3892 broken in to n segments to approximate the path. If no transform is\n\
3893 defined then this simply acts like a call to pljoin.\n\
3895 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3897 This function is used in example 22.\n\
3903plpath(n, x1, y1, x2, y2)\n\
3907 n (PLINT, input) : number of points to use to approximate the path.\n\
3909 x1 (PLFLT, input) : x coordinate of first point.\n\
3911 y1 (PLFLT, input) : y coordinate of first point.\n\
3913 x2 (PLFLT, input) : x coordinate of second point.\n\
3915 y2 (PLFLT, input) : y coordinate of second point.\n\
3918Write text inside the viewport\n\
3922 Writes text at a specified position and inclination within the\n\
3923 viewport. Text is clipped at the viewport boundaries. The reference\n\
3924 point of a string lies along a line passing through the string at half\n\
3925 the height of a capital letter. The position of the reference point\n\
3926 along this line is determined by just, the reference point is placed\n\
3927 at world coordinates (\n\
3929 y) within the viewport. The inclination of the string is specified\n\
3930 in terms of differences of world coordinates making it easy to write\n\
3931 text parallel to a line in a graph.\n\
3933 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3935 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3941plptex(x, y, dx, dy, just, text)\n\
3945 x (PLFLT, input) : x coordinate of reference point of string.\n\
3947 y (PLFLT, input) : y coordinate of reference point of string.\n\
3949 dx (PLFLT, input) : Together with dy, this specifies the\n\
3950 inclination of the string. The baseline of the string is parallel\n\
3951 to a line joining (\n\
3959 dy (PLFLT, input) : Together with dx, this specifies the\n\
3960 inclination of the string.\n\
3962 just (PLFLT, input) : Specifies the position of the string relative\n\
3963 to its reference point. If just=0. , the reference point is at\n\
3964 the left and if just=1. , it is at the right of the string. Other\n\
3965 values of just give intermediate justifications.\n\
3967 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3971Set family file parameters\n\
3975 Sets variables dealing with output file familying. Does nothing if\n\
3976 familying not supported by the driver. This routine, if used, must be\n\
3977 called before initializing PLplot. See the PLplot documentation for\n\
3978 more information.\n\
3980 Redacted form: plsfam(fam, num, bmax)\n\
3982 This function is used in examples 14 and 31.\n\
3988plsfam(fam, num, bmax)\n\
3992 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3995 num (PLINT, input) : Current family file number.\n\
3997 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
4001Set y axis parameters\n\
4005 Identical to plsxax, except that arguments are flags for y axis. See\n\
4006 the description of plsxax for more detail.\n\
4008 Redacted form: plsyax(digmax, digits)\n\
4010 This function is used in examples 1, 14, and 31.\n\
4016plsyax(digmax, digits)\n\
4020 digmax (PLINT, input) : Variable to set the maximum number of\n\
4021 digits for the y axis. If nonzero, the printed label will be\n\
4022 switched to a floating-point representation when the number of\n\
4023 digits exceeds digmax.\n\
4025 digits (PLINT, input) : Field digits value. Currently, changing\n\
4026 its value here has no effect since it is set only by plbox or\n\
4027 plbox3. However, the user may obtain its value after a call to\n\
4028 either of these functions by calling plgyax.\n\
4031Get z axis parameters\n\
4035 Identical to plgxax, except that arguments are flags for z axis. See\n\
4036 the description of plgxax for more detail.\n\
4038 Redacted form: plgzax(p_digmax, p_digits)\n\
4040 This function is used in example 31.\n\
4046plgzax(p_digmax, p_digits)\n\
4050 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4051 number of digits for the z axis. If nonzero, the printed label\n\
4052 has been switched to a floating-point representation when the\n\
4053 number of digits exceeds this value.\n\
4055 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4056 number of digits for the numeric labels (z axis) from the last\n\
4060Set format of numerical label for contours\n\
4064 Set format of numerical label for contours.\n\
4066 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4068 This function is used example 9.\n\
4074pl_setcontlabelformat(lexp, sigdig)\n\
4078 lexp (PLINT, input) : If the contour numerical label is greater\n\
4079 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4080 format is used. Default value of lexp is 4.\n\
4082 sigdig (PLINT, input) : Number of significant digits. Default\n\
4090 Sets the pen width.\n\
4092 Redacted form: plwidth(width)\n\
4094 This function is used in examples 1 and 2.\n\
4104 width (PLFLT, input) : The desired pen width. If width is negative\n\
4105 or the same as the previous value no action is taken. width = 0.\n\
4106 should be interpreted as as the minimum valid pen width for the\n\
4107 device. The interpretation of positive width values is also\n\
4108 device dependent.\n\
4111Get parameters that define current plot-space window\n\
4115 Get relative minima and maxima that define current plot-space window.\n\
4116 If plsdiplt has not been called the default values pointed to by\n\
4117 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4119 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4121 This function is used in example 31.\n\
4127plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4131 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4134 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4137 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4140 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4144Set the cmap1 argument range for continuous color plots\n\
4148 Set the cmap1 argument range for continuous color plots that\n\
4149 corresponds to the range of data values. The maximum range\n\
4150 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4151 the cmap1 argument range that is specified with this routine, the\n\
4152 smaller the subset of the cmap1 color palette that is used to\n\
4153 represent the continuous data being plotted. If\n\
4154 min_color is greater than\n\
4156 max_color is greater than 1.0 or\n\
4157 min_color is less than 0.0 then no change is made to the cmap1\n\
4158 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4160 Redacted form: plscmap1_range(min_color, max_color)\n\
4162 This function is currently used in example 33.\n\
4168plscmap1_range(min_color, max_color)\n\
4172 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4173 than 0.0, then 0.0 is used instead.\n\
4175 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4176 than 1.0, then 1.0 is used instead.\n\
4179Select standard viewport\n\
4183 Selects the largest viewport within the subpage that leaves a standard\n\
4184 margin (left-hand margin of eight character heights, and a margin\n\
4185 around the other three sides of five character heights).\n\
4187 Redacted form: plvsta()\n\
4189 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4198Load Hershey fonts\n\
4202 Loads the Hershey fonts used for text and symbols. This routine may\n\
4203 be called before or after initializing PLplot. If not explicitly\n\
4204 called before PLplot initialization, then by default that\n\
4205 initialization loads Hershey fonts with the extended character set.\n\
4206 This routine only has a practical effect for devices that still use\n\
4207 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4208 system fonts instead of Hershey fonts).\n\
4210 Redacted form: plfontld(fnt)\n\
4212 This function is used in examples 1 and 7.\n\
4222 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4223 A zero value specifies Hershey fonts with the standard character\n\
4224 set and a non-zero value (the default assumed if plfontld is never\n\
4225 called) specifies Hershey fonts with the extended character set.\n\
4228Draw error bars in x direction\n\
4232 Draws a set of n error bars in x direction, the i\'th error bar\n\
4233 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4234 of the error bars are of length equal to the minor tick length\n\
4235 (settable using plsmin).\n\
4237 Redacted form: General: plerrx(xmin, ymax, y)\n\
4240 This function is used in example 29.\n\
4246plerrx(n, xmin, xmax, y)\n\
4250 n (PLINT, input) : Number of error bars to draw.\n\
4252 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4253 of the left-hand endpoints of the error bars.\n\
4255 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4256 of the right-hand endpoints of the error bars.\n\
4258 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4262Plot shaded 3-d surface plot\n\
4266 Plots a three-dimensional shaded surface plot within the environment\n\
4267 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4270 ny], the point z[i][j] being the value of the function at (\n\
4272 y[j]). Note that the points in vectors x and y do not need to be\n\
4273 equally spaced, but must be stored in ascending order. For further\n\
4274 details see the PLplot documentation.\n\
4276 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4278 This function is not used in any examples.\n\
4284plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4288 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4289 which the function is evaluated.\n\
4291 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4292 which the function is evaluated.\n\
4294 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4295 plot. Should have dimensions of\n\
4299 nx (PLINT, input) : Number of x values at which function is\n\
4302 ny (PLINT, input) : Number of y values at which function is\n\
4305 opt (PLINT, input) : Determines the way in which the surface is\n\
4306 represented. To specify more than one option just add the options,\n\
4307 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4308 connecting points at which function is defined.\n\
4309 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4313 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4317 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4318 the borders of the plotted function.\n\
4319 opt=MAG_COLOR : the surface is colored according to the value\n\
4320 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4321 according to the intensity of the reflected light in the\n\
4322 surface from a light source whose position is set using\n\
4326 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4329 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4332Get the current library version number\n\
4336 Get the current library version number. Note: you must have allocated\n\
4337 space for this (80 characters is safe).\n\
4339 Redacted form: plgver(p_ver)\n\
4341 This function is used in example 1.\n\
4351 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4352 (with preallocated length of 80 characters or more) containing the\n\
4353 PLplot version number.\n\
4356End plotting session for current stream\n\
4360 Ends a plotting session for the current output stream only. See\n\
4361 plsstrm for more info.\n\
4363 Redacted form: plend1()\n\
4365 This function is used in examples 1 and 20.\n\
4374Draw error bars in the y direction\n\
4378 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4379 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4380 of the error bars are of length equal to the minor tick length\n\
4381 (settable using plsmin).\n\
4383 Redacted form: General: plerry(x, ymin, ymax)\n\
4386 This function is used in example 29.\n\
4392plerry(n, x, ymin, ymax)\n\
4396 n (PLINT, input) : Number of error bars to draw.\n\
4398 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4401 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4402 of the lower endpoints of the error bars.\n\
4404 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4405 of the upper endpoints of the error bars.\n\
4408Set seed for internal random number generator.\n\
4412 Set the seed for the internal random number generator. See plrandd for\n\
4415 Redacted form: plseed(seed)\n\
4417 This function is used in example 21.\n\
4427 seed (unsigned int, input) : Seed for random number generator.\n\
4430Specify viewport using normalized subpage coordinates\n\
4434 Device-independent routine for setting up the viewport. This defines\n\
4435 the viewport in terms of normalized subpage coordinates which run from\n\
4436 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4437 current subpage. Use the alternate routine plsvpa in order to create\n\
4438 a viewport of a definite size.\n\
4440 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4442 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4443 24, 26, 27, and 31.\n\
4449plvpor(xmin, xmax, ymin, ymax)\n\
4453 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4454 left-hand edge of the viewport.\n\
4456 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4457 right-hand edge of the viewport.\n\
4459 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4460 bottom edge of the viewport.\n\
4462 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4463 edge of the viewport.\n\
4470 Plots a surface mesh within the environment set up by plw3d. The\n\
4471 surface is defined by the matrix z[\n\
4473 ny] , the point z[i][j] being the value of the function at (\n\
4475 y[j]). Note that the points in vectors x and y do not need to be\n\
4476 equally spaced, but must be stored in ascending order. The parameter\n\
4477 opt controls the way in which the surface is displayed. For further\n\
4478 details see the PLplot documentation.\n\
4480 Redacted form: plmesh(x, y, z, opt)\n\
4482 This function is used in example 11.\n\
4488plmesh(x, y, z, nx, ny, opt)\n\
4492 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4493 which the function is evaluated.\n\
4495 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4496 which the function is evaluated.\n\
4498 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4499 plot. Should have dimensions of\n\
4503 nx (PLINT, input) : Number of x values at which function has been\n\
4506 ny (PLINT, input) : Number of y values at which function has been\n\
4509 opt (PLINT, input) : Determines the way in which the surface is\n\
4510 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4511 function of x for each value of y[j] .\n\
4512 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4513 for each value of x[i] .\n\
4514 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4515 at which function is defined.\n\
4518Get the cmap1 argument range for continuous color plots\n\
4522 Get the cmap1 argument range for continuous color plots. (Use\n\
4523 plscmap1_range to set the cmap1 argument range.)\n\
4525 Redacted form: plgcmap1_range(min_color, max_color)\n\
4527 This function is currently not used in any example.\n\
4533plgcmap1_range(min_color, max_color)\n\
4537 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4538 minimum cmap1 argument.\n\
4540 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4541 maximum cmap1 argument.\n\
4544Set arrow style for vector plots\n\
4548 Set the style for the arrow used by plvect to plot vectors.\n\
4550 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4552 This function is used in example 22.\n\
4558plsvect(arrowx, arrowy, npts, fill)\n\
4562 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4563 the x and y points which make up the arrow. The arrow is plotted\n\
4564 by joining these points to form a polygon. The scaling assumes\n\
4565 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4566 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4567 will be reset to its default.\n\
4569 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4572 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4573 fill is false then the arrow is open.\n\
4576Draw filled polygon\n\
4580 Fills the polygon defined by the n points (\n\
4582 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4583 style is a solid fill. The routine will automatically close the\n\
4584 polygon between the last and first vertices. If multiple closed\n\
4585 polygons are passed in x and y then plfill will fill in between them.\n\
4587 Redacted form: plfill(x,y)\n\
4589 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4599 n (PLINT, input) : Number of vertices in polygon.\n\
4601 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4604 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4608Convert HLS color to RGB\n\
4612 Convert HLS color coordinates to RGB.\n\
4614 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4617 This function is used in example 2.\n\
4623plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4627 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4630 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4631 the axis of the color cylinder.\n\
4633 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4634 the radius of the color cylinder.\n\
4636 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4637 (0.0-1.0) of the color.\n\
4639 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4640 intensity (0.0-1.0) of the color.\n\
4642 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4643 intensity (0.0-1.0) of the color.\n\
4646Set format for date / time labels\n\
4650 Sets the format for date / time labels. To enable date / time format\n\
4651 labels see the options to plbox, plbox3, and plenv.\n\
4653 Redacted form: pltimefmt(fmt)\n\
4655 This function is used in example 29.\n\
4665 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4666 interpreted similarly to the format specifier of typical system\n\
4667 strftime routines except that PLplot ignores locale and also\n\
4668 supplies some useful extensions in the context of plotting. All\n\
4669 text in the string is printed as-is other than conversion\n\
4670 specifications which take the form of a \'%\' character followed by\n\
4671 further conversion specification character. The conversion\n\
4672 specifications which are similar to those provided by system\n\
4673 strftime routines are the following: %a: The abbreviated (English)\n\
4675 %A: The full (English) weekday name.\n\
4676 %b: The abbreviated (English) month name.\n\
4677 %B: The full (English) month name.\n\
4678 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4679 %C: The century number (year/100) as a 2-digit integer.\n\
4680 %d: The day of the month as a decimal number (range 01 to 31).\n\
4681 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4682 %e: Like %d, but a leading zero is replaced by a space.\n\
4683 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4684 %h: Equivalent to %b.\n\
4685 %H: The hour as a decimal number using a 24-hour clock (range\n\
4687 %I: The hour as a decimal number using a 12-hour clock (range\n\
4689 %j: The day of the year as a decimal number (range 001 to\n\
4691 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4692 23); single digits are preceded by a blank. (See also %H.)\n\
4693 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4694 12); single digits are preceded by a blank. (See also %I.)\n\
4695 %m: The month as a decimal number (range 01 to 12).\n\
4696 %M: The minute as a decimal number (range 00 to 59).\n\
4697 %n: A newline character.\n\
4698 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4699 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4700 %r: Equivalent to %I:%M:%S %p.\n\
4701 %R: The time in 24-hour notation (%H:%M). For a version\n\
4702 including the seconds, see %T below.\n\
4703 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4705 %S: The second as a decimal number (range 00 to 60). (The\n\
4706 range is up to 60 to allow for occasional leap seconds.)\n\
4707 %t: A tab character.\n\
4708 %T: The time in 24-hour notation (%H:%M:%S).\n\
4709 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4710 being 1. See also %w.\n\
4711 %U: The week number of the current year as a decimal number,\n\
4712 range 00 to 53, starting with the first Sunday as the first\n\
4713 day of week 01. See also %V and %W.\n\
4714 %v: Equivalent to %e-%b-%Y.\n\
4715 %V: The ISO 8601 week number of the current year as a decimal\n\
4716 number, range 01 to 53, where week 1 is the first week that\n\
4717 has at least 4 days in the new year. See also %U and %W.\n\
4718 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4719 being 0. See also %u.\n\
4720 %W: The week number of the current year as a decimal number,\n\
4721 range 00 to 53, starting with the first Monday as the first\n\
4723 %x: Equivalent to %a %b %d %Y.\n\
4724 %X: Equivalent to %T.\n\
4725 %y: The year as a decimal number without a century (range 00\n\
4727 %Y: The year as a decimal number including a century.\n\
4728 %z: The UTC time-zone string = \"+0000\".\n\
4729 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4730 %+: The UTC date and time in default format of the Unix date\n\
4731 command which is equivalent to %a %b %d %T %Z %Y.\n\
4732 %%: A literal \"%\" character.\n\
4733 The conversion specifications which are extensions to those normally\n\
4734 provided by system strftime routines are the following: %(0-9):\n\
4735 The fractional part of the seconds field (including leading\n\
4736 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4737 seconds to millisecond accuracy (00.000).\n\
4738 %.: The fractional part of the seconds field (including\n\
4739 leading decimal point) to the maximum available accuracy. Thus\n\
4740 %S%. would give seconds with fractional part up to 9 decimal\n\
4741 places if available.\n\
4744Get current subpage parameters\n\
4748 Gets the size of the current subpage in millimeters measured from the\n\
4749 bottom left hand corner of the output device page or screen. Can be\n\
4750 used in conjunction with plsvpa for setting the size of a viewport in\n\
4751 absolute coordinates (millimeters).\n\
4753 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4755 This function is used in example 23.\n\
4761plgspa(xmin, xmax, ymin, ymax)\n\
4765 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4766 the left hand edge of the subpage in millimeters.\n\
4768 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4769 the right hand edge of the subpage in millimeters.\n\
4771 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4772 the bottom edge of the subpage in millimeters.\n\
4774 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4775 the top edge of the subpage in millimeters.\n\
4778Calculate world coordinates and corresponding window index from relative device coordinates\n\
4782 Calculate world coordinates, wx and wy, and corresponding window index\n\
4783 from relative device coordinates, rx and ry.\n\
4785 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4788 This function is used in example 31.\n\
4794plcalc_world(rx, ry, wx, wy, window)\n\
4798 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4799 the x coordinate.\n\
4801 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4802 the y coordinate.\n\
4804 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4805 coordinate corresponding to the relative device coordinates rx and\n\
4808 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4809 coordinate corresponding to the relative device coordinates rx and\n\
4812 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4813 defined window index that corresponds to the input relative device\n\
4814 coordinates (and the returned world coordinates). To give some\n\
4815 background on the window index, for each page the initial window\n\
4816 index is set to zero, and each time plwind is called within the\n\
4817 page, world and device coordinates are stored for the window and\n\
4818 the window index is incremented. Thus, for a simple page layout\n\
4819 with non-overlapping viewports and one window per viewport, window\n\
4820 corresponds to the viewport index (in the order which the\n\
4821 viewport/windows were created) of the only viewport/window\n\
4822 corresponding to rx and ry. However, for more complicated layouts\n\
4823 with potentially overlapping viewports and possibly more than one\n\
4824 window (set of world coordinates) per viewport, window and the\n\
4825 corresponding output world coordinates corresponds to the last\n\
4826 window created that fulfills the criterion that the relative\n\
4827 device coordinates are inside it. Finally, in all cases where the\n\
4828 input relative device coordinates are not inside any\n\
4829 viewport/window, then the returned value of the last defined\n\
4830 window index is set to -1.\n\
4833Get output file name\n\
4837 Gets the current output file name, if applicable.\n\
4839 Redacted form: plgfnam(fnam)\n\
4841 This function is used in example 31.\n\
4851 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4852 (with preallocated length of 80 characters or more) containing the\n\
4860 Draws a plot of vector data contained in the matrices (\n\
4866 ny]) . The scaling factor for the vectors is given by scale. A\n\
4867 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4868 additional data required by the transformation routine to map indices\n\
4869 within the matrices to the world coordinates. The style of the vector\n\
4870 arrow may be set using plsvect.\n\
4872 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4873 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4874 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4875 with either one or two dimensions.\n\
4877 This function is used in example 22.\n\
4883plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4887 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4888 and y components of the vector data to be plotted.\n\
4890 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4892 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4893 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4894 automatically calculated for the data. If scale < 0 then the\n\
4895 scaling factor is automatically calculated for the data and then\n\
4897 scale. If scale > 0 then the scaling factor is set to scale.\n\
4899 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4900 defines the transformation between the zero-based indices of the\n\
4901 matrices u and v and world coordinates.For the C case,\n\
4902 transformation functions are provided in the PLplot library: pltr0\n\
4903 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4904 mappings respectively defined by vectors and matrices. In\n\
4905 addition, C callback routines for the transformation can be\n\
4906 supplied by the user such as the mypltr function in\n\
4907 examples/c/x09c.c which provides a general linear transformation\n\
4908 between index coordinates and world coordinates.For languages\n\
4909 other than C you should consult the PLplot documentation for the\n\
4910 details concerning how PLTRANSFORM_callback arguments are\n\
4911 interfaced. However, in general, a particular pattern of\n\
4912 callback-associated arguments such as a tr vector with 6 elements;\n\
4913 xg and yg vectors; or xg and yg matrices are respectively\n\
4914 interfaced to a linear-transformation routine similar to the above\n\
4915 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4916 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4917 support native language callbacks for handling index to\n\
4918 world-coordinate transformations. Examples of these various\n\
4919 approaches are given in examples/<language>x09*,\n\
4920 examples/<language>x16*, examples/<language>x20*,\n\
4921 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4922 supported languages.\n\
4924 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4925 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4926 that is externally supplied.\n\
4929Plot a glyph at the specified points\n\
4933 Plot a glyph at the specified points. (This function is largely\n\
4934 superseded by plstring which gives access to many[!] more glyphs.)\n\
4936 Redacted form: plsym(x, y, code)\n\
4938 This function is used in example 7.\n\
4944plsym(n, x, y, code)\n\
4948 n (PLINT, input) : Number of points in the x and y vectors.\n\
4950 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4953 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4956 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4957 to be plotted at each of the n points.\n\
4960Get viewport limits in normalized device coordinates\n\
4964 Get viewport limits in normalized device coordinates.\n\
4966 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4969 This function is used in example 31.\n\
4975plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4979 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4980 viewport limit of the normalized device coordinate in x.\n\
4982 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4983 viewport limit of the normalized device coordinate in x.\n\
4985 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4986 viewport limit of the normalized device coordinate in y.\n\
4988 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4989 viewport limit of the normalized device coordinate in y.\n\
4992Get page parameters\n\
4996 Gets the current page configuration. The length and offset values are\n\
4997 expressed in units that are specific to the current driver. For\n\
4998 instance: screen drivers will usually interpret them as number of\n\
4999 pixels, whereas printer drivers will usually use mm.\n\
5001 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5003 This function is used in examples 14 and 31.\n\
5009plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5013 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5014 pixels/inch (DPI) in x.\n\
5016 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5017 pixels/inch (DPI) in y.\n\
5019 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5022 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5025 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5028 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5032Plot a glyph at the specified 3D points\n\
5036 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5037 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5038 this function similar to what is done for plline3. The glyph is\n\
5039 specified with a PLplot user string. Note that the user string is not\n\
5040 actually limited to one glyph so it is possible (but not normally\n\
5041 useful) to plot more than one glyph at the specified points with this\n\
5042 function. As with plmtex and plptex, the user string can contain FCI\n\
5043 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5044 else PLplot escapes for Hershey or unicode text to determine the\n\
5047 Redacted form: plstring3(x, y, z, string)\n\
5049 This function is used in example 18.\n\
5055plstring3(n, x, y, z, string)\n\
5059 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5061 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5064 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5067 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5070 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5071 the glyph(s) to be plotted at each of the n points. points.\n\
5074Shade regions on the basis of value\n\
5078 Shade regions on the basis of value. This is the high-level routine\n\
5079 for making continuous color shaded plots with cmap1 while plshade\n\
5080 should be used to plot individual shaded regions using either cmap0 or\n\
5081 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5082 our supported languages.\n\
5084 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5085 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5089 This function is used in examples 16, 21, and 22.\n\
5095plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5099 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5100 plot. Should have dimensions of\n\
5104 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5106 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5108 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5109 the region that should be plotted in the shade plot. This\n\
5110 function accepts x and y coordinates as input arguments and must\n\
5111 return 1 if the point is to be included in the shade plot and 0\n\
5112 otherwise. If you want to plot the entire shade plot (the usual\n\
5113 case), this argument should be set to NULL.\n\
5115 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5116 pltr below for how these arguments are used (only for the special case\n\
5117 when the callback function\n\
5118 pltr is not supplied).\n\
5120 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5121 corresponding to the edges of each shaded region that will be\n\
5122 plotted by this function. To work properly the levels should be\n\
5125 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5126 of shade edge values in clevel).\n\
5128 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5131 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5132 contours defining edges of shaded regions. The pen color is only\n\
5133 temporary set for the contour drawing. Set this value to zero or\n\
5134 less if no shade edge contours are wanted.\n\
5136 cont_width (PLFLT, input) : Defines line width used for contours\n\
5137 defining edges of shaded regions. This value may not be honored\n\
5138 by all drivers. The pen width is only temporary set for the\n\
5139 contour drawing. Set this value to zero or less if no shade edge\n\
5140 contours are wanted.\n\
5142 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5143 region. Use plfill for this purpose.\n\
5145 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5146 map to rectangles after coordinate transformation with pltrl.\n\
5147 Otherwise, set rectangular to false. If rectangular is set to\n\
5148 true, plshade tries to save time by filling large rectangles.\n\
5149 This optimization fails if the coordinate transformation distorts\n\
5150 the shape of rectangles. For example a plot in polar coordinates\n\
5151 has to have rectangular set to false.\n\
5153 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5154 defines the transformation between the zero-based indices of the\n\
5155 matrix a and world coordinates. If\n\
5156 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5157 indices of a are mapped to the range\n\
5159 xmax and the y indices of a are mapped to the range\n\
5161 ymax.For the C case, transformation functions are provided in the\n\
5162 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5163 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5164 matrices. In addition, C callback routines for the transformation\n\
5165 can be supplied by the user such as the mypltr function in\n\
5166 examples/c/x09c.c which provides a general linear transformation\n\
5167 between index coordinates and world coordinates.For languages\n\
5168 other than C you should consult the PLplot documentation for the\n\
5169 details concerning how PLTRANSFORM_callback arguments are\n\
5170 interfaced. However, in general, a particular pattern of\n\
5171 callback-associated arguments such as a tr vector with 6 elements;\n\
5172 xg and yg vectors; or xg and yg matrices are respectively\n\
5173 interfaced to a linear-transformation routine similar to the above\n\
5174 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5175 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5176 support native language callbacks for handling index to\n\
5177 world-coordinate transformations. Examples of these various\n\
5178 approaches are given in examples/<language>x09*,\n\
5179 examples/<language>x16*, examples/<language>x20*,\n\
5180 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5181 supported languages.\n\
5183 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5184 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5185 externally supplied.\n\
5188Set output file name\n\
5192 Sets the current output file name, if applicable. If the file name\n\
5193 has not been specified and is required by the driver, the user will be\n\
5194 prompted for it. If using the X-windows output driver, this sets the\n\
5195 display name. This routine, if used, must be called before\n\
5196 initializing PLplot.\n\
5198 Redacted form: plsfnam(fnam)\n\
5200 This function is used in examples 1 and 20.\n\
5210 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5218 Draws a contour plot of the data in f[\n\
5220 ny], using the nlevel contour levels specified by clevel. Only the\n\
5221 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5222 where all these index ranges are interpreted as one-based for\n\
5223 historical reasons. A transformation routine pointed to by pltr with\n\
5224 a generic pointer pltr_data for additional data required by the\n\
5225 transformation routine is used to map indices within the matrix to the\n\
5226 world coordinates.\n\
5228 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5229 where (see above discussion) the pltr, pltr_data callback arguments\n\
5230 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5231 vectors; or xg and yg matrices.\n\
5233 This function is used in examples 9, 14, 16, and 22.\n\
5239plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5243 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5245 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5247 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5248 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5249 zero-based for historical backwards-compatibility reasons.\n\
5251 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5252 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5253 zero-based for historical backwards-compatibility reasons.\n\
5255 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5256 which to draw contours.\n\
5258 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5260 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5261 defines the transformation between the zero-based indices of the\n\
5262 matrix f and the world coordinates.For the C case, transformation\n\
5263 functions are provided in the PLplot library: pltr0 for the\n\
5264 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5265 respectively defined by vectors and matrices. In addition, C\n\
5266 callback routines for the transformation can be supplied by the\n\
5267 user such as the mypltr function in examples/c/x09c.c which\n\
5268 provides a general linear transformation between index coordinates\n\
5269 and world coordinates.For languages other than C you should\n\
5270 consult the PLplot documentation for the details concerning how\n\
5271 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5272 general, a particular pattern of callback-associated arguments\n\
5273 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5274 yg matrices are respectively interfaced to a linear-transformation\n\
5275 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5276 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5277 the PLplot documentation) support native language callbacks for\n\
5278 handling index to world-coordinate transformations. Examples of\n\
5279 these various approaches are given in examples/<language>x09*,\n\
5280 examples/<language>x16*, examples/<language>x20*,\n\
5281 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5282 supported languages.\n\
5284 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5285 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5286 that is externally supplied.\n\
5289Set parameters that define current plot-space window\n\
5293 Set relative minima and maxima that define the current plot-space\n\
5294 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5295 xmax, and ymax are 0., 0., 1., and 1.\n\
5297 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5299 This function is used in example 31.\n\
5305plsdiplt(xmin, ymin, xmax, ymax)\n\
5309 xmin (PLFLT, input) : Relative minimum in x.\n\
5311 ymin (PLFLT, input) : Relative minimum in y.\n\
5313 xmax (PLFLT, input) : Relative maximum in x.\n\
5315 ymax (PLFLT, input) : Relative maximum in y.\n\
5318Write text inside the viewport of a 3D plot\n\
5322 Writes text at a specified position and inclination and with a\n\
5323 specified shear within the viewport. Text is clipped at the viewport\n\
5324 boundaries. The reference point of a string lies along a line passing\n\
5325 through the string at half the height of a capital letter. The\n\
5326 position of the reference point along this line is determined by just,\n\
5327 and the reference point is placed at world coordinates (\n\
5330 wz) within the viewport. The inclination and shear of the string is\n\
5331 specified in terms of differences of world coordinates making it easy\n\
5332 to write text parallel to a line in a graph.\n\
5334 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5336 This function is used in example 28.\n\
5342plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5346 wx (PLFLT, input) : x world coordinate of reference point of\n\
5349 wy (PLFLT, input) : y world coordinate of reference point of\n\
5352 wz (PLFLT, input) : z world coordinate of reference point of\n\
5355 dx (PLFLT, input) : Together with dy and\n\
5356 dz , this specifies the inclination of the string. The baseline of\n\
5357 the string is parallel to a line joining (\n\
5368 dy (PLFLT, input) : Together with dx and\n\
5369 dz, this specifies the inclination of the string.\n\
5371 dz (PLFLT, input) : Together with dx and\n\
5372 dy, this specifies the inclination of the string.\n\
5374 sx (PLFLT, input) : Together with sy and\n\
5375 sz , this specifies the shear of the string. The string is sheared so\n\
5376 that the characters are vertically parallel to a line joining (\n\
5387 sz = 0.) then the text is not sheared.\n\
5389 sy (PLFLT, input) : Together with sx and\n\
5390 sz, this specifies shear of the string.\n\
5392 sz (PLFLT, input) : Together with sx and\n\
5393 sy, this specifies shear of the string.\n\
5395 just (PLFLT, input) : Specifies the position of the string relative\n\
5396 to its reference point. If just=0. , the reference point is at\n\
5397 the left and if just=1. , it is at the right of the string. Other\n\
5398 values of just give intermediate justifications.\n\
5400 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5404Plot continental outline or shapefile data in world coordinates\n\
5408 Plots continental outlines or shapefile data in world coordinates. A\n\
5409 demonstration of how to use this function to create different\n\
5410 projections can be found in examples/c/x19c. PLplot is provided with\n\
5411 basic coastal outlines and USA state borders. To use the map\n\
5412 functionality PLplot must be compiled with the shapelib library.\n\
5413 Shapefiles have become a popular standard for geographical data and\n\
5414 data in this format can be easily found from a number of online\n\
5415 sources. Shapefile data is actually provided as three or more files\n\
5416 with the same filename, but different extensions. The .shp and .shx\n\
5417 files are required for plotting Shapefile data with PLplot.\n\
5419 PLplot currently supports the point, multipoint, polyline and polygon\n\
5420 objects within shapefiles. However holes in polygons are not\n\
5421 supported. When plmap is used the type of object is derived from the\n\
5422 shapefile, if you wish to override the type then use one of the other\n\
5423 plmap variants. The built in maps have line data only.\n\
5425 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5427 This function is used in example 19.\n\
5433plmap(mapform, name, minx, maxx, miny, maxy)\n\
5437 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5438 transform the original map data coordinates to a new coordinate\n\
5439 system. The PLplot-supplied map data is provided as latitudes and\n\
5440 longitudes; other Shapefile data may be provided in other\n\
5441 coordinate systems as can be found in their .prj plain text files.\n\
5442 For example, by using this transform we can change from a\n\
5443 longitude, latitude coordinate to a polar stereographic\n\
5444 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5445 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5446 corresponding y coordinates (latitudes for the PLplot supplied\n\
5447 data). After the call to mapform(), x[] and y[] should be\n\
5448 replaced by the corresponding plot coordinates. If no transform is\n\
5449 desired, mapform can be replaced by NULL.\n\
5451 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5452 the type of map plotted. This is either one of the PLplot built-in\n\
5453 maps or the file name of a set of Shapefile files without the file\n\
5454 extensions. For the PLplot built-in maps the possible values are:\n\
5455 \"globe\" -- continental outlines\n\
5456 \"usa\" -- USA and state boundaries\n\
5457 \"cglobe\" -- continental outlines and countries\n\
5458 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5461 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5462 drawn. The units must match the shapefile (built in maps are\n\
5463 degrees lat/lon). Objects in the file which do not encroach on the\n\
5464 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5465 note this is simply an optimisation, not a clipping so for objects\n\
5466 with some points inside the box and some points outside the box\n\
5467 all the points will be rendered. These parameters also define\n\
5468 latitude and longitude wrapping for shapefiles using these units.\n\
5469 Longitude points will be wrapped by integer multiples of 360\n\
5470 degrees to place them in the box. This allows the same data to be\n\
5471 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5472 you plot from -180-540 you will get two cycles of data drawn. The\n\
5473 value of minx must be less than the value of maxx. Passing in a\n\
5474 nan, max/-max floating point number or +/-infinity will case the\n\
5475 bounding box from the shapefile to be used.\n\
5477 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5478 drawn - see minx.\n\
5480 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5481 drawn - see minx.\n\
5483 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5484 drawn - see minx.\n\
5487Specify viewport using coordinates and aspect ratio\n\
5491 Device-independent routine for setting up the viewport. The viewport\n\
5492 is chosen to be the largest with the given aspect ratio that fits\n\
5493 within the specified region (in terms of normalized subpage\n\
5494 coordinates). This routine is functionally equivalent to plvpor when\n\
5495 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5496 routine reserves no extra space at the edges for labels.\n\
5498 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5500 This function is used in example 9.\n\
5506plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5510 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5511 left-hand edge of the viewport.\n\
5513 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5514 right-hand edge of the viewport.\n\
5516 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5517 bottom edge of the viewport.\n\
5519 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5520 edge of the viewport.\n\
5522 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5526Set the pause (on end-of-page) status\n\
5530 Set the pause (on end-of-page) status.\n\
5532 Redacted form: plspause(pause)\n\
5534 This function is in examples 14,20.\n\
5544 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5545 end-of-page for those drivers which support this. Otherwise there\n\
5549Plot 3-d surface plot\n\
5553 Plots a three-dimensional surface plot within the environment set up\n\
5554 by plw3d. The surface is defined by the matrix z[\n\
5556 ny] , the point z[i][j] being the value of the function at (\n\
5558 y[j]). Note that the points in vectors x and y do not need to be\n\
5559 equally spaced, but must be stored in ascending order. The parameter\n\
5560 opt controls the way in which the surface is displayed. For further\n\
5561 details see the PLplot documentation. The only difference between\n\
5562 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5563 while plot3d only draws the surface as viewed from the top.\n\
5565 Redacted form: plot3d(x, y, z, opt, side)\n\
5567 This function is used in examples 11 and 21.\n\
5573plot3d(x, y, z, nx, ny, opt, side)\n\
5577 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5578 which the function is evaluated.\n\
5580 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5581 which the function is evaluated.\n\
5583 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5584 plot. Should have dimensions of\n\
5588 nx (PLINT, input) : Number of x values at which function is\n\
5591 ny (PLINT, input) : Number of y values at which function is\n\
5594 opt (PLINT, input) : Determines the way in which the surface is\n\
5595 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5596 function of x for each value of y[j] .\n\
5597 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5598 for each value of x[i] .\n\
5599 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5600 at which function is defined.\n\
5603 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5604 should be draw on the figure. If side is true sides are drawn,\n\
5605 otherwise no sides are drawn.\n\
5608Copy state parameters from the reference stream to the current stream\n\
5612 Copies state parameters from the reference stream to the current\n\
5613 stream. Tell driver interface to map device coordinates unless flags\n\
5616 This function is used for making save files of selected plots (e.g.\n\
5617 from the TK driver). After initializing, you can get a copy of the\n\
5618 current plot to the specified device by switching to this stream and\n\
5619 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5620 appropriate. The plot buffer must have previously been enabled (done\n\
5621 automatically by some display drivers, such as X).\n\
5623 Redacted form: plcpstrm(iplsr, flags)\n\
5625 This function is used in example 1,20.\n\
5631plcpstrm(iplsr, flags)\n\
5635 iplsr (PLINT, input) : Number of reference stream.\n\
5637 flags (PLBOOL, input) : If flags is set to true the device\n\
5638 coordinates are not copied from the reference to current stream.\n\
5641Set page parameters\n\
5645 Sets the page configuration (optional). If an individual parameter is\n\
5646 zero then that parameter value is not updated. Not all parameters are\n\
5647 recognized by all drivers and the interpretation is device-dependent.\n\
5648 The X-window driver uses the length and offset parameters to determine\n\
5649 the window size and location. The length and offset values are\n\
5650 expressed in units that are specific to the current driver. For\n\
5651 instance: screen drivers will usually interpret them as number of\n\
5652 pixels, whereas printer drivers will usually use mm.\n\
5654 This routine, if used, must be called before initializing PLplot. It\n\
5655 may be called at later times for interactive drivers to change only\n\
5656 the dpi for subsequent redraws which you can force via a call to\n\
5657 plreplot. If this function is not called then the page size defaults\n\
5658 to landscape A4 for drivers which use real world page sizes and 744\n\
5659 pixels wide by 538 pixels high for raster drivers. The default value\n\
5660 for dx and dy is 90 pixels per inch for raster drivers.\n\
5664 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5666 This function is used in examples 14 and 31.\n\
5672plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5676 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5677 by raster drivers, ignored by drivers which use \"real world\" units\n\
5680 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5681 by raster drivers, ignored by drivers which use \"real world\" units\n\
5684 xleng (PLINT, input) : Page length, x.\n\
5686 yleng (PLINT, input) : Page length, y.\n\
5688 xoff (PLINT, input) : Page offset, x.\n\
5690 yoff (PLINT, input) : Page offset, y.\n\
5693Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5697 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5698 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5699 Values are negative if an invalid color id is given.\n\
5701 Redacted form: plgcola(r, g, b)\n\
5703 This function is used in example 30.\n\
5709plgcol0a(icol0, r, g, b, alpha)\n\
5713 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5715 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5716 in the range from 0 to 255.\n\
5718 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5719 in the range from 0 to 255.\n\
5721 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5722 in the range from 0 to 255.\n\
5724 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5725 transparency in the range from (0.0-1.0).\n\
5728Returns 8-bit RGB values for given color index from cmap0\n\
5732 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5733 PLplot documentation). Values are negative if an invalid color id is\n\
5736 Redacted form: plgcol0(icol0, r, g, b)\n\
5738 This function is used in example 2.\n\
5744plgcol0(icol0, r, g, b)\n\
5748 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5750 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5753 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5756 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5760Set parameters incrementally (zoom mode) that define current plot-space window\n\
5764 Set relative minima and maxima incrementally (zoom mode) that define\n\
5765 the current plot-space window. This function has the same effect as\n\
5766 plsdiplt if that function has not been previously called. Otherwise,\n\
5767 this function implements zoom mode using the transformation min_used =\n\
5768 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5769 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5770 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5772 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5774 This function is used in example 31.\n\
5780plsdiplz(xmin, ymin, xmax, ymax)\n\
5784 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5786 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5788 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5790 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5793Plot all or a subset of Shapefile data, filling the polygons\n\
5797 As per plmapline, however the items are filled in the same way as\n\
5800 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5803 This function is used in example 19.\n\
5809plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5813 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5814 transform the coordinates given in the shapefile into a plot\n\
5815 coordinate system. By using this transform, we can change from a\n\
5816 longitude, latitude coordinate to a polar stereographic project,\n\
5817 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5818 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5819 mapform(), x[] and y[] should be replaced by the corresponding\n\
5820 plot coordinates. If no transform is desired, mapform can be\n\
5821 replaced by NULL.\n\
5823 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5824 the file name of a set of Shapefile files without the file\n\
5827 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5828 be in the same units as used by the Shapefile. You could use a\n\
5829 very large negative number to plot everything, but you can improve\n\
5830 performance by limiting the area drawn. The units must match those\n\
5831 of the Shapefile projection, which may be for example longitude or\n\
5832 distance. The value of minx must be less than the value of maxx.\n\
5834 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5835 use a very large number to plot everything, but you can improve\n\
5836 performance by limiting the area drawn.\n\
5838 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5839 be in the same units as used by the Shapefile. You could use a\n\
5840 very large negative number to plot everything, but you can improve\n\
5841 performance by limiting the area drawn. The units must match those\n\
5842 of the Shapefile projection, which may be for example latitude or\n\
5843 distance. The value of miny must be less than the value of maxy.\n\
5845 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5846 use a very large number to plot everything, but you can improve\n\
5847 performance by limiting the area drawn.\n\
5849 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5850 zero-based indices of the Shapefile elements which will be drawn.\n\
5852 plotentries to NULL will plot all elements of the Shapefile.\n\
5854 nplotentries (PLINT, input) : The number of items in\n\
5855 plotentries. Ignored if\n\
5856 plotentries is NULL.\n\
5863 Draws line defined by n points in x and y.\n\
5865 Redacted form: plline(x, y)\n\
5867 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5878 n (PLINT, input) : Number of points defining line.\n\
5880 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5883 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5887Get viewport limits in world coordinates\n\
5891 Get viewport limits in world coordinates.\n\
5893 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5896 This function is used in example 31.\n\
5902plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5906 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5907 viewport limit of the world coordinate in x.\n\
5909 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5910 viewport limit of the world coordinate in x.\n\
5912 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5913 viewport limit of the world coordinate in y.\n\
5915 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5916 viewport limit of the world coordinate in y.\n\
5919Set area line fill pattern\n\
5923 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5924 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5925 inclinations and spacings. The arguments to this routine are the\n\
5926 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5927 elements) specifying the inclinations in tenths of a degree and the\n\
5928 spacing in micrometers. (See also plpsty)\n\
5930 Redacted form: General: plpat(inc, del)\n\
5933 This function is used in example 15.\n\
5939plpat(nlin, inc, del)\n\
5943 nlin (PLINT, input) : Number of sets of lines making up the\n\
5944 pattern, either 1 or 2.\n\
5946 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5947 inclination in tenths of a degree. (Should be between -900 and\n\
5950 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5951 spacing in micrometers between the lines making up the pattern.\n\
5954Set x axis parameters\n\
5958 Sets values of the digmax and digits flags for the x axis. See the\n\
5959 PLplot documentation for more information.\n\
5961 Redacted form: plsxax(digmax, digits)\n\
5963 This function is used in example 31.\n\
5969plsxax(digmax, digits)\n\
5973 digmax (PLINT, input) : Variable to set the maximum number of\n\
5974 digits for the x axis. If nonzero, the printed label will be\n\
5975 switched to a floating-point representation when the number of\n\
5976 digits exceeds digmax.\n\
5978 digits (PLINT, input) : Field digits value. Currently, changing\n\
5979 its value here has no effect since it is set only by plbox or\n\
5980 plbox3. However, the user may obtain its value after a call to\n\
5981 either of these functions by calling plgxax.\n\
5984Get family file parameters\n\
5988 Gets information about current family file, if familying is enabled.\n\
5989 See the PLplot documentation for more information.\n\
5991 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5993 This function is used in examples 14 and 31.\n\
5999plgfam(p_fam, p_num, p_bmax)\n\
6003 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6004 family flag value. If nonzero, familying is enabled for the\n\
6007 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6008 family file number.\n\
6010 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6011 file size (in bytes) for a family file.\n\
6014Get y axis parameters\n\
6018 Identical to plgxax, except that arguments are flags for y axis. See\n\
6019 the description of plgxax for more detail.\n\
6021 Redacted form: plgyax(p_digmax, p_digits)\n\
6023 This function is used in example 31.\n\
6029plgyax(p_digmax, p_digits)\n\
6033 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6034 number of digits for the y axis. If nonzero, the printed label\n\
6035 has been switched to a floating-point representation when the\n\
6036 number of digits exceeds this value.\n\
6038 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6039 number of digits for the numeric labels (y axis) from the last\n\
6043Plot a glyph at the specified points\n\
6047 Plot a glyph at the specified points. (This function is largely\n\
6048 superseded by plstring which gives access to many[!] more glyphs.)\n\
6049 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6050 and a draw at the same place. Not ideal, since a sufficiently\n\
6051 intelligent output device may optimize it away, or there may be faster\n\
6052 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6053 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6054 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6055 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6056 code <= 127 the corresponding printable ASCII character is plotted.\n\
6058 Redacted form: plpoin(x, y, code)\n\
6060 This function is used in examples 1, 6, 14, and 29.\n\
6066plpoin(n, x, y, code)\n\
6070 n (PLINT, input) : Number of points in the x and y vectors.\n\
6072 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6075 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6078 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6079 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6080 each of the n points.\n\
6083Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6087 As per plmapline, however the items are plotted as strings or points\n\
6088 in the same way as plstring.\n\
6090 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6091 maxy, plotentries)\n\
6093 This function is not used in any examples.\n\
6099plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6103 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6104 transform the coordinates given in the shapefile into a plot\n\
6105 coordinate system. By using this transform, we can change from a\n\
6106 longitude, latitude coordinate to a polar stereographic project,\n\
6107 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6108 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6109 mapform(), x[] and y[] should be replaced by the corresponding\n\
6110 plot coordinates. If no transform is desired, mapform can be\n\
6111 replaced by NULL.\n\
6113 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6114 the file name of a set of Shapefile files without the file\n\
6117 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6120 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6121 be in the same units as used by the Shapefile. You could use a\n\
6122 very large negative number to plot everything, but you can improve\n\
6123 performance by limiting the area drawn. The units must match those\n\
6124 of the Shapefile projection, which may be for example longitude or\n\
6125 distance. The value of minx must be less than the value of maxx.\n\
6127 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6128 use a very large number to plot everything, but you can improve\n\
6129 performance by limiting the area drawn.\n\
6131 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6132 be in the same units as used by the Shapefile. You could use a\n\
6133 very large negative number to plot everything, but you can improve\n\
6134 performance by limiting the area drawn. The units must match those\n\
6135 of the Shapefile projection, which may be for example latitude or\n\
6136 distance. The value of miny must be less than the value of maxy.\n\
6138 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6139 use a very large number to plot everything, but you can improve\n\
6140 performance by limiting the area drawn.\n\
6142 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6143 zero-based indices of the Shapefile elements which will be drawn.\n\
6145 plotentries to NULL will plot all elements of the Shapefile.\n\
6147 nplotentries (PLINT, input) : The number of items in\n\
6148 plotentries. Ignored if\n\
6149 plotentries is NULL.\n\
6152Select area fill pattern\n\
6157 patt is zero or less use either a hardware solid fill if the drivers\n\
6158 have that capability (virtually all do) or fall back to a software\n\
6159 emulation of a solid fill using the eighth area line fill pattern. If\n\
6161 patt <= 8, then select one of eight predefined area line fill patterns\n\
6162 to use (see plpat if you desire other patterns).\n\
6164 Redacted form: plpsty(patt)\n\
6166 This function is used in examples 12, 13, 15, 16, and 25.\n\
6176 patt (PLINT, input) : The desired pattern index. If\n\
6177 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6179 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6180 line fill capability itself (most deliberately do not so that line\n\
6181 fill patterns look identical for those drivers), the patterns\n\
6182 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6183 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6184 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6185 (8) lines at both 45 degrees and -45 degrees.\n\
6188Set 8-bit RGB values for given cmap0 color index\n\
6192 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6193 index. Overwrites the previous color value for the given index and,\n\
6194 thus, does not result in any additional allocation of space for\n\
6197 Redacted form: plscol0(icol0, r, g, b)\n\
6199 This function is used in any example 31.\n\
6205plscol0(icol0, r, g, b)\n\
6209 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6210 number of colors (which is set by default, by plscmap0n, or even\n\
6213 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6214 degree of red in the color.\n\
6216 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6217 degree of green in the color.\n\
6219 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6220 degree of blue in the color.\n\
6223Used to globally turn color output on/off\n\
6227 Used to globally turn color output on/off for those drivers/devices\n\
6230 Redacted form: plscolor(color)\n\
6232 This function is used in example 31.\n\
6242 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6243 turned off. If non-zero, color is turned on.\n\
6246End plotting session\n\
6250 Ends a plotting session, tidies up all the output files, switches\n\
6251 interactive devices back into text mode and frees up any memory that\n\
6252 was allocated. Must be called before end of program.\n\
6254 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6255 wait state after a call to plend or other functions which trigger the\n\
6256 end of a plot page. To avoid this, use the plspause function.\n\
6258 Redacted form: plend()\n\
6260 This function is used in all of the examples.\n\
6269Plot a histogram from binned data\n\
6273 Plots a histogram consisting of nbin bins. The value associated with\n\
6274 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6275 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6276 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6277 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6278 placed midway between the values in the x vector. Also see plhist for\n\
6279 drawing histograms from unbinned data.\n\
6281 Redacted form: General: plbin(x, y, opt)\n\
6282 Python: plbin(nbin, x, y, opt)\n\
6285 This function is not used in any examples.\n\
6291plbin(nbin, x, y, opt)\n\
6295 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6298 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6299 with bins. These must form a strictly increasing sequence.\n\
6301 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6302 proportional to the number of points in each bin. This is a PLFLT\n\
6303 (instead of PLINT) vector so as to allow histograms of\n\
6304 probabilities, etc.\n\
6306 opt (PLINT, input) : Is a combination of several flags:\n\
6307 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6308 outer bins are expanded to fill up the entire x-axis and bins of\n\
6309 zero height are simply drawn.\n\
6310 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6311 between the x values. If the values in x are equally spaced,\n\
6312 the values are the center values of the bins.\n\
6313 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6314 size as the ones inside.\n\
6315 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6316 (there is a gap for such bins).\n\
6319Plot a 2D matrix using cmap1\n\
6323 Plot a 2D matrix using cmap1.\n\
6325 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6326 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6329 This function is used in example 20.\n\
6335plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6339 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6340 plot. Should have dimensions of\n\
6344 nx, ny (PLINT, input) : Dimensions of idata\n\
6346 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6347 pltr below for how these arguments are used (only for the special case\n\
6348 when the callback function\n\
6349 pltr is not supplied).\n\
6351 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6352 (inclusive) will be plotted.\n\
6354 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6355 values to use for value to color mappings. A datum equal to or\n\
6356 less than valuemin will be plotted with color 0.0, while a datum\n\
6357 equal to or greater than valuemax will be plotted with color 1.0.\n\
6358 Data between valuemin and valuemax map linearly to colors in the\n\
6361 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6362 defines the transformation between the zero-based indices of the\n\
6363 matrix idata and world coordinates. If\n\
6364 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6365 indices of idata are mapped to the range\n\
6367 xmax and the y indices of idata are mapped to the range\n\
6369 ymax.For the C case, transformation functions are provided in the\n\
6370 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6371 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6372 matrices. In addition, C callback routines for the transformation\n\
6373 can be supplied by the user such as the mypltr function in\n\
6374 examples/c/x09c.c which provides a general linear transformation\n\
6375 between index coordinates and world coordinates.For languages\n\
6376 other than C you should consult the PLplot documentation for the\n\
6377 details concerning how PLTRANSFORM_callback arguments are\n\
6378 interfaced. However, in general, a particular pattern of\n\
6379 callback-associated arguments such as a tr vector with 6 elements;\n\
6380 xg and yg vectors; or xg and yg matrices are respectively\n\
6381 interfaced to a linear-transformation routine similar to the above\n\
6382 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6383 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6384 support native language callbacks for handling index to\n\
6385 world-coordinate transformations. Examples of these various\n\
6386 approaches are given in examples/<language>x09*,\n\
6387 examples/<language>x16*, examples/<language>x20*,\n\
6388 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6389 supported languages.\n\
6391 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6392 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6393 externally supplied.\n\
6396Sets the 3D position of the light source\n\
6400 Sets the 3D position of the light source for use with plsurf3d and\n\
6403 Redacted form: pllightsource(x, y, z)\n\
6405 This function is used in example 8.\n\
6411pllightsource(x, y, z)\n\
6415 x (PLFLT, input) : X-coordinate of the light source.\n\
6417 y (PLFLT, input) : Y-coordinate of the light source.\n\
6419 z (PLFLT, input) : Z-coordinate of the light source.\n\
6422Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6426 When the implementation is completed this variant of plot3dc (see that\n\
6427 function\'s documentation for more details) should be suitable for the\n\
6428 case where the area of the x, y coordinate grid where z is defined can\n\
6429 be non-rectangular. The implementation is incomplete so the last 4\n\
6430 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6431 indexymax; are currently ignored and the functionality is otherwise\n\
6432 identical to that of plot3dc.\n\
6434 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6435 indexymin, indexymax)\n\
6438 This function is not used in any example.\n\
6444plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6448 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6449 which the function is evaluated.\n\
6451 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6452 which the function is evaluated.\n\
6454 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6455 plot. Should have dimensions of\n\
6459 nx (PLINT, input) : Number of x values at which the function is\n\
6462 ny (PLINT, input) : Number of y values at which the function is\n\
6465 opt (PLINT, input) : Determines the way in which the surface is\n\
6466 represented. To specify more than one option just add the options,\n\
6467 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6468 showing z as a function of x for each value of y[j] .\n\
6469 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6470 for each value of x[i] .\n\
6471 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6472 at which function is defined.\n\
6473 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6474 the z value being plotted. The color is used from the current\n\
6476 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6480 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6481 the borders of the plotted function.\n\
6484 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6487 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6489 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6490 corresponds to the first x index where z is defined.\n\
6492 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6493 which corresponds (by convention) to one more than the last x\n\
6494 index value where z is defined.\n\
6496 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6497 values which all must be ≥ 0. These values are the first y index\n\
6498 where z is defined for a particular x index in the range from\n\
6499 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6502 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6503 values which all must be ≤ ny. These values correspond (by\n\
6504 convention) to one more than the last y index where z is defined\n\
6505 for a particular x index in the range from indexxmin to indexxmax\n\
6506 - 1. The dimension of indexymax is indexxmax.\n\
6509Creates a new stream and makes it the default\n\
6513 Creates a new stream and makes it the default. Differs from using\n\
6514 plsstrm, in that a free stream number is found, and returned.\n\
6515 Unfortunately, I have to start at stream 1 and work upward, since\n\
6516 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6517 that no initial, library-opening call is required. So stream 0 must\n\
6518 be preallocated, and there is no simple way of determining whether it\n\
6519 is already in use or not.\n\
6521 Redacted form: plmkstrm(p_strm)\n\
6523 This function is used in examples 1 and 20.\n\
6533 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6534 number of the created stream.\n\
6537Set FCI (font characterization integer)\n\
6541 Sets font characteristics to be used at the start of the next string\n\
6542 using the FCI approach. See the PLplot documentation for more\n\
6543 information. Note, plsfont (which calls plsfci internally) provides a\n\
6544 more user-friendly API for setting the font characterisitics.\n\
6546 Redacted form: General: plsfci(fci)\n\
6549 This function is used in example 23.\n\
6559 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6567 Initializing the plotting package. The program prompts for the device\n\
6568 keyword or number of the desired output device. Hitting a RETURN in\n\
6569 response to the prompt is the same as selecting the first device.\n\
6570 plinit will issue no prompt if either the device was specified\n\
6571 previously (via command line flag, the plsetopt function, or the\n\
6572 plsdev function), or if only one device is enabled when PLplot is\n\
6573 installed. If subpages have been specified, the output device is\n\
6574 divided into nx by ny subpages, each of which may be used\n\
6575 independently. If plinit is called again during a program, the\n\
6576 previously opened file will be closed. The subroutine pladv is used\n\
6577 to advance from one subpage to the next.\n\
6579 Redacted form: plinit()\n\
6581 This function is used in all of the examples.\n\
6594 This sets up the line style for all lines subsequently drawn. A line\n\
6595 consists of segments in which the pen is alternately down and up. The\n\
6596 lengths of these segments are passed in the vectors mark and space\n\
6597 respectively. The number of mark-space pairs is specified by nms. In\n\
6598 order to return the line style to the default continuous line, plstyl\n\
6599 should be called with nms =0 .(see also pllsty)\n\
6601 Redacted form: plstyl(mark, space)\n\
6603 This function is used in examples 1, 9, and 14.\n\
6609plstyl(nms, mark, space)\n\
6613 nms (PLINT, input) : The number of mark and space elements in a\n\
6614 line. Thus a simple broken line can be obtained by setting nms=1\n\
6615 . A continuous line is specified by setting nms=0 .\n\
6617 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6618 segments during which the pen is down, measured in micrometers.\n\
6620 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6621 the segments during which the pen is up, measured in micrometers.\n\
6624Set length of minor ticks\n\
6628 This sets up the length of the minor ticks and the length of the\n\
6629 terminals on error bars. The actual length is the product of the\n\
6630 default length and a scaling factor as for character height.\n\
6632 Redacted form: plsmin(def, scale)\n\
6634 This function is used in example 29.\n\
6640plsmin(def, scale)\n\
6644 def (PLFLT, input) : The default length of a minor tick in\n\
6645 millimeters, should be set to zero if the default length is to\n\
6646 remain unchanged.\n\
6648 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6649 actual tick length.\n\
6652Draw a box with axes, etc, in 3-d\n\
6656 Draws axes, numeric and text labels for a three-dimensional surface\n\
6657 plot. For a more complete description of three-dimensional plotting\n\
6658 see the PLplot documentation.\n\
6660 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6661 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6664 This function is used in examples 8, 11, 18, and 21.\n\
6670plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6674 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6675 options for the x axis. The string can include any combination of\n\
6676 the following letters (upper or lower case) in any order: b: Draws\n\
6677 axis at base, at height z=\n\
6678 zmin where zmin is defined by call to plw3d. This character must be\n\
6679 specified in order to use any of the other options.\n\
6680 d: Plot labels as date / time. Values are assumed to be\n\
6681 seconds since the epoch (as used by gmtime).\n\
6682 f: Always use fixed point numeric labels.\n\
6683 i: Inverts tick marks, so they are drawn downwards, rather\n\
6685 l: Labels axis logarithmically. This only affects the labels,\n\
6686 not the data, and so it is necessary to compute the logarithms\n\
6687 of data points before passing them to any of the drawing\n\
6689 n: Writes numeric labels at major tick intervals.\n\
6690 o: Use custom labelling function to generate axis label text.\n\
6691 The custom labelling function can be defined with the\n\
6692 plslabelfunc command.\n\
6693 s: Enables subticks between major ticks, only valid if t is\n\
6695 t: Draws major ticks.\n\
6696 u: If this is specified, the text label for the axis is\n\
6697 written under the axis.\n\
6700 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6701 the text label for the x axis. It is only drawn if u is in the\n\
6704 xtick (PLFLT, input) : World coordinate interval between major\n\
6705 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6706 generates a suitable tick interval.\n\
6708 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6709 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6710 generates a suitable minor tick interval.\n\
6712 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6713 options for the y axis. The string is interpreted in the same way\n\
6716 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6717 the text label for the y axis. It is only drawn if u is in the\n\
6720 ytick (PLFLT, input) : World coordinate interval between major\n\
6721 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6722 generates a suitable tick interval.\n\
6724 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6725 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6726 generates a suitable minor tick interval.\n\
6728 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6729 options for the z axis. The string can include any combination of\n\
6730 the following letters (upper or lower case) in any order: b: Draws\n\
6731 z axis to the left of the surface plot.\n\
6732 c: Draws z axis to the right of the surface plot.\n\
6733 d: Draws grid lines parallel to the x-y plane behind the\n\
6734 figure. These lines are not drawn until after plot3d or\n\
6735 plmesh are called because of the need for hidden line removal.\n\
6736 e: Plot labels as date / time. Values are assumed to be\n\
6737 seconds since the epoch (as used by gmtime). Note this\n\
6738 suboption is interpreted the same as the d suboption for xopt\n\
6739 and yopt, but it has to be identified as e for zopt since d\n\
6740 has already been used for the different purpose above.\n\
6741 f: Always use fixed point numeric labels.\n\
6742 i: Inverts tick marks, so they are drawn away from the center.\n\
6743 l: Labels axis logarithmically. This only affects the labels,\n\
6744 not the data, and so it is necessary to compute the logarithms\n\
6745 of data points before passing them to any of the drawing\n\
6747 m: Writes numeric labels at major tick intervals on the\n\
6748 right-hand z axis.\n\
6749 n: Writes numeric labels at major tick intervals on the\n\
6750 left-hand z axis.\n\
6751 o: Use custom labelling function to generate axis label text.\n\
6752 The custom labelling function can be defined with the\n\
6753 plslabelfunc command.\n\
6754 s: Enables subticks between major ticks, only valid if t is\n\
6756 t: Draws major ticks.\n\
6757 u: If this is specified, the text label is written beside the\n\
6759 v: If this is specified, the text label is written beside the\n\
6763 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6764 the text label for the z axis. It is only drawn if u or v are in\n\
6767 ztick (PLFLT, input) : World coordinate interval between major\n\
6768 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6769 generates a suitable tick interval.\n\
6771 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6772 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6773 generates a suitable minor tick interval.\n\
6776Set character size\n\
6780 This sets up the size of all subsequent characters drawn. The actual\n\
6781 height of a character is the product of the default character size and\n\
6782 a scaling factor.\n\
6784 Redacted form: plschr(def, scale)\n\
6786 This function is used in examples 2, 13, 23, and 24.\n\
6792plschr(def, scale)\n\
6796 def (PLFLT, input) : The default height of a character in\n\
6797 millimeters, should be set to zero if the default height is to\n\
6798 remain unchanged. For rasterized drivers the dx and dy values\n\
6799 specified in plspage are used to convert from mm to pixels (note\n\
6800 the different unit systems used). This dpi aware scaling is not\n\
6801 implemented for all drivers yet.\n\
6803 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6804 actual character height.\n\
6807Calculate continuous time from broken-down time for the current stream\n\
6811 Calculate continuous time, ctime, from broken-down time for the\n\
6812 current stream. The broken-down\n\
6813 time is specified by the following parameters: year, month, day, hour,\n\
6814 min, and sec. This function is the inverse of plbtime.\n\
6816 The PLplot definition of broken-down time is a calendar time that\n\
6817 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6818 responsibility to apply those offsets (if so desired) before using the\n\
6819 PLplot time API. By default broken-down time is defined using the\n\
6820 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6821 continuous time is defined as the number of seconds since the Unix\n\
6822 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6823 broken-down and continuous time are possible, see plconfigtime which\n\
6824 specifies that transformation for the current stream.\n\
6826 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6830 This function is used in example 29.\n\
6836plctime(year, month, day, hour, min, sec, ctime)\n\
6840 year (PLINT, input) : Input year.\n\
6842 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6845 day (PLINT, input) : Input day in range from 1 to 31.\n\
6847 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6849 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6851 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6853 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6854 time calculated from the broken-down time specified by the\n\
6855 previous parameters.\n\
6862 Sets the color index for cmap0 (see the PLplot documentation).\n\
6864 Redacted form: plcol0(icol0)\n\
6866 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6876 icol0 (PLINT, input) : Integer representing the color. The\n\
6877 defaults at present are (these may change):\n\
6878 0 black (default background)\n\
6879 1 red (default foreground)\n\
6895 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6896 change an individual color in the cmap0 color palette.\n\
6903 Sets the color for cmap1 (see the PLplot documentation).\n\
6905 Redacted form: plcol1(col1)\n\
6907 This function is used in examples 12 and 21.\n\
6917 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6918 is mapped to color using the continuous cmap1 palette which by\n\
6919 default ranges from blue to the background color to red. The\n\
6920 cmap1 palette can also be straightforwardly changed by the user\n\
6921 with plscmap1 or plscmap1l.\n\
6924Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6928 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6930 Redacted form: plgcolbg(r, g, b)\n\
6932 This function is used in example 31.\n\
6942 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6943 in the range from 0 to 255.\n\
6945 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6946 in the range from 0 to 255.\n\
6948 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6949 in the range from 0 to 255.\n\
6952Draw a circular or elliptical arc\n\
6956 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6957 semiminor axis b, starting at angle1 and ending at angle2.\n\
6959 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6963 This function is used in examples 3 and 27.\n\
6969plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6973 x (PLFLT, input) : X coordinate of arc center.\n\
6975 y (PLFLT, input) : Y coordinate of arc center.\n\
6977 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6979 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6981 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6984 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6987 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6990 fill (PLBOOL, input) : Draw a filled arc.\n\
6993Parse command-line arguments\n\
6997 Parse command-line arguments.\n\
6999 plparseopts removes all recognized flags (decreasing argc\n\
7000 accordingly), so that invalid input may be readily detected. It can\n\
7001 also be used to process user command line flags. The user can merge\n\
7002 an option table of type PLOptionTable into the internal option table\n\
7003 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7004 the external table(s) be parsed by calling plClearOpts before\n\
7007 The default action taken by plparseopts is as follows:\n\
7008 Returns with an error if an unrecognized option or badly formed\n\
7009 option-value pair are encountered.\n\
7010 Returns immediately (return code 0) when the first non-option command\n\
7011 line argument is found.\n\
7012 Returns with the return code of the option handler, if one was called.\n\
7014 Deletes command line arguments from argv list as they are found, and\n\
7015 decrements argc accordingly.\n\
7016 Does not show \"invisible\" options in usage or help messages.\n\
7017 Assumes the program name is contained in argv[0].\n\
7019 These behaviors may be controlled through the\n\
7022 Redacted form: General: plparseopts(argv, mode)\n\
7025 This function is used in all of the examples.\n\
7031PLINT plparseopts(p_argc, argv, mode)\n\
7035 p_argc (int *, input/output) : Number of arguments.\n\
7037 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7038 strings containing *p_argc command-line arguments.\n\
7040 mode (PLINT, input) : Parsing mode with the following\n\
7041 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7042 and all error messages enabled, including program exit when an\n\
7043 error occurs. Anything on the command line that isn\'t recognized\n\
7044 as a valid option or option argument is flagged as an error.\n\
7045 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7047 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7049 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7050 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7051 pointer to the program name.\n\
7052 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7053 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7054 unrecognized arguments.\n\
7057Get parameters that define current device-space window\n\
7061 Get relative margin width, aspect ratio, and relative justification\n\
7062 that define current device-space window. If plsdidev has not been\n\
7063 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7064 p_jy will all be 0.\n\
7066 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7068 This function is used in example 31.\n\
7074plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7078 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7081 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7084 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7085 justification in x.\n\
7087 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7088 justification in y.\n\
7091Assign a function to use for generating custom axis labels\n\
7095 This function allows a user to provide their own function to provide\n\
7096 axis label text. The user function is given the numeric value for a\n\
7097 point on an axis and returns a string label to correspond with that\n\
7098 value. Custom axis labels can be enabled by passing appropriate\n\
7099 arguments to plenv, plbox, plbox3 and similar functions.\n\
7101 This function is used in example 19.\n\
7107plslabelfunc(label_func, label_data)\n\
7111 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7112 label function. In order to reset to the default labelling, set\n\
7113 this to NULL. The labelling function parameters are, in order:\n\
7114 axis: This indicates which axis a label is being requested for.\n\
7115 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7117 value: This is the value along the axis which is being labelled.\n\
7119 label_text: The string representation of the label value.\n\
7121 length: The maximum length in characters allowed for label_text.\n\
7124 label_data (PLPointer, input) : This parameter may be used to pass\n\
7125 data to the label_func function.\n\
7128Get the (current) run level\n\
7132 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7134 2, viewport defined\n\
7135 3, world coordinates defined\n\
7138 Redacted form: plglevel(p_level)\n\
7140 This function is used in example 31.\n\
7150 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7158 This sets the line style according to one of eight predefined patterns\n\
7159 (also see plstyl).\n\
7161 Redacted form: pllsty(lin)\n\
7163 This function is used in examples 9, 12, 22, and 25.\n\
7173 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7174 a continuous line, line style 2 is a line with short dashes and\n\
7175 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7176 4 has long dashes and short gaps and so on.\n\
7179Set up standard window and draw box\n\
7183 Sets up plotter environment for simple graphs by calling pladv and\n\
7184 setting up viewport and window to sensible default values. plenv\n\
7185 leaves a standard margin (left-hand margin of eight character heights,\n\
7186 and a margin around the other three sides of five character heights)\n\
7187 around most graphs for axis labels and a title. When these defaults\n\
7188 are not suitable, use the individual routines plvpas, plvpor, or\n\
7189 plvasp for setting up the viewport, plwind for defining the window,\n\
7190 and plbox for drawing the box.\n\
7192 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7194 This function is used in example 1,3,9,13,14,19-22,29.\n\
7200plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7204 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7205 world coordinates).\n\
7207 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7208 world coordinates).\n\
7210 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7213 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7216 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7217 scales will not be set, the user must set up the scale before\n\
7218 calling plenv using plsvpa, plvasp or other.\n\
7219 0: the x and y axes are scaled independently to use as much of\n\
7220 the screen as possible.\n\
7221 1: the scales of the x and y axes are made equal.\n\
7222 2: the axis of the x and y axes are made equal, and the plot\n\
7223 box will be square.\n\
7226 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7227 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7228 -1: draw box only.\n\
7229 0: draw box, ticks, and numeric tick labels.\n\
7230 1: also draw coordinate axes at x=0 and y=0.\n\
7231 2: also draw a grid at major tick positions in both\n\
7233 3: also draw a grid at minor tick positions in both\n\
7235 10: same as 0 except logarithmic x tick marks. (The x data\n\
7236 have to be converted to logarithms separately.)\n\
7237 11: same as 1 except logarithmic x tick marks. (The x data\n\
7238 have to be converted to logarithms separately.)\n\
7239 12: same as 2 except logarithmic x tick marks. (The x data\n\
7240 have to be converted to logarithms separately.)\n\
7241 13: same as 3 except logarithmic x tick marks. (The x data\n\
7242 have to be converted to logarithms separately.)\n\
7243 20: same as 0 except logarithmic y tick marks. (The y data\n\
7244 have to be converted to logarithms separately.)\n\
7245 21: same as 1 except logarithmic y tick marks. (The y data\n\
7246 have to be converted to logarithms separately.)\n\
7247 22: same as 2 except logarithmic y tick marks. (The y data\n\
7248 have to be converted to logarithms separately.)\n\
7249 23: same as 3 except logarithmic y tick marks. (The y data\n\
7250 have to be converted to logarithms separately.)\n\
7251 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7252 and y data have to be converted to logarithms separately.)\n\
7253 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7254 and y data have to be converted to logarithms separately.)\n\
7255 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7256 and y data have to be converted to logarithms separately.)\n\
7257 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7258 and y data have to be converted to logarithms separately.)\n\
7259 40: same as 0 except date / time x labels.\n\
7260 41: same as 1 except date / time x labels.\n\
7261 42: same as 2 except date / time x labels.\n\
7262 43: same as 3 except date / time x labels.\n\
7263 50: same as 0 except date / time y labels.\n\
7264 51: same as 1 except date / time y labels.\n\
7265 52: same as 2 except date / time y labels.\n\
7266 53: same as 3 except date / time y labels.\n\
7267 60: same as 0 except date / time x and y labels.\n\
7268 61: same as 1 except date / time x and y labels.\n\
7269 62: same as 2 except date / time x and y labels.\n\
7270 63: same as 3 except date / time x and y labels.\n\
7271 70: same as 0 except custom x and y labels.\n\
7272 71: same as 1 except custom x and y labels.\n\
7273 72: same as 2 except custom x and y labels.\n\
7274 73: same as 3 except custom x and y labels.\n\
7281 Alternative to plstar for initializing the plotting package. The\n\
7282 device name keyword for the desired output device must be supplied as\n\
7283 an argument. These keywords are the same as those printed out by\n\
7284 plstar. If the requested device is not available, or if the input\n\
7285 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7286 is used. This routine also divides the output device page into nx by\n\
7287 ny subpages, each of which may be used independently. The subroutine\n\
7288 pladv is used to advance from one subpage to the next.\n\
7290 Redacted form: General: plstart(devname, nx, ny)\n\
7293 This function is not used in any examples.\n\
7299plstart(devname, nx, ny)\n\
7303 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7304 containing the device name keyword of the required output device.\n\
7306 devname is NULL or if the first character of the string is a ``?\'\',\n\
7307 the normal (prompted) start up is used.\n\
7309 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7312 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7316Plot a glyph at the specified points\n\
7320 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7321 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7322 is specified with a PLplot user string. Note that the user string is\n\
7323 not actually limited to one glyph so it is possible (but not normally\n\
7324 useful) to plot more than one glyph at the specified points with this\n\
7325 function. As with plmtex and plptex, the user string can contain FCI\n\
7326 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7327 else PLplot escapes for Hershey or unicode text to determine the\n\
7330 Redacted form: plstring(x, y, string)\n\
7332 This function is used in examples 4, 21 and 26.\n\
7338plstring(n, x, y, string)\n\
7342 n (PLINT, input) : Number of points in the x and y vectors.\n\
7344 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7347 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7350 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7351 the glyph(s) to be plotted at each of the n points.\n\
7354Write text relative to viewport boundaries in 3D plots\n\
7358 Writes text at a specified position relative to the viewport\n\
7359 boundaries. Text may be written inside or outside the viewport, but\n\
7360 is clipped at the subpage boundaries. The reference point of a string\n\
7361 lies along a line passing through the string at half the height of a\n\
7362 capital letter. The position of the reference point along this line\n\
7363 is determined by just, and the position of the reference point\n\
7364 relative to the viewport is set by disp and pos.\n\
7366 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7368 This function is used in example 28.\n\
7374plmtex3(side, disp, pos, just, text)\n\
7378 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7379 the side of the viewport along which the text is to be written.\n\
7380 The string should contain one or more of the following characters:\n\
7381 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7382 only label the X axis, not both the X and Y axes. x: Label the X\n\
7384 y: Label the Y axis.\n\
7385 z: Label the Z axis.\n\
7386 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7387 For X it is the axis that starts at y-min. For Y it is the\n\
7388 axis that starts at x-min.\n\
7389 s: Label the secondary axis.\n\
7390 v: Draw the text perpendicular to the axis.\n\
7393 disp (PLFLT, input) : Position of the reference point of string,\n\
7394 measured outwards from the specified viewport edge in units of the\n\
7395 current character height. Use negative disp to write within the\n\
7398 pos (PLFLT, input) : Position of the reference point of string\n\
7399 along the specified edge, expressed as a fraction of the length of\n\
7402 just (PLFLT, input) : Specifies the position of the string relative\n\
7403 to its reference point. If just=0. , the reference point is at\n\
7404 the left and if just=1. , it is at the right of the string. Other\n\
7405 values of just give intermediate justifications.\n\
7407 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7411Get plot orientation\n\
7415 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7416 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7417 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7418 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7419 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7420 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7421 not been called the default value pointed to by p_rot will be 0.\n\
7423 Redacted form: plgdiori(p_rot)\n\
7425 This function is not used in any examples.\n\
7435 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7439Simple routine to write labels\n\
7443 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7445 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7447 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7453pllab(xlabel, ylabel, tlabel)\n\
7457 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7458 the label for the x axis.\n\
7460 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7461 the label for the y axis.\n\
7463 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7464 the title of the plot.\n\
7467Switch to text screen\n\
7471 Sets an interactive device to text mode, used in conjunction with\n\
7472 plgra to allow graphics and text to be interspersed. On a device\n\
7473 which supports separate text and graphics windows, this command causes\n\
7474 control to be switched to the text window. This can be useful for\n\
7475 printing diagnostic messages or getting user input, which would\n\
7476 otherwise interfere with the plots. The program must switch back to\n\
7477 the graphics window before issuing plot commands, as the text (or\n\
7478 console) device will probably become quite confused otherwise. If\n\
7479 already in text mode, this command is ignored. It is also ignored on\n\
7480 devices which only support a single window or use a different method\n\
7481 for shifting focus (see also plgra).\n\
7483 Redacted form: pltext()\n\
7485 This function is used in example 1.\n\
7494Plot all or a subset of Shapefile data using lines in world coordinates\n\
7498 Plot all or a subset of Shapefile data using lines in world\n\
7499 coordinates. Our 19th standard example demonstrates how to use this\n\
7500 function. This function plots data from a Shapefile using lines as in\n\
7501 plmap, however it also has the option of also only drawing specified\n\
7502 elements from the Shapefile. The vector of indices of the required\n\
7503 elements are passed as a function argument. The Shapefile data should\n\
7504 include a metadata file (extension.dbf) listing all items within the\n\
7505 Shapefile. This file can be opened by most popular spreadsheet\n\
7506 programs and can be used to decide which indices to pass to this\n\
7509 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7512 This function is used in example 19.\n\
7518plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7522 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7523 transform the coordinates given in the shapefile into a plot\n\
7524 coordinate system. By using this transform, we can change from a\n\
7525 longitude, latitude coordinate to a polar stereographic project,\n\
7526 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7527 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7528 mapform(), x[] and y[] should be replaced by the corresponding\n\
7529 plot coordinates. If no transform is desired, mapform can be\n\
7530 replaced by NULL.\n\
7532 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7533 the file name of a set of Shapefile files without the file\n\
7536 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7537 be in the same units as used by the Shapefile. You could use a\n\
7538 very large negative number to plot everything, but you can improve\n\
7539 performance by limiting the area drawn. The units must match those\n\
7540 of the Shapefile projection, which may be for example longitude or\n\
7541 distance. The value of minx must be less than the value of maxx.\n\
7543 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7544 use a very large number to plot everything, but you can improve\n\
7545 performance by limiting the area drawn.\n\
7547 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7548 be in the same units as used by the Shapefile. You could use a\n\
7549 very large negative number to plot everything, but you can improve\n\
7550 performance by limiting the area drawn. The units must match those\n\
7551 of the Shapefile projection, which may be for example latitude or\n\
7552 distance. The value of miny must be less than the value of maxy.\n\
7554 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7555 use a very large number to plot everything, but you can improve\n\
7556 performance by limiting the area drawn.\n\
7558 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7559 zero-based indices of the Shapefile elements which will be drawn.\n\
7561 plotentries to NULL will plot all elements of the Shapefile.\n\
7563 nplotentries (PLINT, input) : The number of items in\n\
7564 plotentries. Ignored if\n\
7565 plotentries is NULL.\n\
7568Set precision in numeric labels\n\
7572 Sets the number of places after the decimal point in numeric labels.\n\
7574 Redacted form: plprec(setp, prec)\n\
7576 This function is used in example 29.\n\
7582plprec(setp, prec)\n\
7586 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7587 automatically determines the number of places to use after the\n\
7588 decimal point in numeric labels (like those used to label axes).\n\
7589 If setp is 1 then prec sets the number of places.\n\
7591 prec (PLINT, input) : The number of characters to draw after the\n\
7592 decimal point in numeric labels.\n\
7595Draw a line between two points\n\
7599 Joins the point (\n\
7605 Redacted form: pljoin(x1,y1,x2,y2)\n\
7607 This function is used in examples 3 and 14.\n\
7613pljoin(x1, y1, x2, y2)\n\
7617 x1 (PLFLT, input) : x coordinate of first point.\n\
7619 y1 (PLFLT, input) : y coordinate of first point.\n\
7621 x2 (PLFLT, input) : x coordinate of second point.\n\
7623 y2 (PLFLT, input) : y coordinate of second point.\n\
7626Set the device (keyword) name\n\
7630 Set the device (keyword) name.\n\
7632 Redacted form: plsdev(devname)\n\
7634 This function is used in examples 1, 14, and 20.\n\
7644 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7645 containing the device name keyword of the required output device.\n\
7647 devname is NULL or if the first character of the string is a ``?\'\',\n\
7648 the normal (prompted) start up is used.\n\
7651Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7655 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7656 (see the PLplot documentation) index. Overwrites the previous color\n\
7657 value for the given index and, thus, does not result in any additional\n\
7658 allocation of space for colors.\n\
7660 This function is used in example 30.\n\
7666plscol0a(icol0, r, g, b, alpha)\n\
7670 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7671 number of colors (which is set by default, by plscmap0n, or even\n\
7674 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7675 degree of red in the color.\n\
7677 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7678 degree of green in the color.\n\
7680 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7681 degree of blue in the color.\n\
7683 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7687Draw filled polygon in 3D\n\
7691 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7692 vectors using the pattern defined by plpsty or plpat. The routine\n\
7693 will automatically close the polygon between the last and first\n\
7694 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7695 plfill3 will fill in between them.\n\
7697 Redacted form: General: plfill3(x, y, z)\n\
7700 This function is used in example 15.\n\
7706plfill3(n, x, y, z)\n\
7710 n (PLINT, input) : Number of vertices in polygon.\n\
7712 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7715 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7718 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7726 Specify the window, i.e., the world coordinates of the edges of the\n\
7729 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7731 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7738plwind(xmin, xmax, ymin, ymax)\n\
7742 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7745 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7748 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7751 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7755Draw text at points defined by Shapefile data in world coordinates\n\
7759 As per plmapline, however the items are plotted as text in the same\n\
7762 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7763 miny, maxy, plotentry)\n\
7765 This function is used in example 19.\n\
7771plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7775 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7776 transform the coordinates given in the shapefile into a plot\n\
7777 coordinate system. By using this transform, we can change from a\n\
7778 longitude, latitude coordinate to a polar stereographic project,\n\
7779 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7780 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7781 mapform(), x[] and y[] should be replaced by the corresponding\n\
7782 plot coordinates. If no transform is desired, mapform can be\n\
7783 replaced by NULL.\n\
7785 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7786 the file name of a set of Shapefile files without the file\n\
7789 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7792 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7795 just (PLFLT, input) : Set the justification of the text. The value\n\
7796 given will be the fraction of the distance along the string that\n\
7797 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7798 centralized text and 1.0 gives right aligned text.\n\
7800 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7802 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7803 be in the same units as used by the Shapefile. You could use a\n\
7804 very large negative number to plot everything, but you can improve\n\
7805 performance by limiting the area drawn. The units must match those\n\
7806 of the Shapefile projection, which may be for example longitude or\n\
7807 distance. The value of minx must be less than the value of maxx.\n\
7809 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7810 use a very large number to plot everything, but you can improve\n\
7811 performance by limiting the area drawn.\n\
7813 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7814 be in the same units as used by the Shapefile. You could use a\n\
7815 very large negative number to plot everything, but you can improve\n\
7816 performance by limiting the area drawn. The units must match those\n\
7817 of the Shapefile projection, which may be for example latitude or\n\
7818 distance. The value of miny must be less than the value of maxy.\n\
7820 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7821 use a very large number to plot everything, but you can improve\n\
7822 performance by limiting the area drawn.\n\
7824 plotentry (PLINT, input) : An integer indicating which text string\n\
7825 of the Shapefile (zero indexed) will be drawn.\n\
7828Switch to graphics screen\n\
7832 Sets an interactive device to graphics mode, used in conjunction with\n\
7833 pltext to allow graphics and text to be interspersed. On a device\n\
7834 which supports separate text and graphics windows, this command causes\n\
7835 control to be switched to the graphics window. If already in graphics\n\
7836 mode, this command is ignored. It is also ignored on devices which\n\
7837 only support a single window or use a different method for shifting\n\
7838 focus. See also pltext.\n\
7840 Redacted form: plgra()\n\
7842 This function is used in example 1.\n\
7851Set parameters of contour labelling other than format of numerical label\n\
7855 Set parameters of contour labelling other than those handled by\n\
7856 pl_setcontlabelformat.\n\
7858 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7860 This function is used in example 9.\n\
7866pl_setcontlabelparam(offset, size, spacing, active)\n\
7870 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7871 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7873 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7874 Default value is 0.3.\n\
7876 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7877 Default value is 0.1.\n\
7879 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7880 contour labels on. Default is off (0).\n\
7883Get family, style and weight of the current font\n\
7887 Gets information about current font. See the PLplot documentation for\n\
7888 more information on font selection.\n\
7890 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7892 This function is used in example 23.\n\
7898plgfont(p_family, p_style, p_weight)\n\
7902 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7903 font family. The available values are given by the PL_FCI_*\n\
7904 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7905 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7906 p_family is NULL then the font family is not returned.\n\
7908 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7909 font style. The available values are given by the PL_FCI_*\n\
7910 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7911 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7912 style is not returned.\n\
7914 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7915 font weight. The available values are given by the PL_FCI_*\n\
7916 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7917 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7921Plot a histogram from unbinned data\n\
7925 Plots a histogram from n data points stored in the data vector. This\n\
7926 routine bins the data into nbin bins equally spaced between datmin and\n\
7927 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7928 opt allows, among other things, the histogram either to be plotted in\n\
7929 an existing window or causes plhist to call plenv with suitable limits\n\
7930 before plotting the histogram.\n\
7932 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7934 This function is used in example 5.\n\
7940plhist(n, data, datmin, datmax, nbin, opt)\n\
7944 n (PLINT, input) : Number of data points.\n\
7946 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7949 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7951 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7953 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7954 divide the interval xmin to xmax.\n\
7956 opt (PLINT, input) : Is a combination of several flags:\n\
7957 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7958 the histogram data, the outer bins are expanded to fill up the\n\
7959 entire x-axis, data outside the given extremes are assigned to the\n\
7960 outer bins and bins of zero height are simply drawn.\n\
7961 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7962 to fit the histogram data, without this flag, plenv is called\n\
7963 to set the world coordinates.\n\
7964 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7965 extremes are not taken into account. This option should\n\
7966 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7967 properly present the data.\n\
7968 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7969 size as the ones inside.\n\
7970 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7971 (there is a gap for such bins).\n\
7974Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7978 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7979 alpha transparency value.\n\
7981 This function is used in example 31.\n\
7987plgcolbga(r, g, b, alpha)\n\
7991 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7992 in the range from 0 to 255.\n\
7994 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7995 in the range from 0 to 255.\n\
7997 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7998 in the range from 0 to 255.\n\
8000 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8001 transparency in the range (0.0-1.0).\n\
8008 Set integer plot orientation parameter. This function is identical to\n\
8009 plsdiori except for the type of the argument, and should be used in\n\
8010 the same way. See the documentation of plsdiori for details.\n\
8012 Redacted form: plsori(ori)\n\
8014 This function is used in example 3.\n\
8024 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8025 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8029Plot latitude and longitude lines\n\
8033 Displays latitude and longitude on the current plot. The lines are\n\
8034 plotted in the current color and line style.\n\
8036 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8039 This function is used in example 19.\n\
8045plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8049 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8050 transform the coordinate longitudes and latitudes to a plot\n\
8051 coordinate system. By using this transform, we can change from a\n\
8052 longitude, latitude coordinate to a polar stereographic project,\n\
8053 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8054 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8055 mapform(), x[] and y[] should be replaced by the corresponding\n\
8056 plot coordinates. If no transform is desired, mapform can be\n\
8057 replaced by NULL.\n\
8059 dlong (PLFLT, input) : The interval in degrees at which the\n\
8060 longitude lines are to be plotted.\n\
8062 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8063 lines are to be plotted.\n\
8065 minlong (PLFLT, input) : The value of the longitude on the left\n\
8066 side of the plot. The value of minlong must be less than the value\n\
8067 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8070 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8071 side of the plot.\n\
8073 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8074 background. One can always use -90.0 as the boundary outside the\n\
8075 plot window will be automatically eliminated. However, the\n\
8076 program will be faster if one can reduce the size of the\n\
8077 background plotted.\n\
8079 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8080 background. One can always use 90.0 as the boundary outside the\n\
8081 plot window will be automatically eliminated.\n\
8084Clear current (sub)page\n\
8088 Clears the current page, effectively erasing everything that have been\n\
8089 drawn. This command only works with interactive drivers; if the\n\
8090 driver does not support this, the page is filled with the background\n\
8091 color in use. If the current page is divided into subpages, only the\n\
8092 current subpage is erased. The nth subpage can be selected with\n\
8095 Redacted form: General: plclear()\n\
8098 This function is not used in any examples.\n\
8111 Initializing the plotting package. The program prompts for the device\n\
8112 keyword or number of the desired output device. Hitting a RETURN in\n\
8113 response to the prompt is the same as selecting the first device. If\n\
8114 only one device is enabled when PLplot is installed, plstar will issue\n\
8115 no prompt. The output device is divided into nx by ny subpages, each\n\
8116 of which may be used independently. The subroutine pladv is used to\n\
8117 advance from one subpage to the next.\n\
8119 Redacted form: plstar(nx, ny)\n\
8121 This function is used in example 1.\n\
8131 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8134 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8138Write text relative to viewport boundaries\n\
8142 Writes text at a specified position relative to the viewport\n\
8143 boundaries. Text may be written inside or outside the viewport, but\n\
8144 is clipped at the subpage boundaries. The reference point of a string\n\
8145 lies along a line passing through the string at half the height of a\n\
8146 capital letter. The position of the reference point along this line\n\
8147 is determined by just, and the position of the reference point\n\
8148 relative to the viewport is set by disp and pos.\n\
8150 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8153 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8160plmtex(side, disp, pos, just, text)\n\
8164 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8165 the side of the viewport along which the text is to be written.\n\
8166 The string must be one of: b: Bottom of viewport, text written\n\
8167 parallel to edge.\n\
8168 bv: Bottom of viewport, text written at right angles to edge.\n\
8169 l: Left of viewport, text written parallel to edge.\n\
8170 lv: Left of viewport, text written at right angles to edge.\n\
8171 r: Right of viewport, text written parallel to edge.\n\
8172 rv: Right of viewport, text written at right angles to edge.\n\
8173 t: Top of viewport, text written parallel to edge.\n\
8174 tv: Top of viewport, text written at right angles to edge.\n\
8177 disp (PLFLT, input) : Position of the reference point of string,\n\
8178 measured outwards from the specified viewport edge in units of the\n\
8179 current character height. Use negative disp to write within the\n\
8182 pos (PLFLT, input) : Position of the reference point of string\n\
8183 along the specified edge, expressed as a fraction of the length of\n\
8186 just (PLFLT, input) : Specifies the position of the string relative\n\
8187 to its reference point. If just=0. , the reference point is at\n\
8188 the left and if just=1. , it is at the right of the string. Other\n\
8189 values of just give intermediate justifications.\n\
8191 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8195Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8199 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8200 PLFLT alpha transparency value (see the PLplot documentation).\n\
8202 This function is used in example 31.\n\
8208plscolbga(r, g, b, alpha)\n\
8212 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8213 degree of red in the color.\n\
8215 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8216 degree of green in the color.\n\
8218 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8219 degree of blue in the color.\n\
8221 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8225Replays contents of plot buffer to current device/file\n\
8229 Replays contents of plot buffer to current device/file.\n\
8231 Redacted form: plreplot()\n\
8233 This function is used in example 1,20.\n\
8242Plot a glyph at the specified 3D points\n\
8246 Plot a glyph at the specified 3D points. (This function is largely\n\
8247 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8248 Set up the call to this function similar to what is done for plline3.\n\
8249 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8250 and a draw at the same place. Not ideal, since a sufficiently\n\
8251 intelligent output device may optimize it away, or there may be faster\n\
8252 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8253 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8254 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8255 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8256 code <= 127 the corresponding printable ASCII character is plotted.\n\
8258 Redacted form: plpoin3(x, y, z, code)\n\
8260 This function is not used in any example.\n\
8266plpoin3(n, x, y, z, code)\n\
8270 n (PLINT, input) : Number of points in the x and y vectors.\n\
8272 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8275 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8278 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8281 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8282 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8283 each of the n points.\n\
8286Set family, style and weight of the current font\n\
8290 Sets the current font. See the PLplot documentation for more\n\
8291 information on font selection.\n\
8293 Redacted form: plsfont(family, style, weight)\n\
8295 This function is used in example 23.\n\
8301plsfont(family, style, weight)\n\
8305 family (PLINT, input) : Font family to select for the current font.\n\
8306 The available values are given by the PL_FCI_* constants in\n\
8307 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8308 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8309 signifies that the font family should not be altered.\n\
8311 style (PLINT, input) : Font style to select for the current font.\n\
8312 The available values are given by the PL_FCI_* constants in\n\
8313 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8314 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8315 should not be altered.\n\
8317 weight (PLINT, input) : Font weight to select for the current font.\n\
8318 The available values are given by the PL_FCI_* constants in\n\
8319 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8320 negative value signifies that the font weight should not be\n\
8324Draw a box with axes, etc. with arbitrary origin\n\
8328 Draws a box around the currently defined viewport with arbitrary\n\
8329 world-coordinate origin specified by x0 and y0 and labels it with\n\
8330 world coordinate values appropriate to the window. Thus plaxes should\n\
8331 only be called after defining both viewport and window. The ascii\n\
8332 character strings xopt and yopt specify how the box should be drawn as\n\
8333 described below. If ticks and/or subticks are to be drawn for a\n\
8334 particular axis, the tick intervals and number of subintervals may be\n\
8335 specified explicitly, or they may be defaulted by setting the\n\
8336 appropriate arguments to zero.\n\
8338 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8342 This function is not used in any examples.\n\
8348plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8352 x0 (PLFLT, input) : World X coordinate of origin.\n\
8354 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8356 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8357 options for the x axis. The string can include any combination of\n\
8358 the following letters (upper or lower case) in any order: a: Draws\n\
8359 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8361 b: Draws bottom (X) or left (Y) edge of frame.\n\
8362 c: Draws top (X) or right (Y) edge of frame.\n\
8363 d: Plot labels as date / time. Values are assumed to be\n\
8364 seconds since the epoch (as used by gmtime).\n\
8365 f: Always use fixed point numeric labels.\n\
8366 g: Draws a grid at the major tick interval.\n\
8367 h: Draws a grid at the minor tick interval.\n\
8368 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8370 l: Labels axis logarithmically. This only affects the labels,\n\
8371 not the data, and so it is necessary to compute the logarithms\n\
8372 of data points before passing them to any of the drawing\n\
8374 m: Writes numeric labels at major tick intervals in the\n\
8375 unconventional location (above box for X, right of box for Y).\n\
8376 n: Writes numeric labels at major tick intervals in the\n\
8377 conventional location (below box for X, left of box for Y).\n\
8378 o: Use custom labelling function to generate axis label text.\n\
8379 The custom labelling function can be defined with the\n\
8380 plslabelfunc command.\n\
8381 s: Enables subticks between major ticks, only valid if t is\n\
8383 t: Draws major ticks.\n\
8384 u: Exactly like \"b\" except don\'t draw edge line.\n\
8385 w: Exactly like \"c\" except don\'t draw edge line.\n\
8386 x: Exactly like \"t\" (including the side effect of the\n\
8387 numerical labels for the major ticks) except exclude drawing\n\
8388 the major and minor tick marks.\n\
8391 xtick (PLFLT, input) : World coordinate interval between major\n\
8392 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8393 generates a suitable tick interval.\n\
8395 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8396 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8397 generates a suitable minor tick interval.\n\
8399 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8400 options for the y axis. The string can include any combination of\n\
8401 the letters defined above for xopt, and in addition may contain:\n\
8402 v: Write numeric labels for the y axis parallel to the base of the\n\
8403 graph, rather than parallel to the axis.\n\
8406 ytick (PLFLT, input) : World coordinate interval between major\n\
8407 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8408 generates a suitable tick interval.\n\
8410 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8411 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8412 generates a suitable minor tick interval.\n\
8419 Begins a new page. For a file driver, the output file is opened if\n\
8420 necessary. Advancing the page via pleop and plbop is useful when a\n\
8421 page break is desired at a particular point when plotting to subpages.\n\
8422 Another use for pleop and plbop is when plotting pages to different\n\
8423 files, since you can manually set the file name by calling plsfnam\n\
8424 after the call to pleop. (In fact some drivers may only support a\n\
8425 single page per file, making this a necessity.) One way to handle\n\
8426 this case automatically is to page advance via pladv, but enable\n\
8427 familying (see plsfam) with a small limit on the file size so that a\n\
8428 new family member file will be created on each page break.\n\
8430 Redacted form: plbop()\n\
8432 This function is used in examples 2 and 20.\n\
8441Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8445 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8446 and PLFLT alpha transparency value. This sets the entire color map --\n\
8447 only as many colors as specified will be allocated.\n\
8449 Redacted form: plscmap0a(r, g, b, alpha)\n\
8451 This function is used in examples 30.\n\
8457plscmap0a(r, g, b, alpha, ncol0)\n\
8461 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8462 integers (0-255) representing the degree of red in the color.\n\
8464 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8465 integers (0-255) representing the degree of green in the color.\n\
8467 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8468 integers (0-255) representing the degree of blue in the color.\n\
8470 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8471 representing the alpha transparency of the color.\n\
8473 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8477Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8481 This is a variant of plscmap1l that supports alpha channel\n\
8482 transparency. It sets cmap1 colors using a piece-wise linear\n\
8483 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8484 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8485 transparency value (0.0-1.0). It may be called at any time.\n\
8487 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8488 alpha, alt_hue_path)\n\
8490 This function is used in example 30.\n\
8496plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8500 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8502 npts (PLINT, input) : number of control points.\n\
8504 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8505 intensity index (0.0-1.0) in ascending order for each control\n\
8508 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8509 coordinate (H or R) for each control point.\n\
8511 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8512 coordinate (L or G) for each control point.\n\
8514 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8515 coordinate (S or B) for each control point.\n\
8517 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8518 transparency value (0.0-1.0) for each control point.\n\
8520 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8521 npts - 1 elements) containing the alternative interpolation method\n\
8522 Boolean value for each control point interval. (alt_hue_path[i]\n\
8523 refers to the interpolation interval between the i and i + 1\n\
8527Enter or leave xor mode\n\
8531 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8532 those drivers (e.g., the xwin driver) that support it. Enables\n\
8533 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8534 is not capable of xor operation it returns a status of false.\n\
8536 Redacted form: plxormod(mode, status)\n\
8538 This function is used in examples 1 and 20.\n\
8544plxormod(mode, status)\n\
8548 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8549 is false means leave xor mode.\n\
8551 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8552 modestatus of true (false) means driver is capable (incapable) of\n\
8556Eject current page\n\
8560 Clears the graphics screen of an interactive device, or ejects a page\n\
8561 on a plotter. See plbop for more information.\n\
8563 Redacted form: pleop()\n\
8565 This function is used in example 2,14.\n\
8574Draw a box with axes, etc\n\
8578 Draws a box around the currently defined viewport, and labels it with\n\
8579 world coordinate values appropriate to the window. Thus plbox should\n\
8580 only be called after defining both viewport and window. The ascii\n\
8581 character strings xopt and yopt specify how the box should be drawn as\n\
8582 described below. If ticks and/or subticks are to be drawn for a\n\
8583 particular axis, the tick intervals and number of subintervals may be\n\
8584 specified explicitly, or they may be defaulted by setting the\n\
8585 appropriate arguments to zero.\n\
8587 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8590 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8597plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8601 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8602 options for the x axis. The string can include any combination of\n\
8603 the following letters (upper or lower case) in any order: a: Draws\n\
8604 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8606 b: Draws bottom (X) or left (Y) edge of frame.\n\
8607 c: Draws top (X) or right (Y) edge of frame.\n\
8608 d: Plot labels as date / time. Values are assumed to be\n\
8609 seconds since the epoch (as used by gmtime).\n\
8610 f: Always use fixed point numeric labels.\n\
8611 g: Draws a grid at the major tick interval.\n\
8612 h: Draws a grid at the minor tick interval.\n\
8613 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8615 l: Labels axis logarithmically. This only affects the labels,\n\
8616 not the data, and so it is necessary to compute the logarithms\n\
8617 of data points before passing them to any of the drawing\n\
8619 m: Writes numeric labels at major tick intervals in the\n\
8620 unconventional location (above box for X, right of box for Y).\n\
8621 n: Writes numeric labels at major tick intervals in the\n\
8622 conventional location (below box for X, left of box for Y).\n\
8623 o: Use custom labelling function to generate axis label text.\n\
8624 The custom labelling function can be defined with the\n\
8625 plslabelfunc command.\n\
8626 s: Enables subticks between major ticks, only valid if t is\n\
8628 t: Draws major ticks.\n\
8629 u: Exactly like \"b\" except don\'t draw edge line.\n\
8630 w: Exactly like \"c\" except don\'t draw edge line.\n\
8631 x: Exactly like \"t\" (including the side effect of the\n\
8632 numerical labels for the major ticks) except exclude drawing\n\
8633 the major and minor tick marks.\n\
8636 xtick (PLFLT, input) : World coordinate interval between major\n\
8637 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8638 generates a suitable tick interval.\n\
8640 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8641 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8642 generates a suitable minor tick interval.\n\
8644 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8645 options for the y axis. The string can include any combination of\n\
8646 the letters defined above for xopt, and in addition may contain:\n\
8647 v: Write numeric labels for the y axis parallel to the base of the\n\
8648 graph, rather than parallel to the axis.\n\
8651 ytick (PLFLT, input) : World coordinate interval between major\n\
8652 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8653 generates a suitable tick interval.\n\
8655 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8656 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8657 generates a suitable minor tick interval.\n\
8660Get x axis parameters\n\
8664 Returns current values of the p_digmax and p_digits flags for the x\n\
8665 axis. p_digits is updated after the plot is drawn, so this routine\n\
8666 should only be called after the call to plbox (or plbox3) is complete.\n\
8667 See the PLplot documentation for more information.\n\
8669 Redacted form: plgxax(p_digmax, p_digits)\n\
8671 This function is used in example 31.\n\
8677plgxax(p_digmax, p_digits)\n\
8681 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8682 number of digits for the x axis. If nonzero, the printed label\n\
8683 has been switched to a floating-point representation when the\n\
8684 number of digits exceeds this value.\n\
8686 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8687 number of digits for the numeric labels (x axis) from the last\n\
8695 Sets the font used for subsequent text and symbols. For devices that\n\
8696 still use Hershey fonts this routine has no effect unless the Hershey\n\
8697 fonts with extended character set are loaded (see plfontld). For\n\
8698 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8699 this routine calls the plsfci routine with argument set up\n\
8700 appropriately for the various cases below. However, this method of\n\
8701 specifying the font for unicode-aware devices is deprecated, and the\n\
8702 much more flexible method of calling plsfont directly is recommended\n\
8703 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8705 Redacted form: plfont(ifont)\n\
8707 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8717 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8718 (simplest and fastest)\n\
8724Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8728 Routine for creating a discrete plot legend with a plotted filled box,\n\
8729 line, and/or line of symbols for each annotated legend entry. (See\n\
8730 plcolorbar for similar functionality for creating continuous color\n\
8731 bars.) The arguments of pllegend provide control over the location\n\
8732 and size of the legend as well as the location and characteristics of\n\
8733 the elements (most of which are optional) within that legend. The\n\
8734 resulting legend is clipped at the boundaries of the current subpage.\n\
8735 (N.B. the adopted coordinate system used for some of the parameters is\n\
8736 defined in the documentation of the position parameter.)\n\
8738 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8739 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8740 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8741 test_justification, text_colors, text, box_colors, box_patterns,\n\
8742 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8743 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8745 This function is used in examples 4, 26, and 33.\n\
8751pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8755 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8756 legend width in adopted coordinates. This quantity is calculated\n\
8757 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8758 the routine depending on nlegend and nrow), and the length\n\
8759 (calculated internally) of the longest text string.\n\
8761 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8762 legend height in adopted coordinates. This quantity is calculated\n\
8763 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8764 the routine depending on nlegend and nrow).\n\
8766 opt (PLINT, input) : opt contains bits controlling the overall\n\
8767 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8768 on the left of the legend and the plotted area on the right.\n\
8769 Otherwise, put the text area on the right of the legend and the\n\
8770 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8771 plot a (semitransparent) background for the legend. If the\n\
8772 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8773 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8774 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8775 plot the resulting array of legend entries in row-major order.\n\
8776 Otherwise, plot the legend entries in column-major order.\n\
8778 position (PLINT, input) : position contains bits which control the\n\
8779 overall position of the legend and the definition of the adopted\n\
8780 coordinates used for positions just like what is done for the\n\
8781 position argument for plcolorbar. However, note that the defaults\n\
8782 for the position bits (see below) are different than the\n\
8783 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8784 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8785 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8786 the 16 possible standard positions (the 4 corners and centers of\n\
8787 the 4 sides for both the inside and outside cases) of the legend\n\
8788 relative to the adopted coordinate system. The corner positions\n\
8789 are specified by the appropriate combination of two of the\n\
8790 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8791 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8792 value of one of those bits. The adopted coordinates are\n\
8793 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8794 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8795 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8796 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8797 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8798 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8799 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8800 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8802 x (PLFLT, input) : X offset of the legend position in adopted\n\
8803 coordinates from the specified standard position of the legend.\n\
8804 For positive x, the direction of motion away from the standard\n\
8805 position is inward/outward from the standard corner positions or\n\
8806 standard left or right positions if the\n\
8807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8808 For the standard top or bottom positions, the direction of motion\n\
8809 is toward positive X.\n\
8811 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8812 coordinates from the specified standard position of the legend.\n\
8813 For positive y, the direction of motion away from the standard\n\
8814 position is inward/outward from the standard corner positions or\n\
8815 standard top or bottom positions if the\n\
8816 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8817 the standard left or right positions, the direction of motion is\n\
8818 toward positive Y.\n\
8820 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8821 of the plot area (where the colored boxes, lines, and/or lines of\n\
8822 symbols are drawn) of the legend.\n\
8824 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8825 legend (PL_LEGEND_BACKGROUND).\n\
8827 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8828 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8830 bb_style (PLINT, input) : The pllsty style number for the\n\
8831 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8833 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8835 nlegend legend entries. For internal transformations of\n\
8836 nrow, see further remarks under\n\
8839 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8841 nlegend legend entries. For internal transformations of\n\
8842 ncolumn, see further remarks under\n\
8845 nlegend (PLINT, input) : Number of legend entries. The above\n\
8847 ncolumn values are transformed internally to be consistent with\n\
8848 nlegend. If either\n\
8850 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8853 ncolumn is less than\n\
8854 nlegend, the smaller of the two (or\n\
8857 ncolumn) is increased so the product is >=\n\
8858 nlegend. Thus, for example, the common\n\
8860 ncolumn = 0 case is transformed internally to\n\
8863 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8866 opt_array (PLINT_VECTOR, input) : A vector of\n\
8867 nlegend values of options to control each individual plotted area\n\
8868 corresponding to a legend entry. If the\n\
8869 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8871 PL_LEGEND_COLOR_BOX,\n\
8872 PL_LEGEND_LINE, and/or\n\
8873 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8874 entry is plotted with a colored box; a line; and/or a line of\n\
8877 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8878 area in units of character width.\n\
8880 text_scale (PLFLT, input) : Character height scale for text\n\
8883 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8884 character height from one legend entry to the next.\n\
8886 text_justification (PLFLT, input) : Justification parameter used\n\
8887 for text justification. The most common values of\n\
8888 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8889 is left justified, centred, or right justified within the text\n\
8890 area, but other values are allowed as well.\n\
8892 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8893 nlegend cmap0 text colors.\n\
8895 text (PLCHAR_MATRIX, input) : A vector of\n\
8896 nlegend UTF-8 character strings containing the legend annotations.\n\
8898 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8899 nlegend cmap0 colors for the discrete colored boxes (\n\
8900 PL_LEGEND_COLOR_BOX).\n\
8902 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8903 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8904 PL_LEGEND_COLOR_BOX).\n\
8906 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8907 nlegend scales (units of fraction of character height) for the height\n\
8908 of the discrete colored boxes (\n\
8909 PL_LEGEND_COLOR_BOX).\n\
8911 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8912 nlegend line widths for the patterns specified by box_patterns (\n\
8913 PL_LEGEND_COLOR_BOX).\n\
8915 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8916 nlegend cmap0 line colors (\n\
8919 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8920 nlegend line styles (plsty indices) (\n\
8923 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8924 nlegend line widths (\n\
8927 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8928 nlegend cmap0 symbol colors (\n\
8929 PL_LEGEND_SYMBOL).\n\
8931 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8932 nlegend scale values for the symbol height (\n\
8933 PL_LEGEND_SYMBOL).\n\
8935 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8936 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8938 PL_LEGEND_SYMBOL).\n\
8940 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8941 nlegend UTF-8 character strings containing the legend symbols. (\n\
8942 PL_LEGEND_SYMBOL).\n\
8945Set the background color by 8-bit RGB value\n\
8949 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8950 the PLplot documentation).\n\
8952 Redacted form: plscolbg(r, g, b)\n\
8954 This function is used in examples 15 and 31.\n\
8964 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8965 degree of red in the color.\n\
8967 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8968 degree of green in the color.\n\
8970 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8971 degree of blue in the color.\n\
8974Set parameters that define current device-space window\n\
8978 Set relative margin width, aspect ratio, and relative justification\n\
8979 that define current device-space window. If you want to just use the\n\
8980 previous value for any of these, just pass in the magic value\n\
8981 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8982 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8983 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8984 to a device-specific value.\n\
8986 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8988 This function is used in example 31.\n\
8994plsdidev(mar, aspect, jx, jy)\n\
8998 mar (PLFLT, input) : Relative margin width.\n\
9000 aspect (PLFLT, input) : Aspect ratio.\n\
9002 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9003 the range -0.5 to 0.5.\n\
9005 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9006 the range -0.5 to 0.5.\n\
9009Specify viewport using aspect ratio only\n\
9013 Selects the largest viewport with the given aspect ratio within the\n\
9014 subpage that leaves a standard margin (left-hand margin of eight\n\
9015 character heights, and a margin around the other three sides of five\n\
9016 character heights).\n\
9018 Redacted form: plvasp(aspect)\n\
9020 This function is used in example 13.\n\
9030 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9031 axis of resulting viewport.\n\
9034Configure the transformations required for projecting a 3D surface on a 2D window\n\
9038 Configure the transformations required for projecting a 3D surface on\n\
9039 an existing 2D window. Those transformations (see the PLplot\n\
9040 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9041 surface which has its limits expressed in 3D world coordinates and\n\
9042 also normalized 3D coordinates (used for interpreting the altitude and\n\
9043 azimuth of the viewing angle). The transformations consist of the\n\
9044 linear transform from 3D world coordinates to normalized 3D\n\
9045 coordinates, and the 3D rotation of normalized coordinates required to\n\
9046 align the pole of the new 3D coordinate system with the viewing\n\
9047 direction specified by altitude and azimuth so that x and y of the\n\
9048 surface elements in that transformed coordinate system are the\n\
9049 projection of the 3D surface with given viewing direction on the 2D\n\
9052 The enclosing rectangular cuboid for the surface plot is defined by\n\
9053 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9054 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9055 sizes of basex by basey by height so that xmin maps to -\n\
9056 basex/2, xmax maps to basex/2, ymin maps to -\n\
9057 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9058 The resulting rectangular cuboid in normalized coordinates is then\n\
9059 viewed by an observer at altitude alt and azimuth az. This routine\n\
9060 must be called before plbox3 or any of the 3D surface plotting\n\
9061 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9062 plsurf3dl or plfill3.\n\
9064 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9065 zmin, zmax, alt, az)\n\
9067 This function is examples 8, 11, 18, and 21.\n\
9073plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9077 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9078 rectangular cuboid.\n\
9080 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9081 rectangular cuboid.\n\
9083 height (PLFLT, input) : The normalized z coordinate size of the\n\
9084 rectangular cuboid.\n\
9086 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9087 rectangular cuboid.\n\
9089 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9090 rectangular cuboid.\n\
9092 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9093 rectangular cuboid.\n\
9095 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9096 rectangular cuboid.\n\
9098 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9099 rectangular cuboid.\n\
9101 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9102 rectangular cuboid.\n\
9104 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9105 plane of the rectangular cuboid in normalized coordinates.\n\
9107 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9108 rectangular cuboid in normalized coordinates. When az=0, the\n\
9109 observer is looking face onto the zx plane of the rectangular\n\
9110 cuboid in normalized coordinates, and as az is increased, the\n\
9111 observer moves clockwise around that cuboid when viewed from above\n\
9115Wait for graphics input event and translate to world coordinates.\n\
9119 Wait for graphics input event and translate to world coordinates.\n\
9120 Returns 0 if no translation to world coordinates is possible.\n\
9122 This function returns 1 on success and 0 if no translation to world\n\
9123 coordinates is possible.\n\
9125 Redacted form: plGetCursor(gin)\n\
9127 This function is used in examples 1 and 20.\n\
9133PLINT plGetCursor(gin)\n\
9137 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9138 which will contain the output. The structure is not allocated by\n\
9139 the routine and must exist before the function is called.\n\
9142Set number of colors in cmap0\n\
9146 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9147 (or reallocate) cmap0, and fill with default values for those colors\n\
9148 not previously allocated. The first 16 default colors are given in\n\
9149 the plcol0 documentation. For larger indices the default color is\n\
9152 The drivers are not guaranteed to support more than 16 colors.\n\
9154 Redacted form: plscmap0n(ncol0)\n\
9156 This function is used in examples 15, 16, and 24.\n\
9166 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9167 the cmap0 palette. If this number is zero or less, then the value\n\
9168 from the previous call to plscmap0n is used and if there is no\n\
9169 previous call, then a default value is used.\n\
9172Set z axis parameters\n\
9176 Identical to plsxax, except that arguments are flags for z axis. See\n\
9177 the description of plsxax for more detail.\n\
9179 Redacted form: plszax(digmax, digits)\n\
9181 This function is used in example 31.\n\
9187plszax(digmax, digits)\n\
9191 digmax (PLINT, input) : Variable to set the maximum number of\n\
9192 digits for the z axis. If nonzero, the printed label will be\n\
9193 switched to a floating-point representation when the number of\n\
9194 digits exceeds digmax.\n\
9196 digits (PLINT, input) : Field digits value. Currently, changing\n\
9197 its value here has no effect since it is set only by plbox or\n\
9198 plbox3. However, the user may obtain its value after a call to\n\
9199 either of these functions by calling plgzax.\n\
9202Get FCI (font characterization integer)\n\
9206 Gets information about the current font using the FCI approach. See\n\
9207 the PLplot documentation for more information.\n\
9209 Redacted form: plgfci(p_fci)\n\
9211 This function is used in example 23.\n\
9221 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9225Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9229 Sets up plotter environment for simple graphs by calling pladv and\n\
9230 setting up viewport and window to sensible default values. plenv0\n\
9231 leaves a standard margin (left-hand margin of eight character heights,\n\
9232 and a margin around the other three sides of five character heights)\n\
9233 around most graphs for axis labels and a title. When these defaults\n\
9234 are not suitable, use the individual routines plvpas, plvpor, or\n\
9235 plvasp for setting up the viewport, plwind for defining the window,\n\
9236 and plbox for drawing the box.\n\
9238 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9240 This function is used in example 21.\n\
9246plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9250 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9251 world coordinates).\n\
9253 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9254 world coordinates).\n\
9256 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9259 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9262 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9263 scales will not be set, the user must set up the scale before\n\
9264 calling plenv0 using plsvpa, plvasp or other.\n\
9265 0: the x and y axes are scaled independently to use as much of\n\
9266 the screen as possible.\n\
9267 1: the scales of the x and y axes are made equal.\n\
9268 2: the axis of the x and y axes are made equal, and the plot\n\
9269 box will be square.\n\
9272 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9273 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9274 -1: draw box only.\n\
9275 0: draw box, ticks, and numeric tick labels.\n\
9276 1: also draw coordinate axes at x=0 and y=0.\n\
9277 2: also draw a grid at major tick positions in both\n\
9279 3: also draw a grid at minor tick positions in both\n\
9281 10: same as 0 except logarithmic x tick marks. (The x data\n\
9282 have to be converted to logarithms separately.)\n\
9283 11: same as 1 except logarithmic x tick marks. (The x data\n\
9284 have to be converted to logarithms separately.)\n\
9285 12: same as 2 except logarithmic x tick marks. (The x data\n\
9286 have to be converted to logarithms separately.)\n\
9287 13: same as 3 except logarithmic x tick marks. (The x data\n\
9288 have to be converted to logarithms separately.)\n\
9289 20: same as 0 except logarithmic y tick marks. (The y data\n\
9290 have to be converted to logarithms separately.)\n\
9291 21: same as 1 except logarithmic y tick marks. (The y data\n\
9292 have to be converted to logarithms separately.)\n\
9293 22: same as 2 except logarithmic y tick marks. (The y data\n\
9294 have to be converted to logarithms separately.)\n\
9295 23: same as 3 except logarithmic y tick marks. (The y data\n\
9296 have to be converted to logarithms separately.)\n\
9297 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9298 and y data have to be converted to logarithms separately.)\n\
9299 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9300 and y data have to be converted to logarithms separately.)\n\
9301 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9302 and y data have to be converted to logarithms separately.)\n\
9303 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9304 and y data have to be converted to logarithms separately.)\n\
9305 40: same as 0 except date / time x labels.\n\
9306 41: same as 1 except date / time x labels.\n\
9307 42: same as 2 except date / time x labels.\n\
9308 43: same as 3 except date / time x labels.\n\
9309 50: same as 0 except date / time y labels.\n\
9310 51: same as 1 except date / time y labels.\n\
9311 52: same as 2 except date / time y labels.\n\
9312 53: same as 3 except date / time y labels.\n\
9313 60: same as 0 except date / time x and y labels.\n\
9314 61: same as 1 except date / time x and y labels.\n\
9315 62: same as 2 except date / time x and y labels.\n\
9316 63: same as 3 except date / time x and y labels.\n\
9317 70: same as 0 except custom x and y labels.\n\
9318 71: same as 1 except custom x and y labels.\n\
9319 72: same as 2 except custom x and y labels.\n\
9320 73: same as 3 except custom x and y labels.\n\
9327 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9328 plsym. The actual height of a symbol is the product of the default\n\
9329 symbol size and a scaling factor as for the character height.\n\
9331 Redacted form: plssym(def, scale)\n\
9333 This function is used in example 29.\n\
9339plssym(def, scale)\n\
9343 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9344 should be set to zero if the default height is to remain\n\
9347 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9348 actual symbol height.\n\
9351Set plot orientation\n\
9355 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9356 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9357 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9358 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9359 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9360 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9361 not called the default value of rot is 0.\n\
9363 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9364 probably want to change the aspect ratio to a value suitable for the\n\
9365 plot orientation using a call to plsdidev or the command-line options\n\
9366 -a or -freeaspect. For more documentation of those options see the\n\
9367 PLplot documentation. Such command-line options can be set internally\n\
9368 using plsetopt or set directly using the command line and parsed using\n\
9369 a call to plparseopts.\n\
9371 Redacted form: plsdiori(rot)\n\
9373 This function is not used in any examples.\n\
9383 rot (PLFLT, input) : Plot orientation parameter.\n\
9386Advance the (sub-)page\n\
9390 Advances to the next subpage if sub=0, performing a page advance if\n\
9391 there are no remaining subpages on the current page. If subpages\n\
9392 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9393 PLplot switches to the specified subpage. Note that this allows you\n\
9394 to overwrite a plot on the specified subpage; if this is not what you\n\
9395 intended, use pleop followed by plbop to first advance the page. This\n\
9396 routine is called automatically (with page=0) by plenv, but if plenv\n\
9397 is not used, pladv must be called after initializing PLplot but before\n\
9398 defining the viewport.\n\
9400 Redacted form: pladv(page)\n\
9402 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9413 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9414 in the top left corner and increasing along the rows) to which to\n\
9415 advance. Set to zero to advance to the next subpage (or to the\n\
9416 next page if subpages are not being used).\n\
9419Set cmap0 colors by 8-bit RGB values\n\
9423 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9424 documentation). This sets the entire color map -- only as many colors\n\
9425 as specified will be allocated.\n\
9427 Redacted form: plscmap0(r, g, b)\n\
9429 This function is used in examples 2 and 24.\n\
9435plscmap0(r, g, b, ncol0)\n\
9439 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9440 integers (0-255) representing the degree of red in the color.\n\
9442 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9443 integers (0-255) representing the degree of green in the color.\n\
9445 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9446 integers (0-255) representing the degree of blue in the color.\n\
9448 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9451Get character default height and current (scaled) height\n\
9455 Get character default height and current (scaled) height.\n\
9457 Redacted form: plgchr(p_def, p_ht)\n\
9459 This function is used in example 23.\n\
9465plgchr(p_def, p_ht)\n\
9469 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9470 character height (mm).\n\
9472 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9473 character height (mm).\n\
9476Set opaque RGB cmap1 colors values\n\
9480 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9481 vector values. This function also sets the number of cmap1 colors.\n\
9482 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9483 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9484 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9486 ncol1-1. So in order for this continuous color model to work\n\
9487 properly, it is the responsibility of the user of plscmap1 to insure\n\
9488 that these RGB vectors are continuous functions of their integer\n\
9491 Redacted form: plscmap1(r, g, b)\n\
9493 This function is used in example 31.\n\
9499plscmap1(r, g, b, ncol1)\n\
9503 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9504 8-bit integers in the range from 0-255) the degree of red in the\n\
9505 color as a continuous function of the integer index of the vector.\n\
9507 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9508 8-bit integers in the range from 0-255) the degree of green in the\n\
9509 color as a continuous function of the integer index of the vector.\n\
9511 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9512 8-bit integers in the range from 0-255) the degree of blue in the\n\
9513 color as a continuous function of the integer index of the vector.\n\
9515 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9518Set any command-line option\n\
9522 Set any command-line option internally from a program before it\n\
9523 invokes plinit. opt is the name of the command-line option and optarg\n\
9524 is the corresponding command-line option argument.\n\
9526 This function returns 0 on success.\n\
9528 Redacted form: plsetopt(opt, optarg)\n\
9530 This function is used in example 14.\n\
9536PLINT plsetopt(opt, optarg)\n\
9540 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9541 the command-line option.\n\
9543 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9544 containing the argument of the command-line option.\n\
9547Draw linear gradient inside polygon\n\
9551 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9554 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9555 polygon coordinates and the gradient angle are all expressed in world\n\
9556 coordinates. The angle from the x axis for both the rotated\n\
9557 coordinate system and the gradient vector is specified by angle. The\n\
9558 magnitude of the gradient vector is the difference between the maximum\n\
9559 and minimum values of x for the vertices in the rotated coordinate\n\
9560 system. The origin of the gradient vector can be interpreted as being\n\
9561 anywhere on the line corresponding to the minimum x value for the\n\
9562 vertices in the rotated coordinate system. The distance along the\n\
9563 gradient vector is linearly transformed to the independent variable of\n\
9564 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9565 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9566 color corresponding to the independent variable of cmap1. For more\n\
9567 information about cmap1 (see the PLplot documentation).\n\
9569 Redacted form: plgradient(x,y,angle)\n\
9571 This function is used in examples 25 and 30.\n\
9577plgradient(n, x, y, angle)\n\
9581 n (PLINT, input) : Number of vertices in polygon.\n\
9583 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9586 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9589 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9593Set length of major ticks\n\
9597 This sets up the length of the major ticks. The actual length is the\n\
9598 product of the default length and a scaling factor as for character\n\
9601 Redacted form: plsmaj(def, scale)\n\
9603 This function is used in example 29.\n\
9609plsmaj(def, scale)\n\
9613 def (PLFLT, input) : The default length of a major tick in\n\
9614 millimeters, should be set to zero if the default length is to\n\
9615 remain unchanged.\n\
9617 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9618 actual tick length.\n\
9621Set a global coordinate transform function\n\
9625 This function can be used to define a coordinate transformation which\n\
9626 affects all elements drawn within the current plot window. The\n\
9627 coordinate_transform callback function is similar to that provided for\n\
9628 the plmap and plmeridians functions. The coordinate_transform_data\n\
9629 parameter may be used to pass extra data to coordinate_transform.\n\
9631 Redacted form: General: plstransform(coordinate_transform,\n\
9632 coordinate_transform_data)\n\
9635 This function is used in examples 19 and 22.\n\
9641plstransform(coordinate_transform, coordinate_transform_data)\n\
9645 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9646 function that defines the transformation from the input (x, y)\n\
9647 world coordinates to new PLplot world coordinates. If\n\
9648 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9649 case), then no transform is applied.\n\
9651 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9653 coordinate_transform.\n\
9656Configure the transformation between continuous and broken-down time for the current stream\n\
9660 Configure the transformation between continuous and broken-down time\n\
9661 for the current stream. This transformation is used by both plbtime\n\
9664 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9665 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9668 This function is used in example 29.\n\
9674plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9678 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9679 As a special case, if\n\
9680 scale is 0., then all other arguments are ignored, and the result (the\n\
9681 default used by PLplot) is the equivalent of a call to\n\
9682 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9683 That is, for this special case broken-down time is calculated with\n\
9684 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9685 and the continuous time is defined as the number of seconds since\n\
9686 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9688 offset1 (PLFLT, input) : If\n\
9689 ifbtime_offset is true, the parameters\n\
9691 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9692 (with units in days) specify the epoch of the continuous time\n\
9693 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9694 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9695 are used to specify the origin to allow users (by specifying\n\
9696 offset1 as an integer that can be exactly represented by a\n\
9697 floating-point variable and specifying\n\
9698 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9699 the numerical errors of the continuous time representation.\n\
9701 offset2 (PLFLT, input) : See documentation of\n\
9704 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9705 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9706 calendar is used for broken-down time rather than the proleptic\n\
9707 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9708 have been historically used to define UTC are inserted into the\n\
9709 broken-down time. Other possibilities for additional control bits\n\
9710 for ccontrol exist such as making the historical time corrections\n\
9711 in the broken-down time corresponding to ET (ephemeris time) or\n\
9712 making the (slightly non-constant) corrections from international\n\
9713 atomic time (TAI) to what astronomers define as terrestrial time\n\
9714 (TT). But those additional possibilities have not been\n\
9715 implemented yet in the qsastime library (one of the PLplot utility\n\
9718 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9719 epoch of the continuous time scale is specified by the user. If\n\
9720 ifbtime_offset is false, then\n\
9722 offset2 are used to specify the epoch, and the following broken-down\n\
9723 time parameters are completely ignored. If\n\
9724 ifbtime_offset is true, then\n\
9726 offset2 are completely ignored, and the following broken-down time\n\
9727 parameters are used to specify the epoch.\n\
9729 year (PLINT, input) : Year of epoch.\n\
9731 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9734 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9736 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9738 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9740 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9743Flushes the output stream\n\
9747 Flushes the output stream. Use sparingly, if at all.\n\
9749 Redacted form: plflush()\n\
9751 This function is used in examples 1 and 14.\n\
9760Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9764 This variant of plsurf3d (see that function\'s documentation for more\n\
9765 details) should be suitable for the case where the area of the x, y\n\
9766 coordinate grid where z is defined can be non-rectangular. The limits\n\
9767 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9768 indexymin, and indexymax.\n\
9770 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9773 This function is used in example 8.\n\
9779plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9783 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9784 which the function is evaluated.\n\
9786 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9787 which the function is evaluated.\n\
9789 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9790 plot. Should have dimensions of\n\
9794 nx (PLINT, input) : Number of x values at which function is\n\
9797 ny (PLINT, input) : Number of y values at which function is\n\
9800 opt (PLINT, input) : Determines the way in which the surface is\n\
9801 represented. To specify more than one option just add the options,\n\
9802 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9803 connecting points at which function is defined.\n\
9804 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9808 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9812 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9813 the borders of the plotted function.\n\
9814 opt=MAG_COLOR : the surface is colored according to the value\n\
9815 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9816 according to the intensity of the reflected light in the\n\
9817 surface from a light source whose position is set using\n\
9821 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9824 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9826 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9827 corresponds to the first x index where z is defined.\n\
9829 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9830 which corresponds (by convention) to one more than the last x\n\
9831 index value where z is defined.\n\
9833 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9834 values which all must be ≥ 0. These values are the first y index\n\
9835 where z is defined for a particular x index in the range from\n\
9836 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9839 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9840 values which all must be ≤ ny. These values correspond (by\n\
9841 convention) to one more than the last y index where z is defined\n\
9842 for a particular x index in the range from indexxmin to indexxmax\n\
9843 - 1. The dimension of indexymax is indexxmax.\n\
9846Set semitransparent cmap1 RGBA colors.\n\
9850 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9851 RGBA vector values. This function also sets the number of cmap1\n\
9852 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9853 floating-point index in the range from 0.0-1.0 which is linearly\n\
9854 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9855 vectors in the range from 0 to\n\
9856 ncol1-1. So in order for this continuous color model to work\n\
9857 properly, it is the responsibility of the user of plscmap1 to insure\n\
9858 that these RGBA vectors are continuous functions of their integer\n\
9861 Redacted form: plscmap1a(r, g, b, alpha)\n\
9863 This function is used in example 31.\n\
9869plscmap1a(r, g, b, alpha, ncol1)\n\
9873 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9874 8-bit integers in the range from 0-255) the degree of red in the\n\
9875 color as a continuous function of the integer index of the vector.\n\
9877 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9878 8-bit integers in the range from 0-255) the degree of green in the\n\
9879 color as a continuous function of the integer index of the vector.\n\
9881 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9882 8-bit integers in the range from 0-255) the degree of blue in the\n\
9883 color as a continuous function of the integer index of the vector.\n\
9885 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9886 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9887 completely transparent and 1.0 corresponds to completely opaque)\n\
9888 the alpha transparency of the color as a continuous function of\n\
9889 the integer index of the vector.\n\
9891 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9895Calculate broken-down time from continuous time for the current stream\n\
9899 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9900 continuous time, ctime for the current stream. This function is the\n\
9901 inverse of plctime.\n\
9903 The PLplot definition of broken-down time is a calendar time that\n\
9904 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9905 responsibility to apply those offsets (if so desired) before using the\n\
9906 PLplot time API. By default broken-down time is defined using the\n\
9907 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9908 continuous time is defined as the number of seconds since the Unix\n\
9909 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9910 broken-down and continuous time are possible, see plconfigtime.\n\
9912 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9916 This function is used in example 29.\n\
9922plbtime(year, month, day, hour, min, sec, ctime)\n\
9926 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9927 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9928 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9931 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9932 the year in the range from 0 (January) to 11 (December).\n\
9934 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9935 month in the range from 1 to 31.\n\
9937 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9938 day in the range from 0 to 23.\n\
9940 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9941 hour in the range from 0 to 59\n\
9943 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9944 minute in range from 0. to 60.\n\
9946 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9947 time is calculated.\n\
9950Convert RGB color to HLS\n\
9954 Convert RGB color coordinates to HLS\n\
9956 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9959 This function is used in example 2.\n\
9965plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9969 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9971 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9973 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9975 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9976 degrees (0.0-360.0) on the color cylinder.\n\
9978 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9979 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9982 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9983 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9987Get the current device (keyword) name\n\
9991 Get the current device (keyword) name. Note: you must have allocated\n\
9992 space for this (80 characters is safe).\n\
9994 Redacted form: plgdev(p_dev)\n\
9996 This function is used in example 14.\n\
10006 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10007 (with preallocated length of 80 characters or more) containing the\n\
10008 device (keyword) name.\n\
10011Set the number of subpages in x and y\n\
10015 Set the number of subpages in x and y.\n\
10017 Redacted form: plssub(nx, ny)\n\
10019 This function is examples 1,2,14,21,25,27.\n\
10029 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10030 of window columns).\n\
10032 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10033 of window rows).\n\
10036Get current stream number\n\
10040 Gets the number of the current output stream. See also plsstrm.\n\
10042 Redacted form: plgstrm(p_strm)\n\
10044 This function is used in example 1,20.\n\
10054 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10058Random number generator returning a real random number in the range [0,1]\n\
10062 Random number generator returning a real random number in the range\n\
10063 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10064 / compilers provide their own random number generator, and so this is\n\
10065 provided purely for convenience and to give a consistent random number\n\
10066 generator across all languages supported by PLplot. This is\n\
10067 particularly useful for comparing results from the test suite of\n\
10070 Redacted form: plrandd()\n\
10072 This function is used in examples 17 and 21.\n\
10081Add a point to a strip chart\n\
10085 Add a point to a given pen of a given strip chart. There is no need\n\
10086 for all pens to have the same number of points or to be equally\n\
10087 sampled in the x coordinate. Allocates memory and rescales as\n\
10090 Redacted form: plstripa(id, pen, x, y)\n\
10092 This function is used in example 17.\n\
10098plstripa(id, pen, x, y)\n\
10102 id (PLINT, input) : Identification number of the strip chart (set\n\
10103 up in plstripc).\n\
10105 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10107 x (PLFLT, input) : X coordinate of point to plot.\n\
10109 y (PLFLT, input) : Y coordinate of point to plot.\n\
10112Set device-compression level\n\
10116 Set device-compression level. Only used for drivers that provide\n\
10117 compression. This function, if used, should be invoked before a call\n\
10120 Redacted form: plscompression(compression)\n\
10122 This function is used in example 31.\n\
10128plscompression(compression)\n\
10132 compression (PLINT, input) : The desired compression level. This is\n\
10133 a device-dependent value. Currently only the jpeg and png devices\n\
10134 use these values. For jpeg value is the jpeg quality which should\n\
10135 normally be in the range 0-95. Higher values denote higher quality\n\
10136 and hence larger image sizes. For png values are in the range -1\n\
10137 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10138 A value of -1 denotes the default zlib compression level. Values\n\
10139 in the range 10-99 are divided by 10 and then used as the zlib\n\
10140 compression level. Higher compression levels correspond to greater\n\
10141 compression and small file sizes at the expense of more\n\
10145Specify viewport in absolute coordinates\n\
10149 Alternate routine to plvpor for setting up the viewport. This routine\n\
10150 should be used only if the viewport is required to have a definite\n\
10151 size in millimeters. The routine plgspa is useful for finding out the\n\
10152 size of the current subpage.\n\
10154 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10156 This function is used in example 10.\n\
10162plsvpa(xmin, xmax, ymin, ymax)\n\
10166 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10167 viewport from the left-hand edge of the subpage in millimeters.\n\
10169 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10170 viewport from the left-hand edge of the subpage in millimeters.\n\
10172 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10173 viewport from the bottom edge of the subpage in millimeters.\n\
10175 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10176 from the bottom edge of the subpage in millimeters.\n\
10179Draw a polygon in 3 space\n\
10183 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10184 like plline3, but differs from that function in that plpoly3 attempts\n\
10185 to determine if the polygon is viewable depending on the order of the\n\
10186 points within the vector and the value of ifcc. If the back of\n\
10187 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10188 you want, then use plline3 instead.\n\
10190 The points are assumed to be in a plane, and the directionality of the\n\
10191 plane is determined from the first three points. Additional points do\n\
10192 not have to lie on the plane defined by the first three, but if they\n\
10193 do not, then the determination of visibility obviously can\'t be 100%\n\
10194 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10195 consider breaking them into smaller polygons. 3 points define a plane\n\
10198 Bugs: If one of the first two segments is of zero length, or if they\n\
10199 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10200 being correct. Avoid such situations :-). See x18c.c for an example\n\
10201 of this problem. (Search for 20.1).\n\
10203 Redacted form: plpoly3(x, y, z, code)\n\
10205 This function is used in example 18.\n\
10211plpoly3(n, x, y, z, draw, ifcc)\n\
10215 n (PLINT, input) : Number of points defining line.\n\
10217 x (PLFLT_VECTOR, input) : A vector containing\n\
10218 n x coordinates of points.\n\
10220 y (PLFLT_VECTOR, input) : A vector containing\n\
10221 n y coordinates of points.\n\
10223 z (PLFLT_VECTOR, input) : A vector containing\n\
10224 n z coordinates of points.\n\
10226 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10227 n-1 Boolean values which control drawing the segments of the polygon.\n\
10228 If draw[i] is true, then the polygon segment from index [i] to\n\
10229 [i+1] is drawn, otherwise, not.\n\
10231 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10232 polygon is determined by assuming the points are laid out in a\n\
10233 counter-clockwise order. Otherwise, the directionality of the\n\
10234 polygon is determined by assuming the points are laid out in a\n\
10235 clockwise order.\n\
10238Magnitude colored plot surface with contour\n\
10242 Aside from dropping the\n\
10243 side functionality this is a more powerful form of plot3d: the surface\n\
10244 mesh can be colored accordingly to the current z value being plotted,\n\
10245 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10246 drawn between the plotted function border and the base XY plane. The\n\
10247 arguments are identical to those of plmeshc. The only difference\n\
10248 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10249 the surface, while plot3dc only draws the surface as viewed from the\n\
10252 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10255 This function is used in example 21.\n\
10261plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10265 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10266 which the function is evaluated.\n\
10268 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10269 which the function is evaluated.\n\
10271 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10272 plot. Should have dimensions of\n\
10276 nx (PLINT, input) : Number of x values at which function is\n\
10279 ny (PLINT, input) : Number of y values at which function is\n\
10282 opt (PLINT, input) : Determines the way in which the surface is\n\
10283 represented. To specify more than one option just add the options,\n\
10284 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10285 showing z as a function of x for each value of y[j] .\n\
10286 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10287 for each value of x[i] .\n\
10288 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10289 at which function is defined.\n\
10290 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10291 the z value being plotted. The color is used from the current\n\
10293 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10294 using parameters\n\
10297 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10298 the borders of the plotted function.\n\
10301 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10304 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10307Create a 4-pen strip chart\n\
10311 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10313 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10314 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10315 styline, legline, labx, laby, labz)\n\
10318 This function is used in example 17.\n\
10324plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10328 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10329 number of the strip chart to use on plstripa and plstripd.\n\
10331 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10332 the x-axis specification as in plbox.\n\
10334 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10335 the y-axis specification as in plbox.\n\
10337 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10338 change as data are added.\n\
10340 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10341 change as data are added.\n\
10343 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10344 is multiplied by the factor (1 +\n\
10347 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10348 change as data are added.\n\
10350 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10351 change as data are added.\n\
10353 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10355 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10357 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10358 true, otherwise not.\n\
10360 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10361 otherwise slide display.\n\
10363 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10365 collab (PLINT, input) : Legend color index (cmap0).\n\
10367 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10368 indices for the 4 pens.\n\
10370 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10371 indices for the 4 pens.\n\
10373 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10374 strings containing legends for the 4 pens.\n\
10376 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10377 the label for the x axis.\n\
10379 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10380 the label for the y axis.\n\
10382 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10386Deletes and releases memory used by a strip chart\n\
10390 Deletes and releases memory used by a strip chart.\n\
10392 Redacted form: plstripd(id)\n\
10394 This function is used in example 17.\n\
10404 id (PLINT, input) : Identification number of strip chart to delete.\n\
10407Set cmap1 colors using a piece-wise linear relationship\n\
10411 Set cmap1 colors using a piece-wise linear relationship between the\n\
10412 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10413 (see the PLplot documentation). May be called at any time.\n\
10415 The idea here is to specify a number of control points that define the\n\
10416 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10417 these points, linear interpolation is used which gives a smooth\n\
10418 variation of color with intensity index. Any number of control points\n\
10419 may be specified, located at arbitrary positions, although typically 2\n\
10420 - 4 are enough. Another way of stating this is that we are traversing\n\
10421 a given number of lines through HLS or RGB space as we move through\n\
10422 cmap1 intensity indices. The control points at the minimum and\n\
10423 maximum position (0 and 1) must always be specified. By adding more\n\
10424 control points you can get more variation. One good technique for\n\
10425 plotting functions that vary about some expected average is to use an\n\
10426 additional 2 control points in the center (position ~= 0.5) that are\n\
10427 the same lightness as the background (typically white for paper\n\
10428 output, black for crt), and same hue as the boundary control points.\n\
10429 This allows the highs and lows to be very easily distinguished.\n\
10431 Each control point must specify the cmap1 intensity index and the\n\
10432 associated three coordinates in HLS or RGB space. The first point\n\
10433 must correspond to position = 0, and the last to position = 1.\n\
10435 If RGB colors are provided then the interpolation takes place in RGB\n\
10436 space and is trivial. However if HLS colors are provided then, because\n\
10437 of the circular nature of the color wheel for the hue coordinate, the\n\
10438 interpolation could be performed in either direction around the color\n\
10439 wheel. The default behaviour is for the hue to be linearly\n\
10440 interpolated ignoring this circular property of hue. So for example,\n\
10441 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10442 green and cyan. If instead you wish to interpolate the other way\n\
10443 around the color wheel you have two options. You may provide hues\n\
10444 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10445 for red the interpolation will proceed via magenta. Alternatively you\n\
10446 can utilise the alt_hue_path variable to reverse the direction of\n\
10447 interpolation if you need to provide hues within the [0-360) range.\n\
10449 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10450 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10451 -120]falsegreen-yellow-red-magenta-blue[240\n\
10452 480]falseblue-magenta-red-yellow-green[120\n\
10453 240]truegreen-yellow-red-magenta-blue[240\n\
10454 120]trueblue-magenta-red-yellow-green\n\
10456 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10457 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10458 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10460 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10463 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10469plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10473 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10475 npts (PLINT, input) : number of control points\n\
10477 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10478 intensity index (0.0-1.0) in ascending order for each control\n\
10481 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10482 coordinate (H or R) for each control point.\n\
10484 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10485 coordinate (L or G) for each control point.\n\
10487 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10488 coordinate (S or B) for each control point.\n\
10490 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10491 npts - 1 elements), each containing either true to use the reversed\n\
10492 HLS interpolation or false to use the regular HLS interpolation.\n\
10493 (alt_hue_path[i] refers to the interpolation interval between the\n\
10494 i and i + 1 control points). This parameter is not used for RGB\n\
10499Shade individual region on the basis of value\n\
10503 Shade individual region on the basis of value. Use plshades if you\n\
10504 want to shade a number of contiguous regions using continuous colors.\n\
10505 In particular the edge contours are treated properly in plshades. If\n\
10506 you attempt to do contiguous regions with plshade the contours at the\n\
10507 edge of the shade are partially obliterated by subsequent plots of\n\
10508 contiguous shaded regions.\n\
10510 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10511 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10512 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10515 This function is used in example 15.\n\
10521plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10525 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10526 plot. Should have dimensions of\n\
10530 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10532 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10534 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10535 the region that should be plotted in the shade plot. This\n\
10536 function accepts x and y coordinates as input arguments and must\n\
10537 return 1 if the point is to be included in the shade plot and 0\n\
10538 otherwise. If you want to plot the entire shade plot (the usual\n\
10539 case), this argument should be set to NULL.\n\
10541 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10542 pltr below for how these arguments are used (only for the special case\n\
10543 when the callback function\n\
10544 pltr is not supplied).\n\
10546 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10547 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10549 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10550 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10552 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10553 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10554 then sh_color is interpreted as a cmap1 argument in the range\n\
10557 sh_color (PLFLT, input) : Defines color map index with integer\n\
10558 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10560 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10562 min_color (PLINT, input) : Defines pen color, width used by the\n\
10563 boundary of shaded region. The min values are used for the\n\
10564 shade_min boundary, and the max values are used on the shade_max\n\
10565 boundary. Set color and width to zero for no plotted boundaries.\n\
10567 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10568 boundary of shaded region. The min values are used for the\n\
10569 shade_min boundary, and the max values are used on the shade_max\n\
10570 boundary. Set color and width to zero for no plotted boundaries.\n\
10572 max_color (PLINT, input) : Defines pen color, width used by the\n\
10573 boundary of shaded region. The min values are used for the\n\
10574 shade_min boundary, and the max values are used on the shade_max\n\
10575 boundary. Set color and width to zero for no plotted boundaries.\n\
10577 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10578 boundary of shaded region. The min values are used for the\n\
10579 shade_min boundary, and the max values are used on the shade_max\n\
10580 boundary. Set color and width to zero for no plotted boundaries.\n\
10582 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10583 Use plfill. Future version of PLplot may have other fill\n\
10586 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10587 map to rectangles after coordinate transformation with pltrl.\n\
10588 Otherwise, set rectangular to false. If rectangular is set to\n\
10589 true, plshade tries to save time by filling large rectangles.\n\
10590 This optimization fails if the coordinate transformation distorts\n\
10591 the shape of rectangles. For example a plot in polar coordinates\n\
10592 has to have rectangular set to false.\n\
10594 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10595 defines the transformation between the zero-based indices of the\n\
10596 matrix a and world coordinates. If\n\
10597 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10598 indices of a are mapped to the range\n\
10600 xmax and the y indices of a are mapped to the range\n\
10602 ymax.For the C case, transformation functions are provided in the\n\
10603 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10604 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10605 matrices. In addition, C callback routines for the transformation\n\
10606 can be supplied by the user such as the mypltr function in\n\
10607 examples/c/x09c.c which provides a general linear transformation\n\
10608 between index coordinates and world coordinates.For languages\n\
10609 other than C you should consult the PLplot documentation for the\n\
10610 details concerning how PLTRANSFORM_callback arguments are\n\
10611 interfaced. However, in general, a particular pattern of\n\
10612 callback-associated arguments such as a tr vector with 6 elements;\n\
10613 xg and yg vectors; or xg and yg matrices are respectively\n\
10614 interfaced to a linear-transformation routine similar to the above\n\
10615 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10616 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10617 support native language callbacks for handling index to\n\
10618 world-coordinate transformations. Examples of these various\n\
10619 approaches are given in examples/<language>x09*,\n\
10620 examples/<language>x16*, examples/<language>x20*,\n\
10621 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10622 supported languages.\n\
10624 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10625 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10626 externally supplied.\n\
10629Set number of colors in cmap1\n\
10633 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10634 values if this is the first allocation (see the PLplot documentation).\n\
10636 Redacted form: plscmap1n(ncol1)\n\
10638 This function is used in examples 8, 11, 20, and 21.\n\
10648 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10649 the cmap1 palette. If this number is zero or less, then the value\n\
10650 from the previous call to plscmap1n is used and if there is no\n\
10651 previous call, then a default value is used.\n\
10654Advance to the next family file on the next new page\n\
10658 Advance to the next family file on the next new page.\n\
10660 Redacted form: plfamadv()\n\
10662 This function is not used in any examples.\n\
10671Set the escape character for text strings\n\
10675 Set the escape character for text strings. From C (in contrast to\n\
10676 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10677 characters are allowed to prevent the user from shooting himself in\n\
10678 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10679 use of backslash as a character escape). Here are the allowed escape\n\
10680 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10691 Redacted form: General: plsesc(esc)\n\
10694 This function is used in example 29.\n\
10704 esc (char, input) : Escape character.\n\
10706static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10707Plot color bar for image, shade or gradient plots\n\
10711 Routine for creating a continuous color bar for image, shade, or\n\
10712 gradient plots. (See pllegend for similar functionality for creating\n\
10713 legends with discrete elements). The arguments of plcolorbar provide\n\
10714 control over the location and size of the color bar as well as the\n\
10715 location and characteristics of the elements (most of which are\n\
10716 optional) within that color bar. The resulting color bar is clipped\n\
10717 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10718 system used for some of the parameters is defined in the documentation\n\
10719 of the position parameter.)\n\
10721 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10722 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10723 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10724 labels, axis_opts, ticks, sub_ticks, values)\n\
10726 This function is used in examples 16 and 33.\n\
10732plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n\
10736 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10737 labelled and decorated color bar width in adopted coordinates.\n\
10739 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10740 labelled and decorated color bar height in adopted coordinates.\n\
10742 opt (PLINT, input) : opt contains bits controlling the overall\n\
10743 color bar. The orientation (direction of the maximum value) of\n\
10744 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10745 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10746 specified, the default orientation is toward the top if the\n\
10747 colorbar is placed on the left or right of the viewport or toward\n\
10748 the right if the colorbar is placed on the top or bottom of the\n\
10749 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10750 (semitransparent) background for the color bar. If the\n\
10751 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10752 color bar. The type of color bar must be specified with one of\n\
10753 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10754 more than one of those bits is set only the first one in the above\n\
10755 list is honored. The position of the (optional) label/title can be\n\
10756 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10757 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10758 will be drawn. If more than one of this list of bits is specified,\n\
10759 only the first one on the list is honored. End-caps for the color\n\
10760 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10761 If a particular color bar cap option is not specified then no cap\n\
10762 will be drawn for that end. As a special case for\n\
10763 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10764 specified. If this option is provided then any tick marks and tick\n\
10765 labels will be placed at the breaks between shaded segments. TODO:\n\
10766 This should be expanded to support custom placement of tick marks\n\
10767 and tick labels at custom value locations for any color bar type.\n\
10769 position (PLINT, input) : position contains bits which control the\n\
10770 overall position of the color bar and the definition of the\n\
10771 adopted coordinates used for positions just like what is done for\n\
10772 the position argument for pllegend. However, note that the\n\
10773 defaults for the position bits (see below) are different than the\n\
10774 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10775 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10776 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10777 the 16 possible standard positions (the 4 corners and centers of\n\
10778 the 4 sides for both the inside and outside cases) of the color\n\
10779 bar relative to the adopted coordinate system. The corner\n\
10780 positions are specified by the appropriate combination of two of\n\
10781 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10782 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10783 value of one of those bits. The adopted coordinates are\n\
10784 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10785 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10786 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10787 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10788 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10789 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10790 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10791 PL_POSITION_VIEWPORT.\n\
10793 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10794 coordinates from the specified standard position of the color bar.\n\
10795 For positive x, the direction of motion away from the standard\n\
10796 position is inward/outward from the standard corner positions or\n\
10797 standard left or right positions if the\n\
10798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10799 For the standard top or bottom positions, the direction of motion\n\
10800 is toward positive X.\n\
10802 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10803 coordinates from the specified standard position of the color bar.\n\
10804 For positive y, the direction of motion away from the standard\n\
10805 position is inward/outward from the standard corner positions or\n\
10806 standard top or bottom positions if the\n\
10807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10808 For the standard left or right positions, the direction of motion\n\
10809 is toward positive Y.\n\
10811 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10812 the X direction in adopted coordinates.\n\
10814 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10815 the Y direction in adopted coordinates.\n\
10817 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10818 color bar (PL_COLORBAR_BACKGROUND).\n\
10820 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10821 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10823 bb_style (PLINT, input) : The pllsty style number for the\n\
10824 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10826 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10827 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10829 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10830 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10832 cont_color (PLINT, input) : The cmap0 contour color for\n\
10833 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10834 it will be interpreted according to the design of plshades.\n\
10836 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10837 plots. This is passed directly to plshades, so it will be\n\
10838 interpreted according to the design of plshades.\n\
10840 n_labels (PLINT, input) : Number of labels to place around the\n\
10843 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10844 n_labels labels.\n\
10846 labels (PLCHAR_MATRIX, input) : A vector of\n\
10847 n_labels UTF-8 character strings containing the labels for the color\n\
10848 bar. Ignored if no label position is specified with one of the\n\
10849 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10850 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10851 corresponding label_opts field.\n\
10853 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10854 value must be greater than 0. It is typically 1 (numerical axis\n\
10855 labels are provided for one of the long edges of the color bar),\n\
10856 but it can be larger if multiple numerical axis labels for the\n\
10857 long edges of the color bar are desired.\n\
10859 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10860 n_axes ascii character strings containing options (interpreted as for\n\
10861 plbox) for the color bar\'s axis definitions.\n\
10863 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10864 spacing of the major tick marks (interpreted as for plbox) for the\n\
10865 color bar\'s axis definitions.\n\
10867 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10868 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10869 axis definitions.\n\
10871 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10872 elements in each of the n_axes rows of the values matrix.\n\
10874 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10875 values for the data range represented by the color bar. For a row\n\
10876 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10877 elements in the row is specified by n_values[i_axis]. For\n\
10878 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10879 is 2, and the corresponding row elements of the values matrix are\n\
10880 the minimum and maximum value represented by the colorbar. For\n\
10881 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10882 of the values matrix is interpreted the same as the nlevel and\n\
10883 clevel arguments of plshades.\n\
10885static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10886Set current output stream\n\
10890 Sets the number of the current output stream. The stream number\n\
10891 defaults to 0 unless changed by this routine. The first use of this\n\
10892 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10894 Redacted form: plsstrm(strm)\n\
10896 This function is examples 1,14,20.\n\
10906 strm (PLINT, input) : The current stream number.\n\
10908static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10909Get the current device-compression setting\n\
10913 Get the current device-compression setting. This parameter is only\n\
10914 used for drivers that provide compression.\n\
10916 Redacted form: plgcompression(compression)\n\
10918 This function is used in example 31.\n\
10924plgcompression(compression)\n\
10928 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10929 compression setting for the current device.\n\
10931static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10932Grid data from irregularly sampled data\n\
10936 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10937 require data organized as a grid, i.e., with x sample point values\n\
10938 independent of y coordinate and vice versa. This function takes\n\
10939 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10940 vectors; reads the desired grid location from the input vectors\n\
10941 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10942 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10943 interpolate the data to the grid is specified with the argument type\n\
10944 which can have one parameter specified in argument data.\n\
10946 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10947 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10950 This function is used in example 21.\n\
10956plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10960 x (PLFLT_VECTOR, input) : The input x vector.\n\
10962 y (PLFLT_VECTOR, input) : The input y vector.\n\
10964 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10965 y[i], z[i] represents one data sample coordinate.\n\
10967 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10970 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10971 in the x direction. Usually xg has nptsx equally spaced values\n\
10972 from the minimum to the maximum values of the x input vector.\n\
10974 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10976 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10977 in the y direction. Similar to the xg parameter.\n\
10979 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10981 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10982 where data lies in the grid specified by xg and yg. Therefore the\n\
10983 zg matrix must be dimensioned\n\
10987 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10988 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10989 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10990 GRID_NNI: Natural Neighbors Interpolation\n\
10991 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10992 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10993 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10995 For details of the algorithms read the source file plgridd.c.\n\
10997 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10998 which can be specified through this argument. Currently, for\n\
10999 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11000 use, the lower the value, the noisier (more local) the\n\
11001 approximation is.\n\
11002 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11003 range [1. .. 2.]. High values enable the usage of very thin\n\
11004 triangles for interpolation, possibly resulting in error in\n\
11005 the approximation.\n\
11006 GRID_NNI, only weights greater than data will be accepted. If\n\
11007 0, all weights will be accepted.\n\
11013 char **arg3 = (
char **) 0 ;
11015 octave_value_list _out;
11016 octave_value_list *_outp=&_out;
11017 octave_value _outv;
11024 if (
_n_dims( args(0) ) > 1 )
11030 temp1 = args(0).matrix_value();
11034 charMatrix temp_matrix;
11038 size_t max_length = 0, non_blank_length;
11040 if (
_n_dims( args(1) ) > 2 )
11042 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
11044#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11045 if ( !args(1).isempty() )
11047 if ( !args(1).is_empty() )
11052 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
11054 arg3 =
new char*[
Alen];
11055#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11056 ifcell = args(1).iscell();
11058 ifcell = args(1).is_cell();
11062 temp_cell = args(1).cell_value();
11066 temp_matrix = args(1).char_matrix_value();
11068 max_length =
_dim( args(1), 1 ) + 1;
11071 for ( i = 0; i <
Alen; i++ )
11078 if ( temp_cell.elem( i ).is_string() )
11080 str = temp_cell.elem( i ).string_value();
11082 max_length = str.size() + 1;
11083 tmp_cstring = (
char *) str.c_str();
11093 tmp_cstring = (
char *)
"";
11098 str = temp_matrix.row_as_string( i );
11099 tmp_cstring = (
char *) str.c_str();
11101 arg3[i] =
new char[max_length];
11102 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11103 arg3[i][max_length - 1] =
'\0';
11118 non_blank_length = max_length - 2;
11119 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11121 non_blank_length--;
11123 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11125 non_blank_length--;
11127 arg3[i][non_blank_length + 1] =
'\0';
11136 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11137 _outv = octave_value();
11144 if ( arg3 != NULL )
11146 for ( i = 0; i <
Alen; i++ )
11160 if ( arg3 != NULL )
11162 for ( i = 0; i <
Alen; i++ )
11169 return octave_value_list();
11177 if ( arg3 != NULL )
11179 for ( i = 0; i <
Alen; i++ )
11192 int *arg1 = (
int *) 0 ;
11193 int *arg2 = (
int *) 0 ;
11194 int *arg3 = (
int *) 0 ;
11195 char *arg4 = (
char *) 0 ;
11196 int *arg5 = (
int *) 0 ;
11197 int *arg6 = (
int *) 0 ;
11202 int *arg11 = (
int *) 0 ;
11209 char local_string4[80] ;
11224 size_t local_string_length4 ;
11225 charMatrix local_charMatrix4 ;
11226 octave_value_list retval4 ;
11227 octave_value_list _out;
11228 octave_value_list *_outp=&_out;
11229 octave_value _outv;
11237 arg4 = local_string4;
11249 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11271 local_string_length4 = strlen( local_string4 );
11272 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11273 local_charMatrix4.insert( local_string4, 0, 0 );
11274 retval4( 0 ) = octave_value( local_charMatrix4 );
11321 return octave_value_list();
11342 octave_value_list _out;
11343 octave_value_list *_outp=&_out;
11344 octave_value _outv;
11357 arg3 =
static_cast< PLFLT >(val3);
11362 arg4 =
static_cast< PLFLT >(val4);
11380 return octave_value_list();
11390 char *arg2 = (
char *) 0 ;
11391 char *arg3 = (
char *) 0 ;
11405 char *arg17 = (
char *) 0 ;
11406 char *arg18 = (
char *) 0 ;
11407 char *arg19 = (
char *) 0 ;
11408 char *arg20 = (
char *) 0 ;
11409 char *arg21 = (
char *) 0 ;
11410 char *arg22 = (
char *) 0 ;
11411 char *arg23 = (
char *) 0 ;
11465 octave_value_list _out;
11466 octave_value_list *_outp=&_out;
11467 octave_value _outv;
11478 arg2 =
reinterpret_cast< char *
>(buf2);
11483 arg3 =
reinterpret_cast< char *
>(buf3);
11488 arg4 =
static_cast< PLFLT >(val4);
11493 arg5 =
static_cast< PLFLT >(val5);
11498 arg6 =
static_cast< PLFLT >(val6);
11503 arg7 =
static_cast< PLFLT >(val7);
11508 arg8 =
static_cast< PLFLT >(val8);
11513 arg9 =
static_cast< PLFLT >(val9);
11518 arg10 =
static_cast< PLFLT >(val10);
11523 arg11 =
static_cast< PLBOOL >(val11);
11528 arg12 =
static_cast< PLBOOL >(val12);
11533 arg13 =
static_cast< PLINT >(val13);
11538 arg14 =
static_cast< PLINT >(val14);
11540 if (
_n_dims( args(13) ) > 1 )
11545 temp15 = args(13).matrix_value();
11550 if (
_n_dims( args(14) ) > 1 )
11554 if (
_dim( args(14), 0 ) !=
Alen )
11558 temp16 = args(14).matrix_value();
11566 arg17 =
reinterpret_cast< char *
>(buf17);
11571 arg18 =
reinterpret_cast< char *
>(buf18);
11576 arg19 =
reinterpret_cast< char *
>(buf19);
11581 arg20 =
reinterpret_cast< char *
>(buf20);
11586 arg21 =
reinterpret_cast< char *
>(buf21);
11591 arg22 =
reinterpret_cast< char *
>(buf22);
11596 arg23 =
reinterpret_cast< char *
>(buf23);
11597 my_plstripc(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(
int const *)arg15,(
int const *)arg16,(
char const *)arg17,(
char const *)arg18,(
char const *)arg19,(
char const *)arg20,(
char const *)arg21,(
char const *)arg22,(
char const *)arg23);
11598 _outv = octave_value();
11638 return octave_value_list();
11683 octave_value_list _out;
11684 octave_value_list *_outp=&_out;
11685 octave_value _outv;
11692 if (
_n_dims( args(0) ) > 2 )
11694 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11696 temp1 = args(0).matrix_value();
11697 arg1 = &temp1( 0, 0 );
11705 arg4 =
static_cast< PLINT >(val4);
11710 arg5 =
static_cast< PLINT >(val5);
11715 arg6 =
static_cast< PLINT >(val6);
11720 arg7 =
static_cast< PLINT >(val7);
11722 if (
_n_dims( args(5) ) > 1 )
11726 temp8 = args(5).matrix_value();
11727 arg8 = &temp8( 0, 0 );
11731 if (
_n_dims( args(6) ) > 1 )
11735 if (
_dim( args(6), 0 ) != 6 )
11739 temp10 = args(6).matrix_value();
11740 arg10 = &temp10( 0, 0 );
11742 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11743 _outv = octave_value();
11765 return octave_value_list();
11802 octave_value_list _out;
11803 octave_value_list *_outp=&_out;
11804 octave_value _outv;
11811 if (
_n_dims( args(0) ) > 2 )
11813 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11815 temp1 = args(0).matrix_value();
11816 arg1 = &temp1( 0, 0 );
11824 arg4 =
static_cast< PLINT >(val4);
11829 arg5 =
static_cast< PLINT >(val5);
11834 arg6 =
static_cast< PLINT >(val6);
11839 arg7 =
static_cast< PLINT >(val7);
11841 if (
_n_dims( args(5) ) > 1 )
11845 temp8 = args(5).matrix_value();
11846 arg8 = &temp8( 0, 0 );
11849 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11850 _outv = octave_value();
11866 return octave_value_list();
11904 octave_value_list _out;
11905 octave_value_list *_outp=&_out;
11906 octave_value _outv;
11913 if (
_n_dims( args(0) ) > 2 )
11915 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11917 temp1 = args(0).matrix_value();
11918 arg1 = &temp1( 0, 0 );
11926 arg4 =
static_cast< PLINT >(val4);
11931 arg5 =
static_cast< PLINT >(val5);
11936 arg6 =
static_cast< PLINT >(val6);
11941 arg7 =
static_cast< PLINT >(val7);
11943 if (
_n_dims( args(5) ) > 1 )
11947 temp8 = args(5).matrix_value();
11948 arg8 = &temp8( 0, 0 );
11952 if (
_n_dims( args(6) ) > 1 )
11960 temp10 = args(6).matrix_value();
11961 arg10 = &temp10( 0, 0 );
11964 if (
_n_dims( args(7) ) > 1 )
11972 temp11 = args(7).matrix_value();
11973 arg11 = &temp11( 0, 0 );
11975 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11976 _outv = octave_value();
12004 return octave_value_list();
12048 octave_value_list _out;
12049 octave_value_list *_outp=&_out;
12050 octave_value _outv;
12057 if (
_n_dims( args(0) ) > 2 )
12059 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12061 temp1 = args(0).matrix_value();
12062 arg1 = &temp1( 0, 0 );
12070 arg4 =
static_cast< PLINT >(val4);
12075 arg5 =
static_cast< PLINT >(val5);
12080 arg6 =
static_cast< PLINT >(val6);
12085 arg7 =
static_cast< PLINT >(val7);
12087 if (
_n_dims( args(5) ) > 1 )
12091 temp8 = args(5).matrix_value();
12092 arg8 = &temp8( 0, 0 );
12096 if (
_n_dims( args(6) ) > 2 )
12098 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12102 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12106 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12108 temp10 = args(6).matrix_value();
12109 arg10 = &temp10( 0, 0 );
12112 if (
_n_dims( args(7) ) > 2 )
12114 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12118 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12122 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12124 temp11 = args(7).matrix_value();
12125 arg11 = &temp11( 0, 0 );
12127 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12128 _outv = octave_value();
12156 return octave_value_list();
12200 octave_value_list _out;
12201 octave_value_list *_outp=&_out;
12202 octave_value _outv;
12209 if (
_n_dims( args(0) ) > 2 )
12211 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12213 temp1 = args(0).matrix_value();
12214 arg1 = &temp1( 0, 0 );
12222 arg4 =
static_cast< PLINT >(val4);
12227 arg5 =
static_cast< PLINT >(val5);
12232 arg6 =
static_cast< PLINT >(val6);
12237 arg7 =
static_cast< PLINT >(val7);
12239 if (
_n_dims( args(5) ) > 1 )
12243 temp8 = args(5).matrix_value();
12244 arg8 = &temp8( 0, 0 );
12248 if (
_n_dims( args(6) ) > 2 )
12250 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12254 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12258 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12260 temp10 = args(6).matrix_value();
12261 arg10 = &temp10( 0, 0 );
12264 if (
_n_dims( args(7) ) > 2 )
12266 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12270 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12274 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12276 temp11 = args(7).matrix_value();
12277 arg11 = &temp11( 0, 0 );
12279 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12280 _outv = octave_value();
12308 return octave_value_list();
12345 octave_value_list retval7 ;
12350 octave_value_list _out;
12351 octave_value_list *_outp=&_out;
12352 octave_value _outv;
12359 if (
_n_dims( args(0) ) > 1 )
12364 temp1 = args(0).matrix_value();
12365 arg1 = &temp1( 0, 0 );
12368 if (
_n_dims( args(1) ) > 1 )
12376 temp2 = args(1).matrix_value();
12377 arg2 = &temp2( 0, 0 );
12380 if (
_n_dims( args(2) ) > 1 )
12388 temp3 = args(2).matrix_value();
12389 arg3 = &temp3( 0, 0 );
12393 if (
_n_dims( args(3) ) > 1 )
12397 temp5 = args(3).matrix_value();
12398 arg5 = &temp5( 0, 0 );
12402 if (
_n_dims( args(4) ) > 1 )
12406 temp7 = args(4).matrix_value();
12407 arg7 = &temp7( 0, 0 );
12409 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12410 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12416 arg10 =
static_cast< PLINT >(val10);
12421 arg11 =
static_cast< PLFLT >(val11);
12422 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12423 _outv = octave_value();
12460 return octave_value_list();
12495 octave_value_list _out;
12496 octave_value_list *_outp=&_out;
12497 octave_value _outv;
12504 if (
_n_dims( args(0) ) > 1 )
12508 temp1 = args(0).matrix_value();
12509 arg1 = &temp1( 0, 0 );
12513 if (
_n_dims( args(1) ) > 1 )
12517 temp2 = args(1).matrix_value();
12518 arg2 = &temp2( 0, 0 );
12522 if (
_n_dims( args(2) ) > 2 )
12524 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12528 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12532 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12534 temp3 = args(2).matrix_value();
12535 arg3 = &temp3( 0, 0 );
12543 arg6 =
static_cast< PLINT >(val6);
12544 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12545 _outv = octave_value();
12567 return octave_value_list();
12599 octave_value_list _out;
12600 octave_value_list *_outp=&_out;
12601 octave_value _outv;
12608 if (
_n_dims( args(0) ) > 1 )
12612 temp1 = args(0).matrix_value();
12613 arg1 = &temp1( 0, 0 );
12617 if (
_n_dims( args(1) ) > 1 )
12621 temp2 = args(1).matrix_value();
12622 arg2 = &temp2( 0, 0 );
12626 if (
_n_dims( args(2) ) > 2 )
12628 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12632 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12636 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12638 temp3 = args(2).matrix_value();
12639 arg3 = &temp3( 0, 0 );
12647 arg6 =
static_cast< PLINT >(val6);
12649 if (
_n_dims( args(4) ) > 1 )
12653 temp7 = args(4).matrix_value();
12654 arg7 = &temp7( 0, 0 );
12657 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12658 _outv = octave_value();
12686 return octave_value_list();
12721 octave_value_list _out;
12722 octave_value_list *_outp=&_out;
12723 octave_value _outv;
12730 if (
_n_dims( args(0) ) > 1 )
12734 temp1 = args(0).matrix_value();
12735 arg1 = &temp1( 0, 0 );
12739 if (
_n_dims( args(1) ) > 1 )
12743 temp2 = args(1).matrix_value();
12744 arg2 = &temp2( 0, 0 );
12748 if (
_n_dims( args(2) ) > 2 )
12750 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12754 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12758 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12760 temp3 = args(2).matrix_value();
12761 arg3 = &temp3( 0, 0 );
12769 arg6 =
static_cast< PLINT >(val6);
12774 arg7 =
static_cast< PLBOOL >(val7);
12775 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12776 _outv = octave_value();
12798 return octave_value_list();
12830 octave_value_list _out;
12831 octave_value_list *_outp=&_out;
12832 octave_value _outv;
12839 if (
_n_dims( args(0) ) > 1 )
12843 temp1 = args(0).matrix_value();
12844 arg1 = &temp1( 0, 0 );
12848 if (
_n_dims( args(1) ) > 1 )
12852 temp2 = args(1).matrix_value();
12853 arg2 = &temp2( 0, 0 );
12857 if (
_n_dims( args(2) ) > 2 )
12859 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12863 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12867 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12869 temp3 = args(2).matrix_value();
12870 arg3 = &temp3( 0, 0 );
12878 arg6 =
static_cast< PLINT >(val6);
12880 if (
_n_dims( args(4) ) > 1 )
12884 temp7 = args(4).matrix_value();
12885 arg7 = &temp7( 0, 0 );
12888 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12889 _outv = octave_value();
12917 return octave_value_list();
12960 octave_value_list _out;
12961 octave_value_list *_outp=&_out;
12962 octave_value _outv;
12969 if (
_n_dims( args(0) ) > 1 )
12973 temp1 = args(0).matrix_value();
12974 arg1 = &temp1( 0, 0 );
12978 if (
_n_dims( args(1) ) > 1 )
12982 temp2 = args(1).matrix_value();
12983 arg2 = &temp2( 0, 0 );
12987 if (
_n_dims( args(2) ) > 2 )
12989 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12993 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12997 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12999 temp3 = args(2).matrix_value();
13000 arg3 = &temp3( 0, 0 );
13008 arg6 =
static_cast< PLINT >(val6);
13010 if (
_n_dims( args(4) ) > 1 )
13014 temp7 = args(4).matrix_value();
13015 arg7 = &temp7( 0, 0 );
13022 arg9 =
static_cast< PLINT >(val9);
13024 if (
_n_dims( args(6) ) > 1 )
13030 temp10 = args(6).matrix_value();
13034 if (
_n_dims( args(7) ) > 1 )
13042 temp12 = args(7).matrix_value();
13046 my_plot3dcl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
13047 _outv = octave_value();
13087 return octave_value_list();
13128 octave_value_list _out;
13129 octave_value_list *_outp=&_out;
13130 octave_value _outv;
13137 if (
_n_dims( args(0) ) > 1 )
13141 temp1 = args(0).matrix_value();
13142 arg1 = &temp1( 0, 0 );
13146 if (
_n_dims( args(1) ) > 1 )
13150 temp2 = args(1).matrix_value();
13151 arg2 = &temp2( 0, 0 );
13155 if (
_n_dims( args(2) ) > 2 )
13157 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13161 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13165 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13167 temp3 = args(2).matrix_value();
13168 arg3 = &temp3( 0, 0 );
13176 arg6 =
static_cast< PLINT >(val6);
13178 if (
_n_dims( args(4) ) > 1 )
13182 temp7 = args(4).matrix_value();
13183 arg7 = &temp7( 0, 0 );
13186 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13187 _outv = octave_value();
13215 return octave_value_list();
13258 octave_value_list _out;
13259 octave_value_list *_outp=&_out;
13260 octave_value _outv;
13267 if (
_n_dims( args(0) ) > 1 )
13271 temp1 = args(0).matrix_value();
13272 arg1 = &temp1( 0, 0 );
13276 if (
_n_dims( args(1) ) > 1 )
13280 temp2 = args(1).matrix_value();
13281 arg2 = &temp2( 0, 0 );
13285 if (
_n_dims( args(2) ) > 2 )
13287 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13291 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13295 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13297 temp3 = args(2).matrix_value();
13298 arg3 = &temp3( 0, 0 );
13306 arg6 =
static_cast< PLINT >(val6);
13308 if (
_n_dims( args(4) ) > 1 )
13312 temp7 = args(4).matrix_value();
13313 arg7 = &temp7( 0, 0 );
13320 arg9 =
static_cast< PLINT >(val9);
13322 if (
_n_dims( args(6) ) > 1 )
13328 temp10 = args(6).matrix_value();
13332 if (
_n_dims( args(7) ) > 1 )
13340 temp12 = args(7).matrix_value();
13344 my_plsurf3dl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
13345 _outv = octave_value();
13385 return octave_value_list();
13462 octave_value_list _out;
13463 octave_value_list *_outp=&_out;
13464 octave_value _outv;
13471 if (
_n_dims( args(0) ) > 2 )
13473 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13475 temp1 = args(0).matrix_value();
13476 arg1 = &temp1( 0, 0 );
13481 if (
_n_dims( args(1) ) > 1 )
13486 temp4 = args(1).matrix_value();
13487 arg4 = &temp4( 0, 0 );
13493 arg5 =
static_cast< PLFLT >(val5);
13498 arg6 =
static_cast< PLFLT >(val6);
13503 arg7 =
static_cast< PLFLT >(val7);
13508 arg8 =
static_cast< PLFLT >(val8);
13513 arg9 =
static_cast< PLFLT >(val9);
13518 arg10 =
static_cast< PLFLT >(val10);
13523 arg11 =
static_cast< PLINT >(val11);
13528 arg12 =
static_cast< PLFLT >(val12);
13533 arg13 =
static_cast< PLINT >(val13);
13538 arg14 =
static_cast< PLINT >(val14);
13543 arg15 =
static_cast< PLINT >(val15);
13548 arg16 =
static_cast< PLINT >(val16);
13553 arg17 =
static_cast< PLINT >(val17);
13558 arg18 =
static_cast< PLBOOL >(val18);
13560 if (
_n_dims( args(16) ) > 1 )
13564 if (
_dim( args(16), 0 ) != 6 )
13568 temp19 = args(16).matrix_value();
13569 arg19 = &temp19( 0, 0 );
13571 my_plshade((
double const *)arg1,arg2,arg3,(
double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
13572 _outv = octave_value();
13594 return octave_value_list();
13615 char *arg4 = (
char *) 0 ;
13666 octave_value_list _out;
13667 octave_value_list *_outp=&_out;
13668 octave_value _outv;
13675 if (
_n_dims( args(0) ) > 2 )
13677 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13679 temp1 = args(0).matrix_value();
13680 arg1 = &temp1( 0, 0 );
13688 arg4 =
reinterpret_cast< char *
>(buf4);
13693 arg5 =
static_cast< PLFLT >(val5);
13698 arg6 =
static_cast< PLFLT >(val6);
13703 arg7 =
static_cast< PLFLT >(val7);
13708 arg8 =
static_cast< PLFLT >(val8);
13713 arg9 =
static_cast< PLFLT >(val9);
13718 arg10 =
static_cast< PLFLT >(val10);
13723 arg11 =
static_cast< PLINT >(val11);
13728 arg12 =
static_cast< PLFLT >(val12);
13733 arg13 =
static_cast< PLINT >(val13);
13738 arg14 =
static_cast< PLINT >(val14);
13743 arg15 =
static_cast< PLINT >(val15);
13748 arg16 =
static_cast< PLINT >(val16);
13753 arg17 =
static_cast< PLINT >(val17);
13758 arg18 =
static_cast< PLBOOL >(val18);
13760 if (
_n_dims( args(16) ) > 1 )
13764 if (
_dim( args(16), 0 ) !=
Xlen )
13768 temp19 = args(16).matrix_value();
13769 arg19 = &temp19( 0, 0 );
13772 if (
_n_dims( args(17) ) > 1 )
13776 if (
_dim( args(17), 0 ) !=
Ylen )
13780 temp20 = args(17).matrix_value();
13781 arg20 = &temp20( 0, 0 );
13783 my_plshade1((
double const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(
double const *)arg19,(
double const *)arg20);
13784 _outv = octave_value();
13808 return octave_value_list();
13830 char *arg4 = (
char *) 0 ;
13881 octave_value_list _out;
13882 octave_value_list *_outp=&_out;
13883 octave_value _outv;
13890 if (
_n_dims( args(0) ) > 2 )
13892 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13894 temp1 = args(0).matrix_value();
13895 arg1 = &temp1( 0, 0 );
13903 arg4 =
reinterpret_cast< char *
>(buf4);
13908 arg5 =
static_cast< PLFLT >(val5);
13913 arg6 =
static_cast< PLFLT >(val6);
13918 arg7 =
static_cast< PLFLT >(val7);
13923 arg8 =
static_cast< PLFLT >(val8);
13928 arg9 =
static_cast< PLFLT >(val9);
13933 arg10 =
static_cast< PLFLT >(val10);
13938 arg11 =
static_cast< PLINT >(val11);
13943 arg12 =
static_cast< PLFLT >(val12);
13948 arg13 =
static_cast< PLINT >(val13);
13953 arg14 =
static_cast< PLINT >(val14);
13958 arg15 =
static_cast< PLINT >(val15);
13963 arg16 =
static_cast< PLINT >(val16);
13968 arg17 =
static_cast< PLINT >(val17);
13973 arg18 =
static_cast< PLBOOL >(val18);
13975 if (
_n_dims( args(16) ) > 2 )
13977 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13979 temp19 = args(16).matrix_value();
13980 arg19 = &temp19( 0, 0 );
13985 if (
_n_dims( args(17) ) > 2 )
13987 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13989 temp20 = args(17).matrix_value();
13990 arg20 = &temp20( 0, 0 );
13994 my_plshade2((
double const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(
double const *)arg19,(
double const *)arg20);
13995 _outv = octave_value();
14019 return octave_value_list();
14069 octave_value_list _out;
14070 octave_value_list *_outp=&_out;
14071 octave_value _outv;
14078 if (
_n_dims( args(0) ) > 2 )
14080 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14082 temp1 = args(0).matrix_value();
14083 arg1 = &temp1( 0, 0 );
14091 arg4 =
static_cast< PLFLT >(val4);
14096 arg5 =
static_cast< PLFLT >(val5);
14101 arg6 =
static_cast< PLFLT >(val6);
14106 arg7 =
static_cast< PLFLT >(val7);
14108 if (
_n_dims( args(5) ) > 1 )
14112 temp8 = args(5).matrix_value();
14113 arg8 = &temp8( 0, 0 );
14120 arg10 =
static_cast< PLINT >(val10);
14125 arg11 =
static_cast< PLINT >(val11);
14130 arg12 =
static_cast< PLINT >(val12);
14135 arg13 =
static_cast< PLBOOL >(val13);
14136 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14137 _outv = octave_value();
14153 return octave_value_list();
14201 octave_value_list _out;
14202 octave_value_list *_outp=&_out;
14203 octave_value _outv;
14210 if (
_n_dims( args(0) ) > 2 )
14212 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14214 temp1 = args(0).matrix_value();
14215 arg1 = &temp1( 0, 0 );
14223 arg4 =
static_cast< PLFLT >(val4);
14228 arg5 =
static_cast< PLFLT >(val5);
14233 arg6 =
static_cast< PLFLT >(val6);
14238 arg7 =
static_cast< PLFLT >(val7);
14240 if (
_n_dims( args(5) ) > 1 )
14244 temp8 = args(5).matrix_value();
14245 arg8 = &temp8( 0, 0 );
14252 arg10 =
static_cast< PLINT >(val10);
14257 arg11 =
static_cast< PLINT >(val11);
14262 arg12 =
static_cast< PLINT >(val12);
14267 arg13 =
static_cast< PLBOOL >(val13);
14269 if (
_n_dims( args(10) ) > 1 )
14273 if (
_dim( args(10), 0 ) != 6 )
14277 temp14 = args(10).matrix_value();
14278 arg14 = &temp14( 0, 0 );
14280 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14281 _outv = octave_value();
14303 return octave_value_list();
14356 octave_value_list _out;
14357 octave_value_list *_outp=&_out;
14358 octave_value _outv;
14365 if (
_n_dims( args(0) ) > 2 )
14367 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14369 temp1 = args(0).matrix_value();
14370 arg1 = &temp1( 0, 0 );
14378 arg4 =
static_cast< PLFLT >(val4);
14383 arg5 =
static_cast< PLFLT >(val5);
14388 arg6 =
static_cast< PLFLT >(val6);
14393 arg7 =
static_cast< PLFLT >(val7);
14395 if (
_n_dims( args(5) ) > 1 )
14399 temp8 = args(5).matrix_value();
14400 arg8 = &temp8( 0, 0 );
14407 arg10 =
static_cast< PLINT >(val10);
14412 arg11 =
static_cast< PLINT >(val11);
14417 arg12 =
static_cast< PLINT >(val12);
14422 arg13 =
static_cast< PLBOOL >(val13);
14424 if (
_n_dims( args(10) ) > 1 )
14428 if (
_dim( args(10), 0 ) !=
Xlen )
14432 temp14 = args(10).matrix_value();
14433 arg14 = &temp14( 0, 0 );
14436 if (
_n_dims( args(11) ) > 1 )
14440 if (
_dim( args(11), 0 ) !=
Ylen )
14444 temp15 = args(11).matrix_value();
14445 arg15 = &temp15( 0, 0 );
14447 my_plshades1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,(
double const *)arg14,(
double const *)arg15);
14448 _outv = octave_value();
14476 return octave_value_list();
14532 octave_value_list _out;
14533 octave_value_list *_outp=&_out;
14534 octave_value _outv;
14541 if (
_n_dims( args(0) ) > 2 )
14543 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14545 temp1 = args(0).matrix_value();
14546 arg1 = &temp1( 0, 0 );
14554 arg4 =
static_cast< PLFLT >(val4);
14559 arg5 =
static_cast< PLFLT >(val5);
14564 arg6 =
static_cast< PLFLT >(val6);
14569 arg7 =
static_cast< PLFLT >(val7);
14571 if (
_n_dims( args(5) ) > 1 )
14575 temp8 = args(5).matrix_value();
14576 arg8 = &temp8( 0, 0 );
14583 arg10 =
static_cast< PLINT >(val10);
14588 arg11 =
static_cast< PLINT >(val11);
14593 arg12 =
static_cast< PLINT >(val12);
14598 arg13 =
static_cast< PLBOOL >(val13);
14600 if (
_n_dims( args(10) ) > 2 )
14602 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14604 temp14 = args(10).matrix_value();
14605 arg14 = &temp14( 0, 0 );
14610 if (
_n_dims( args(11) ) > 2 )
14612 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14614 temp15 = args(11).matrix_value();
14615 arg15 = &temp15( 0, 0 );
14619 my_plshades2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,(
double const *)arg14,(
double const *)arg15);
14620 _outv = octave_value();
14648 return octave_value_list();
14680 octave_value_list _out;
14681 octave_value_list *_outp=&_out;
14682 octave_value _outv;
14689 if (
_n_dims( args(0) ) > 2 )
14691 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14693 temp1 = args(0).matrix_value();
14694 arg1 = &temp1( 0, 0 );
14699 if (
_n_dims( args(1) ) > 2 )
14701 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14705 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14709 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14711 temp2 = args(1).matrix_value();
14712 arg2 = &temp2( 0, 0 );
14720 arg5 =
static_cast< PLFLT >(val5);
14722 if (
_n_dims( args(3) ) > 1 )
14726 if (
_dim( args(3), 0 ) != 6 )
14730 temp6 = args(3).matrix_value();
14731 arg6 = &temp6( 0, 0 );
14733 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14734 _outv = octave_value();
14756 return octave_value_list();
14787 octave_value_list _out;
14788 octave_value_list *_outp=&_out;
14789 octave_value _outv;
14796 if (
_n_dims( args(0) ) > 2 )
14798 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14800 temp1 = args(0).matrix_value();
14801 arg1 = &temp1( 0, 0 );
14806 if (
_n_dims( args(1) ) > 2 )
14808 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14812 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14816 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14818 temp2 = args(1).matrix_value();
14819 arg2 = &temp2( 0, 0 );
14827 arg5 =
static_cast< PLFLT >(val5);
14829 if (
_n_dims( args(3) ) > 1 )
14837 temp6 = args(3).matrix_value();
14838 arg6 = &temp6( 0, 0 );
14841 if (
_n_dims( args(4) ) > 1 )
14849 temp7 = args(4).matrix_value();
14850 arg7 = &temp7( 0, 0 );
14852 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14853 _outv = octave_value();
14881 return octave_value_list();
14915 octave_value_list _out;
14916 octave_value_list *_outp=&_out;
14917 octave_value _outv;
14924 if (
_n_dims( args(0) ) > 2 )
14926 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14928 temp1 = args(0).matrix_value();
14929 arg1 = &temp1( 0, 0 );
14934 if (
_n_dims( args(1) ) > 2 )
14936 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14940 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14944 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14946 temp2 = args(1).matrix_value();
14947 arg2 = &temp2( 0, 0 );
14955 arg5 =
static_cast< PLFLT >(val5);
14957 if (
_n_dims( args(3) ) > 2 )
14959 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14961 temp6 = args(3).matrix_value();
14962 arg6 = &temp6( 0, 0 );
14967 if (
_n_dims( args(4) ) > 2 )
14969 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14971 temp7 = args(4).matrix_value();
14972 arg7 = &temp7( 0, 0 );
14976 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14977 _outv = octave_value();
15005 return octave_value_list();
15060 octave_value_list _out;
15061 octave_value_list *_outp=&_out;
15062 octave_value _outv;
15069 if (
_n_dims( args(0) ) > 2 )
15071 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15073 temp1 = args(0).matrix_value();
15074 arg1 = &temp1( 0, 0 );
15082 arg4 =
static_cast< PLFLT >(val4);
15087 arg5 =
static_cast< PLFLT >(val5);
15092 arg6 =
static_cast< PLFLT >(val6);
15097 arg7 =
static_cast< PLFLT >(val7);
15102 arg8 =
static_cast< PLFLT >(val8);
15107 arg9 =
static_cast< PLFLT >(val9);
15112 arg10 =
static_cast< PLFLT >(val10);
15117 arg11 =
static_cast< PLFLT >(val11);
15122 arg12 =
static_cast< PLFLT >(val12);
15127 arg13 =
static_cast< PLFLT >(val13);
15128 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15129 _outv = octave_value();
15139 return octave_value_list();
15179 octave_value_list _out;
15180 octave_value_list *_outp=&_out;
15181 octave_value _outv;
15188 if (
_n_dims( args(0) ) > 2 )
15190 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15192 temp1 = args(0).matrix_value();
15193 arg1 = &temp1( 0, 0 );
15201 arg4 =
static_cast< PLFLT >(val4);
15206 arg5 =
static_cast< PLFLT >(val5);
15211 arg6 =
static_cast< PLFLT >(val6);
15216 arg7 =
static_cast< PLFLT >(val7);
15221 arg8 =
static_cast< PLFLT >(val8);
15226 arg9 =
static_cast< PLFLT >(val9);
15231 arg10 =
static_cast< PLFLT >(val10);
15236 arg11 =
static_cast< PLFLT >(val11);
15237 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15238 _outv = octave_value();
15248 return octave_value_list();
15290 octave_value_list _out;
15291 octave_value_list *_outp=&_out;
15292 octave_value _outv;
15299 if (
_n_dims( args(0) ) > 2 )
15301 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15303 temp1 = args(0).matrix_value();
15304 arg1 = &temp1( 0, 0 );
15312 arg4 =
static_cast< PLFLT >(val4);
15317 arg5 =
static_cast< PLFLT >(val5);
15322 arg6 =
static_cast< PLFLT >(val6);
15327 arg7 =
static_cast< PLFLT >(val7);
15332 arg8 =
static_cast< PLFLT >(val8);
15337 arg9 =
static_cast< PLFLT >(val9);
15342 arg10 =
static_cast< PLFLT >(val10);
15347 arg11 =
static_cast< PLFLT >(val11);
15349 if (
_n_dims( args(9) ) > 1 )
15353 if (
_dim( args(9), 0 ) != 6 )
15357 temp12 = args(9).matrix_value();
15358 arg12 = &temp12( 0, 0 );
15360 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15361 _outv = octave_value();
15377 return octave_value_list();
15424 octave_value_list _out;
15425 octave_value_list *_outp=&_out;
15426 octave_value _outv;
15433 if (
_n_dims( args(0) ) > 2 )
15435 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15437 temp1 = args(0).matrix_value();
15438 arg1 = &temp1( 0, 0 );
15446 arg4 =
static_cast< PLFLT >(val4);
15451 arg5 =
static_cast< PLFLT >(val5);
15456 arg6 =
static_cast< PLFLT >(val6);
15461 arg7 =
static_cast< PLFLT >(val7);
15466 arg8 =
static_cast< PLFLT >(val8);
15471 arg9 =
static_cast< PLFLT >(val9);
15476 arg10 =
static_cast< PLFLT >(val10);
15481 arg11 =
static_cast< PLFLT >(val11);
15483 if (
_n_dims( args(9) ) > 1 )
15491 temp12 = args(9).matrix_value();
15492 arg12 = &temp12( 0, 0 );
15495 if (
_n_dims( args(10) ) > 1 )
15499 if (
_dim( args(10), 0 ) !=
Ylen )
15503 temp13 = args(10).matrix_value();
15504 arg13 = &temp13( 0, 0 );
15506 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15507 _outv = octave_value();
15529 return octave_value_list();
15579 octave_value_list _out;
15580 octave_value_list *_outp=&_out;
15581 octave_value _outv;
15588 if (
_n_dims( args(0) ) > 2 )
15590 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15592 temp1 = args(0).matrix_value();
15593 arg1 = &temp1( 0, 0 );
15601 arg4 =
static_cast< PLFLT >(val4);
15606 arg5 =
static_cast< PLFLT >(val5);
15611 arg6 =
static_cast< PLFLT >(val6);
15616 arg7 =
static_cast< PLFLT >(val7);
15621 arg8 =
static_cast< PLFLT >(val8);
15626 arg9 =
static_cast< PLFLT >(val9);
15631 arg10 =
static_cast< PLFLT >(val10);
15636 arg11 =
static_cast< PLFLT >(val11);
15638 if (
_n_dims( args(9) ) > 2 )
15640 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15642 temp12 = args(9).matrix_value();
15643 arg12 = &temp12( 0, 0 );
15648 if (
_n_dims( args(10) ) > 2 )
15650 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15652 temp13 = args(10).matrix_value();
15653 arg13 = &temp13( 0, 0 );
15657 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15658 _outv = octave_value();
15680 return octave_value_list();
15715 char **arg18 = (
char **) 0 ;
15717 char **arg20 = (
char **) 0 ;
15757 octave_value_list _out;
15758 octave_value_list *_outp=&_out;
15759 octave_value _outv;
15771 arg3 =
static_cast< PLINT >(val3);
15776 arg4 =
static_cast< PLINT >(val4);
15781 arg5 =
static_cast< PLFLT >(val5);
15786 arg6 =
static_cast< PLFLT >(val6);
15791 arg7 =
static_cast< PLFLT >(val7);
15796 arg8 =
static_cast< PLFLT >(val8);
15801 arg9 =
static_cast< PLINT >(val9);
15806 arg10 =
static_cast< PLINT >(val10);
15811 arg11 =
static_cast< PLINT >(val11);
15816 arg12 =
static_cast< PLFLT >(val12);
15821 arg13 =
static_cast< PLFLT >(val13);
15826 arg14 =
static_cast< PLINT >(val14);
15831 arg15 =
static_cast< PLFLT >(val15);
15833 if (
_n_dims( args(13) ) > 1 )
15839 temp16 = args(13).matrix_value();
15843 charMatrix temp_matrix;
15847 size_t max_length = 0, non_blank_length;
15849 if (
_n_dims( args(14) ) > 2 )
15851 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15853#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15854 if ( !args(14).isempty() )
15856 if ( !args(14).is_empty() )
15859 if (
_dim( args(14), 0 ) !=
Alen )
15861 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15863 arg18 =
new char*[
Alen];
15864#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15865 ifcell = args(14).iscell();
15867 ifcell = args(14).is_cell();
15871 temp_cell = args(14).cell_value();
15875 temp_matrix = args(14).char_matrix_value();
15877 max_length =
_dim( args(14), 1 ) + 1;
15880 for ( i = 0; i <
Alen; i++ )
15887 if ( temp_cell.elem( i ).is_string() )
15889 str = temp_cell.elem( i ).string_value();
15891 max_length = str.size() + 1;
15892 tmp_cstring = (
char *) str.c_str();
15902 tmp_cstring = (
char *)
"";
15907 str = temp_matrix.row_as_string( i );
15908 tmp_cstring = (
char *) str.c_str();
15910 arg18[i] =
new char[max_length];
15911 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15912 arg18[i][max_length - 1] =
'\0';
15927 non_blank_length = max_length - 2;
15928 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15930 non_blank_length--;
15932 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15934 non_blank_length--;
15936 arg18[i][non_blank_length + 1] =
'\0';
15946 charMatrix temp_matrix;
15950 size_t max_length = 0, non_blank_length;
15952 if (
_n_dims( args(15) ) > 2 )
15954 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15956#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15957 if ( !args(15).isempty() )
15959 if ( !args(15).is_empty() )
15964 arg20 =
new char*[
Alen];
15965#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15966 ifcell = args(15).iscell();
15968 ifcell = args(15).is_cell();
15972 temp_cell = args(15).cell_value();
15976 temp_matrix = args(15).char_matrix_value();
15978 max_length =
_dim( args(15), 1 ) + 1;
15981 for ( i = 0; i <
Alen; i++ )
15988 if ( temp_cell.elem( i ).is_string() )
15990 str = temp_cell.elem( i ).string_value();
15992 max_length = str.size() + 1;
15993 tmp_cstring = (
char *) str.c_str();
16003 tmp_cstring = (
char *)
"";
16008 str = temp_matrix.row_as_string( i );
16009 tmp_cstring = (
char *) str.c_str();
16011 arg20[i] =
new char[max_length];
16012 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16013 arg20[i][max_length - 1] =
'\0';
16028 non_blank_length = max_length - 2;
16029 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16031 non_blank_length--;
16033 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16035 non_blank_length--;
16037 arg20[i][non_blank_length + 1] =
'\0';
16048 if (
_n_dims( args(16) ) > 1 )
16052 if (
_dim( args(16), 0 ) !=
Alen )
16056 temp21 = args(16).matrix_value();
16057 arg21 = &temp21( 0, 0 );
16060 if (
_n_dims( args(17) ) > 1 )
16064 if (
_dim( args(17), 0 ) !=
Alen )
16068 temp22 = args(17).matrix_value();
16074 if (
_n_dims( args(18) ) > 1 )
16078 if (
_dim( args(18), 0 ) !=
Alen )
16083 temp23 = args(18).matrix_value();
16087 for ( i = 0; i <
Xlen; i++ )
16088 if ( arg23[i] >
Ylen )
16092 if (
_n_dims( args(19) ) > 2 )
16094 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16096 if (
_dim( args(19), 0 ) !=
Xlen )
16098 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16100 if (
_dim( args(19), 1 ) !=
Ylen )
16102 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16104 temp24 = args(19).matrix_value();
16105 arg24 = &temp24( 0, 0 );
16107 my_plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(
int const *)arg17,(
char const **)arg18,arg19,(
char const **)arg20,(
double const *)arg21,(
int const *)arg22,(
int const *)arg23,(
double const *)arg24);
16108 _outv = octave_value();
16127 if ( arg18 != NULL )
16129 for ( i = 0; i <
Alen; i++ )
16138 if ( arg20 != NULL )
16140 for ( i = 0; i <
Alen; i++ )
16166 if ( arg18 != NULL )
16168 for ( i = 0; i <
Alen; i++ )
16177 if ( arg20 != NULL )
16179 for ( i = 0; i <
Alen; i++ )
16198 return octave_value_list();
16206 if ( arg18 != NULL )
16208 for ( i = 0; i <
Alen; i++ )
16217 if ( arg20 != NULL )
16219 for ( i = 0; i <
Alen; i++ )
16250 octave_value_list _out;
16251 octave_value_list *_outp=&_out;
16252 octave_value _outv;
16267 arg2 =
static_cast< int >(val2);
16268 if (arg1) (arg1)->type = arg2;
16269 _outv = octave_value();
16273 return octave_value_list();
16285 octave_value_list _out;
16286 octave_value_list *_outp=&_out;
16287 octave_value _outv;
16299 result = (int) ((arg1)->type);
16304 return octave_value_list();
16314 unsigned int arg2 ;
16317 unsigned int val2 ;
16319 octave_value_list _out;
16320 octave_value_list *_outp=&_out;
16321 octave_value _outv;
16336 arg2 =
static_cast< unsigned int >(val2);
16337 if (arg1) (arg1)->state = arg2;
16338 _outv = octave_value();
16342 return octave_value_list();
16354 octave_value_list _out;
16355 octave_value_list *_outp=&_out;
16356 octave_value _outv;
16357 unsigned int result;
16368 result = (
unsigned int) ((arg1)->state);
16373 return octave_value_list();
16383 unsigned int arg2 ;
16386 unsigned int val2 ;
16388 octave_value_list _out;
16389 octave_value_list *_outp=&_out;
16390 octave_value _outv;
16405 arg2 =
static_cast< unsigned int >(val2);
16406 if (arg1) (arg1)->keysym = arg2;
16407 _outv = octave_value();
16411 return octave_value_list();
16423 octave_value_list _out;
16424 octave_value_list *_outp=&_out;
16425 octave_value _outv;
16426 unsigned int result;
16437 result = (
unsigned int) ((arg1)->keysym);
16442 return octave_value_list();
16452 unsigned int arg2 ;
16455 unsigned int val2 ;
16457 octave_value_list _out;
16458 octave_value_list *_outp=&_out;
16459 octave_value _outv;
16474 arg2 =
static_cast< unsigned int >(val2);
16475 if (arg1) (arg1)->button = arg2;
16476 _outv = octave_value();
16480 return octave_value_list();
16492 octave_value_list _out;
16493 octave_value_list *_outp=&_out;
16494 octave_value _outv;
16495 unsigned int result;
16506 result = (
unsigned int) ((arg1)->button);
16511 return octave_value_list();
16526 octave_value_list _out;
16527 octave_value_list *_outp=&_out;
16528 octave_value _outv;
16543 arg2 =
static_cast< PLINT >(val2);
16544 if (arg1) (arg1)->subwindow = arg2;
16545 _outv = octave_value();
16549 return octave_value_list();
16561 octave_value_list _out;
16562 octave_value_list *_outp=&_out;
16563 octave_value _outv;
16575 result = (
PLINT) ((arg1)->subwindow);
16580 return octave_value_list();
16590 char *arg2 = (
char *) (
char *)0 ;
16595 octave_value_list _out;
16596 octave_value_list *_outp=&_out;
16597 octave_value _outv;
16612 arg2 =
reinterpret_cast< char *
>(temp2);
16613 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16614 else memset(arg1->
string,0,16*
sizeof(
char));
16615 _outv = octave_value();
16619 return octave_value_list();
16631 octave_value_list _out;
16632 octave_value_list *_outp=&_out;
16633 octave_value _outv;
16645 result = (
char *)(
char *) ((arg1)->string);
16656 return octave_value_list();
16671 octave_value_list _out;
16672 octave_value_list *_outp=&_out;
16673 octave_value _outv;
16688 arg2 =
static_cast< int >(val2);
16689 if (arg1) (arg1)->pX = arg2;
16690 _outv = octave_value();
16694 return octave_value_list();
16706 octave_value_list _out;
16707 octave_value_list *_outp=&_out;
16708 octave_value _outv;
16720 result = (int) ((arg1)->pX);
16725 return octave_value_list();
16740 octave_value_list _out;
16741 octave_value_list *_outp=&_out;
16742 octave_value _outv;
16757 arg2 =
static_cast< int >(val2);
16758 if (arg1) (arg1)->pY = arg2;
16759 _outv = octave_value();
16763 return octave_value_list();
16775 octave_value_list _out;
16776 octave_value_list *_outp=&_out;
16777 octave_value _outv;
16789 result = (int) ((arg1)->pY);
16794 return octave_value_list();
16809 octave_value_list _out;
16810 octave_value_list *_outp=&_out;
16811 octave_value _outv;
16826 arg2 =
static_cast< PLFLT >(val2);
16827 if (arg1) (arg1)->dX = arg2;
16828 _outv = octave_value();
16832 return octave_value_list();
16844 octave_value_list _out;
16845 octave_value_list *_outp=&_out;
16846 octave_value _outv;
16858 result = (
PLFLT) ((arg1)->dX);
16863 return octave_value_list();
16878 octave_value_list _out;
16879 octave_value_list *_outp=&_out;
16880 octave_value _outv;
16895 arg2 =
static_cast< PLFLT >(val2);
16896 if (arg1) (arg1)->dY = arg2;
16897 _outv = octave_value();
16901 return octave_value_list();
16913 octave_value_list _out;
16914 octave_value_list *_outp=&_out;
16915 octave_value _outv;
16927 result = (
PLFLT) ((arg1)->dY);
16932 return octave_value_list();
16947 octave_value_list _out;
16948 octave_value_list *_outp=&_out;
16949 octave_value _outv;
16964 arg2 =
static_cast< PLFLT >(val2);
16965 if (arg1) (arg1)->wX = arg2;
16966 _outv = octave_value();
16970 return octave_value_list();
16982 octave_value_list _out;
16983 octave_value_list *_outp=&_out;
16984 octave_value _outv;
16996 result = (
PLFLT) ((arg1)->wX);
17001 return octave_value_list();
17016 octave_value_list _out;
17017 octave_value_list *_outp=&_out;
17018 octave_value _outv;
17033 arg2 =
static_cast< PLFLT >(val2);
17034 if (arg1) (arg1)->wY = arg2;
17035 _outv = octave_value();
17039 return octave_value_list();
17051 octave_value_list _out;
17052 octave_value_list *_outp=&_out;
17053 octave_value _outv;
17065 result = (
PLFLT) ((arg1)->wY);
17070 return octave_value_list();
17079 octave_value_list _out;
17080 octave_value_list *_outp=&_out;
17081 octave_value _outv;
17093 return octave_value_list();
17105 octave_value_list _out;
17106 octave_value_list *_outp=&_out;
17107 octave_value _outv;
17119 _outv = octave_value();
17123 return octave_value_list();
17157 octave_value_list _out;
17158 octave_value_list *_outp=&_out;
17159 octave_value _outv;
17169 arg1 =
static_cast< PLINT >(val1);
17174 arg2 =
static_cast< PLINT >(val2);
17176 _outv = octave_value();
17180 return octave_value_list();
17201 octave_value_list _out;
17202 octave_value_list *_outp=&_out;
17203 octave_value _outv;
17213 arg1 =
static_cast< PLFLT >(val1);
17218 arg2 =
static_cast< PLFLT >(val2);
17223 arg3 =
static_cast< PLFLT >(val3);
17228 arg4 =
static_cast< PLINT >(val4);
17230 _outv = octave_value();
17234 return octave_value_list();
17246 octave_value_list _out;
17247 octave_value_list *_outp=&_out;
17248 octave_value _outv;
17258 arg1 =
static_cast< PLINT >(val1);
17260 _outv = octave_value();
17264 return octave_value_list();
17297 octave_value_list _out;
17298 octave_value_list *_outp=&_out;
17299 octave_value _outv;
17309 arg1 =
static_cast< PLFLT >(val1);
17314 arg2 =
static_cast< PLFLT >(val2);
17319 arg3 =
static_cast< PLFLT >(val3);
17324 arg4 =
static_cast< PLFLT >(val4);
17329 arg5 =
static_cast< PLFLT >(val5);
17334 arg6 =
static_cast< PLFLT >(val6);
17339 arg7 =
static_cast< PLFLT >(val7);
17344 arg8 =
static_cast< PLBOOL >(val8);
17345 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17346 _outv = octave_value();
17350 return octave_value_list();
17361 char *arg3 = (
char *) 0 ;
17364 char *arg6 = (
char *) 0 ;
17385 octave_value_list _out;
17386 octave_value_list *_outp=&_out;
17387 octave_value _outv;
17397 arg1 =
static_cast< PLFLT >(val1);
17402 arg2 =
static_cast< PLFLT >(val2);
17407 arg3 =
reinterpret_cast< char *
>(buf3);
17412 arg4 =
static_cast< PLFLT >(val4);
17417 arg5 =
static_cast< PLINT >(val5);
17422 arg6 =
reinterpret_cast< char *
>(buf6);
17427 arg7 =
static_cast< PLFLT >(val7);
17432 arg8 =
static_cast< PLINT >(val8);
17433 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17434 _outv = octave_value();
17442 return octave_value_list();
17461 octave_value_list _out;
17462 octave_value_list *_outp=&_out;
17463 octave_value _outv;
17470 if (
_n_dims( args(0) ) > 1 )
17475 temp1 = args(0).matrix_value();
17476 arg2 = &temp1( 0, 0 );
17479 if (
_n_dims( args(1) ) > 1 )
17487 temp3 = args(1).matrix_value();
17488 arg3 = &temp3( 0, 0 );
17494 arg4 =
static_cast< PLINT >(val4);
17495 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17496 _outv = octave_value();
17512 return octave_value_list();
17548 octave_value_list _out;
17549 octave_value_list *_outp=&_out;
17550 octave_value _outv;
17566 arg7 =
static_cast< PLFLT >(val7);
17567 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17568 _outv = octave_value();
17608 return octave_value_list();
17617 octave_value_list _out;
17618 octave_value_list *_outp=&_out;
17619 octave_value _outv;
17626 _outv = octave_value();
17630 return octave_value_list();
17639 char *arg1 = (
char *) 0 ;
17642 char *arg4 = (
char *) 0 ;
17659 octave_value_list _out;
17660 octave_value_list *_outp=&_out;
17661 octave_value _outv;
17671 arg1 =
reinterpret_cast< char *
>(buf1);
17676 arg2 =
static_cast< PLFLT >(val2);
17681 arg3 =
static_cast< PLINT >(val3);
17686 arg4 =
reinterpret_cast< char *
>(buf4);
17691 arg5 =
static_cast< PLFLT >(val5);
17696 arg6 =
static_cast< PLINT >(val6);
17697 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17698 _outv = octave_value();
17706 return octave_value_list();
17717 char *arg1 = (
char *) 0 ;
17718 char *arg2 = (
char *) 0 ;
17721 char *arg5 = (
char *) 0 ;
17722 char *arg6 = (
char *) 0 ;
17725 char *arg9 = (
char *) 0 ;
17726 char *arg10 = (
char *) 0 ;
17759 octave_value_list _out;
17760 octave_value_list *_outp=&_out;
17761 octave_value _outv;
17771 arg1 =
reinterpret_cast< char *
>(buf1);
17776 arg2 =
reinterpret_cast< char *
>(buf2);
17781 arg3 =
static_cast< PLFLT >(val3);
17786 arg4 =
static_cast< PLINT >(val4);
17791 arg5 =
reinterpret_cast< char *
>(buf5);
17796 arg6 =
reinterpret_cast< char *
>(buf6);
17801 arg7 =
static_cast< PLFLT >(val7);
17806 arg8 =
static_cast< PLINT >(val8);
17811 arg9 =
reinterpret_cast< char *
>(buf9);
17816 arg10 =
reinterpret_cast< char *
>(buf10);
17821 arg11 =
static_cast< PLFLT >(val11);
17826 arg12 =
static_cast< PLINT >(val12);
17827 plbox3((
char const *)arg1,(
char const *)arg2,arg3,arg4,(
char const *)arg5,(
char const *)arg6,arg7,arg8,(
char const *)arg9,(
char const *)arg10,arg11,arg12);
17828 _outv = octave_value();
17844 return octave_value_list();
17874 octave_value_list _out;
17875 octave_value_list *_outp=&_out;
17876 octave_value _outv;
17889 arg1 =
static_cast< PLFLT >(val1);
17894 arg2 =
static_cast< PLFLT >(val2);
17896 _outv = octave_value();
17918 return octave_value_list();
17927 octave_value_list _out;
17928 octave_value_list *_outp=&_out;
17929 octave_value _outv;
17936 _outv = octave_value();
17940 return octave_value_list();
17952 octave_value_list _out;
17953 octave_value_list *_outp=&_out;
17954 octave_value _outv;
17964 arg1 =
static_cast< PLINT >(val1);
17966 _outv = octave_value();
17970 return octave_value_list();
17982 octave_value_list _out;
17983 octave_value_list *_outp=&_out;
17984 octave_value _outv;
17994 arg1 =
static_cast< PLFLT >(val1);
17996 _outv = octave_value();
18000 return octave_value_list();
18042 octave_value_list _out;
18043 octave_value_list *_outp=&_out;
18044 octave_value _outv;
18054 arg1 =
static_cast< PLFLT >(val1);
18059 arg2 =
static_cast< PLFLT >(val2);
18064 arg3 =
static_cast< PLFLT >(val3);
18069 arg4 =
static_cast< PLINT >(val4);
18074 arg5 =
static_cast< PLBOOL >(val5);
18079 arg6 =
static_cast< PLINT >(val6);
18084 arg7 =
static_cast< PLINT >(val7);
18089 arg8 =
static_cast< PLINT >(val8);
18094 arg9 =
static_cast< PLINT >(val9);
18099 arg10 =
static_cast< PLINT >(val10);
18104 arg11 =
static_cast< PLFLT >(val11);
18105 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18106 _outv = octave_value();
18110 return octave_value_list();
18140 octave_value_list _out;
18141 octave_value_list *_outp=&_out;
18142 octave_value _outv;
18153 arg1 =
static_cast< PLINT >(val1);
18158 arg2 =
static_cast< PLINT >(val2);
18163 arg3 =
static_cast< PLINT >(val3);
18168 arg4 =
static_cast< PLINT >(val4);
18173 arg5 =
static_cast< PLINT >(val5);
18178 arg6 =
static_cast< PLFLT >(val6);
18179 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18180 _outv = octave_value();
18190 return octave_value_list();
18205 octave_value_list _out;
18206 octave_value_list *_outp=&_out;
18207 octave_value _outv;
18217 arg1 =
static_cast< PLINT >(val1);
18222 arg2 =
static_cast< PLBOOL >(val2);
18224 _outv = octave_value();
18228 return octave_value_list();
18237 octave_value_list _out;
18238 octave_value_list *_outp=&_out;
18239 octave_value _outv;
18246 _outv = octave_value();
18250 return octave_value_list();
18259 octave_value_list _out;
18260 octave_value_list *_outp=&_out;
18261 octave_value _outv;
18268 _outv = octave_value();
18272 return octave_value_list();
18299 octave_value_list _out;
18300 octave_value_list *_outp=&_out;
18301 octave_value _outv;
18311 arg1 =
static_cast< PLFLT >(val1);
18316 arg2 =
static_cast< PLFLT >(val2);
18321 arg3 =
static_cast< PLFLT >(val3);
18326 arg4 =
static_cast< PLFLT >(val4);
18331 arg5 =
static_cast< PLINT >(val5);
18336 arg6 =
static_cast< PLINT >(val6);
18337 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18338 _outv = octave_value();
18342 return octave_value_list();
18369 octave_value_list _out;
18370 octave_value_list *_outp=&_out;
18371 octave_value _outv;
18381 arg1 =
static_cast< PLFLT >(val1);
18386 arg2 =
static_cast< PLFLT >(val2);
18391 arg3 =
static_cast< PLFLT >(val3);
18396 arg4 =
static_cast< PLFLT >(val4);
18401 arg5 =
static_cast< PLINT >(val5);
18406 arg6 =
static_cast< PLINT >(val6);
18407 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18408 _outv = octave_value();
18412 return octave_value_list();
18421 octave_value_list _out;
18422 octave_value_list *_outp=&_out;
18423 octave_value _outv;
18430 _outv = octave_value();
18434 return octave_value_list();
18450 octave_value_list _out;
18451 octave_value_list *_outp=&_out;
18452 octave_value _outv;
18459 if (
_n_dims( args(0) ) > 1 )
18464 temp1 = args(0).matrix_value();
18465 arg2 = &temp1( 0, 0 );
18468 if (
_n_dims( args(1) ) > 1 )
18476 temp3 = args(1).matrix_value();
18477 arg3 = &temp3( 0, 0 );
18480 if (
_n_dims( args(2) ) > 1 )
18488 temp4 = args(2).matrix_value();
18489 arg4 = &temp4( 0, 0 );
18491 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18492 _outv = octave_value();
18514 return octave_value_list();
18539 octave_value_list _out;
18540 octave_value_list *_outp=&_out;
18541 octave_value _outv;
18548 if (
_n_dims( args(0) ) > 1 )
18553 temp1 = args(0).matrix_value();
18554 arg2 = &temp1( 0, 0 );
18557 if (
_n_dims( args(1) ) > 1 )
18565 temp3 = args(1).matrix_value();
18566 arg3 = &temp3( 0, 0 );
18569 if (
_n_dims( args(2) ) > 1 )
18577 temp4 = args(2).matrix_value();
18578 arg4 = &temp4( 0, 0 );
18580 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18581 _outv = octave_value();
18603 return octave_value_list();
18621 octave_value_list _out;
18622 octave_value_list *_outp=&_out;
18623 octave_value _outv;
18630 _outv = octave_value();
18634 return octave_value_list();
18648 octave_value_list _out;
18649 octave_value_list *_outp=&_out;
18650 octave_value _outv;
18657 if (
_n_dims( args(0) ) > 1 )
18662 temp1 = args(0).matrix_value();
18663 arg2 = &temp1( 0, 0 );
18666 if (
_n_dims( args(1) ) > 1 )
18674 temp3 = args(1).matrix_value();
18675 arg3 = &temp3( 0, 0 );
18677 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18678 _outv = octave_value();
18694 return octave_value_list();
18716 octave_value_list _out;
18717 octave_value_list *_outp=&_out;
18718 octave_value _outv;
18725 if (
_n_dims( args(0) ) > 1 )
18730 temp1 = args(0).matrix_value();
18731 arg2 = &temp1( 0, 0 );
18734 if (
_n_dims( args(1) ) > 1 )
18742 temp3 = args(1).matrix_value();
18743 arg3 = &temp3( 0, 0 );
18746 if (
_n_dims( args(2) ) > 1 )
18754 temp4 = args(2).matrix_value();
18755 arg4 = &temp4( 0, 0 );
18757 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18758 _outv = octave_value();
18780 return octave_value_list();
18806 octave_value_list _out;
18807 octave_value_list *_outp=&_out;
18808 octave_value _outv;
18815 if (
_n_dims( args(0) ) > 1 )
18820 temp1 = args(0).matrix_value();
18821 arg2 = &temp1( 0, 0 );
18824 if (
_n_dims( args(1) ) > 1 )
18832 temp3 = args(1).matrix_value();
18833 arg3 = &temp3( 0, 0 );
18839 arg4 =
static_cast< PLFLT >(val4);
18840 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18841 _outv = octave_value();
18857 return octave_value_list();
18872 octave_value_list _out;
18873 octave_value_list *_outp=&_out;
18874 octave_value _outv;
18881 _outv = octave_value();
18885 return octave_value_list();
18897 octave_value_list _out;
18898 octave_value_list *_outp=&_out;
18899 octave_value _outv;
18909 arg1 =
static_cast< PLINT >(val1);
18911 _outv = octave_value();
18915 return octave_value_list();
18927 octave_value_list _out;
18928 octave_value_list *_outp=&_out;
18929 octave_value _outv;
18939 arg1 =
static_cast< PLINT >(val1);
18941 _outv = octave_value();
18945 return octave_value_list();
18960 octave_value_list _out;
18961 octave_value_list *_outp=&_out;
18962 octave_value _outv;
18971 _outv = octave_value();
18987 return octave_value_list();
19008 octave_value_list _out;
19009 octave_value_list *_outp=&_out;
19010 octave_value _outv;
19023 arg1 =
static_cast< PLINT >(val1);
19024 plgcol0(arg1,arg2,arg3,arg4);
19025 _outv = octave_value();
19047 return octave_value_list();
19071 octave_value_list _out;
19072 octave_value_list *_outp=&_out;
19073 octave_value _outv;
19087 arg1 =
static_cast< PLINT >(val1);
19088 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19089 _outv = octave_value();
19117 return octave_value_list();
19135 octave_value_list _out;
19136 octave_value_list *_outp=&_out;
19137 octave_value _outv;
19147 _outv = octave_value();
19169 return octave_value_list();
19190 octave_value_list _out;
19191 octave_value_list *_outp=&_out;
19192 octave_value _outv;
19203 _outv = octave_value();
19231 return octave_value_list();
19243 octave_value_list _out;
19244 octave_value_list *_outp=&_out;
19245 octave_value _outv;
19253 _outv = octave_value();
19263 return octave_value_list();
19272 char *arg1 = (
char *) 0 ;
19273 char local_string1[80] ;
19274 size_t local_string_length1 ;
19275 charMatrix local_charMatrix1 ;
19276 octave_value_list retval1 ;
19277 octave_value_list _out;
19278 octave_value_list *_outp=&_out;
19279 octave_value _outv;
19283 arg1 = local_string1;
19289 _outv = octave_value();
19292 local_string_length1 = strlen( local_string1 );
19293 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19294 local_charMatrix1.insert( local_string1, 0, 0 );
19295 retval1( 0 ) = octave_value( local_charMatrix1 );
19300 return octave_value_list();
19321 octave_value_list _out;
19322 octave_value_list *_outp=&_out;
19323 octave_value _outv;
19334 _outv = octave_value();
19362 return octave_value_list();
19374 octave_value_list _out;
19375 octave_value_list *_outp=&_out;
19376 octave_value _outv;
19384 _outv = octave_value();
19394 return octave_value_list();
19415 octave_value_list _out;
19416 octave_value_list *_outp=&_out;
19417 octave_value _outv;
19428 _outv = octave_value();
19456 return octave_value_list();
19474 octave_value_list _out;
19475 octave_value_list *_outp=&_out;
19476 octave_value _outv;
19486 _outv = octave_value();
19508 return octave_value_list();
19520 octave_value_list _out;
19521 octave_value_list *_outp=&_out;
19522 octave_value _outv;
19530 _outv = octave_value();
19540 return octave_value_list();
19549 char *arg1 = (
char *) 0 ;
19550 char local_string1[80] ;
19551 size_t local_string_length1 ;
19552 charMatrix local_charMatrix1 ;
19553 octave_value_list retval1 ;
19554 octave_value_list _out;
19555 octave_value_list *_outp=&_out;
19556 octave_value _outv;
19560 arg1 = local_string1;
19566 _outv = octave_value();
19569 local_string_length1 = strlen( local_string1 );
19570 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19571 local_charMatrix1.insert( local_string1, 0, 0 );
19572 retval1( 0 ) = octave_value( local_charMatrix1 );
19577 return octave_value_list();
19595 octave_value_list _out;
19596 octave_value_list *_outp=&_out;
19597 octave_value _outv;
19607 _outv = octave_value();
19629 return octave_value_list();
19641 octave_value_list _out;
19642 octave_value_list *_outp=&_out;
19643 octave_value _outv;
19651 _outv = octave_value();
19661 return octave_value_list();
19688 octave_value_list _out;
19689 octave_value_list *_outp=&_out;
19690 octave_value _outv;
19702 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19703 _outv = octave_value();
19743 return octave_value_list();
19752 octave_value_list _out;
19753 octave_value_list *_outp=&_out;
19754 octave_value _outv;
19761 _outv = octave_value();
19765 return octave_value_list();
19786 octave_value_list _out;
19787 octave_value_list *_outp=&_out;
19788 octave_value _outv;
19798 plgspa(arg1,arg2,arg3,arg4);
19799 _outv = octave_value();
19827 return octave_value_list();
19839 octave_value_list _out;
19840 octave_value_list *_outp=&_out;
19841 octave_value _outv;
19849 _outv = octave_value();
19859 return octave_value_list();
19868 char *arg1 = (
char *) 0 ;
19869 char local_string1[80] ;
19870 size_t local_string_length1 ;
19871 charMatrix local_charMatrix1 ;
19872 octave_value_list retval1 ;
19873 octave_value_list _out;
19874 octave_value_list *_outp=&_out;
19875 octave_value _outv;
19879 arg1 = local_string1;
19885 _outv = octave_value();
19888 local_string_length1 = strlen( local_string1 );
19889 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19890 local_charMatrix1.insert( local_string1, 0, 0 );
19891 retval1( 0 ) = octave_value( local_charMatrix1 );
19896 return octave_value_list();
19917 octave_value_list _out;
19918 octave_value_list *_outp=&_out;
19919 octave_value _outv;
19929 plgvpd(arg1,arg2,arg3,arg4);
19930 _outv = octave_value();
19958 return octave_value_list();
19979 octave_value_list _out;
19980 octave_value_list *_outp=&_out;
19981 octave_value _outv;
19991 plgvpw(arg1,arg2,arg3,arg4);
19992 _outv = octave_value();
20020 return octave_value_list();
20035 octave_value_list _out;
20036 octave_value_list *_outp=&_out;
20037 octave_value _outv;
20046 _outv = octave_value();
20062 return octave_value_list();
20077 octave_value_list _out;
20078 octave_value_list *_outp=&_out;
20079 octave_value _outv;
20088 _outv = octave_value();
20104 return octave_value_list();
20119 octave_value_list _out;
20120 octave_value_list *_outp=&_out;
20121 octave_value _outv;
20130 _outv = octave_value();
20146 return octave_value_list();
20170 octave_value_list _out;
20171 octave_value_list *_outp=&_out;
20172 octave_value _outv;
20179 if (
_n_dims( args(0) ) > 1 )
20184 temp1 = args(0).matrix_value();
20185 arg2 = &temp1( 0, 0 );
20191 arg3 =
static_cast< PLFLT >(val3);
20196 arg4 =
static_cast< PLFLT >(val4);
20201 arg5 =
static_cast< PLINT >(val5);
20206 arg6 =
static_cast< PLINT >(val6);
20207 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20208 _outv = octave_value();
20218 return octave_value_list();
20248 octave_value_list _out;
20249 octave_value_list *_outp=&_out;
20250 octave_value _outv;
20263 arg1 =
static_cast< PLFLT >(val1);
20268 arg2 =
static_cast< PLFLT >(val2);
20273 arg3 =
static_cast< PLFLT >(val3);
20274 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20275 _outv = octave_value();
20297 return octave_value_list();
20306 octave_value_list _out;
20307 octave_value_list *_outp=&_out;
20308 octave_value _outv;
20315 _outv = octave_value();
20319 return octave_value_list();
20340 octave_value_list _out;
20341 octave_value_list *_outp=&_out;
20342 octave_value _outv;
20352 arg1 =
static_cast< PLFLT >(val1);
20357 arg2 =
static_cast< PLFLT >(val2);
20362 arg3 =
static_cast< PLFLT >(val3);
20367 arg4 =
static_cast< PLFLT >(val4);
20368 pljoin(arg1,arg2,arg3,arg4);
20369 _outv = octave_value();
20373 return octave_value_list();
20382 char *arg1 = (
char *) 0 ;
20383 char *arg2 = (
char *) 0 ;
20384 char *arg3 = (
char *) 0 ;
20394 octave_value_list _out;
20395 octave_value_list *_outp=&_out;
20396 octave_value _outv;
20406 arg1 =
reinterpret_cast< char *
>(buf1);
20411 arg2 =
reinterpret_cast< char *
>(buf2);
20416 arg3 =
reinterpret_cast< char *
>(buf3);
20417 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20418 _outv = octave_value();
20428 return octave_value_list();
20459 char **arg20 = (
char **) 0 ;
20470 char **arg31 = (
char **) 0 ;
20515 octave_value_list _out;
20516 octave_value_list *_outp=&_out;
20517 octave_value _outv;
20529 arg3 =
static_cast< PLINT >(val3);
20534 arg4 =
static_cast< PLINT >(val4);
20539 arg5 =
static_cast< PLFLT >(val5);
20544 arg6 =
static_cast< PLFLT >(val6);
20549 arg7 =
static_cast< PLFLT >(val7);
20554 arg8 =
static_cast< PLINT >(val8);
20559 arg9 =
static_cast< PLINT >(val9);
20564 arg10 =
static_cast< PLINT >(val10);
20569 arg11 =
static_cast< PLINT >(val11);
20574 arg12 =
static_cast< PLINT >(val12);
20576 if (
_n_dims( args(10) ) > 1 )
20582 temp13 = args(10).matrix_value();
20589 arg15 =
static_cast< PLFLT >(val15);
20594 arg16 =
static_cast< PLFLT >(val16);
20599 arg17 =
static_cast< PLFLT >(val17);
20604 arg18 =
static_cast< PLFLT >(val18);
20606 if (
_n_dims( args(15) ) > 1 )
20610 if (
_dim( args(15), 0 ) !=
Alen )
20614 temp19 = args(15).matrix_value();
20619 charMatrix temp_matrix;
20623 size_t max_length = 0, non_blank_length;
20625 if (
_n_dims( args(16) ) > 2 )
20627 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20629#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20630 if ( !args(16).isempty() )
20632 if ( !args(16).is_empty() )
20635 if (
_dim( args(16), 0 ) !=
Alen )
20637 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20639 arg20 =
new char*[
Alen];
20640#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20641 ifcell = args(16).iscell();
20643 ifcell = args(16).is_cell();
20647 temp_cell = args(16).cell_value();
20651 temp_matrix = args(16).char_matrix_value();
20653 max_length =
_dim( args(16), 1 ) + 1;
20656 for ( i = 0; i <
Alen; i++ )
20663 if ( temp_cell.elem( i ).is_string() )
20665 str = temp_cell.elem( i ).string_value();
20667 max_length = str.size() + 1;
20668 tmp_cstring = (
char *) str.c_str();
20678 tmp_cstring = (
char *)
"";
20683 str = temp_matrix.row_as_string( i );
20684 tmp_cstring = (
char *) str.c_str();
20686 arg20[i] =
new char[max_length];
20687 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20688 arg20[i][max_length - 1] =
'\0';
20703 non_blank_length = max_length - 2;
20704 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20706 non_blank_length--;
20708 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20710 non_blank_length--;
20712 arg20[i][non_blank_length + 1] =
'\0';
20722 if (
_n_dims( args(17) ) > 1 )
20726#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20727 if ( !args(17).isempty() )
20729 if ( !args(17).is_empty() )
20732 if (
_dim( args(17), 0 ) !=
Alen )
20736 temp21 = args(17).matrix_value();
20746 if (
_n_dims( args(18) ) > 1 )
20750#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20751 if ( !args(18).isempty() )
20753 if ( !args(18).is_empty() )
20756 if (
_dim( args(18), 0 ) !=
Alen )
20760 temp22 = args(18).matrix_value();
20770 if (
_n_dims( args(19) ) > 1 )
20774#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20775 if ( !args(19).isempty() )
20777 if ( !args(19).is_empty() )
20780 if (
_dim( args(19), 0 ) !=
Alen )
20784 temp23 = args(19).matrix_value();
20785 arg23 = &temp23( 0, 0 );
20793 if (
_n_dims( args(20) ) > 1 )
20797#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20798 if ( !args(20).isempty() )
20800 if ( !args(20).is_empty() )
20803 if (
_dim( args(20), 0 ) !=
Alen )
20807 temp24 = args(20).matrix_value();
20808 arg24 = &temp24( 0, 0 );
20816 if (
_n_dims( args(21) ) > 1 )
20820#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20821 if ( !args(21).isempty() )
20823 if ( !args(21).is_empty() )
20826 if (
_dim( args(21), 0 ) !=
Alen )
20830 temp25 = args(21).matrix_value();
20840 if (
_n_dims( args(22) ) > 1 )
20844#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20845 if ( !args(22).isempty() )
20847 if ( !args(22).is_empty() )
20850 if (
_dim( args(22), 0 ) !=
Alen )
20854 temp26 = args(22).matrix_value();
20864 if (
_n_dims( args(23) ) > 1 )
20868#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20869 if ( !args(23).isempty() )
20871 if ( !args(23).is_empty() )
20874 if (
_dim( args(23), 0 ) !=
Alen )
20878 temp27 = args(23).matrix_value();
20879 arg27 = &temp27( 0, 0 );
20887 if (
_n_dims( args(24) ) > 1 )
20891#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20892 if ( !args(24).isempty() )
20894 if ( !args(24).is_empty() )
20897 if (
_dim( args(24), 0 ) !=
Alen )
20901 temp28 = args(24).matrix_value();
20911 if (
_n_dims( args(25) ) > 1 )
20915#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20916 if ( !args(25).isempty() )
20918 if ( !args(25).is_empty() )
20921 if (
_dim( args(25), 0 ) !=
Alen )
20925 temp29 = args(25).matrix_value();
20926 arg29 = &temp29( 0, 0 );
20934 if (
_n_dims( args(26) ) > 1 )
20938#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20939 if ( !args(26).isempty() )
20941 if ( !args(26).is_empty() )
20944 if (
_dim( args(26), 0 ) !=
Alen )
20948 temp30 = args(26).matrix_value();
20958 charMatrix temp_matrix;
20962 size_t max_length = 0, non_blank_length;
20964 if (
_n_dims( args(27) ) > 2 )
20966 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20968#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20969 if ( !args(27).isempty() )
20971 if ( !args(27).is_empty() )
20974 if (
_dim( args(27), 0 ) !=
Alen )
20976 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20978 arg31 =
new char*[
Alen];
20979#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20980 ifcell = args(27).iscell();
20982 ifcell = args(27).is_cell();
20986 temp_cell = args(27).cell_value();
20990 temp_matrix = args(27).char_matrix_value();
20992 max_length =
_dim( args(27), 1 ) + 1;
20995 for ( i = 0; i <
Alen; i++ )
21002 if ( temp_cell.elem( i ).is_string() )
21004 str = temp_cell.elem( i ).string_value();
21006 max_length = str.size() + 1;
21007 tmp_cstring = (
char *) str.c_str();
21017 tmp_cstring = (
char *)
"";
21022 str = temp_matrix.row_as_string( i );
21023 tmp_cstring = (
char *) str.c_str();
21025 arg31[i] =
new char[max_length];
21026 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21027 arg31[i][max_length - 1] =
'\0';
21042 non_blank_length = max_length - 2;
21043 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
21045 non_blank_length--;
21047 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
21049 non_blank_length--;
21051 arg31[i][non_blank_length + 1] =
'\0';
21060 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(
int const *)arg14,arg15,arg16,arg17,arg18,(
int const *)arg19,(
char const **)arg20,(
int const *)arg21,(
int const *)arg22,(
double const *)arg23,(
double const *)arg24,(
int const *)arg25,(
int const *)arg26,(
double const *)arg27,(
int const *)arg28,(
double const *)arg29,(
int const *)arg30,(
char const **)arg31);
21061 _outv = octave_value();
21083 if ( arg20 != NULL )
21085 for ( i = 0; i <
Alen; i++ )
21093 if ( arg21 != NULL )
21097 if ( arg22 != NULL )
21107 if ( arg25 != NULL )
21111 if ( arg26 != NULL )
21118 if ( arg28 != NULL )
21125 if ( arg30 != NULL )
21130 if ( arg31 != NULL )
21132 for ( i = 0; i <
Alen; i++ )
21149 if ( arg20 != NULL )
21151 for ( i = 0; i <
Alen; i++ )
21159 if ( arg21 != NULL )
21163 if ( arg22 != NULL )
21173 if ( arg25 != NULL )
21177 if ( arg26 != NULL )
21184 if ( arg28 != NULL )
21191 if ( arg30 != NULL )
21196 if ( arg31 != NULL )
21198 for ( i = 0; i <
Alen; i++ )
21205 return octave_value_list();
21216 if ( arg20 != NULL )
21218 for ( i = 0; i <
Alen; i++ )
21226 if ( arg21 != NULL )
21230 if ( arg22 != NULL )
21240 if ( arg25 != NULL )
21244 if ( arg26 != NULL )
21251 if ( arg28 != NULL )
21258 if ( arg30 != NULL )
21263 if ( arg31 != NULL )
21265 for ( i = 0; i <
Alen; i++ )
21287 octave_value_list _out;
21288 octave_value_list *_outp=&_out;
21289 octave_value _outv;
21299 arg1 =
static_cast< PLFLT >(val1);
21304 arg2 =
static_cast< PLFLT >(val2);
21309 arg3 =
static_cast< PLFLT >(val3);
21311 _outv = octave_value();
21315 return octave_value_list();
21329 octave_value_list _out;
21330 octave_value_list *_outp=&_out;
21331 octave_value _outv;
21338 if (
_n_dims( args(0) ) > 1 )
21343 temp1 = args(0).matrix_value();
21344 arg2 = &temp1( 0, 0 );
21347 if (
_n_dims( args(1) ) > 1 )
21355 temp3 = args(1).matrix_value();
21356 arg3 = &temp3( 0, 0 );
21358 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21359 _outv = octave_value();
21375 return octave_value_list();
21397 octave_value_list _out;
21398 octave_value_list *_outp=&_out;
21399 octave_value _outv;
21406 if (
_n_dims( args(0) ) > 1 )
21411 temp1 = args(0).matrix_value();
21412 arg2 = &temp1( 0, 0 );
21415 if (
_n_dims( args(1) ) > 1 )
21423 temp3 = args(1).matrix_value();
21424 arg3 = &temp3( 0, 0 );
21427 if (
_n_dims( args(2) ) > 1 )
21435 temp4 = args(2).matrix_value();
21436 arg4 = &temp4( 0, 0 );
21438 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21439 _outv = octave_value();
21461 return octave_value_list();
21482 octave_value_list _out;
21483 octave_value_list *_outp=&_out;
21484 octave_value _outv;
21494 arg1 =
static_cast< PLINT >(val1);
21496 _outv = octave_value();
21500 return octave_value_list();
21512 octave_value_list _out;
21513 octave_value_list *_outp=&_out;
21514 octave_value _outv;
21522 _outv = octave_value();
21532 return octave_value_list();
21541 char *arg1 = (
char *) 0 ;
21545 char *arg5 = (
char *) 0 ;
21558 octave_value_list _out;
21559 octave_value_list *_outp=&_out;
21560 octave_value _outv;
21570 arg1 =
reinterpret_cast< char *
>(buf1);
21575 arg2 =
static_cast< PLFLT >(val2);
21580 arg3 =
static_cast< PLFLT >(val3);
21585 arg4 =
static_cast< PLFLT >(val4);
21590 arg5 =
reinterpret_cast< char *
>(buf5);
21591 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21592 _outv = octave_value();
21600 return octave_value_list();
21611 char *arg1 = (
char *) 0 ;
21615 char *arg5 = (
char *) 0 ;
21628 octave_value_list _out;
21629 octave_value_list *_outp=&_out;
21630 octave_value _outv;
21640 arg1 =
reinterpret_cast< char *
>(buf1);
21645 arg2 =
static_cast< PLFLT >(val2);
21650 arg3 =
static_cast< PLFLT >(val3);
21655 arg4 =
static_cast< PLFLT >(val4);
21660 arg5 =
reinterpret_cast< char *
>(buf5);
21661 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21662 _outv = octave_value();
21670 return octave_value_list();
21681 int *arg1 = (
int *) 0 ;
21682 char **arg2 = (
char **) 0 ;
21690 octave_value_list _out;
21691 octave_value_list *_outp=&_out;
21692 octave_value _outv;
21703 arg1 =
reinterpret_cast< int *
>(argp1);
21708 arg2 =
reinterpret_cast< char **
>(argp2);
21713 arg3 =
static_cast< PLINT >(val3);
21719 return octave_value_list();
21733 octave_value_list _out;
21734 octave_value_list *_outp=&_out;
21735 octave_value _outv;
21742 if (
_n_dims( args(0) ) > 1 )
21748 temp1 = args(0).matrix_value();
21752 if (
_n_dims( args(1) ) > 1 )
21760 temp3 = args(1).matrix_value();
21764 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21765 _outv = octave_value();
21781 return octave_value_list();
21811 octave_value_list _out;
21812 octave_value_list *_outp=&_out;
21813 octave_value _outv;
21823 arg1 =
static_cast< PLINT >(val1);
21828 arg2 =
static_cast< PLFLT >(val2);
21833 arg3 =
static_cast< PLFLT >(val3);
21838 arg4 =
static_cast< PLFLT >(val4);
21843 arg5 =
static_cast< PLFLT >(val5);
21844 plpath(arg1,arg2,arg3,arg4,arg5);
21845 _outv = octave_value();
21849 return octave_value_list();
21866 octave_value_list _out;
21867 octave_value_list *_outp=&_out;
21868 octave_value _outv;
21875 if (
_n_dims( args(0) ) > 1 )
21880 temp1 = args(0).matrix_value();
21881 arg2 = &temp1( 0, 0 );
21884 if (
_n_dims( args(1) ) > 1 )
21892 temp3 = args(1).matrix_value();
21893 arg3 = &temp3( 0, 0 );
21899 arg4 =
static_cast< PLINT >(val4);
21900 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21901 _outv = octave_value();
21917 return octave_value_list();
21942 octave_value_list _out;
21943 octave_value_list *_outp=&_out;
21944 octave_value _outv;
21951 if (
_n_dims( args(0) ) > 1 )
21956 temp1 = args(0).matrix_value();
21957 arg2 = &temp1( 0, 0 );
21960 if (
_n_dims( args(1) ) > 1 )
21968 temp3 = args(1).matrix_value();
21969 arg3 = &temp3( 0, 0 );
21972 if (
_n_dims( args(2) ) > 1 )
21980 temp4 = args(2).matrix_value();
21981 arg4 = &temp4( 0, 0 );
21987 arg5 =
static_cast< PLINT >(val5);
21988 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21989 _outv = octave_value();
22011 return octave_value_list();
22041 octave_value_list _out;
22042 octave_value_list *_outp=&_out;
22043 octave_value _outv;
22050 if (
_n_dims( args(0) ) > 1 )
22055 temp1 = args(0).matrix_value();
22056 arg2 = &temp1( 0, 0 );
22059 if (
_n_dims( args(1) ) > 1 )
22067 temp3 = args(1).matrix_value();
22068 arg3 = &temp3( 0, 0 );
22071 if (
_n_dims( args(2) ) > 1 )
22079 temp4 = args(2).matrix_value();
22080 arg4 = &temp4( 0, 0 );
22083 if (
_n_dims( args(3) ) > 1 )
22089 error(
"argument vector must be same length or one less" );
SWIG_fail;
22091 temp5 = args(3).matrix_value();
22099 arg6 =
static_cast< PLBOOL >(val6);
22100 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22101 _outv = octave_value();
22129 return octave_value_list();
22156 octave_value_list _out;
22157 octave_value_list *_outp=&_out;
22158 octave_value _outv;
22168 arg1 =
static_cast< PLINT >(val1);
22173 arg2 =
static_cast< PLINT >(val2);
22175 _outv = octave_value();
22179 return octave_value_list();
22191 octave_value_list _out;
22192 octave_value_list *_outp=&_out;
22193 octave_value _outv;
22203 arg1 =
static_cast< PLINT >(val1);
22205 _outv = octave_value();
22209 return octave_value_list();
22223 char *arg6 = (
char *) 0 ;
22237 octave_value_list _out;
22238 octave_value_list *_outp=&_out;
22239 octave_value _outv;
22249 arg1 =
static_cast< PLFLT >(val1);
22254 arg2 =
static_cast< PLFLT >(val2);
22259 arg3 =
static_cast< PLFLT >(val3);
22264 arg4 =
static_cast< PLFLT >(val4);
22269 arg5 =
static_cast< PLFLT >(val5);
22274 arg6 =
reinterpret_cast< char *
>(buf6);
22275 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22276 _outv = octave_value();
22282 return octave_value_list();
22302 char *arg11 = (
char *) 0 ;
22326 octave_value_list _out;
22327 octave_value_list *_outp=&_out;
22328 octave_value _outv;
22338 arg1 =
static_cast< PLFLT >(val1);
22343 arg2 =
static_cast< PLFLT >(val2);
22348 arg3 =
static_cast< PLFLT >(val3);
22353 arg4 =
static_cast< PLFLT >(val4);
22358 arg5 =
static_cast< PLFLT >(val5);
22363 arg6 =
static_cast< PLFLT >(val6);
22368 arg7 =
static_cast< PLFLT >(val7);
22373 arg8 =
static_cast< PLFLT >(val8);
22378 arg9 =
static_cast< PLFLT >(val9);
22383 arg10 =
static_cast< PLFLT >(val10);
22388 arg11 =
reinterpret_cast< char *
>(buf11);
22389 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22390 _outv = octave_value();
22396 return octave_value_list();
22406 octave_value_list _out;
22407 octave_value_list *_outp=&_out;
22408 octave_value _outv;
22420 return octave_value_list();
22429 octave_value_list _out;
22430 octave_value_list *_outp=&_out;
22431 octave_value _outv;
22438 _outv = octave_value();
22442 return octave_value_list();
22469 octave_value_list _out;
22470 octave_value_list *_outp=&_out;
22471 octave_value _outv;
22484 arg1 =
static_cast< PLFLT >(val1);
22489 arg2 =
static_cast< PLFLT >(val2);
22494 arg3 =
static_cast< PLFLT >(val3);
22495 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22496 _outv = octave_value();
22518 return octave_value_list();
22533 octave_value_list _out;
22534 octave_value_list *_outp=&_out;
22535 octave_value _outv;
22545 arg1 =
static_cast< PLFLT >(val1);
22550 arg2 =
static_cast< PLFLT >(val2);
22552 _outv = octave_value();
22556 return octave_value_list();
22572 octave_value_list _out;
22573 octave_value_list *_outp=&_out;
22574 octave_value _outv;
22581 if (
_n_dims( args(0) ) > 1 )
22586 temp1 = args(0).matrix_value();
22591 if (
_n_dims( args(1) ) > 1 )
22599 temp2 = args(1).matrix_value();
22604 if (
_n_dims( args(2) ) > 1 )
22612 temp3 = args(2).matrix_value();
22617 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22618 _outv = octave_value();
22640 return octave_value_list();
22667 octave_value_list _out;
22668 octave_value_list *_outp=&_out;
22669 octave_value _outv;
22676 if (
_n_dims( args(0) ) > 1 )
22681 temp1 = args(0).matrix_value();
22686 if (
_n_dims( args(1) ) > 1 )
22694 temp2 = args(1).matrix_value();
22699 if (
_n_dims( args(2) ) > 1 )
22707 temp3 = args(2).matrix_value();
22712 if (
_n_dims( args(3) ) > 1 )
22720 temp4 = args(3).matrix_value();
22721 arg4 = &temp4( 0, 0 );
22724 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22725 _outv = octave_value();
22753 return octave_value_list();
22777 octave_value_list _out;
22778 octave_value_list *_outp=&_out;
22779 octave_value _outv;
22789 arg1 =
static_cast< PLINT >(val1);
22791 _outv = octave_value();
22795 return octave_value_list();
22811 octave_value_list _out;
22812 octave_value_list *_outp=&_out;
22813 octave_value _outv;
22820 if (
_n_dims( args(0) ) > 1 )
22825 temp1 = args(0).matrix_value();
22830 if (
_n_dims( args(1) ) > 1 )
22838 temp2 = args(1).matrix_value();
22843 if (
_n_dims( args(2) ) > 1 )
22851 temp3 = args(2).matrix_value();
22856 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22857 _outv = octave_value();
22879 return octave_value_list();
22906 octave_value_list _out;
22907 octave_value_list *_outp=&_out;
22908 octave_value _outv;
22915 if (
_n_dims( args(0) ) > 1 )
22920 temp1 = args(0).matrix_value();
22925 if (
_n_dims( args(1) ) > 1 )
22933 temp2 = args(1).matrix_value();
22938 if (
_n_dims( args(2) ) > 1 )
22946 temp3 = args(2).matrix_value();
22951 if (
_n_dims( args(3) ) > 1 )
22959 temp4 = args(3).matrix_value();
22960 arg4 = &temp4( 0, 0 );
22963 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22964 _outv = octave_value();
22992 return octave_value_list();
23027 octave_value_list _out;
23028 octave_value_list *_outp=&_out;
23029 octave_value _outv;
23039 arg1 =
static_cast< PLBOOL >(val1);
23041 if (
_n_dims( args(1) ) > 1 )
23046 temp2 = args(1).matrix_value();
23047 arg3 = &temp2( 0, 0 );
23050 if (
_n_dims( args(2) ) > 1 )
23058 temp4 = args(2).matrix_value();
23059 arg4 = &temp4( 0, 0 );
23062 if (
_n_dims( args(3) ) > 1 )
23070 temp5 = args(3).matrix_value();
23071 arg5 = &temp5( 0, 0 );
23074 if (
_n_dims( args(4) ) > 1 )
23082 temp6 = args(4).matrix_value();
23083 arg6 = &temp6( 0, 0 );
23086 if (
_n_dims( args(5) ) > 1 )
23092 error(
"argument vector must be same length or one less" );
SWIG_fail;
23094 temp7 = args(5).matrix_value();
23098 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23099 _outv = octave_value();
23133 return octave_value_list();
23173 octave_value_list _out;
23174 octave_value_list *_outp=&_out;
23175 octave_value _outv;
23185 arg1 =
static_cast< PLBOOL >(val1);
23187 if (
_n_dims( args(1) ) > 1 )
23192 temp2 = args(1).matrix_value();
23193 arg3 = &temp2( 0, 0 );
23196 if (
_n_dims( args(2) ) > 1 )
23204 temp4 = args(2).matrix_value();
23205 arg4 = &temp4( 0, 0 );
23208 if (
_n_dims( args(3) ) > 1 )
23216 temp5 = args(3).matrix_value();
23217 arg5 = &temp5( 0, 0 );
23220 if (
_n_dims( args(4) ) > 1 )
23228 temp6 = args(4).matrix_value();
23229 arg6 = &temp6( 0, 0 );
23232 if (
_n_dims( args(5) ) > 1 )
23240 temp7 = args(5).matrix_value();
23241 arg7 = &temp7( 0, 0 );
23244 if (
_n_dims( args(6) ) > 1 )
23250 error(
"argument vector must be same length or one less" );
SWIG_fail;
23252 temp8 = args(6).matrix_value();
23256 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23257 _outv = octave_value();
23297 return octave_value_list();
23327 octave_value_list _out;
23328 octave_value_list *_outp=&_out;
23329 octave_value _outv;
23339 arg1 =
static_cast< PLINT >(val1);
23341 _outv = octave_value();
23345 return octave_value_list();
23360 octave_value_list _out;
23361 octave_value_list *_outp=&_out;
23362 octave_value _outv;
23372 arg1 =
static_cast< PLFLT >(val1);
23377 arg2 =
static_cast< PLFLT >(val2);
23379 _outv = octave_value();
23383 return octave_value_list();
23398 octave_value_list _out;
23399 octave_value_list *_outp=&_out;
23400 octave_value _outv;
23409 _outv = octave_value();
23425 return octave_value_list();
23446 octave_value_list _out;
23447 octave_value_list *_outp=&_out;
23448 octave_value _outv;
23458 arg1 =
static_cast< PLINT >(val1);
23463 arg2 =
static_cast< PLINT >(val2);
23468 arg3 =
static_cast< PLINT >(val3);
23473 arg4 =
static_cast< PLINT >(val4);
23474 plscol0(arg1,arg2,arg3,arg4);
23475 _outv = octave_value();
23479 return octave_value_list();
23503 octave_value_list _out;
23504 octave_value_list *_outp=&_out;
23505 octave_value _outv;
23515 arg1 =
static_cast< PLINT >(val1);
23520 arg2 =
static_cast< PLINT >(val2);
23525 arg3 =
static_cast< PLINT >(val3);
23530 arg4 =
static_cast< PLINT >(val4);
23535 arg5 =
static_cast< PLFLT >(val5);
23536 plscol0a(arg1,arg2,arg3,arg4,arg5);
23537 _outv = octave_value();
23541 return octave_value_list();
23559 octave_value_list _out;
23560 octave_value_list *_outp=&_out;
23561 octave_value _outv;
23571 arg1 =
static_cast< PLINT >(val1);
23576 arg2 =
static_cast< PLINT >(val2);
23581 arg3 =
static_cast< PLINT >(val3);
23583 _outv = octave_value();
23587 return octave_value_list();
23608 octave_value_list _out;
23609 octave_value_list *_outp=&_out;
23610 octave_value _outv;
23620 arg1 =
static_cast< PLINT >(val1);
23625 arg2 =
static_cast< PLINT >(val2);
23630 arg3 =
static_cast< PLINT >(val3);
23635 arg4 =
static_cast< PLFLT >(val4);
23637 _outv = octave_value();
23641 return octave_value_list();
23653 octave_value_list _out;
23654 octave_value_list *_outp=&_out;
23655 octave_value _outv;
23665 arg1 =
static_cast< PLINT >(val1);
23667 _outv = octave_value();
23671 return octave_value_list();
23683 octave_value_list _out;
23684 octave_value_list *_outp=&_out;
23685 octave_value _outv;
23695 arg1 =
static_cast< PLINT >(val1);
23697 _outv = octave_value();
23701 return octave_value_list();
23710 char *arg1 = (
char *) 0 ;
23714 octave_value_list _out;
23715 octave_value_list *_outp=&_out;
23716 octave_value _outv;
23726 arg1 =
reinterpret_cast< char *
>(buf1);
23727 plsdev((
char const *)arg1);
23728 _outv = octave_value();
23734 return octave_value_list();
23756 octave_value_list _out;
23757 octave_value_list *_outp=&_out;
23758 octave_value _outv;
23768 arg1 =
static_cast< PLFLT >(val1);
23773 arg2 =
static_cast< PLFLT >(val2);
23778 arg3 =
static_cast< PLFLT >(val3);
23783 arg4 =
static_cast< PLFLT >(val4);
23785 _outv = octave_value();
23789 return octave_value_list();
23816 octave_value_list _out;
23817 octave_value_list *_outp=&_out;
23818 octave_value _outv;
23828 arg1 =
static_cast< PLINT >(val1);
23833 arg2 =
static_cast< PLINT >(val2);
23838 arg3 =
static_cast< PLINT >(val3);
23843 arg4 =
static_cast< PLINT >(val4);
23848 arg5 =
static_cast< PLFLT >(val5);
23853 arg6 =
static_cast< PLFLT >(val6);
23854 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23855 _outv = octave_value();
23859 return octave_value_list();
23871 octave_value_list _out;
23872 octave_value_list *_outp=&_out;
23873 octave_value _outv;
23883 arg1 =
static_cast< PLFLT >(val1);
23885 _outv = octave_value();
23889 return octave_value_list();
23910 octave_value_list _out;
23911 octave_value_list *_outp=&_out;
23912 octave_value _outv;
23922 arg1 =
static_cast< PLFLT >(val1);
23927 arg2 =
static_cast< PLFLT >(val2);
23932 arg3 =
static_cast< PLFLT >(val3);
23937 arg4 =
static_cast< PLFLT >(val4);
23939 _outv = octave_value();
23943 return octave_value_list();
23964 octave_value_list _out;
23965 octave_value_list *_outp=&_out;
23966 octave_value _outv;
23976 arg1 =
static_cast< PLFLT >(val1);
23981 arg2 =
static_cast< PLFLT >(val2);
23986 arg3 =
static_cast< PLFLT >(val3);
23991 arg4 =
static_cast< PLFLT >(val4);
23993 _outv = octave_value();
23997 return octave_value_list();
24006 unsigned int arg1 ;
24007 unsigned int val1 ;
24009 octave_value_list _out;
24010 octave_value_list *_outp=&_out;
24011 octave_value _outv;
24021 arg1 =
static_cast< unsigned int >(val1);
24023 _outv = octave_value();
24027 return octave_value_list();
24039 octave_value_list _out;
24040 octave_value_list *_outp=&_out;
24041 octave_value _outv;
24051 arg1 =
static_cast< char >(val1);
24053 _outv = octave_value();
24057 return octave_value_list();
24066 char *arg1 = (
char *) 0 ;
24067 char *arg2 = (
char *) 0 ;
24074 octave_value_list _out;
24075 octave_value_list *_outp=&_out;
24076 octave_value _outv;
24087 arg1 =
reinterpret_cast< char *
>(buf1);
24092 arg2 =
reinterpret_cast< char *
>(buf2);
24093 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24102 return octave_value_list();
24122 octave_value_list _out;
24123 octave_value_list *_outp=&_out;
24124 octave_value _outv;
24134 arg1 =
static_cast< PLINT >(val1);
24139 arg2 =
static_cast< PLINT >(val2);
24144 arg3 =
static_cast< PLINT >(val3);
24146 _outv = octave_value();
24150 return octave_value_list();
24160 unsigned int val1 ;
24162 octave_value_list _out;
24163 octave_value_list *_outp=&_out;
24164 octave_value _outv;
24176 _outv = octave_value();
24180 return octave_value_list();
24189 char *arg1 = (
char *) 0 ;
24193 octave_value_list _out;
24194 octave_value_list *_outp=&_out;
24195 octave_value _outv;
24205 arg1 =
reinterpret_cast< char *
>(buf1);
24207 _outv = octave_value();
24213 return octave_value_list();
24232 octave_value_list _out;
24233 octave_value_list *_outp=&_out;
24234 octave_value _outv;
24244 arg1 =
static_cast< PLINT >(val1);
24249 arg2 =
static_cast< PLINT >(val2);
24254 arg3 =
static_cast< PLINT >(val3);
24256 _outv = octave_value();
24260 return octave_value_list();
24272 octave_value_list _out;
24273 octave_value_list *_outp=&_out;
24274 octave_value _outv;
24281 octave_value obj = args(0);
24282#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24283 if ( !obj.isempty() )
24285 if ( !obj.is_empty() )
24288 if ( obj.is_function_handle() || obj.is_inline_function() )
24292 else if ( obj.is_string() )
24309 _outv = octave_value();
24313 return octave_value_list();
24328 octave_value_list _out;
24329 octave_value_list *_outp=&_out;
24330 octave_value _outv;
24340 arg1 =
static_cast< PLFLT >(val1);
24345 arg2 =
static_cast< PLFLT >(val2);
24347 _outv = octave_value();
24351 return octave_value_list();
24366 octave_value_list _out;
24367 octave_value_list *_outp=&_out;
24368 octave_value _outv;
24378 arg1 =
static_cast< PLFLT >(val1);
24383 arg2 =
static_cast< PLFLT >(val2);
24385 _outv = octave_value();
24389 return octave_value_list();
24401 octave_value_list _out;
24402 octave_value_list *_outp=&_out;
24403 octave_value _outv;
24413 arg1 =
static_cast< PLINT >(val1);
24415 _outv = octave_value();
24419 return octave_value_list();
24446 octave_value_list _out;
24447 octave_value_list *_outp=&_out;
24448 octave_value _outv;
24458 arg1 =
static_cast< PLFLT >(val1);
24463 arg2 =
static_cast< PLFLT >(val2);
24468 arg3 =
static_cast< PLINT >(val3);
24473 arg4 =
static_cast< PLINT >(val4);
24478 arg5 =
static_cast< PLINT >(val5);
24483 arg6 =
static_cast< PLINT >(val6);
24484 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24485 _outv = octave_value();
24489 return octave_value_list();
24498 char *arg1 = (
char *) 0 ;
24502 octave_value_list _out;
24503 octave_value_list *_outp=&_out;
24504 octave_value _outv;
24514 arg1 =
reinterpret_cast< char *
>(buf1);
24516 _outv = octave_value();
24522 return octave_value_list();
24532 char *arg1 = (
char *) 0 ;
24539 octave_value_list _out;
24540 octave_value_list *_outp=&_out;
24541 octave_value _outv;
24551 arg1 =
reinterpret_cast< char *
>(buf1);
24556 arg2 =
static_cast< PLBOOL >(val2);
24557 plspal1((
char const *)arg1,arg2);
24558 _outv = octave_value();
24564 return octave_value_list();
24577 octave_value_list _out;
24578 octave_value_list *_outp=&_out;
24579 octave_value _outv;
24589 arg1 =
static_cast< PLBOOL >(val1);
24591 _outv = octave_value();
24595 return octave_value_list();
24607 octave_value_list _out;
24608 octave_value_list *_outp=&_out;
24609 octave_value _outv;
24619 arg1 =
static_cast< PLINT >(val1);
24621 _outv = octave_value();
24625 return octave_value_list();
24640 octave_value_list _out;
24641 octave_value_list *_outp=&_out;
24642 octave_value _outv;
24652 arg1 =
static_cast< PLINT >(val1);
24657 arg2 =
static_cast< PLINT >(val2);
24659 _outv = octave_value();
24663 return octave_value_list();
24678 octave_value_list _out;
24679 octave_value_list *_outp=&_out;
24680 octave_value _outv;
24690 arg1 =
static_cast< PLFLT >(val1);
24695 arg2 =
static_cast< PLFLT >(val2);
24697 _outv = octave_value();
24701 return octave_value_list();
24716 octave_value_list _out;
24717 octave_value_list *_outp=&_out;
24718 octave_value _outv;
24728 arg1 =
static_cast< PLINT >(val1);
24733 arg2 =
static_cast< PLINT >(val2);
24735 _outv = octave_value();
24739 return octave_value_list();
24748 char *arg1 = (
char *) 0 ;
24758 octave_value_list _out;
24759 octave_value_list *_outp=&_out;
24760 octave_value _outv;
24770 arg1 =
reinterpret_cast< char *
>(buf1);
24775 arg2 =
static_cast< PLINT >(val2);
24780 arg3 =
static_cast< PLINT >(val3);
24781 plstart((
char const *)arg1,arg2,arg3);
24782 _outv = octave_value();
24788 return octave_value_list();
24801 octave_value_list _out;
24802 octave_value_list *_outp=&_out;
24803 octave_value _outv;
24810 octave_value obj = args(0);
24811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24812 if ( !obj.isempty() )
24814 if ( !obj.is_empty() )
24817 if ( obj.is_function_handle() || obj.is_inline_function() )
24821 else if ( obj.is_string() )
24838 _outv = octave_value();
24842 return octave_value_list();
24854 char *arg4 = (
char *) 0 ;
24860 octave_value_list _out;
24861 octave_value_list *_outp=&_out;
24862 octave_value _outv;
24869 if (
_n_dims( args(0) ) > 1 )
24874 temp1 = args(0).matrix_value();
24875 arg2 = &temp1( 0, 0 );
24878 if (
_n_dims( args(1) ) > 1 )
24886 temp3 = args(1).matrix_value();
24887 arg3 = &temp3( 0, 0 );
24893 arg4 =
reinterpret_cast< char *
>(buf4);
24894 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24895 _outv = octave_value();
24913 return octave_value_list();
24933 char *arg5 = (
char *) 0 ;
24940 octave_value_list _out;
24941 octave_value_list *_outp=&_out;
24942 octave_value _outv;
24949 if (
_n_dims( args(0) ) > 1 )
24954 temp1 = args(0).matrix_value();
24955 arg2 = &temp1( 0, 0 );
24958 if (
_n_dims( args(1) ) > 1 )
24966 temp3 = args(1).matrix_value();
24967 arg3 = &temp3( 0, 0 );
24970 if (
_n_dims( args(2) ) > 1 )
24978 temp4 = args(2).matrix_value();
24979 arg4 = &temp4( 0, 0 );
24985 arg5 =
reinterpret_cast< char *
>(buf5);
24986 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24987 _outv = octave_value();
25011 return octave_value_list();
25042 octave_value_list _out;
25043 octave_value_list *_outp=&_out;
25044 octave_value _outv;
25054 arg1 =
static_cast< PLINT >(val1);
25059 arg2 =
static_cast< PLINT >(val2);
25064 arg3 =
static_cast< PLFLT >(val3);
25069 arg4 =
static_cast< PLFLT >(val4);
25071 _outv = octave_value();
25075 return octave_value_list();
25087 octave_value_list _out;
25088 octave_value_list *_outp=&_out;
25089 octave_value _outv;
25099 arg1 =
static_cast< PLINT >(val1);
25101 _outv = octave_value();
25105 return octave_value_list();
25119 octave_value_list _out;
25120 octave_value_list *_outp=&_out;
25121 octave_value _outv;
25128 if (
_n_dims( args(0) ) > 1 )
25134 temp1 = args(0).matrix_value();
25138 if (
_n_dims( args(1) ) > 1 )
25146 temp3 = args(1).matrix_value();
25150 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25151 _outv = octave_value();
25167 return octave_value_list();
25190 octave_value_list _out;
25191 octave_value_list *_outp=&_out;
25192 octave_value _outv;
25199 if (
_n_dims( args(0) ) > 1 )
25203#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25204 if ( !args(0).isempty() )
25206 if ( !args(0).is_empty() )
25210 temp1 = args(0).matrix_value();
25211 arg1 = &temp1( 0, 0 );
25220 if (
_n_dims( args(1) ) > 1 )
25224#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25225 if ( !args(1).isempty() )
25227 if ( !args(1).is_empty() )
25234 temp2 = args(1).matrix_value();
25235 arg2 = &temp2( 0, 0 );
25248 arg4 =
static_cast< PLBOOL >(val4);
25249 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25250 _outv = octave_value();
25266 return octave_value_list();
25293 octave_value_list _out;
25294 octave_value_list *_outp=&_out;
25295 octave_value _outv;
25305 arg1 =
static_cast< PLFLT >(val1);
25310 arg2 =
static_cast< PLFLT >(val2);
25315 arg3 =
static_cast< PLFLT >(val3);
25320 arg4 =
static_cast< PLFLT >(val4);
25321 plsvpa(arg1,arg2,arg3,arg4);
25322 _outv = octave_value();
25326 return octave_value_list();
25341 octave_value_list _out;
25342 octave_value_list *_outp=&_out;
25343 octave_value _outv;
25353 arg1 =
static_cast< PLINT >(val1);
25358 arg2 =
static_cast< PLINT >(val2);
25360 _outv = octave_value();
25364 return octave_value_list();
25379 octave_value_list _out;
25380 octave_value_list *_outp=&_out;
25381 octave_value _outv;
25391 arg1 =
static_cast< PLINT >(val1);
25396 arg2 =
static_cast< PLINT >(val2);
25398 _outv = octave_value();
25402 return octave_value_list();
25419 octave_value_list _out;
25420 octave_value_list *_outp=&_out;
25421 octave_value _outv;
25428 if (
_n_dims( args(0) ) > 1 )
25433 temp1 = args(0).matrix_value();
25434 arg2 = &temp1( 0, 0 );
25437 if (
_n_dims( args(1) ) > 1 )
25445 temp3 = args(1).matrix_value();
25446 arg3 = &temp3( 0, 0 );
25452 arg4 =
static_cast< PLINT >(val4);
25453 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25454 _outv = octave_value();
25470 return octave_value_list();
25491 octave_value_list _out;
25492 octave_value_list *_outp=&_out;
25493 octave_value _outv;
25503 arg1 =
static_cast< PLINT >(val1);
25508 arg2 =
static_cast< PLINT >(val2);
25510 _outv = octave_value();
25514 return octave_value_list();
25523 octave_value_list _out;
25524 octave_value_list *_outp=&_out;
25525 octave_value _outv;
25532 _outv = octave_value();
25536 return octave_value_list();
25545 char *arg1 = (
char *) 0 ;
25549 octave_value_list _out;
25550 octave_value_list *_outp=&_out;
25551 octave_value _outv;
25561 arg1 =
reinterpret_cast< char *
>(buf1);
25563 _outv = octave_value();
25569 return octave_value_list();
25582 octave_value_list _out;
25583 octave_value_list *_outp=&_out;
25584 octave_value _outv;
25594 arg1 =
static_cast< PLFLT >(val1);
25596 _outv = octave_value();
25600 return octave_value_list();
25624 octave_value_list _out;
25625 octave_value_list *_outp=&_out;
25626 octave_value _outv;
25636 arg1 =
static_cast< PLFLT >(val1);
25641 arg2 =
static_cast< PLFLT >(val2);
25646 arg3 =
static_cast< PLFLT >(val3);
25651 arg4 =
static_cast< PLFLT >(val4);
25656 arg5 =
static_cast< PLFLT >(val5);
25657 plvpas(arg1,arg2,arg3,arg4,arg5);
25658 _outv = octave_value();
25662 return octave_value_list();
25683 octave_value_list _out;
25684 octave_value_list *_outp=&_out;
25685 octave_value _outv;
25695 arg1 =
static_cast< PLFLT >(val1);
25700 arg2 =
static_cast< PLFLT >(val2);
25705 arg3 =
static_cast< PLFLT >(val3);
25710 arg4 =
static_cast< PLFLT >(val4);
25711 plvpor(arg1,arg2,arg3,arg4);
25712 _outv = octave_value();
25716 return octave_value_list();
25725 octave_value_list _out;
25726 octave_value_list *_outp=&_out;
25727 octave_value _outv;
25734 _outv = octave_value();
25738 return octave_value_list();
25780 octave_value_list _out;
25781 octave_value_list *_outp=&_out;
25782 octave_value _outv;
25792 arg1 =
static_cast< PLFLT >(val1);
25797 arg2 =
static_cast< PLFLT >(val2);
25802 arg3 =
static_cast< PLFLT >(val3);
25807 arg4 =
static_cast< PLFLT >(val4);
25812 arg5 =
static_cast< PLFLT >(val5);
25817 arg6 =
static_cast< PLFLT >(val6);
25822 arg7 =
static_cast< PLFLT >(val7);
25827 arg8 =
static_cast< PLFLT >(val8);
25832 arg9 =
static_cast< PLFLT >(val9);
25837 arg10 =
static_cast< PLFLT >(val10);
25842 arg11 =
static_cast< PLFLT >(val11);
25843 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25844 _outv = octave_value();
25848 return octave_value_list();
25860 octave_value_list _out;
25861 octave_value_list *_outp=&_out;
25862 octave_value _outv;
25872 arg1 =
static_cast< PLFLT >(val1);
25874 _outv = octave_value();
25878 return octave_value_list();
25899 octave_value_list _out;
25900 octave_value_list *_outp=&_out;
25901 octave_value _outv;
25911 arg1 =
static_cast< PLFLT >(val1);
25916 arg2 =
static_cast< PLFLT >(val2);
25921 arg3 =
static_cast< PLFLT >(val3);
25926 arg4 =
static_cast< PLFLT >(val4);
25927 plwind(arg1,arg2,arg3,arg4);
25928 _outv = octave_value();
25932 return octave_value_list();
25947 octave_value_list _out;
25948 octave_value_list *_outp=&_out;
25949 octave_value _outv;
25960 arg1 =
static_cast< PLBOOL >(val1);
25962 _outv = octave_value();
25972 return octave_value_list();
25982 char *arg2 = (
char *) 0 ;
25998 octave_value_list _out;
25999 octave_value_list *_outp=&_out;
26000 octave_value _outv;
26007 octave_value obj = args(0);
26008#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26009 if ( !obj.isempty() )
26011 if ( !obj.is_empty() )
26014 if ( obj.is_function_handle() || obj.is_inline_function() )
26018 else if ( obj.is_string() )
26034 arg2 =
reinterpret_cast< char *
>(buf2);
26039 arg3 =
static_cast< PLFLT >(val3);
26044 arg4 =
static_cast< PLFLT >(val4);
26049 arg5 =
static_cast< PLFLT >(val5);
26054 arg6 =
static_cast< PLFLT >(val6);
26055 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
26056 _outv = octave_value();
26062 return octave_value_list();
26073 char *arg2 = (
char *) 0 ;
26092 octave_value_list _out;
26093 octave_value_list *_outp=&_out;
26094 octave_value _outv;
26101 octave_value obj = args(0);
26102#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26103 if ( !obj.isempty() )
26105 if ( !obj.is_empty() )
26108 if ( obj.is_function_handle() || obj.is_inline_function() )
26112 else if ( obj.is_string() )
26128 arg2 =
reinterpret_cast< char *
>(buf2);
26133 arg3 =
static_cast< PLFLT >(val3);
26138 arg4 =
static_cast< PLFLT >(val4);
26143 arg5 =
static_cast< PLFLT >(val5);
26148 arg6 =
static_cast< PLFLT >(val6);
26150 if (
_n_dims( args(6) ) > 1 )
26154#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26155 if ( !args(6).isempty() )
26157 if ( !args(6).is_empty() )
26161 temp7 = args(6).matrix_value();
26162 arg7 =
new PLINT[arg8];
26171 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26172 _outv = octave_value();
26184 return octave_value_list();
26198 char *arg2 = (
char *) 0 ;
26199 char *arg3 = (
char *) 0 ;
26221 octave_value_list _out;
26222 octave_value_list *_outp=&_out;
26223 octave_value _outv;
26230 octave_value obj = args(0);
26231#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26232 if ( !obj.isempty() )
26234 if ( !obj.is_empty() )
26237 if ( obj.is_function_handle() || obj.is_inline_function() )
26241 else if ( obj.is_string() )
26257 arg2 =
reinterpret_cast< char *
>(buf2);
26262 arg3 =
reinterpret_cast< char *
>(buf3);
26267 arg4 =
static_cast< PLFLT >(val4);
26272 arg5 =
static_cast< PLFLT >(val5);
26277 arg6 =
static_cast< PLFLT >(val6);
26282 arg7 =
static_cast< PLFLT >(val7);
26284 if (
_n_dims( args(7) ) > 1 )
26288#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26289 if ( !args(7).isempty() )
26291 if ( !args(7).is_empty() )
26295 temp8 = args(7).matrix_value();
26296 arg8 =
new PLINT[arg9];
26305 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26306 _outv = octave_value();
26320 return octave_value_list();
26335 char *arg2 = (
char *) 0 ;
26339 char *arg6 = (
char *) 0 ;
26367 octave_value_list _out;
26368 octave_value_list *_outp=&_out;
26369 octave_value _outv;
26376 octave_value obj = args(0);
26377#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26378 if ( !obj.isempty() )
26380 if ( !obj.is_empty() )
26383 if ( obj.is_function_handle() || obj.is_inline_function() )
26387 else if ( obj.is_string() )
26403 arg2 =
reinterpret_cast< char *
>(buf2);
26408 arg3 =
static_cast< PLFLT >(val3);
26413 arg4 =
static_cast< PLFLT >(val4);
26418 arg5 =
static_cast< PLFLT >(val5);
26423 arg6 =
reinterpret_cast< char *
>(buf6);
26428 arg7 =
static_cast< PLFLT >(val7);
26433 arg8 =
static_cast< PLFLT >(val8);
26438 arg9 =
static_cast< PLFLT >(val9);
26443 arg10 =
static_cast< PLFLT >(val10);
26448 arg11 =
static_cast< PLINT >(val11);
26449 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26450 _outv = octave_value();
26458 return octave_value_list();
26470 char *arg2 = (
char *) 0 ;
26489 octave_value_list _out;
26490 octave_value_list *_outp=&_out;
26491 octave_value _outv;
26498 octave_value obj = args(0);
26499#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26500 if ( !obj.isempty() )
26502 if ( !obj.is_empty() )
26505 if ( obj.is_function_handle() || obj.is_inline_function() )
26509 else if ( obj.is_string() )
26525 arg2 =
reinterpret_cast< char *
>(buf2);
26530 arg3 =
static_cast< PLFLT >(val3);
26535 arg4 =
static_cast< PLFLT >(val4);
26540 arg5 =
static_cast< PLFLT >(val5);
26545 arg6 =
static_cast< PLFLT >(val6);
26547 if (
_n_dims( args(6) ) > 1 )
26551#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26552 if ( !args(6).isempty() )
26554 if ( !args(6).is_empty() )
26558 temp7 = args(6).matrix_value();
26559 arg7 =
new PLINT[arg8];
26568 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26569 _outv = octave_value();
26581 return octave_value_list();
26613 octave_value_list _out;
26614 octave_value_list *_outp=&_out;
26615 octave_value _outv;
26622 octave_value obj = args(0);
26623#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26624 if ( !obj.isempty() )
26626 if ( !obj.is_empty() )
26629 if ( obj.is_function_handle() || obj.is_inline_function() )
26633 else if ( obj.is_string() )
26649 arg2 =
static_cast< PLFLT >(val2);
26654 arg3 =
static_cast< PLFLT >(val3);
26659 arg4 =
static_cast< PLFLT >(val4);
26664 arg5 =
static_cast< PLFLT >(val5);
26669 arg6 =
static_cast< PLFLT >(val6);
26674 arg7 =
static_cast< PLFLT >(val7);
26676 _outv = octave_value();
26680 return octave_value_list();
26689 octave_value_list _out;
26690 octave_value_list *_outp=&_out;
26691 octave_value _outv;
26698 _outv = octave_value();
26702 return octave_value_list();
26711 octave_value_list _out;
26712 octave_value_list *_outp=&_out;
26713 octave_value _outv;
26720 _outv = octave_value();
26724 return octave_value_list();
26733 char *arg1 = (
char *) 0 ;
26734 char *arg2 = (
char *) 0 ;
26741 octave_value_list _out;
26742 octave_value_list *_outp=&_out;
26743 octave_value _outv;
26753 arg1 =
reinterpret_cast< char *
>(buf1);
26758 arg2 =
reinterpret_cast< char *
>(buf2);
26759 plSetUsage((
char const *)arg1,(
char const *)arg2);
26760 _outv = octave_value();
26768 return octave_value_list();
26779 octave_value_list _out;
26780 octave_value_list *_outp=&_out;
26781 octave_value _outv;
26788 _outv = octave_value();
26792 return octave_value_list();
26802{
"testppchar",_wrap_testppchar,0,0,2,0},
26804{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26807{
"plcont0",_wrap_plcont0,0,0,2,0},
26808{
"plcont1",_wrap_plcont1,0,0,2,0},
26809{
"plcont2",_wrap_plcont2,0,0,2,0},
26810{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26820{
"plshade1",_wrap_plshade1,0,0,2,0},
26821{
"plshade2",_wrap_plshade2,0,0,2,0},
26823{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26824{
"plshades1",_wrap_plshades1,0,0,2,0},
26825{
"plshades2",_wrap_plshades2,0,0,2,0},
26827{
"plvect1",_wrap_plvect1,0,0,2,0},
26828{
"plvect2",_wrap_plvect2,0,0,2,0},
26829{
"pplimage",_wrap_pplimage,0,0,2,0},
26831{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26832{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26833{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27119#define SWIGRUNTIME_DEBUG
27122#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27123#define SWIG_INIT_CLIENT_DATA_TYPE void *
27145 if (!module_head) {
27158 }
while (iter!= module_head);
27169 if (init == 0)
return;
27172#ifdef SWIGRUNTIME_DEBUG
27173 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.size);
27180#ifdef SWIGRUNTIME_DEBUG
27181 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27190#ifdef SWIGRUNTIME_DEBUG
27191 printf(
"SWIG_InitializeModule: found type %s\n", type->name);
27194 type->clientdata =
swig_module.type_initial[i]->clientdata;
27195#ifdef SWIGRUNTIME_DEBUG
27196 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27205 while (cast->
type) {
27209#ifdef SWIGRUNTIME_DEBUG
27210 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27214#ifdef SWIGRUNTIME_DEBUG
27215 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27220#ifdef SWIGRUNTIME_DEBUG
27221 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27228#ifdef SWIGRUNTIME_DEBUG
27229 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27231 if (!ocast) ret = 0;
27236#ifdef SWIGRUNTIME_DEBUG
27237 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27240 type->cast->prev = cast;
27241 cast->
next = type->cast;
27252#ifdef SWIGRUNTIME_DEBUG
27253 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27257 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27258 while (cast->
type) {
27259 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27263 printf(
"---- Total casts: %d\n",j);
27265 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27278 static int init_run = 0;
27280 if (init_run)
return;
27291 equiv = equiv->
next;
27311#if SWIG_OCTAVE_PREREQ(6,0,0)
27312#elif SWIG_OCTAVE_PREREQ(4,2,0)
27313 octave::unwind_protect frame;
27314 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27315 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27316#elif SWIG_OCTAVE_PREREQ(3,3,50)
27317 unwind_protect frame;
27318 frame.protect_var(error_state); error_state = 0;
27319 frame.protect_var(warning_state); warning_state = 0;
27320 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27321 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27323 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27324 unwind_protect_int(error_state); error_state = 0;
27325 unwind_protect_int(warning_state); warning_state = 0;
27326 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27327 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27329#if SWIG_OCTAVE_PREREQ(4,2,0)
27331#if SWIG_OCTAVE_PREREQ(4,4,0)
27332 octave::feval(
name, octave_value_list(), 0);
27334 feval(
name, octave_value_list(), 0);
27337 }
catch (octave::execution_exception&) { }
27339 feval(
name, octave_value_list(), 0);
27340 retn = (error_state == 0);
27342#if !SWIG_OCTAVE_PREREQ(3,3,50)
27343 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27355#if SWIG_OCTAVE_PREREQ(6,0,0)
27356#elif SWIG_OCTAVE_PREREQ(4,2,0)
27357 octave::unwind_protect frame;
27358 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27359 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27360#elif SWIG_OCTAVE_PREREQ(3,3,50)
27361 unwind_protect frame;
27362 frame.protect_var(error_state); error_state = 0;
27363 frame.protect_var(warning_state); warning_state = 0;
27364 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27365 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27367 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27368 unwind_protect_int(error_state); error_state = 0;
27369 unwind_protect_int(warning_state); warning_state = 0;
27370 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27371 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27373 octave_value_list args;
27375 args.append(octloadfcn->fcn_file_name());
27376#if SWIG_OCTAVE_PREREQ(4,2,0)
27378#if SWIG_OCTAVE_PREREQ(4,4,0)
27379 octave::feval(
"autoload", args, 0);
27381 feval(
"autoload", args, 0);
27384 }
catch (octave::execution_exception&) { }
27386 feval(
"autoload", args, 0);
27387 retn = (error_state == 0);
27389#if !SWIG_OCTAVE_PREREQ(3,3,50)
27390 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27400@deftypefn {Loadable Function} {} subclass()\n\
27401@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27402Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27404See the SWIG manual for usage examples.\n\
27409 for (
int j = 0; j < args.length(); ++j) {
27410 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27414 error(
"subclass: cannot subclass object not constructed on octave side");
27415 return octave_value_list();
27418 }
else if (args(j).is_function_handle()) {
27419 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27420 }
else if (args(j).is_string()) {
27421 if (j + 1 >= args.length()) {
27422 error(
"subclass: member assignments must be of string,value form");
27423 return octave_value_list();
27425 top->
assign(args(j).string_value(), args(j + 1));
27428 error(
"subclass: invalid arguments to subclass()");
27429 return octave_value_list();
27436@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27437Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27441 if (args.length() != 1) {
27442 error(
"swig_type: must be called with only a single object");
27443 return octave_value_list();
27447 error(
"swig_type: object is not a swig_ref");
27448 return octave_value_list();
27454@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27455Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27456otherwise return `<unknown>'.\n\
27460 if (args.length() != 1 || !args(0).is_string()) {
27461 error(
"swig_typequery: must be called with single string argument");
27462 return octave_value_list();
27467 return octave_value(
"<unknown>");
27468 return octave_value(type->name);
27472@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27473Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27477 if (args.length() != 1) {
27478 error(
"swig_this: must be called with only a single object");
27479 return octave_value_list();
27481 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27482 return octave_value(octave_uint64(0));
27485 error(
"swig_this: object is not a swig_ref");
27486 return octave_value_list();
27488 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27492@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27493Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27497 if (args.length() != 3) {
27498 error(
"swig_octave_prereq: must be called with 3 arguments");
27499 return octave_value_list();
27501 const int major = args(0).int_value();
27502 const int minor = args(1).int_value();
27503 const int patch = args(2).int_value();
27505 return octave_value(prereq);
27509@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27510Exit Octave without performing any memory cleanup.\n\
27514 if (args.length() > 1) {
27515 error(
"swig_exit: must be called with at most one arguments");
27516 return octave_value_list();
27518 int exit_status = 0;
27519 if (args.length() == 1) {
27520 exit_status = args(0).int_value();
27522 ::_Exit(exit_status);
27523 return octave_value();
27527@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27528Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27541#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27542#if !SWIG_OCTAVE_PREREQ(4,4,0)
27543#if SWIG_OCTAVE_PREREQ(3,2,0)
27544 octave_exit = ::_Exit;
27550 if (args.length() != 0 || nargout != 0) {
27552 return octave_value_list();
27560#if SWIG_OCTAVE_PREREQ(3,2,0)
27561 octave_value_list eval_args;
27562 eval_args.append(
"base");
27563 eval_args.append(
"function __swig_atexit__; "
27570 "__swig_atexit__; "
27571 "atexit(\"__swig_atexit__\", false); "
27572 "atexit(\"__swig_atexit__\")");
27573#if SWIG_OCTAVE_PREREQ(4,4,0)
27574 octave::feval(
"evalin", eval_args, 0);
27576 feval(
"evalin", eval_args, 0);
27580#if SWIG_OCTAVE_PREREQ(4,4,0)
27582 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27583 string_vector types = typeinfo.installed_type_names();
27584 bool register_octave_swig_ref =
true;
27585 bool register_octave_swig_packed =
true;
27586 for (
int i = 0; i < types.numel(); ++i) {
27587 if (types(i) == octave_swig_ref::static_type_name()) {
27588 register_octave_swig_ref =
false;
27589 octave_swig_ref::set_type_id(i);
27591 if (types(i) == octave_swig_packed::static_type_name()) {
27592 register_octave_swig_packed =
false;
27593 octave_swig_packed::set_type_id(i);
27596 if (register_octave_swig_ref) {
27597 octave_swig_ref::register_type();
27599 if (register_octave_swig_packed) {
27600 octave_swig_packed::register_type();
27604 octave_swig_ref::register_type();
27605 octave_swig_packed::register_type();
27610#if SWIG_OCTAVE_PREREQ(8,0,0)
27611 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27612 octave_function *me = tree_eval.current_function();
27613#elif SWIG_OCTAVE_PREREQ(6,0,0)
27614 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27615 octave::call_stack& stack = tree_eval.get_call_stack();
27616 octave_function *me = stack.current_function();
27617#elif SWIG_OCTAVE_PREREQ(4,4,0)
27618 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27619 octave_function *me = stack.current();
27621 octave_function *me = octave_call_stack::current();
27625 return octave_value_list();
27628 return octave_value_list();
27631 return octave_value_list();
27634 return octave_value_list();
27637 return octave_value_list();
27640 return octave_value_list();
27678 return octave_value_list();
27685 if (mb->second.first && mb->second.first->method) {
27687 return octave_value_list();
27692#if SWIG_OCTAVE_PREREQ(4,4,0)
27693 octave::interpreter::the_interpreter()->mlock();
27694#elif SWIG_OCTAVE_PREREQ(3,2,0)
27704 if (mb->second.second.is_defined()) {
27713 return octave_value_list();
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
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
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)
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
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)
swig_module_info * module
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)
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
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)
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
static PLFLT value(double n1, double n2, double hue)
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)
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)
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
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)
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)
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
PLINT plTranslateCursor(PLGraphicsIn *plg)
PLINT plGetCursor(PLGraphicsIn *plg)
#define pl_setcontlabelformat
#define pl_setcontlabelparam
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
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)
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
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
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)
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
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
static const char * _wrap_plstripd_texinfo
static const char * _wrap_plsori_texinfo
static const char * _wrap_plsdiplt_texinfo
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)
#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
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static int _n_dims(const octave_value &o_obj)
static const char * _wrap_plot3d_texinfo
static const char * _wrap_plmtex_texinfo
static const char * _wrap_plmap_texinfo
#define swigreg_unary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plaxes_texinfo
static const char * _wrap_plscmap0n_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
static const char * _wrap_plsesc_texinfo
static const char * _wrap_plgvpw_texinfo
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
#define SWIG_POINTER_RELEASE
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
#define SWIG_POINTER_CLEAR
static const char * _wrap_plssub_texinfo
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
static const char * _wrap_plline_texinfo
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static const char *const swig_type_usage
static const char * _wrap_plshade_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
static const char *const swig_exit_usage
static const char * _wrap_plsdev_texinfo
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plinit_texinfo
plgriddata(x, y, z, xg, yg, type, data)\n\ \n\ \n\ This function is used in example 21.\n\ \n\ \n\ \n\ SYNOPSIS:\n\ \n\ plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ \n\ ARGUMENTS:\n\ \n\ x(PLFLT_VECTOR, input) : The input x vector.\n\ \n\ y(PLFLT_VECTOR, input) : The input y vector.\n\ \n\ z(PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\ y[i], z[i] represents one data sample coordinate.\n\ \n\ npts(PLINT, input) : The number of data samples in the x, y and z\n\ vectors.\n\ \n\ xg(PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ in the x direction. Usually xg has nptsx equally spaced values\n\ from the minimum to the maximum values of the x input vector.\n\ \n\ nptsx(PLINT, input) : The number of points in the xg vector.\n\ \n\ yg(PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ in the y direction. Similar to the xg parameter.\n\ \n\ nptsy(PLINT, input) : The number of points in the yg vector.\n\ \n\ zg(PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\ where data lies in the grid specified by xg and yg. Therefore the\n\ zg matrix must be dimensioned\n\ nptsx by\n\ nptsy.\n\ \n\ type(PLINT, input) : The type of grid interpolation algorithm to\n\ use, which can be:GRID_CSA:Bivariate Cubic Spline approximation\n\ GRID_DTLI:Delaunay Triangulation Linear Interpolation\n\ GRID_NNI:Natural Neighbors Interpolation\n\ GRID_NNIDW:Nearest Neighbors Inverse Distance Weighted\n\ GRID_NNLI:Nearest Neighbors Linear Interpolation\n\ GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\ Weighted\n\ For details of the algorithms read the source file plgridd.c.\n\ \n\ data(PLFLT, input) : Some gridding algorithms require extra data,\n\ which can be specified through this argument. Currently, for\n\ algorithm:GRID_NNIDW, data specifies the number of neighbors to\n\ use, the lower the value, the noisier(more local) the\n\ approximation is.\n\ GRID_NNLI, data specifies what a thin triangle is, in the\n\ range[1. .. 2.]. High values enable the usage of very thin\n\ triangles for interpolation, possibly resulting in error in\n\ the approximation.\n\ GRID_NNI, only weights greater than data will be accepted. If\n\ 0, all weights will be accepted.\n\ " zg
static const char * _wrap_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plcpstrm_texinfo
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plvect_texinfo
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
static const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plscmap1a_texinfo
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
static int _dim(const octave_value &o_obj, int dim_idx)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
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
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
#define SWIG_POINTER_DISOWN
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)
#define SWIG_ERROR_RELEASE_NOT_OWNED
static const char * _wrap_plclear_texinfo
#define SWIG_CAST_NEW_MEMORY
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)
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)
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
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)
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
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)
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)
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
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)
struct swig_cast_info swig_cast_info
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)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
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)
struct swig_type_info swig_type_info
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)
struct swig_module_info swig_module_info
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)
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
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)
#define SWIG_RuntimeError
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 SWIG_RUNTIME_VERSION
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)
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
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[]
#define SWIG_AttributeError
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 swig_type_info _swigt__p_double
#define SWIG_SetModule(clientdata, pointer)
#define SWIG_INIT_CLIENT_DATA_TYPE
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_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)
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)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define SWIG_POINTER_NO_NULL
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_PLGraphicsIn
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_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[]
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)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
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 SWIG_DivisionByZero
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
static swig_type_info _swigt__p_char
#define SWIG_OverflowError
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
static swig_lua_class _wrap_class_PLGraphicsIn
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
#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)
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)
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)
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
octave_value operator*() const
const octave_value_list & ovl
octave_value_ref(const octave_value_list &_ovl, int _j)
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
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
const char * constructor_doc
struct swig_cast_info * cast
static Tcl_Interp * interp