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);
1165 if ((m = find_member(c->
base[j],
name)))
1172 member_map::iterator it = members.find(
name);
1173 if (it != members.end())
1176 for (
unsigned int j = 0; j < types.size(); ++j)
1177 if ((m = find_member(types[j].first,
name)))
1178 return &members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1179 if (!insert_if_not_found)
1181 return &members[
name];
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);
1230 load_members(cj,out);
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;
1271 args.append(make_value_hack(rhs));
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)
1325 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1326 always_static(_always_static) {
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)
1349 if (c->
destructor && !types[j].second.destroyed && types[j].second.ptr) {
1354#ifdef SWIG_DIRECTORS
1355 for (
unsigned int j = 0; j < types.size(); ++j)
1356 Swig::erase_rtdir(types[j].second.ptr);
1362 if (!dispatch_unary_op(
"__dims__", out))
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);
1497 types.insert(types.end(), rhs.
types.begin(), rhs.
types.end());
1499#if SWIG_OCTAVE_PREREQ(4,4,0)
1513 int clear_pointer = 0;
1521 *own = *own | thisown;
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;
1632 if (ops[skip] ==
'(' && construct_type) {
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)))
1664 m = find_member(subname,
false);
1666 error(
"member not found");
1667 return octave_value_list();
1670 octave_value_list args;
1671 if (!always_static &&
1672 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1673 args.append(as_value());
1674 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1675 ((m->first && m->first->method) || m->second.is_function() ||
1676 m->second.is_function_handle())) {
1677 args.append(*idx_it++);
1679 sub_ovl = member_invoke(m, args, nargout);
1681 sub_ovl = member_deref(m, args);
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++);
1691 if (!dispatch_index_op(op_name, args, sub_ovl)) {
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;
1730 args.append(as_value());
1731 args.append(*idx_it);
1733 member_invoke(m, args, 1);
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())
1751 args.append(as_value());
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 {
1777 if (!dispatch_unary_op(
"__str__", ret)) {
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();
1790 if (!dispatch_unary_op(
"__float__", ret)) {
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 {
1894 return string_value();
1898 return string_value();
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;
1928 args.append(make_value_hack(x));
1929 if (dispatch_global_op(symbol, args, ret))
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;
1956 args.append(make_value_hack(lhs));
1957 args.append(make_value_hack(rhs));
1965 if (dispatch_global_op(symbol, args, ret))
1974 if (dispatch_global_op(symbol, args, ret))
1983 if (dispatch_global_op(symbol, args, ret))
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
1997 os << string_value();
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(); }
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(); }
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
2149 octave::mach_info::float_format fmt)
2151 oct_mach_info::float_format 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
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; }
2197 return octave_base_value::type_conv_info (default_numeric_conversion_function,
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));
3651 static int init = 0;
3664 return std::string(carray,carray+size);
3672 for (p = s; maxlen-- && *p; p++)
3686 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3687 if (val) *val =
static_cast< char >(v);
3697Set up transformation from metafile coordinates\n\
3701 Set up transformation from metafile coordinates. The size of the plot\n\
3702 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3703 general-purpose facility just yet (not sure why the user would need\n\
3706 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3709 This function is not used in any examples.\n\
3715plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3719 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3721 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3723 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3725 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3727 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3729 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3732Set the cmap0 palette using the specified cmap0*.pal format file\n\
3736 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3738 Redacted form: plspal0(filename)\n\
3740 This function is in example 16.\n\
3750 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3751 containing the name of the cmap0*.pal file. If this string is\n\
3752 empty, use the default cmap0*.pal file.\n\
3755Set the cmap1 palette using the specified cmap1*.pal format file\n\
3759 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3761 Redacted form: plspal1(filename, interpolate)\n\
3763 This function is used in example 16.\n\
3769plspal1(filename, interpolate)\n\
3773 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3774 containing the name of the cmap1*.pal file. If this string is\n\
3775 empty, use the default cmap1*.pal file.\n\
3777 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3778 columns containing the intensity index, r, g, b, alpha and\n\
3779 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3780 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3781 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3782 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3783 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3784 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3785 are used instead to set the cmap1 palette directly with a call to\n\
3789Draw a line in 3 space\n\
3793 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3794 first set up the viewport, the 2d viewing window (in world\n\
3795 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3798 Redacted form: plline3(x, y, z)\n\
3800 This function is used in example 18.\n\
3806plline3(n, x, y, z)\n\
3810 n (PLINT, input) : Number of points defining line.\n\
3812 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3815 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3818 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3822Magnitude colored plot surface mesh with contour\n\
3826 A more powerful form of plmesh: the surface mesh can be colored\n\
3827 accordingly to the current z value being plotted, a contour plot can\n\
3828 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3829 plotted function border and the base XY plane.\n\
3831 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3833 This function is used in example 11.\n\
3839plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3843 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3844 which the function is evaluated.\n\
3846 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3847 which the function is evaluated.\n\
3849 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3850 plot. Should have dimensions of\n\
3854 nx (PLINT, input) : Number of x values at which function is\n\
3857 ny (PLINT, input) : Number of y values at which function is\n\
3860 opt (PLINT, input) : Determines the way in which the surface is\n\
3861 represented. To specify more than one option just add the options,\n\
3862 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3863 showing z as a function of x for each value of y[j] .\n\
3864 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3865 for each value of x[i] .\n\
3866 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3867 at which function is defined.\n\
3868 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3869 the z value being plotted. The color is used from the current\n\
3871 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3875 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3876 the borders of the plotted function.\n\
3879 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3882 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3885Draw a line between two points, accounting for coordinate transforms\n\
3889 Joins the point (\n\
3893 y2) . If a global coordinate transform is defined then the line is\n\
3894 broken in to n segments to approximate the path. If no transform is\n\
3895 defined then this simply acts like a call to pljoin.\n\
3897 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3899 This function is used in example 22.\n\
3905plpath(n, x1, y1, x2, y2)\n\
3909 n (PLINT, input) : number of points to use to approximate the path.\n\
3911 x1 (PLFLT, input) : x coordinate of first point.\n\
3913 y1 (PLFLT, input) : y coordinate of first point.\n\
3915 x2 (PLFLT, input) : x coordinate of second point.\n\
3917 y2 (PLFLT, input) : y coordinate of second point.\n\
3920Write text inside the viewport\n\
3924 Writes text at a specified position and inclination within the\n\
3925 viewport. Text is clipped at the viewport boundaries. The reference\n\
3926 point of a string lies along a line passing through the string at half\n\
3927 the height of a capital letter. The position of the reference point\n\
3928 along this line is determined by just, the reference point is placed\n\
3929 at world coordinates (\n\
3931 y) within the viewport. The inclination of the string is specified\n\
3932 in terms of differences of world coordinates making it easy to write\n\
3933 text parallel to a line in a graph.\n\
3935 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3937 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3943plptex(x, y, dx, dy, just, text)\n\
3947 x (PLFLT, input) : x coordinate of reference point of string.\n\
3949 y (PLFLT, input) : y coordinate of reference point of string.\n\
3951 dx (PLFLT, input) : Together with dy, this specifies the\n\
3952 inclination of the string. The baseline of the string is parallel\n\
3953 to a line joining (\n\
3961 dy (PLFLT, input) : Together with dx, this specifies the\n\
3962 inclination of the string.\n\
3964 just (PLFLT, input) : Specifies the position of the string relative\n\
3965 to its reference point. If just=0. , the reference point is at\n\
3966 the left and if just=1. , it is at the right of the string. Other\n\
3967 values of just give intermediate justifications.\n\
3969 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3973Set family file parameters\n\
3977 Sets variables dealing with output file familying. Does nothing if\n\
3978 familying not supported by the driver. This routine, if used, must be\n\
3979 called before initializing PLplot. See the PLplot documentation for\n\
3980 more information.\n\
3982 Redacted form: plsfam(fam, num, bmax)\n\
3984 This function is used in examples 14 and 31.\n\
3990plsfam(fam, num, bmax)\n\
3994 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3997 num (PLINT, input) : Current family file number.\n\
3999 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
4003Set y axis parameters\n\
4007 Identical to plsxax, except that arguments are flags for y axis. See\n\
4008 the description of plsxax for more detail.\n\
4010 Redacted form: plsyax(digmax, digits)\n\
4012 This function is used in examples 1, 14, and 31.\n\
4018plsyax(digmax, digits)\n\
4022 digmax (PLINT, input) : Variable to set the maximum number of\n\
4023 digits for the y axis. If nonzero, the printed label will be\n\
4024 switched to a floating-point representation when the number of\n\
4025 digits exceeds digmax.\n\
4027 digits (PLINT, input) : Field digits value. Currently, changing\n\
4028 its value here has no effect since it is set only by plbox or\n\
4029 plbox3. However, the user may obtain its value after a call to\n\
4030 either of these functions by calling plgyax.\n\
4033Get z axis parameters\n\
4037 Identical to plgxax, except that arguments are flags for z axis. See\n\
4038 the description of plgxax for more detail.\n\
4040 Redacted form: plgzax(p_digmax, p_digits)\n\
4042 This function is used in example 31.\n\
4048plgzax(p_digmax, p_digits)\n\
4052 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4053 number of digits for the z axis. If nonzero, the printed label\n\
4054 has been switched to a floating-point representation when the\n\
4055 number of digits exceeds this value.\n\
4057 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4058 number of digits for the numeric labels (z axis) from the last\n\
4062Set format of numerical label for contours\n\
4066 Set format of numerical label for contours.\n\
4068 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4070 This function is used example 9.\n\
4076pl_setcontlabelformat(lexp, sigdig)\n\
4080 lexp (PLINT, input) : If the contour numerical label is greater\n\
4081 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4082 format is used. Default value of lexp is 4.\n\
4084 sigdig (PLINT, input) : Number of significant digits. Default\n\
4092 Sets the pen width.\n\
4094 Redacted form: plwidth(width)\n\
4096 This function is used in examples 1 and 2.\n\
4106 width (PLFLT, input) : The desired pen width. If width is negative\n\
4107 or the same as the previous value no action is taken. width = 0.\n\
4108 should be interpreted as as the minimum valid pen width for the\n\
4109 device. The interpretation of positive width values is also\n\
4110 device dependent.\n\
4113Get parameters that define current plot-space window\n\
4117 Get relative minima and maxima that define current plot-space window.\n\
4118 If plsdiplt has not been called the default values pointed to by\n\
4119 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4121 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4123 This function is used in example 31.\n\
4129plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4133 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4136 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4139 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4142 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4146Set the cmap1 argument range for continuous color plots\n\
4150 Set the cmap1 argument range for continuous color plots that\n\
4151 corresponds to the range of data values. The maximum range\n\
4152 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4153 the cmap1 argument range that is specified with this routine, the\n\
4154 smaller the subset of the cmap1 color palette that is used to\n\
4155 represent the continuous data being plotted. If\n\
4156 min_color is greater than\n\
4158 max_color is greater than 1.0 or\n\
4159 min_color is less than 0.0 then no change is made to the cmap1\n\
4160 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4162 Redacted form: plscmap1_range(min_color, max_color)\n\
4164 This function is currently used in example 33.\n\
4170plscmap1_range(min_color, max_color)\n\
4174 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4175 than 0.0, then 0.0 is used instead.\n\
4177 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4178 than 1.0, then 1.0 is used instead.\n\
4181Select standard viewport\n\
4185 Selects the largest viewport within the subpage that leaves a standard\n\
4186 margin (left-hand margin of eight character heights, and a margin\n\
4187 around the other three sides of five character heights).\n\
4189 Redacted form: plvsta()\n\
4191 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4200Load Hershey fonts\n\
4204 Loads the Hershey fonts used for text and symbols. This routine may\n\
4205 be called before or after initializing PLplot. If not explicitly\n\
4206 called before PLplot initialization, then by default that\n\
4207 initialization loads Hershey fonts with the extended character set.\n\
4208 This routine only has a practical effect for devices that still use\n\
4209 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4210 system fonts instead of Hershey fonts).\n\
4212 Redacted form: plfontld(fnt)\n\
4214 This function is used in examples 1 and 7.\n\
4224 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4225 A zero value specifies Hershey fonts with the standard character\n\
4226 set and a non-zero value (the default assumed if plfontld is never\n\
4227 called) specifies Hershey fonts with the extended character set.\n\
4230Draw error bars in x direction\n\
4234 Draws a set of n error bars in x direction, the i\'th error bar\n\
4235 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4236 of the error bars are of length equal to the minor tick length\n\
4237 (settable using plsmin).\n\
4239 Redacted form: General: plerrx(xmin, ymax, y)\n\
4242 This function is used in example 29.\n\
4248plerrx(n, xmin, xmax, y)\n\
4252 n (PLINT, input) : Number of error bars to draw.\n\
4254 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4255 of the left-hand endpoints of the error bars.\n\
4257 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4258 of the right-hand endpoints of the error bars.\n\
4260 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4264Plot shaded 3-d surface plot\n\
4268 Plots a three-dimensional shaded surface plot within the environment\n\
4269 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4272 ny], the point z[i][j] being the value of the function at (\n\
4274 y[j]). Note that the points in vectors x and y do not need to be\n\
4275 equally spaced, but must be stored in ascending order. For further\n\
4276 details see the PLplot documentation.\n\
4278 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4280 This function is not used in any examples.\n\
4286plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4290 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4291 which the function is evaluated.\n\
4293 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4294 which the function is evaluated.\n\
4296 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4297 plot. Should have dimensions of\n\
4301 nx (PLINT, input) : Number of x values at which function is\n\
4304 ny (PLINT, input) : Number of y values at which function is\n\
4307 opt (PLINT, input) : Determines the way in which the surface is\n\
4308 represented. To specify more than one option just add the options,\n\
4309 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4310 connecting points at which function is defined.\n\
4311 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4315 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4319 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4320 the borders of the plotted function.\n\
4321 opt=MAG_COLOR : the surface is colored according to the value\n\
4322 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4323 according to the intensity of the reflected light in the\n\
4324 surface from a light source whose position is set using\n\
4328 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4331 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4334Get the current library version number\n\
4338 Get the current library version number. Note: you must have allocated\n\
4339 space for this (80 characters is safe).\n\
4341 Redacted form: plgver(p_ver)\n\
4343 This function is used in example 1.\n\
4353 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4354 (with preallocated length of 80 characters or more) containing the\n\
4355 PLplot version number.\n\
4358End plotting session for current stream\n\
4362 Ends a plotting session for the current output stream only. See\n\
4363 plsstrm for more info.\n\
4365 Redacted form: plend1()\n\
4367 This function is used in examples 1 and 20.\n\
4376Draw error bars in the y direction\n\
4380 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4381 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4382 of the error bars are of length equal to the minor tick length\n\
4383 (settable using plsmin).\n\
4385 Redacted form: General: plerry(x, ymin, ymax)\n\
4388 This function is used in example 29.\n\
4394plerry(n, x, ymin, ymax)\n\
4398 n (PLINT, input) : Number of error bars to draw.\n\
4400 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4403 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4404 of the lower endpoints of the error bars.\n\
4406 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4407 of the upper endpoints of the error bars.\n\
4410Set seed for internal random number generator.\n\
4414 Set the seed for the internal random number generator. See plrandd for\n\
4417 Redacted form: plseed(seed)\n\
4419 This function is used in example 21.\n\
4429 seed (unsigned int, input) : Seed for random number generator.\n\
4432Specify viewport using normalized subpage coordinates\n\
4436 Device-independent routine for setting up the viewport. This defines\n\
4437 the viewport in terms of normalized subpage coordinates which run from\n\
4438 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4439 current subpage. Use the alternate routine plsvpa in order to create\n\
4440 a viewport of a definite size.\n\
4442 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4444 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4445 24, 26, 27, and 31.\n\
4451plvpor(xmin, xmax, ymin, ymax)\n\
4455 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4456 left-hand edge of the viewport.\n\
4458 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4459 right-hand edge of the viewport.\n\
4461 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4462 bottom edge of the viewport.\n\
4464 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4465 edge of the viewport.\n\
4472 Plots a surface mesh within the environment set up by plw3d. The\n\
4473 surface is defined by the matrix z[\n\
4475 ny] , the point z[i][j] being the value of the function at (\n\
4477 y[j]). Note that the points in vectors x and y do not need to be\n\
4478 equally spaced, but must be stored in ascending order. The parameter\n\
4479 opt controls the way in which the surface is displayed. For further\n\
4480 details see the PLplot documentation.\n\
4482 Redacted form: plmesh(x, y, z, opt)\n\
4484 This function is used in example 11.\n\
4490plmesh(x, y, z, nx, ny, opt)\n\
4494 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4495 which the function is evaluated.\n\
4497 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4498 which the function is evaluated.\n\
4500 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4501 plot. Should have dimensions of\n\
4505 nx (PLINT, input) : Number of x values at which function has been\n\
4508 ny (PLINT, input) : Number of y values at which function has been\n\
4511 opt (PLINT, input) : Determines the way in which the surface is\n\
4512 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4513 function of x for each value of y[j] .\n\
4514 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4515 for each value of x[i] .\n\
4516 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4517 at which function is defined.\n\
4520Get the cmap1 argument range for continuous color plots\n\
4524 Get the cmap1 argument range for continuous color plots. (Use\n\
4525 plscmap1_range to set the cmap1 argument range.)\n\
4527 Redacted form: plgcmap1_range(min_color, max_color)\n\
4529 This function is currently not used in any example.\n\
4535plgcmap1_range(min_color, max_color)\n\
4539 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4540 minimum cmap1 argument.\n\
4542 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4543 maximum cmap1 argument.\n\
4546Set arrow style for vector plots\n\
4550 Set the style for the arrow used by plvect to plot vectors.\n\
4552 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4554 This function is used in example 22.\n\
4560plsvect(arrowx, arrowy, npts, fill)\n\
4564 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4565 the x and y points which make up the arrow. The arrow is plotted\n\
4566 by joining these points to form a polygon. The scaling assumes\n\
4567 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4568 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4569 will be reset to its default.\n\
4571 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4574 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4575 fill is false then the arrow is open.\n\
4578Draw filled polygon\n\
4582 Fills the polygon defined by the n points (\n\
4584 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4585 style is a solid fill. The routine will automatically close the\n\
4586 polygon between the last and first vertices. If multiple closed\n\
4587 polygons are passed in x and y then plfill will fill in between them.\n\
4589 Redacted form: plfill(x,y)\n\
4591 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4601 n (PLINT, input) : Number of vertices in polygon.\n\
4603 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4606 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4610Convert HLS color to RGB\n\
4614 Convert HLS color coordinates to RGB.\n\
4616 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4619 This function is used in example 2.\n\
4625plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4629 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4632 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4633 the axis of the color cylinder.\n\
4635 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4636 the radius of the color cylinder.\n\
4638 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4639 (0.0-1.0) of the color.\n\
4641 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4642 intensity (0.0-1.0) of the color.\n\
4644 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4645 intensity (0.0-1.0) of the color.\n\
4648Set format for date / time labels\n\
4652 Sets the format for date / time labels. To enable date / time format\n\
4653 labels see the options to plbox, plbox3, and plenv.\n\
4655 Redacted form: pltimefmt(fmt)\n\
4657 This function is used in example 29.\n\
4667 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4668 interpreted similarly to the format specifier of typical system\n\
4669 strftime routines except that PLplot ignores locale and also\n\
4670 supplies some useful extensions in the context of plotting. All\n\
4671 text in the string is printed as-is other than conversion\n\
4672 specifications which take the form of a \'%\' character followed by\n\
4673 further conversion specification character. The conversion\n\
4674 specifications which are similar to those provided by system\n\
4675 strftime routines are the following: %a: The abbreviated (English)\n\
4677 %A: The full (English) weekday name.\n\
4678 %b: The abbreviated (English) month name.\n\
4679 %B: The full (English) month name.\n\
4680 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4681 %C: The century number (year/100) as a 2-digit integer.\n\
4682 %d: The day of the month as a decimal number (range 01 to 31).\n\
4683 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4684 %e: Like %d, but a leading zero is replaced by a space.\n\
4685 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4686 %h: Equivalent to %b.\n\
4687 %H: The hour as a decimal number using a 24-hour clock (range\n\
4689 %I: The hour as a decimal number using a 12-hour clock (range\n\
4691 %j: The day of the year as a decimal number (range 001 to\n\
4693 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4694 23); single digits are preceded by a blank. (See also %H.)\n\
4695 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4696 12); single digits are preceded by a blank. (See also %I.)\n\
4697 %m: The month as a decimal number (range 01 to 12).\n\
4698 %M: The minute as a decimal number (range 00 to 59).\n\
4699 %n: A newline character.\n\
4700 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4701 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4702 %r: Equivalent to %I:%M:%S %p.\n\
4703 %R: The time in 24-hour notation (%H:%M). For a version\n\
4704 including the seconds, see %T below.\n\
4705 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4707 %S: The second as a decimal number (range 00 to 60). (The\n\
4708 range is up to 60 to allow for occasional leap seconds.)\n\
4709 %t: A tab character.\n\
4710 %T: The time in 24-hour notation (%H:%M:%S).\n\
4711 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4712 being 1. See also %w.\n\
4713 %U: The week number of the current year as a decimal number,\n\
4714 range 00 to 53, starting with the first Sunday as the first\n\
4715 day of week 01. See also %V and %W.\n\
4716 %v: Equivalent to %e-%b-%Y.\n\
4717 %V: The ISO 8601 week number of the current year as a decimal\n\
4718 number, range 01 to 53, where week 1 is the first week that\n\
4719 has at least 4 days in the new year. See also %U and %W.\n\
4720 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4721 being 0. See also %u.\n\
4722 %W: The week number of the current year as a decimal number,\n\
4723 range 00 to 53, starting with the first Monday as the first\n\
4725 %x: Equivalent to %a %b %d %Y.\n\
4726 %X: Equivalent to %T.\n\
4727 %y: The year as a decimal number without a century (range 00\n\
4729 %Y: The year as a decimal number including a century.\n\
4730 %z: The UTC time-zone string = \"+0000\".\n\
4731 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4732 %+: The UTC date and time in default format of the Unix date\n\
4733 command which is equivalent to %a %b %d %T %Z %Y.\n\
4734 %%: A literal \"%\" character.\n\
4735 The conversion specifications which are extensions to those normally\n\
4736 provided by system strftime routines are the following: %(0-9):\n\
4737 The fractional part of the seconds field (including leading\n\
4738 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4739 seconds to millisecond accuracy (00.000).\n\
4740 %.: The fractional part of the seconds field (including\n\
4741 leading decimal point) to the maximum available accuracy. Thus\n\
4742 %S%. would give seconds with fractional part up to 9 decimal\n\
4743 places if available.\n\
4746Get current subpage parameters\n\
4750 Gets the size of the current subpage in millimeters measured from the\n\
4751 bottom left hand corner of the output device page or screen. Can be\n\
4752 used in conjunction with plsvpa for setting the size of a viewport in\n\
4753 absolute coordinates (millimeters).\n\
4755 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4757 This function is used in example 23.\n\
4763plgspa(xmin, xmax, ymin, ymax)\n\
4767 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4768 the left hand edge of the subpage in millimeters.\n\
4770 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4771 the right hand edge of the subpage in millimeters.\n\
4773 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4774 the bottom edge of the subpage in millimeters.\n\
4776 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4777 the top edge of the subpage in millimeters.\n\
4780Calculate world coordinates and corresponding window index from relative device coordinates\n\
4784 Calculate world coordinates, wx and wy, and corresponding window index\n\
4785 from relative device coordinates, rx and ry.\n\
4787 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4790 This function is used in example 31.\n\
4796plcalc_world(rx, ry, wx, wy, window)\n\
4800 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4801 the x coordinate.\n\
4803 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4804 the y coordinate.\n\
4806 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4807 coordinate corresponding to the relative device coordinates rx and\n\
4810 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4811 coordinate corresponding to the relative device coordinates rx and\n\
4814 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4815 defined window index that corresponds to the input relative device\n\
4816 coordinates (and the returned world coordinates). To give some\n\
4817 background on the window index, for each page the initial window\n\
4818 index is set to zero, and each time plwind is called within the\n\
4819 page, world and device coordinates are stored for the window and\n\
4820 the window index is incremented. Thus, for a simple page layout\n\
4821 with non-overlapping viewports and one window per viewport, window\n\
4822 corresponds to the viewport index (in the order which the\n\
4823 viewport/windows were created) of the only viewport/window\n\
4824 corresponding to rx and ry. However, for more complicated layouts\n\
4825 with potentially overlapping viewports and possibly more than one\n\
4826 window (set of world coordinates) per viewport, window and the\n\
4827 corresponding output world coordinates corresponds to the last\n\
4828 window created that fulfills the criterion that the relative\n\
4829 device coordinates are inside it. Finally, in all cases where the\n\
4830 input relative device coordinates are not inside any\n\
4831 viewport/window, then the returned value of the last defined\n\
4832 window index is set to -1.\n\
4835Get output file name\n\
4839 Gets the current output file name, if applicable.\n\
4841 Redacted form: plgfnam(fnam)\n\
4843 This function is used in example 31.\n\
4853 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4854 (with preallocated length of 80 characters or more) containing the\n\
4862 Draws a plot of vector data contained in the matrices (\n\
4868 ny]) . The scaling factor for the vectors is given by scale. A\n\
4869 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4870 additional data required by the transformation routine to map indices\n\
4871 within the matrices to the world coordinates. The style of the vector\n\
4872 arrow may be set using plsvect.\n\
4874 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4875 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4876 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4877 with either one or two dimensions.\n\
4879 This function is used in example 22.\n\
4885plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4889 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4890 and y components of the vector data to be plotted.\n\
4892 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4894 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4895 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4896 automatically calculated for the data. If scale < 0 then the\n\
4897 scaling factor is automatically calculated for the data and then\n\
4899 scale. If scale > 0 then the scaling factor is set to scale.\n\
4901 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4902 defines the transformation between the zero-based indices of the\n\
4903 matrices u and v and world coordinates.For the C case,\n\
4904 transformation functions are provided in the PLplot library: pltr0\n\
4905 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4906 mappings respectively defined by vectors and matrices. In\n\
4907 addition, C callback routines for the transformation can be\n\
4908 supplied by the user such as the mypltr function in\n\
4909 examples/c/x09c.c which provides a general linear transformation\n\
4910 between index coordinates and world coordinates.For languages\n\
4911 other than C you should consult the PLplot documentation for the\n\
4912 details concerning how PLTRANSFORM_callback arguments are\n\
4913 interfaced. However, in general, a particular pattern of\n\
4914 callback-associated arguments such as a tr vector with 6 elements;\n\
4915 xg and yg vectors; or xg and yg matrices are respectively\n\
4916 interfaced to a linear-transformation routine similar to the above\n\
4917 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4918 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4919 support native language callbacks for handling index to\n\
4920 world-coordinate transformations. Examples of these various\n\
4921 approaches are given in examples/<language>x09*,\n\
4922 examples/<language>x16*, examples/<language>x20*,\n\
4923 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4924 supported languages.\n\
4926 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4927 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4928 that is externally supplied.\n\
4931Plot a glyph at the specified points\n\
4935 Plot a glyph at the specified points. (This function is largely\n\
4936 superseded by plstring which gives access to many[!] more glyphs.)\n\
4938 Redacted form: plsym(x, y, code)\n\
4940 This function is used in example 7.\n\
4946plsym(n, x, y, code)\n\
4950 n (PLINT, input) : Number of points in the x and y vectors.\n\
4952 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4955 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4958 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4959 to be plotted at each of the n points.\n\
4962Get viewport limits in normalized device coordinates\n\
4966 Get viewport limits in normalized device coordinates.\n\
4968 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4971 This function is used in example 31.\n\
4977plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4981 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4982 viewport limit of the normalized device coordinate in x.\n\
4984 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4985 viewport limit of the normalized device coordinate in x.\n\
4987 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4988 viewport limit of the normalized device coordinate in y.\n\
4990 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4991 viewport limit of the normalized device coordinate in y.\n\
4994Get page parameters\n\
4998 Gets the current page configuration. The length and offset values are\n\
4999 expressed in units that are specific to the current driver. For\n\
5000 instance: screen drivers will usually interpret them as number of\n\
5001 pixels, whereas printer drivers will usually use mm.\n\
5003 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5005 This function is used in examples 14 and 31.\n\
5011plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5015 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5016 pixels/inch (DPI) in x.\n\
5018 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5019 pixels/inch (DPI) in y.\n\
5021 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5024 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5027 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5030 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5034Plot a glyph at the specified 3D points\n\
5038 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5039 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5040 this function similar to what is done for plline3. The glyph is\n\
5041 specified with a PLplot user string. Note that the user string is not\n\
5042 actually limited to one glyph so it is possible (but not normally\n\
5043 useful) to plot more than one glyph at the specified points with this\n\
5044 function. As with plmtex and plptex, the user string can contain FCI\n\
5045 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5046 else PLplot escapes for Hershey or unicode text to determine the\n\
5049 Redacted form: plstring3(x, y, z, string)\n\
5051 This function is used in example 18.\n\
5057plstring3(n, x, y, z, string)\n\
5061 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5063 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5066 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5069 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5072 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5073 the glyph(s) to be plotted at each of the n points. points.\n\
5076Shade regions on the basis of value\n\
5080 Shade regions on the basis of value. This is the high-level routine\n\
5081 for making continuous color shaded plots with cmap1 while plshade\n\
5082 should be used to plot individual shaded regions using either cmap0 or\n\
5083 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5084 our supported languages.\n\
5086 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5087 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5091 This function is used in examples 16, 21, and 22.\n\
5097plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5101 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5102 plot. Should have dimensions of\n\
5106 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5108 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5110 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5111 the region that should be plotted in the shade plot. This\n\
5112 function accepts x and y coordinates as input arguments and must\n\
5113 return 1 if the point is to be included in the shade plot and 0\n\
5114 otherwise. If you want to plot the entire shade plot (the usual\n\
5115 case), this argument should be set to NULL.\n\
5117 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5118 pltr below for how these arguments are used (only for the special case\n\
5119 when the callback function\n\
5120 pltr is not supplied).\n\
5122 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5123 corresponding to the edges of each shaded region that will be\n\
5124 plotted by this function. To work properly the levels should be\n\
5127 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5128 of shade edge values in clevel).\n\
5130 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5133 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5134 contours defining edges of shaded regions. The pen color is only\n\
5135 temporary set for the contour drawing. Set this value to zero or\n\
5136 less if no shade edge contours are wanted.\n\
5138 cont_width (PLFLT, input) : Defines line width used for contours\n\
5139 defining edges of shaded regions. This value may not be honored\n\
5140 by all drivers. The pen width is only temporary set for the\n\
5141 contour drawing. Set this value to zero or less if no shade edge\n\
5142 contours are wanted.\n\
5144 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5145 region. Use plfill for this purpose.\n\
5147 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5148 map to rectangles after coordinate transformation with pltrl.\n\
5149 Otherwise, set rectangular to false. If rectangular is set to\n\
5150 true, plshade tries to save time by filling large rectangles.\n\
5151 This optimization fails if the coordinate transformation distorts\n\
5152 the shape of rectangles. For example a plot in polar coordinates\n\
5153 has to have rectangular set to false.\n\
5155 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5156 defines the transformation between the zero-based indices of the\n\
5157 matrix a and world coordinates. If\n\
5158 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5159 indices of a are mapped to the range\n\
5161 xmax and the y indices of a are mapped to the range\n\
5163 ymax.For the C case, transformation functions are provided in the\n\
5164 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5165 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5166 matrices. In addition, C callback routines for the transformation\n\
5167 can be supplied by the user such as the mypltr function in\n\
5168 examples/c/x09c.c which provides a general linear transformation\n\
5169 between index coordinates and world coordinates.For languages\n\
5170 other than C you should consult the PLplot documentation for the\n\
5171 details concerning how PLTRANSFORM_callback arguments are\n\
5172 interfaced. However, in general, a particular pattern of\n\
5173 callback-associated arguments such as a tr vector with 6 elements;\n\
5174 xg and yg vectors; or xg and yg matrices are respectively\n\
5175 interfaced to a linear-transformation routine similar to the above\n\
5176 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5177 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5178 support native language callbacks for handling index to\n\
5179 world-coordinate transformations. Examples of these various\n\
5180 approaches are given in examples/<language>x09*,\n\
5181 examples/<language>x16*, examples/<language>x20*,\n\
5182 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5183 supported languages.\n\
5185 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5186 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5187 externally supplied.\n\
5190Set output file name\n\
5194 Sets the current output file name, if applicable. If the file name\n\
5195 has not been specified and is required by the driver, the user will be\n\
5196 prompted for it. If using the X-windows output driver, this sets the\n\
5197 display name. This routine, if used, must be called before\n\
5198 initializing PLplot.\n\
5200 Redacted form: plsfnam(fnam)\n\
5202 This function is used in examples 1 and 20.\n\
5212 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5220 Draws a contour plot of the data in f[\n\
5222 ny], using the nlevel contour levels specified by clevel. Only the\n\
5223 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5224 where all these index ranges are interpreted as one-based for\n\
5225 historical reasons. A transformation routine pointed to by pltr with\n\
5226 a generic pointer pltr_data for additional data required by the\n\
5227 transformation routine is used to map indices within the matrix to the\n\
5228 world coordinates.\n\
5230 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5231 where (see above discussion) the pltr, pltr_data callback arguments\n\
5232 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5233 vectors; or xg and yg matrices.\n\
5235 This function is used in examples 9, 14, 16, and 22.\n\
5241plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5245 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5247 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5249 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5250 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5251 zero-based for historical backwards-compatibility reasons.\n\
5253 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5254 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5255 zero-based for historical backwards-compatibility reasons.\n\
5257 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5258 which to draw contours.\n\
5260 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5262 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5263 defines the transformation between the zero-based indices of the\n\
5264 matrix f and the world coordinates.For the C case, transformation\n\
5265 functions are provided in the PLplot library: pltr0 for the\n\
5266 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5267 respectively defined by vectors and matrices. In addition, C\n\
5268 callback routines for the transformation can be supplied by the\n\
5269 user such as the mypltr function in examples/c/x09c.c which\n\
5270 provides a general linear transformation between index coordinates\n\
5271 and world coordinates.For languages other than C you should\n\
5272 consult the PLplot documentation for the details concerning how\n\
5273 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5274 general, a particular pattern of callback-associated arguments\n\
5275 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5276 yg matrices are respectively interfaced to a linear-transformation\n\
5277 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5278 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5279 the PLplot documentation) support native language callbacks for\n\
5280 handling index to world-coordinate transformations. Examples of\n\
5281 these various approaches are given in examples/<language>x09*,\n\
5282 examples/<language>x16*, examples/<language>x20*,\n\
5283 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5284 supported languages.\n\
5286 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5287 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5288 that is externally supplied.\n\
5291Set parameters that define current plot-space window\n\
5295 Set relative minima and maxima that define the current plot-space\n\
5296 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5297 xmax, and ymax are 0., 0., 1., and 1.\n\
5299 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5301 This function is used in example 31.\n\
5307plsdiplt(xmin, ymin, xmax, ymax)\n\
5311 xmin (PLFLT, input) : Relative minimum in x.\n\
5313 ymin (PLFLT, input) : Relative minimum in y.\n\
5315 xmax (PLFLT, input) : Relative maximum in x.\n\
5317 ymax (PLFLT, input) : Relative maximum in y.\n\
5320Write text inside the viewport of a 3D plot\n\
5324 Writes text at a specified position and inclination and with a\n\
5325 specified shear within the viewport. Text is clipped at the viewport\n\
5326 boundaries. The reference point of a string lies along a line passing\n\
5327 through the string at half the height of a capital letter. The\n\
5328 position of the reference point along this line is determined by just,\n\
5329 and the reference point is placed at world coordinates (\n\
5332 wz) within the viewport. The inclination and shear of the string is\n\
5333 specified in terms of differences of world coordinates making it easy\n\
5334 to write text parallel to a line in a graph.\n\
5336 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5338 This function is used in example 28.\n\
5344plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5348 wx (PLFLT, input) : x world coordinate of reference point of\n\
5351 wy (PLFLT, input) : y world coordinate of reference point of\n\
5354 wz (PLFLT, input) : z world coordinate of reference point of\n\
5357 dx (PLFLT, input) : Together with dy and\n\
5358 dz , this specifies the inclination of the string. The baseline of\n\
5359 the string is parallel to a line joining (\n\
5370 dy (PLFLT, input) : Together with dx and\n\
5371 dz, this specifies the inclination of the string.\n\
5373 dz (PLFLT, input) : Together with dx and\n\
5374 dy, this specifies the inclination of the string.\n\
5376 sx (PLFLT, input) : Together with sy and\n\
5377 sz , this specifies the shear of the string. The string is sheared so\n\
5378 that the characters are vertically parallel to a line joining (\n\
5389 sz = 0.) then the text is not sheared.\n\
5391 sy (PLFLT, input) : Together with sx and\n\
5392 sz, this specifies shear of the string.\n\
5394 sz (PLFLT, input) : Together with sx and\n\
5395 sy, this specifies shear of the string.\n\
5397 just (PLFLT, input) : Specifies the position of the string relative\n\
5398 to its reference point. If just=0. , the reference point is at\n\
5399 the left and if just=1. , it is at the right of the string. Other\n\
5400 values of just give intermediate justifications.\n\
5402 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5406Plot continental outline or shapefile data in world coordinates\n\
5410 Plots continental outlines or shapefile data in world coordinates. A\n\
5411 demonstration of how to use this function to create different\n\
5412 projections can be found in examples/c/x19c. PLplot is provided with\n\
5413 basic coastal outlines and USA state borders. To use the map\n\
5414 functionality PLplot must be compiled with the shapelib library.\n\
5415 Shapefiles have become a popular standard for geographical data and\n\
5416 data in this format can be easily found from a number of online\n\
5417 sources. Shapefile data is actually provided as three or more files\n\
5418 with the same filename, but different extensions. The .shp and .shx\n\
5419 files are required for plotting Shapefile data with PLplot.\n\
5421 PLplot currently supports the point, multipoint, polyline and polygon\n\
5422 objects within shapefiles. However holes in polygons are not\n\
5423 supported. When plmap is used the type of object is derived from the\n\
5424 shapefile, if you wish to override the type then use one of the other\n\
5425 plmap variants. The built in maps have line data only.\n\
5427 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5429 This function is used in example 19.\n\
5435plmap(mapform, name, minx, maxx, miny, maxy)\n\
5439 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5440 transform the original map data coordinates to a new coordinate\n\
5441 system. The PLplot-supplied map data is provided as latitudes and\n\
5442 longitudes; other Shapefile data may be provided in other\n\
5443 coordinate systems as can be found in their .prj plain text files.\n\
5444 For example, by using this transform we can change from a\n\
5445 longitude, latitude coordinate to a polar stereographic\n\
5446 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5447 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5448 corresponding y coordinates (latitudes for the PLplot supplied\n\
5449 data). After the call to mapform(), x[] and y[] should be\n\
5450 replaced by the corresponding plot coordinates. If no transform is\n\
5451 desired, mapform can be replaced by NULL.\n\
5453 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5454 the type of map plotted. This is either one of the PLplot built-in\n\
5455 maps or the file name of a set of Shapefile files without the file\n\
5456 extensions. For the PLplot built-in maps the possible values are:\n\
5457 \"globe\" -- continental outlines\n\
5458 \"usa\" -- USA and state boundaries\n\
5459 \"cglobe\" -- continental outlines and countries\n\
5460 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5463 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5464 drawn. The units must match the shapefile (built in maps are\n\
5465 degrees lat/lon). Objects in the file which do not encroach on the\n\
5466 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5467 note this is simply an optimisation, not a clipping so for objects\n\
5468 with some points inside the box and some points outside the box\n\
5469 all the points will be rendered. These parameters also define\n\
5470 latitude and longitude wrapping for shapefiles using these units.\n\
5471 Longitude points will be wrapped by integer multiples of 360\n\
5472 degrees to place them in the box. This allows the same data to be\n\
5473 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5474 you plot from -180-540 you will get two cycles of data drawn. The\n\
5475 value of minx must be less than the value of maxx. Passing in a\n\
5476 nan, max/-max floating point number or +/-infinity will case the\n\
5477 bounding box from the shapefile to be used.\n\
5479 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5480 drawn - see minx.\n\
5482 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5483 drawn - see minx.\n\
5485 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5486 drawn - see minx.\n\
5489Specify viewport using coordinates and aspect ratio\n\
5493 Device-independent routine for setting up the viewport. The viewport\n\
5494 is chosen to be the largest with the given aspect ratio that fits\n\
5495 within the specified region (in terms of normalized subpage\n\
5496 coordinates). This routine is functionally equivalent to plvpor when\n\
5497 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5498 routine reserves no extra space at the edges for labels.\n\
5500 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5502 This function is used in example 9.\n\
5508plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5512 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5513 left-hand edge of the viewport.\n\
5515 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5516 right-hand edge of the viewport.\n\
5518 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5519 bottom edge of the viewport.\n\
5521 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5522 edge of the viewport.\n\
5524 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5528Set the pause (on end-of-page) status\n\
5532 Set the pause (on end-of-page) status.\n\
5534 Redacted form: plspause(pause)\n\
5536 This function is in examples 14,20.\n\
5546 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5547 end-of-page for those drivers which support this. Otherwise there\n\
5551Plot 3-d surface plot\n\
5555 Plots a three-dimensional surface plot within the environment set up\n\
5556 by plw3d. The surface is defined by the matrix z[\n\
5558 ny] , the point z[i][j] being the value of the function at (\n\
5560 y[j]). Note that the points in vectors x and y do not need to be\n\
5561 equally spaced, but must be stored in ascending order. The parameter\n\
5562 opt controls the way in which the surface is displayed. For further\n\
5563 details see the PLplot documentation. The only difference between\n\
5564 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5565 while plot3d only draws the surface as viewed from the top.\n\
5567 Redacted form: plot3d(x, y, z, opt, side)\n\
5569 This function is used in examples 11 and 21.\n\
5575plot3d(x, y, z, nx, ny, opt, side)\n\
5579 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5580 which the function is evaluated.\n\
5582 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5583 which the function is evaluated.\n\
5585 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5586 plot. Should have dimensions of\n\
5590 nx (PLINT, input) : Number of x values at which function is\n\
5593 ny (PLINT, input) : Number of y values at which function is\n\
5596 opt (PLINT, input) : Determines the way in which the surface is\n\
5597 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5598 function of x for each value of y[j] .\n\
5599 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5600 for each value of x[i] .\n\
5601 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5602 at which function is defined.\n\
5605 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5606 should be draw on the figure. If side is true sides are drawn,\n\
5607 otherwise no sides are drawn.\n\
5610Copy state parameters from the reference stream to the current stream\n\
5614 Copies state parameters from the reference stream to the current\n\
5615 stream. Tell driver interface to map device coordinates unless flags\n\
5618 This function is used for making save files of selected plots (e.g.\n\
5619 from the TK driver). After initializing, you can get a copy of the\n\
5620 current plot to the specified device by switching to this stream and\n\
5621 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5622 appropriate. The plot buffer must have previously been enabled (done\n\
5623 automatically by some display drivers, such as X).\n\
5625 Redacted form: plcpstrm(iplsr, flags)\n\
5627 This function is used in example 1,20.\n\
5633plcpstrm(iplsr, flags)\n\
5637 iplsr (PLINT, input) : Number of reference stream.\n\
5639 flags (PLBOOL, input) : If flags is set to true the device\n\
5640 coordinates are not copied from the reference to current stream.\n\
5643Set page parameters\n\
5647 Sets the page configuration (optional). If an individual parameter is\n\
5648 zero then that parameter value is not updated. Not all parameters are\n\
5649 recognized by all drivers and the interpretation is device-dependent.\n\
5650 The X-window driver uses the length and offset parameters to determine\n\
5651 the window size and location. The length and offset values are\n\
5652 expressed in units that are specific to the current driver. For\n\
5653 instance: screen drivers will usually interpret them as number of\n\
5654 pixels, whereas printer drivers will usually use mm.\n\
5656 This routine, if used, must be called before initializing PLplot. It\n\
5657 may be called at later times for interactive drivers to change only\n\
5658 the dpi for subsequent redraws which you can force via a call to\n\
5659 plreplot. If this function is not called then the page size defaults\n\
5660 to landscape A4 for drivers which use real world page sizes and 744\n\
5661 pixels wide by 538 pixels high for raster drivers. The default value\n\
5662 for dx and dy is 90 pixels per inch for raster drivers.\n\
5666 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5668 This function is used in examples 14 and 31.\n\
5674plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5678 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5679 by raster drivers, ignored by drivers which use \"real world\" units\n\
5682 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5683 by raster drivers, ignored by drivers which use \"real world\" units\n\
5686 xleng (PLINT, input) : Page length, x.\n\
5688 yleng (PLINT, input) : Page length, y.\n\
5690 xoff (PLINT, input) : Page offset, x.\n\
5692 yoff (PLINT, input) : Page offset, y.\n\
5695Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5699 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5700 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5701 Values are negative if an invalid color id is given.\n\
5703 Redacted form: plgcola(r, g, b)\n\
5705 This function is used in example 30.\n\
5711plgcol0a(icol0, r, g, b, alpha)\n\
5715 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5717 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5718 in the range from 0 to 255.\n\
5720 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5721 in the range from 0 to 255.\n\
5723 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5724 in the range from 0 to 255.\n\
5726 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5727 transparency in the range from (0.0-1.0).\n\
5730Returns 8-bit RGB values for given color index from cmap0\n\
5734 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5735 PLplot documentation). Values are negative if an invalid color id is\n\
5738 Redacted form: plgcol0(icol0, r, g, b)\n\
5740 This function is used in example 2.\n\
5746plgcol0(icol0, r, g, b)\n\
5750 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5752 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5755 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5758 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5762Set parameters incrementally (zoom mode) that define current plot-space window\n\
5766 Set relative minima and maxima incrementally (zoom mode) that define\n\
5767 the current plot-space window. This function has the same effect as\n\
5768 plsdiplt if that function has not been previously called. Otherwise,\n\
5769 this function implements zoom mode using the transformation min_used =\n\
5770 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5771 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5772 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5774 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5776 This function is used in example 31.\n\
5782plsdiplz(xmin, ymin, xmax, ymax)\n\
5786 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5788 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5790 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5792 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5795Plot all or a subset of Shapefile data, filling the polygons\n\
5799 As per plmapline, however the items are filled in the same way as\n\
5802 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5805 This function is used in example 19.\n\
5811plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5815 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5816 transform the coordinates given in the shapefile into a plot\n\
5817 coordinate system. By using this transform, we can change from a\n\
5818 longitude, latitude coordinate to a polar stereographic project,\n\
5819 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5820 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5821 mapform(), x[] and y[] should be replaced by the corresponding\n\
5822 plot coordinates. If no transform is desired, mapform can be\n\
5823 replaced by NULL.\n\
5825 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5826 the file name of a set of Shapefile files without the file\n\
5829 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5830 be in the same units as used by the Shapefile. You could use a\n\
5831 very large negative number to plot everything, but you can improve\n\
5832 performance by limiting the area drawn. The units must match those\n\
5833 of the Shapefile projection, which may be for example longitude or\n\
5834 distance. The value of minx must be less than the value of maxx.\n\
5836 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5837 use a very large number to plot everything, but you can improve\n\
5838 performance by limiting the area drawn.\n\
5840 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5841 be in the same units as used by the Shapefile. You could use a\n\
5842 very large negative number to plot everything, but you can improve\n\
5843 performance by limiting the area drawn. The units must match those\n\
5844 of the Shapefile projection, which may be for example latitude or\n\
5845 distance. The value of miny must be less than the value of maxy.\n\
5847 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5848 use a very large number to plot everything, but you can improve\n\
5849 performance by limiting the area drawn.\n\
5851 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5852 zero-based indices of the Shapefile elements which will be drawn.\n\
5854 plotentries to NULL will plot all elements of the Shapefile.\n\
5856 nplotentries (PLINT, input) : The number of items in\n\
5857 plotentries. Ignored if\n\
5858 plotentries is NULL.\n\
5865 Draws line defined by n points in x and y.\n\
5867 Redacted form: plline(x, y)\n\
5869 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5880 n (PLINT, input) : Number of points defining line.\n\
5882 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5885 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5889Get viewport limits in world coordinates\n\
5893 Get viewport limits in world coordinates.\n\
5895 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5898 This function is used in example 31.\n\
5904plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5908 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5909 viewport limit of the world coordinate in x.\n\
5911 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5912 viewport limit of the world coordinate in x.\n\
5914 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5915 viewport limit of the world coordinate in y.\n\
5917 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5918 viewport limit of the world coordinate in y.\n\
5921Set area line fill pattern\n\
5925 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5926 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5927 inclinations and spacings. The arguments to this routine are the\n\
5928 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5929 elements) specifying the inclinations in tenths of a degree and the\n\
5930 spacing in micrometers. (See also plpsty)\n\
5932 Redacted form: General: plpat(inc, del)\n\
5935 This function is used in example 15.\n\
5941plpat(nlin, inc, del)\n\
5945 nlin (PLINT, input) : Number of sets of lines making up the\n\
5946 pattern, either 1 or 2.\n\
5948 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5949 inclination in tenths of a degree. (Should be between -900 and\n\
5952 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5953 spacing in micrometers between the lines making up the pattern.\n\
5956Set x axis parameters\n\
5960 Sets values of the digmax and digits flags for the x axis. See the\n\
5961 PLplot documentation for more information.\n\
5963 Redacted form: plsxax(digmax, digits)\n\
5965 This function is used in example 31.\n\
5971plsxax(digmax, digits)\n\
5975 digmax (PLINT, input) : Variable to set the maximum number of\n\
5976 digits for the x axis. If nonzero, the printed label will be\n\
5977 switched to a floating-point representation when the number of\n\
5978 digits exceeds digmax.\n\
5980 digits (PLINT, input) : Field digits value. Currently, changing\n\
5981 its value here has no effect since it is set only by plbox or\n\
5982 plbox3. However, the user may obtain its value after a call to\n\
5983 either of these functions by calling plgxax.\n\
5986Get family file parameters\n\
5990 Gets information about current family file, if familying is enabled.\n\
5991 See the PLplot documentation for more information.\n\
5993 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5995 This function is used in examples 14 and 31.\n\
6001plgfam(p_fam, p_num, p_bmax)\n\
6005 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6006 family flag value. If nonzero, familying is enabled for the\n\
6009 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6010 family file number.\n\
6012 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6013 file size (in bytes) for a family file.\n\
6016Get y axis parameters\n\
6020 Identical to plgxax, except that arguments are flags for y axis. See\n\
6021 the description of plgxax for more detail.\n\
6023 Redacted form: plgyax(p_digmax, p_digits)\n\
6025 This function is used in example 31.\n\
6031plgyax(p_digmax, p_digits)\n\
6035 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6036 number of digits for the y axis. If nonzero, the printed label\n\
6037 has been switched to a floating-point representation when the\n\
6038 number of digits exceeds this value.\n\
6040 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6041 number of digits for the numeric labels (y axis) from the last\n\
6045Plot a glyph at the specified points\n\
6049 Plot a glyph at the specified points. (This function is largely\n\
6050 superseded by plstring which gives access to many[!] more glyphs.)\n\
6051 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6052 and a draw at the same place. Not ideal, since a sufficiently\n\
6053 intelligent output device may optimize it away, or there may be faster\n\
6054 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6055 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6056 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6057 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6058 code <= 127 the corresponding printable ASCII character is plotted.\n\
6060 Redacted form: plpoin(x, y, code)\n\
6062 This function is used in examples 1, 6, 14, and 29.\n\
6068plpoin(n, x, y, code)\n\
6072 n (PLINT, input) : Number of points in the x and y vectors.\n\
6074 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6077 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6080 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6081 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6082 each of the n points.\n\
6085Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6089 As per plmapline, however the items are plotted as strings or points\n\
6090 in the same way as plstring.\n\
6092 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6093 maxy, plotentries)\n\
6095 This function is not used in any examples.\n\
6101plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6105 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6106 transform the coordinates given in the shapefile into a plot\n\
6107 coordinate system. By using this transform, we can change from a\n\
6108 longitude, latitude coordinate to a polar stereographic project,\n\
6109 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6110 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6111 mapform(), x[] and y[] should be replaced by the corresponding\n\
6112 plot coordinates. If no transform is desired, mapform can be\n\
6113 replaced by NULL.\n\
6115 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6116 the file name of a set of Shapefile files without the file\n\
6119 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6122 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6123 be in the same units as used by the Shapefile. You could use a\n\
6124 very large negative number to plot everything, but you can improve\n\
6125 performance by limiting the area drawn. The units must match those\n\
6126 of the Shapefile projection, which may be for example longitude or\n\
6127 distance. The value of minx must be less than the value of maxx.\n\
6129 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6130 use a very large number to plot everything, but you can improve\n\
6131 performance by limiting the area drawn.\n\
6133 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6134 be in the same units as used by the Shapefile. You could use a\n\
6135 very large negative number to plot everything, but you can improve\n\
6136 performance by limiting the area drawn. The units must match those\n\
6137 of the Shapefile projection, which may be for example latitude or\n\
6138 distance. The value of miny must be less than the value of maxy.\n\
6140 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6141 use a very large number to plot everything, but you can improve\n\
6142 performance by limiting the area drawn.\n\
6144 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6145 zero-based indices of the Shapefile elements which will be drawn.\n\
6147 plotentries to NULL will plot all elements of the Shapefile.\n\
6149 nplotentries (PLINT, input) : The number of items in\n\
6150 plotentries. Ignored if\n\
6151 plotentries is NULL.\n\
6154Select area fill pattern\n\
6159 patt is zero or less use either a hardware solid fill if the drivers\n\
6160 have that capability (virtually all do) or fall back to a software\n\
6161 emulation of a solid fill using the eighth area line fill pattern. If\n\
6163 patt <= 8, then select one of eight predefined area line fill patterns\n\
6164 to use (see plpat if you desire other patterns).\n\
6166 Redacted form: plpsty(patt)\n\
6168 This function is used in examples 12, 13, 15, 16, and 25.\n\
6178 patt (PLINT, input) : The desired pattern index. If\n\
6179 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6181 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6182 line fill capability itself (most deliberately do not so that line\n\
6183 fill patterns look identical for those drivers), the patterns\n\
6184 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6185 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6186 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6187 (8) lines at both 45 degrees and -45 degrees.\n\
6190Set 8-bit RGB values for given cmap0 color index\n\
6194 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6195 index. Overwrites the previous color value for the given index and,\n\
6196 thus, does not result in any additional allocation of space for\n\
6199 Redacted form: plscol0(icol0, r, g, b)\n\
6201 This function is used in any example 31.\n\
6207plscol0(icol0, r, g, b)\n\
6211 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6212 number of colors (which is set by default, by plscmap0n, or even\n\
6215 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6216 degree of red in the color.\n\
6218 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6219 degree of green in the color.\n\
6221 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6222 degree of blue in the color.\n\
6225Used to globally turn color output on/off\n\
6229 Used to globally turn color output on/off for those drivers/devices\n\
6232 Redacted form: plscolor(color)\n\
6234 This function is used in example 31.\n\
6244 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6245 turned off. If non-zero, color is turned on.\n\
6248End plotting session\n\
6252 Ends a plotting session, tidies up all the output files, switches\n\
6253 interactive devices back into text mode and frees up any memory that\n\
6254 was allocated. Must be called before end of program.\n\
6256 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6257 wait state after a call to plend or other functions which trigger the\n\
6258 end of a plot page. To avoid this, use the plspause function.\n\
6260 Redacted form: plend()\n\
6262 This function is used in all of the examples.\n\
6271Plot a histogram from binned data\n\
6275 Plots a histogram consisting of nbin bins. The value associated with\n\
6276 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6277 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6278 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6279 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6280 placed midway between the values in the x vector. Also see plhist for\n\
6281 drawing histograms from unbinned data.\n\
6283 Redacted form: General: plbin(x, y, opt)\n\
6284 Python: plbin(nbin, x, y, opt)\n\
6287 This function is not used in any examples.\n\
6293plbin(nbin, x, y, opt)\n\
6297 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6300 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6301 with bins. These must form a strictly increasing sequence.\n\
6303 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6304 proportional to the number of points in each bin. This is a PLFLT\n\
6305 (instead of PLINT) vector so as to allow histograms of\n\
6306 probabilities, etc.\n\
6308 opt (PLINT, input) : Is a combination of several flags:\n\
6309 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6310 outer bins are expanded to fill up the entire x-axis and bins of\n\
6311 zero height are simply drawn.\n\
6312 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6313 between the x values. If the values in x are equally spaced,\n\
6314 the values are the center values of the bins.\n\
6315 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6316 size as the ones inside.\n\
6317 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6318 (there is a gap for such bins).\n\
6321Plot a 2D matrix using cmap1\n\
6325 Plot a 2D matrix using cmap1.\n\
6327 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6328 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6331 This function is used in example 20.\n\
6337plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6341 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6342 plot. Should have dimensions of\n\
6346 nx, ny (PLINT, input) : Dimensions of idata\n\
6348 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6349 pltr below for how these arguments are used (only for the special case\n\
6350 when the callback function\n\
6351 pltr is not supplied).\n\
6353 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6354 (inclusive) will be plotted.\n\
6356 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6357 values to use for value to color mappings. A datum equal to or\n\
6358 less than valuemin will be plotted with color 0.0, while a datum\n\
6359 equal to or greater than valuemax will be plotted with color 1.0.\n\
6360 Data between valuemin and valuemax map linearly to colors in the\n\
6363 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6364 defines the transformation between the zero-based indices of the\n\
6365 matrix idata and world coordinates. If\n\
6366 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6367 indices of idata are mapped to the range\n\
6369 xmax and the y indices of idata are mapped to the range\n\
6371 ymax.For the C case, transformation functions are provided in the\n\
6372 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6373 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6374 matrices. In addition, C callback routines for the transformation\n\
6375 can be supplied by the user such as the mypltr function in\n\
6376 examples/c/x09c.c which provides a general linear transformation\n\
6377 between index coordinates and world coordinates.For languages\n\
6378 other than C you should consult the PLplot documentation for the\n\
6379 details concerning how PLTRANSFORM_callback arguments are\n\
6380 interfaced. However, in general, a particular pattern of\n\
6381 callback-associated arguments such as a tr vector with 6 elements;\n\
6382 xg and yg vectors; or xg and yg matrices are respectively\n\
6383 interfaced to a linear-transformation routine similar to the above\n\
6384 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6385 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6386 support native language callbacks for handling index to\n\
6387 world-coordinate transformations. Examples of these various\n\
6388 approaches are given in examples/<language>x09*,\n\
6389 examples/<language>x16*, examples/<language>x20*,\n\
6390 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6391 supported languages.\n\
6393 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6394 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6395 externally supplied.\n\
6398Sets the 3D position of the light source\n\
6402 Sets the 3D position of the light source for use with plsurf3d and\n\
6405 Redacted form: pllightsource(x, y, z)\n\
6407 This function is used in example 8.\n\
6413pllightsource(x, y, z)\n\
6417 x (PLFLT, input) : X-coordinate of the light source.\n\
6419 y (PLFLT, input) : Y-coordinate of the light source.\n\
6421 z (PLFLT, input) : Z-coordinate of the light source.\n\
6424Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6428 When the implementation is completed this variant of plot3dc (see that\n\
6429 function\'s documentation for more details) should be suitable for the\n\
6430 case where the area of the x, y coordinate grid where z is defined can\n\
6431 be non-rectangular. The implementation is incomplete so the last 4\n\
6432 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6433 indexymax; are currently ignored and the functionality is otherwise\n\
6434 identical to that of plot3dc.\n\
6436 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6437 indexymin, indexymax)\n\
6440 This function is not used in any example.\n\
6446plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6450 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6451 which the function is evaluated.\n\
6453 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6454 which the function is evaluated.\n\
6456 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6457 plot. Should have dimensions of\n\
6461 nx (PLINT, input) : Number of x values at which the function is\n\
6464 ny (PLINT, input) : Number of y values at which the function is\n\
6467 opt (PLINT, input) : Determines the way in which the surface is\n\
6468 represented. To specify more than one option just add the options,\n\
6469 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6470 showing z as a function of x for each value of y[j] .\n\
6471 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6472 for each value of x[i] .\n\
6473 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6474 at which function is defined.\n\
6475 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6476 the z value being plotted. The color is used from the current\n\
6478 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6482 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6483 the borders of the plotted function.\n\
6486 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6489 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6491 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6492 corresponds to the first x index where z is defined.\n\
6494 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6495 which corresponds (by convention) to one more than the last x\n\
6496 index value where z is defined.\n\
6498 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6499 values which all must be ≥ 0. These values are the first y index\n\
6500 where z is defined for a particular x index in the range from\n\
6501 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6504 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6505 values which all must be ≤ ny. These values correspond (by\n\
6506 convention) to one more than the last y index where z is defined\n\
6507 for a particular x index in the range from indexxmin to indexxmax\n\
6508 - 1. The dimension of indexymax is indexxmax.\n\
6511Creates a new stream and makes it the default\n\
6515 Creates a new stream and makes it the default. Differs from using\n\
6516 plsstrm, in that a free stream number is found, and returned.\n\
6517 Unfortunately, I have to start at stream 1 and work upward, since\n\
6518 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6519 that no initial, library-opening call is required. So stream 0 must\n\
6520 be preallocated, and there is no simple way of determining whether it\n\
6521 is already in use or not.\n\
6523 Redacted form: plmkstrm(p_strm)\n\
6525 This function is used in examples 1 and 20.\n\
6535 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6536 number of the created stream.\n\
6539Set FCI (font characterization integer)\n\
6543 Sets font characteristics to be used at the start of the next string\n\
6544 using the FCI approach. See the PLplot documentation for more\n\
6545 information. Note, plsfont (which calls plsfci internally) provides a\n\
6546 more user-friendly API for setting the font characterisitics.\n\
6548 Redacted form: General: plsfci(fci)\n\
6551 This function is used in example 23.\n\
6561 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6569 Initializing the plotting package. The program prompts for the device\n\
6570 keyword or number of the desired output device. Hitting a RETURN in\n\
6571 response to the prompt is the same as selecting the first device.\n\
6572 plinit will issue no prompt if either the device was specified\n\
6573 previously (via command line flag, the plsetopt function, or the\n\
6574 plsdev function), or if only one device is enabled when PLplot is\n\
6575 installed. If subpages have been specified, the output device is\n\
6576 divided into nx by ny subpages, each of which may be used\n\
6577 independently. If plinit is called again during a program, the\n\
6578 previously opened file will be closed. The subroutine pladv is used\n\
6579 to advance from one subpage to the next.\n\
6581 Redacted form: plinit()\n\
6583 This function is used in all of the examples.\n\
6596 This sets up the line style for all lines subsequently drawn. A line\n\
6597 consists of segments in which the pen is alternately down and up. The\n\
6598 lengths of these segments are passed in the vectors mark and space\n\
6599 respectively. The number of mark-space pairs is specified by nms. In\n\
6600 order to return the line style to the default continuous line, plstyl\n\
6601 should be called with nms =0 .(see also pllsty)\n\
6603 Redacted form: plstyl(mark, space)\n\
6605 This function is used in examples 1, 9, and 14.\n\
6611plstyl(nms, mark, space)\n\
6615 nms (PLINT, input) : The number of mark and space elements in a\n\
6616 line. Thus a simple broken line can be obtained by setting nms=1\n\
6617 . A continuous line is specified by setting nms=0 .\n\
6619 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6620 segments during which the pen is down, measured in micrometers.\n\
6622 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6623 the segments during which the pen is up, measured in micrometers.\n\
6626Set length of minor ticks\n\
6630 This sets up the length of the minor ticks and the length of the\n\
6631 terminals on error bars. The actual length is the product of the\n\
6632 default length and a scaling factor as for character height.\n\
6634 Redacted form: plsmin(def, scale)\n\
6636 This function is used in example 29.\n\
6642plsmin(def, scale)\n\
6646 def (PLFLT, input) : The default length of a minor tick in\n\
6647 millimeters, should be set to zero if the default length is to\n\
6648 remain unchanged.\n\
6650 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6651 actual tick length.\n\
6654Draw a box with axes, etc, in 3-d\n\
6658 Draws axes, numeric and text labels for a three-dimensional surface\n\
6659 plot. For a more complete description of three-dimensional plotting\n\
6660 see the PLplot documentation.\n\
6662 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6663 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6666 This function is used in examples 8, 11, 18, and 21.\n\
6672plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6676 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6677 options for the x axis. The string can include any combination of\n\
6678 the following letters (upper or lower case) in any order: b: Draws\n\
6679 axis at base, at height z=\n\
6680 zmin where zmin is defined by call to plw3d. This character must be\n\
6681 specified in order to use any of the other options.\n\
6682 d: Plot labels as date / time. Values are assumed to be\n\
6683 seconds since the epoch (as used by gmtime).\n\
6684 f: Always use fixed point numeric labels.\n\
6685 i: Inverts tick marks, so they are drawn downwards, rather\n\
6687 l: Labels axis logarithmically. This only affects the labels,\n\
6688 not the data, and so it is necessary to compute the logarithms\n\
6689 of data points before passing them to any of the drawing\n\
6691 n: Writes numeric labels at major tick intervals.\n\
6692 o: Use custom labelling function to generate axis label text.\n\
6693 The custom labelling function can be defined with the\n\
6694 plslabelfunc command.\n\
6695 s: Enables subticks between major ticks, only valid if t is\n\
6697 t: Draws major ticks.\n\
6698 u: If this is specified, the text label for the axis is\n\
6699 written under the axis.\n\
6702 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6703 the text label for the x axis. It is only drawn if u is in the\n\
6706 xtick (PLFLT, input) : World coordinate interval between major\n\
6707 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6708 generates a suitable tick interval.\n\
6710 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6711 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6712 generates a suitable minor tick interval.\n\
6714 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6715 options for the y axis. The string is interpreted in the same way\n\
6718 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6719 the text label for the y axis. It is only drawn if u is in the\n\
6722 ytick (PLFLT, input) : World coordinate interval between major\n\
6723 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6724 generates a suitable tick interval.\n\
6726 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6727 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6728 generates a suitable minor tick interval.\n\
6730 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6731 options for the z axis. The string can include any combination of\n\
6732 the following letters (upper or lower case) in any order: b: Draws\n\
6733 z axis to the left of the surface plot.\n\
6734 c: Draws z axis to the right of the surface plot.\n\
6735 d: Draws grid lines parallel to the x-y plane behind the\n\
6736 figure. These lines are not drawn until after plot3d or\n\
6737 plmesh are called because of the need for hidden line removal.\n\
6738 e: Plot labels as date / time. Values are assumed to be\n\
6739 seconds since the epoch (as used by gmtime). Note this\n\
6740 suboption is interpreted the same as the d suboption for xopt\n\
6741 and yopt, but it has to be identified as e for zopt since d\n\
6742 has already been used for the different purpose above.\n\
6743 f: Always use fixed point numeric labels.\n\
6744 i: Inverts tick marks, so they are drawn away from the center.\n\
6745 l: Labels axis logarithmically. This only affects the labels,\n\
6746 not the data, and so it is necessary to compute the logarithms\n\
6747 of data points before passing them to any of the drawing\n\
6749 m: Writes numeric labels at major tick intervals on the\n\
6750 right-hand z axis.\n\
6751 n: Writes numeric labels at major tick intervals on the\n\
6752 left-hand z axis.\n\
6753 o: Use custom labelling function to generate axis label text.\n\
6754 The custom labelling function can be defined with the\n\
6755 plslabelfunc command.\n\
6756 s: Enables subticks between major ticks, only valid if t is\n\
6758 t: Draws major ticks.\n\
6759 u: If this is specified, the text label is written beside the\n\
6761 v: If this is specified, the text label is written beside the\n\
6765 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6766 the text label for the z axis. It is only drawn if u or v are in\n\
6769 ztick (PLFLT, input) : World coordinate interval between major\n\
6770 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6771 generates a suitable tick interval.\n\
6773 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6774 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6775 generates a suitable minor tick interval.\n\
6778Set character size\n\
6782 This sets up the size of all subsequent characters drawn. The actual\n\
6783 height of a character is the product of the default character size and\n\
6784 a scaling factor.\n\
6786 Redacted form: plschr(def, scale)\n\
6788 This function is used in examples 2, 13, 23, and 24.\n\
6794plschr(def, scale)\n\
6798 def (PLFLT, input) : The default height of a character in\n\
6799 millimeters, should be set to zero if the default height is to\n\
6800 remain unchanged. For rasterized drivers the dx and dy values\n\
6801 specified in plspage are used to convert from mm to pixels (note\n\
6802 the different unit systems used). This dpi aware scaling is not\n\
6803 implemented for all drivers yet.\n\
6805 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6806 actual character height.\n\
6809Calculate continuous time from broken-down time for the current stream\n\
6813 Calculate continuous time, ctime, from broken-down time for the\n\
6814 current stream. The broken-down\n\
6815 time is specified by the following parameters: year, month, day, hour,\n\
6816 min, and sec. This function is the inverse of plbtime.\n\
6818 The PLplot definition of broken-down time is a calendar time that\n\
6819 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6820 responsibility to apply those offsets (if so desired) before using the\n\
6821 PLplot time API. By default broken-down time is defined using the\n\
6822 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6823 continuous time is defined as the number of seconds since the Unix\n\
6824 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6825 broken-down and continuous time are possible, see plconfigtime which\n\
6826 specifies that transformation for the current stream.\n\
6828 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6832 This function is used in example 29.\n\
6838plctime(year, month, day, hour, min, sec, ctime)\n\
6842 year (PLINT, input) : Input year.\n\
6844 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6847 day (PLINT, input) : Input day in range from 1 to 31.\n\
6849 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6851 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6853 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6855 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6856 time calculated from the broken-down time specified by the\n\
6857 previous parameters.\n\
6864 Sets the color index for cmap0 (see the PLplot documentation).\n\
6866 Redacted form: plcol0(icol0)\n\
6868 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6878 icol0 (PLINT, input) : Integer representing the color. The\n\
6879 defaults at present are (these may change):\n\
6880 0 black (default background)\n\
6881 1 red (default foreground)\n\
6897 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6898 change an individual color in the cmap0 color palette.\n\
6905 Sets the color for cmap1 (see the PLplot documentation).\n\
6907 Redacted form: plcol1(col1)\n\
6909 This function is used in examples 12 and 21.\n\
6919 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6920 is mapped to color using the continuous cmap1 palette which by\n\
6921 default ranges from blue to the background color to red. The\n\
6922 cmap1 palette can also be straightforwardly changed by the user\n\
6923 with plscmap1 or plscmap1l.\n\
6926Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6930 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6932 Redacted form: plgcolbg(r, g, b)\n\
6934 This function is used in example 31.\n\
6944 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6945 in the range from 0 to 255.\n\
6947 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6948 in the range from 0 to 255.\n\
6950 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6951 in the range from 0 to 255.\n\
6954Draw a circular or elliptical arc\n\
6958 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6959 semiminor axis b, starting at angle1 and ending at angle2.\n\
6961 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6965 This function is used in examples 3 and 27.\n\
6971plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6975 x (PLFLT, input) : X coordinate of arc center.\n\
6977 y (PLFLT, input) : Y coordinate of arc center.\n\
6979 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6981 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6983 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6986 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6989 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6992 fill (PLBOOL, input) : Draw a filled arc.\n\
6995Parse command-line arguments\n\
6999 Parse command-line arguments.\n\
7001 plparseopts removes all recognized flags (decreasing argc\n\
7002 accordingly), so that invalid input may be readily detected. It can\n\
7003 also be used to process user command line flags. The user can merge\n\
7004 an option table of type PLOptionTable into the internal option table\n\
7005 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7006 the external table(s) be parsed by calling plClearOpts before\n\
7009 The default action taken by plparseopts is as follows:\n\
7010 Returns with an error if an unrecognized option or badly formed\n\
7011 option-value pair are encountered.\n\
7012 Returns immediately (return code 0) when the first non-option command\n\
7013 line argument is found.\n\
7014 Returns with the return code of the option handler, if one was called.\n\
7016 Deletes command line arguments from argv list as they are found, and\n\
7017 decrements argc accordingly.\n\
7018 Does not show \"invisible\" options in usage or help messages.\n\
7019 Assumes the program name is contained in argv[0].\n\
7021 These behaviors may be controlled through the\n\
7024 Redacted form: General: plparseopts(argv, mode)\n\
7027 This function is used in all of the examples.\n\
7033PLINT plparseopts(p_argc, argv, mode)\n\
7037 p_argc (int *, input/output) : Number of arguments.\n\
7039 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7040 strings containing *p_argc command-line arguments.\n\
7042 mode (PLINT, input) : Parsing mode with the following\n\
7043 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7044 and all error messages enabled, including program exit when an\n\
7045 error occurs. Anything on the command line that isn\'t recognized\n\
7046 as a valid option or option argument is flagged as an error.\n\
7047 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7049 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7051 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7052 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7053 pointer to the program name.\n\
7054 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7055 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7056 unrecognized arguments.\n\
7059Get parameters that define current device-space window\n\
7063 Get relative margin width, aspect ratio, and relative justification\n\
7064 that define current device-space window. If plsdidev has not been\n\
7065 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7066 p_jy will all be 0.\n\
7068 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7070 This function is used in example 31.\n\
7076plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7080 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7083 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7086 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7087 justification in x.\n\
7089 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7090 justification in y.\n\
7093Assign a function to use for generating custom axis labels\n\
7097 This function allows a user to provide their own function to provide\n\
7098 axis label text. The user function is given the numeric value for a\n\
7099 point on an axis and returns a string label to correspond with that\n\
7100 value. Custom axis labels can be enabled by passing appropriate\n\
7101 arguments to plenv, plbox, plbox3 and similar functions.\n\
7103 This function is used in example 19.\n\
7109plslabelfunc(label_func, label_data)\n\
7113 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7114 label function. In order to reset to the default labelling, set\n\
7115 this to NULL. The labelling function parameters are, in order:\n\
7116 axis: This indicates which axis a label is being requested for.\n\
7117 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7119 value: This is the value along the axis which is being labelled.\n\
7121 label_text: The string representation of the label value.\n\
7123 length: The maximum length in characters allowed for label_text.\n\
7126 label_data (PLPointer, input) : This parameter may be used to pass\n\
7127 data to the label_func function.\n\
7130Get the (current) run level\n\
7134 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7136 2, viewport defined\n\
7137 3, world coordinates defined\n\
7140 Redacted form: plglevel(p_level)\n\
7142 This function is used in example 31.\n\
7152 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7160 This sets the line style according to one of eight predefined patterns\n\
7161 (also see plstyl).\n\
7163 Redacted form: pllsty(lin)\n\
7165 This function is used in examples 9, 12, 22, and 25.\n\
7175 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7176 a continuous line, line style 2 is a line with short dashes and\n\
7177 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7178 4 has long dashes and short gaps and so on.\n\
7181Set up standard window and draw box\n\
7185 Sets up plotter environment for simple graphs by calling pladv and\n\
7186 setting up viewport and window to sensible default values. plenv\n\
7187 leaves a standard margin (left-hand margin of eight character heights,\n\
7188 and a margin around the other three sides of five character heights)\n\
7189 around most graphs for axis labels and a title. When these defaults\n\
7190 are not suitable, use the individual routines plvpas, plvpor, or\n\
7191 plvasp for setting up the viewport, plwind for defining the window,\n\
7192 and plbox for drawing the box.\n\
7194 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7196 This function is used in example 1,3,9,13,14,19-22,29.\n\
7202plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7206 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7207 world coordinates).\n\
7209 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7210 world coordinates).\n\
7212 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7215 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7218 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7219 scales will not be set, the user must set up the scale before\n\
7220 calling plenv using plsvpa, plvasp or other.\n\
7221 0: the x and y axes are scaled independently to use as much of\n\
7222 the screen as possible.\n\
7223 1: the scales of the x and y axes are made equal.\n\
7224 2: the axis of the x and y axes are made equal, and the plot\n\
7225 box will be square.\n\
7228 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7229 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7230 -1: draw box only.\n\
7231 0: draw box, ticks, and numeric tick labels.\n\
7232 1: also draw coordinate axes at x=0 and y=0.\n\
7233 2: also draw a grid at major tick positions in both\n\
7235 3: also draw a grid at minor tick positions in both\n\
7237 10: same as 0 except logarithmic x tick marks. (The x data\n\
7238 have to be converted to logarithms separately.)\n\
7239 11: same as 1 except logarithmic x tick marks. (The x data\n\
7240 have to be converted to logarithms separately.)\n\
7241 12: same as 2 except logarithmic x tick marks. (The x data\n\
7242 have to be converted to logarithms separately.)\n\
7243 13: same as 3 except logarithmic x tick marks. (The x data\n\
7244 have to be converted to logarithms separately.)\n\
7245 20: same as 0 except logarithmic y tick marks. (The y data\n\
7246 have to be converted to logarithms separately.)\n\
7247 21: same as 1 except logarithmic y tick marks. (The y data\n\
7248 have to be converted to logarithms separately.)\n\
7249 22: same as 2 except logarithmic y tick marks. (The y data\n\
7250 have to be converted to logarithms separately.)\n\
7251 23: same as 3 except logarithmic y tick marks. (The y data\n\
7252 have to be converted to logarithms separately.)\n\
7253 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7254 and y data have to be converted to logarithms separately.)\n\
7255 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7256 and y data have to be converted to logarithms separately.)\n\
7257 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7258 and y data have to be converted to logarithms separately.)\n\
7259 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7260 and y data have to be converted to logarithms separately.)\n\
7261 40: same as 0 except date / time x labels.\n\
7262 41: same as 1 except date / time x labels.\n\
7263 42: same as 2 except date / time x labels.\n\
7264 43: same as 3 except date / time x labels.\n\
7265 50: same as 0 except date / time y labels.\n\
7266 51: same as 1 except date / time y labels.\n\
7267 52: same as 2 except date / time y labels.\n\
7268 53: same as 3 except date / time y labels.\n\
7269 60: same as 0 except date / time x and y labels.\n\
7270 61: same as 1 except date / time x and y labels.\n\
7271 62: same as 2 except date / time x and y labels.\n\
7272 63: same as 3 except date / time x and y labels.\n\
7273 70: same as 0 except custom x and y labels.\n\
7274 71: same as 1 except custom x and y labels.\n\
7275 72: same as 2 except custom x and y labels.\n\
7276 73: same as 3 except custom x and y labels.\n\
7283 Alternative to plstar for initializing the plotting package. The\n\
7284 device name keyword for the desired output device must be supplied as\n\
7285 an argument. These keywords are the same as those printed out by\n\
7286 plstar. If the requested device is not available, or if the input\n\
7287 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7288 is used. This routine also divides the output device page into nx by\n\
7289 ny subpages, each of which may be used independently. The subroutine\n\
7290 pladv is used to advance from one subpage to the next.\n\
7292 Redacted form: General: plstart(devname, nx, ny)\n\
7295 This function is not used in any examples.\n\
7301plstart(devname, nx, ny)\n\
7305 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7306 containing the device name keyword of the required output device.\n\
7308 devname is NULL or if the first character of the string is a ``?\'\',\n\
7309 the normal (prompted) start up is used.\n\
7311 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7314 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7318Plot a glyph at the specified points\n\
7322 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7323 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7324 is specified with a PLplot user string. Note that the user string is\n\
7325 not actually limited to one glyph so it is possible (but not normally\n\
7326 useful) to plot more than one glyph at the specified points with this\n\
7327 function. As with plmtex and plptex, the user string can contain FCI\n\
7328 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7329 else PLplot escapes for Hershey or unicode text to determine the\n\
7332 Redacted form: plstring(x, y, string)\n\
7334 This function is used in examples 4, 21 and 26.\n\
7340plstring(n, x, y, string)\n\
7344 n (PLINT, input) : Number of points in the x and y vectors.\n\
7346 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7349 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7352 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7353 the glyph(s) to be plotted at each of the n points.\n\
7356Write text relative to viewport boundaries in 3D plots\n\
7360 Writes text at a specified position relative to the viewport\n\
7361 boundaries. Text may be written inside or outside the viewport, but\n\
7362 is clipped at the subpage boundaries. The reference point of a string\n\
7363 lies along a line passing through the string at half the height of a\n\
7364 capital letter. The position of the reference point along this line\n\
7365 is determined by just, and the position of the reference point\n\
7366 relative to the viewport is set by disp and pos.\n\
7368 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7370 This function is used in example 28.\n\
7376plmtex3(side, disp, pos, just, text)\n\
7380 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7381 the side of the viewport along which the text is to be written.\n\
7382 The string should contain one or more of the following characters:\n\
7383 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7384 only label the X axis, not both the X and Y axes. x: Label the X\n\
7386 y: Label the Y axis.\n\
7387 z: Label the Z axis.\n\
7388 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7389 For X it is the axis that starts at y-min. For Y it is the\n\
7390 axis that starts at x-min.\n\
7391 s: Label the secondary axis.\n\
7392 v: Draw the text perpendicular to the axis.\n\
7395 disp (PLFLT, input) : Position of the reference point of string,\n\
7396 measured outwards from the specified viewport edge in units of the\n\
7397 current character height. Use negative disp to write within the\n\
7400 pos (PLFLT, input) : Position of the reference point of string\n\
7401 along the specified edge, expressed as a fraction of the length of\n\
7404 just (PLFLT, input) : Specifies the position of the string relative\n\
7405 to its reference point. If just=0. , the reference point is at\n\
7406 the left and if just=1. , it is at the right of the string. Other\n\
7407 values of just give intermediate justifications.\n\
7409 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7413Get plot orientation\n\
7417 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7418 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7419 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7420 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7421 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7422 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7423 not been called the default value pointed to by p_rot will be 0.\n\
7425 Redacted form: plgdiori(p_rot)\n\
7427 This function is not used in any examples.\n\
7437 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7441Simple routine to write labels\n\
7445 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7447 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7449 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7455pllab(xlabel, ylabel, tlabel)\n\
7459 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7460 the label for the x axis.\n\
7462 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7463 the label for the y axis.\n\
7465 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7466 the title of the plot.\n\
7469Switch to text screen\n\
7473 Sets an interactive device to text mode, used in conjunction with\n\
7474 plgra to allow graphics and text to be interspersed. On a device\n\
7475 which supports separate text and graphics windows, this command causes\n\
7476 control to be switched to the text window. This can be useful for\n\
7477 printing diagnostic messages or getting user input, which would\n\
7478 otherwise interfere with the plots. The program must switch back to\n\
7479 the graphics window before issuing plot commands, as the text (or\n\
7480 console) device will probably become quite confused otherwise. If\n\
7481 already in text mode, this command is ignored. It is also ignored on\n\
7482 devices which only support a single window or use a different method\n\
7483 for shifting focus (see also plgra).\n\
7485 Redacted form: pltext()\n\
7487 This function is used in example 1.\n\
7496Plot all or a subset of Shapefile data using lines in world coordinates\n\
7500 Plot all or a subset of Shapefile data using lines in world\n\
7501 coordinates. Our 19th standard example demonstrates how to use this\n\
7502 function. This function plots data from a Shapefile using lines as in\n\
7503 plmap, however it also has the option of also only drawing specified\n\
7504 elements from the Shapefile. The vector of indices of the required\n\
7505 elements are passed as a function argument. The Shapefile data should\n\
7506 include a metadata file (extension.dbf) listing all items within the\n\
7507 Shapefile. This file can be opened by most popular spreadsheet\n\
7508 programs and can be used to decide which indices to pass to this\n\
7511 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7514 This function is used in example 19.\n\
7520plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7524 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7525 transform the coordinates given in the shapefile into a plot\n\
7526 coordinate system. By using this transform, we can change from a\n\
7527 longitude, latitude coordinate to a polar stereographic project,\n\
7528 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7529 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7530 mapform(), x[] and y[] should be replaced by the corresponding\n\
7531 plot coordinates. If no transform is desired, mapform can be\n\
7532 replaced by NULL.\n\
7534 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7535 the file name of a set of Shapefile files without the file\n\
7538 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7539 be in the same units as used by the Shapefile. You could use a\n\
7540 very large negative number to plot everything, but you can improve\n\
7541 performance by limiting the area drawn. The units must match those\n\
7542 of the Shapefile projection, which may be for example longitude or\n\
7543 distance. The value of minx must be less than the value of maxx.\n\
7545 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7546 use a very large number to plot everything, but you can improve\n\
7547 performance by limiting the area drawn.\n\
7549 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7550 be in the same units as used by the Shapefile. You could use a\n\
7551 very large negative number to plot everything, but you can improve\n\
7552 performance by limiting the area drawn. The units must match those\n\
7553 of the Shapefile projection, which may be for example latitude or\n\
7554 distance. The value of miny must be less than the value of maxy.\n\
7556 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7557 use a very large number to plot everything, but you can improve\n\
7558 performance by limiting the area drawn.\n\
7560 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7561 zero-based indices of the Shapefile elements which will be drawn.\n\
7563 plotentries to NULL will plot all elements of the Shapefile.\n\
7565 nplotentries (PLINT, input) : The number of items in\n\
7566 plotentries. Ignored if\n\
7567 plotentries is NULL.\n\
7570Set precision in numeric labels\n\
7574 Sets the number of places after the decimal point in numeric labels.\n\
7576 Redacted form: plprec(setp, prec)\n\
7578 This function is used in example 29.\n\
7584plprec(setp, prec)\n\
7588 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7589 automatically determines the number of places to use after the\n\
7590 decimal point in numeric labels (like those used to label axes).\n\
7591 If setp is 1 then prec sets the number of places.\n\
7593 prec (PLINT, input) : The number of characters to draw after the\n\
7594 decimal point in numeric labels.\n\
7597Draw a line between two points\n\
7601 Joins the point (\n\
7607 Redacted form: pljoin(x1,y1,x2,y2)\n\
7609 This function is used in examples 3 and 14.\n\
7615pljoin(x1, y1, x2, y2)\n\
7619 x1 (PLFLT, input) : x coordinate of first point.\n\
7621 y1 (PLFLT, input) : y coordinate of first point.\n\
7623 x2 (PLFLT, input) : x coordinate of second point.\n\
7625 y2 (PLFLT, input) : y coordinate of second point.\n\
7628Set the device (keyword) name\n\
7632 Set the device (keyword) name.\n\
7634 Redacted form: plsdev(devname)\n\
7636 This function is used in examples 1, 14, and 20.\n\
7646 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7647 containing the device name keyword of the required output device.\n\
7649 devname is NULL or if the first character of the string is a ``?\'\',\n\
7650 the normal (prompted) start up is used.\n\
7653Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7657 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7658 (see the PLplot documentation) index. Overwrites the previous color\n\
7659 value for the given index and, thus, does not result in any additional\n\
7660 allocation of space for colors.\n\
7662 This function is used in example 30.\n\
7668plscol0a(icol0, r, g, b, alpha)\n\
7672 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7673 number of colors (which is set by default, by plscmap0n, or even\n\
7676 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7677 degree of red in the color.\n\
7679 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7680 degree of green in the color.\n\
7682 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7683 degree of blue in the color.\n\
7685 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7689Draw filled polygon in 3D\n\
7693 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7694 vectors using the pattern defined by plpsty or plpat. The routine\n\
7695 will automatically close the polygon between the last and first\n\
7696 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7697 plfill3 will fill in between them.\n\
7699 Redacted form: General: plfill3(x, y, z)\n\
7702 This function is used in example 15.\n\
7708plfill3(n, x, y, z)\n\
7712 n (PLINT, input) : Number of vertices in polygon.\n\
7714 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7717 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7720 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7728 Specify the window, i.e., the world coordinates of the edges of the\n\
7731 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7733 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7740plwind(xmin, xmax, ymin, ymax)\n\
7744 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7747 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7750 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7753 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7757Draw text at points defined by Shapefile data in world coordinates\n\
7761 As per plmapline, however the items are plotted as text in the same\n\
7764 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7765 miny, maxy, plotentry)\n\
7767 This function is used in example 19.\n\
7773plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7777 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7778 transform the coordinates given in the shapefile into a plot\n\
7779 coordinate system. By using this transform, we can change from a\n\
7780 longitude, latitude coordinate to a polar stereographic project,\n\
7781 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7782 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7783 mapform(), x[] and y[] should be replaced by the corresponding\n\
7784 plot coordinates. If no transform is desired, mapform can be\n\
7785 replaced by NULL.\n\
7787 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7788 the file name of a set of Shapefile files without the file\n\
7791 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7794 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7797 just (PLFLT, input) : Set the justification of the text. The value\n\
7798 given will be the fraction of the distance along the string that\n\
7799 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7800 centralized text and 1.0 gives right aligned text.\n\
7802 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7804 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7805 be in the same units as used by the Shapefile. You could use a\n\
7806 very large negative number to plot everything, but you can improve\n\
7807 performance by limiting the area drawn. The units must match those\n\
7808 of the Shapefile projection, which may be for example longitude or\n\
7809 distance. The value of minx must be less than the value of maxx.\n\
7811 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7812 use a very large number to plot everything, but you can improve\n\
7813 performance by limiting the area drawn.\n\
7815 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7816 be in the same units as used by the Shapefile. You could use a\n\
7817 very large negative number to plot everything, but you can improve\n\
7818 performance by limiting the area drawn. The units must match those\n\
7819 of the Shapefile projection, which may be for example latitude or\n\
7820 distance. The value of miny must be less than the value of maxy.\n\
7822 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7823 use a very large number to plot everything, but you can improve\n\
7824 performance by limiting the area drawn.\n\
7826 plotentry (PLINT, input) : An integer indicating which text string\n\
7827 of the Shapefile (zero indexed) will be drawn.\n\
7830Switch to graphics screen\n\
7834 Sets an interactive device to graphics mode, used in conjunction with\n\
7835 pltext to allow graphics and text to be interspersed. On a device\n\
7836 which supports separate text and graphics windows, this command causes\n\
7837 control to be switched to the graphics window. If already in graphics\n\
7838 mode, this command is ignored. It is also ignored on devices which\n\
7839 only support a single window or use a different method for shifting\n\
7840 focus. See also pltext.\n\
7842 Redacted form: plgra()\n\
7844 This function is used in example 1.\n\
7853Set parameters of contour labelling other than format of numerical label\n\
7857 Set parameters of contour labelling other than those handled by\n\
7858 pl_setcontlabelformat.\n\
7860 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7862 This function is used in example 9.\n\
7868pl_setcontlabelparam(offset, size, spacing, active)\n\
7872 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7873 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7875 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7876 Default value is 0.3.\n\
7878 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7879 Default value is 0.1.\n\
7881 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7882 contour labels on. Default is off (0).\n\
7885Get family, style and weight of the current font\n\
7889 Gets information about current font. See the PLplot documentation for\n\
7890 more information on font selection.\n\
7892 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7894 This function is used in example 23.\n\
7900plgfont(p_family, p_style, p_weight)\n\
7904 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7905 font family. The available values are given by the PL_FCI_*\n\
7906 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7907 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7908 p_family is NULL then the font family is not returned.\n\
7910 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7911 font style. The available values are given by the PL_FCI_*\n\
7912 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7913 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7914 style is not returned.\n\
7916 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7917 font weight. The available values are given by the PL_FCI_*\n\
7918 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7919 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7923Plot a histogram from unbinned data\n\
7927 Plots a histogram from n data points stored in the data vector. This\n\
7928 routine bins the data into nbin bins equally spaced between datmin and\n\
7929 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7930 opt allows, among other things, the histogram either to be plotted in\n\
7931 an existing window or causes plhist to call plenv with suitable limits\n\
7932 before plotting the histogram.\n\
7934 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7936 This function is used in example 5.\n\
7942plhist(n, data, datmin, datmax, nbin, opt)\n\
7946 n (PLINT, input) : Number of data points.\n\
7948 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7951 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7953 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7955 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7956 divide the interval xmin to xmax.\n\
7958 opt (PLINT, input) : Is a combination of several flags:\n\
7959 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7960 the histogram data, the outer bins are expanded to fill up the\n\
7961 entire x-axis, data outside the given extremes are assigned to the\n\
7962 outer bins and bins of zero height are simply drawn.\n\
7963 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7964 to fit the histogram data, without this flag, plenv is called\n\
7965 to set the world coordinates.\n\
7966 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7967 extremes are not taken into account. This option should\n\
7968 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7969 properly present the data.\n\
7970 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7971 size as the ones inside.\n\
7972 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7973 (there is a gap for such bins).\n\
7976Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7980 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7981 alpha transparency value.\n\
7983 This function is used in example 31.\n\
7989plgcolbga(r, g, b, alpha)\n\
7993 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7994 in the range from 0 to 255.\n\
7996 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7997 in the range from 0 to 255.\n\
7999 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
8000 in the range from 0 to 255.\n\
8002 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8003 transparency in the range (0.0-1.0).\n\
8010 Set integer plot orientation parameter. This function is identical to\n\
8011 plsdiori except for the type of the argument, and should be used in\n\
8012 the same way. See the documentation of plsdiori for details.\n\
8014 Redacted form: plsori(ori)\n\
8016 This function is used in example 3.\n\
8026 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8027 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8031Plot latitude and longitude lines\n\
8035 Displays latitude and longitude on the current plot. The lines are\n\
8036 plotted in the current color and line style.\n\
8038 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8041 This function is used in example 19.\n\
8047plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8051 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8052 transform the coordinate longitudes and latitudes to a plot\n\
8053 coordinate system. By using this transform, we can change from a\n\
8054 longitude, latitude coordinate to a polar stereographic project,\n\
8055 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8056 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8057 mapform(), x[] and y[] should be replaced by the corresponding\n\
8058 plot coordinates. If no transform is desired, mapform can be\n\
8059 replaced by NULL.\n\
8061 dlong (PLFLT, input) : The interval in degrees at which the\n\
8062 longitude lines are to be plotted.\n\
8064 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8065 lines are to be plotted.\n\
8067 minlong (PLFLT, input) : The value of the longitude on the left\n\
8068 side of the plot. The value of minlong must be less than the value\n\
8069 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8072 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8073 side of the plot.\n\
8075 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8076 background. One can always use -90.0 as the boundary outside the\n\
8077 plot window will be automatically eliminated. However, the\n\
8078 program will be faster if one can reduce the size of the\n\
8079 background plotted.\n\
8081 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8082 background. One can always use 90.0 as the boundary outside the\n\
8083 plot window will be automatically eliminated.\n\
8086Clear current (sub)page\n\
8090 Clears the current page, effectively erasing everything that have been\n\
8091 drawn. This command only works with interactive drivers; if the\n\
8092 driver does not support this, the page is filled with the background\n\
8093 color in use. If the current page is divided into subpages, only the\n\
8094 current subpage is erased. The nth subpage can be selected with\n\
8097 Redacted form: General: plclear()\n\
8100 This function is not used in any examples.\n\
8113 Initializing the plotting package. The program prompts for the device\n\
8114 keyword or number of the desired output device. Hitting a RETURN in\n\
8115 response to the prompt is the same as selecting the first device. If\n\
8116 only one device is enabled when PLplot is installed, plstar will issue\n\
8117 no prompt. The output device is divided into nx by ny subpages, each\n\
8118 of which may be used independently. The subroutine pladv is used to\n\
8119 advance from one subpage to the next.\n\
8121 Redacted form: plstar(nx, ny)\n\
8123 This function is used in example 1.\n\
8133 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8136 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8140Write text relative to viewport boundaries\n\
8144 Writes text at a specified position relative to the viewport\n\
8145 boundaries. Text may be written inside or outside the viewport, but\n\
8146 is clipped at the subpage boundaries. The reference point of a string\n\
8147 lies along a line passing through the string at half the height of a\n\
8148 capital letter. The position of the reference point along this line\n\
8149 is determined by just, and the position of the reference point\n\
8150 relative to the viewport is set by disp and pos.\n\
8152 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8155 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8162plmtex(side, disp, pos, just, text)\n\
8166 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8167 the side of the viewport along which the text is to be written.\n\
8168 The string must be one of: b: Bottom of viewport, text written\n\
8169 parallel to edge.\n\
8170 bv: Bottom of viewport, text written at right angles to edge.\n\
8171 l: Left of viewport, text written parallel to edge.\n\
8172 lv: Left of viewport, text written at right angles to edge.\n\
8173 r: Right of viewport, text written parallel to edge.\n\
8174 rv: Right of viewport, text written at right angles to edge.\n\
8175 t: Top of viewport, text written parallel to edge.\n\
8176 tv: Top of viewport, text written at right angles to edge.\n\
8179 disp (PLFLT, input) : Position of the reference point of string,\n\
8180 measured outwards from the specified viewport edge in units of the\n\
8181 current character height. Use negative disp to write within the\n\
8184 pos (PLFLT, input) : Position of the reference point of string\n\
8185 along the specified edge, expressed as a fraction of the length of\n\
8188 just (PLFLT, input) : Specifies the position of the string relative\n\
8189 to its reference point. If just=0. , the reference point is at\n\
8190 the left and if just=1. , it is at the right of the string. Other\n\
8191 values of just give intermediate justifications.\n\
8193 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8197Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8201 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8202 PLFLT alpha transparency value (see the PLplot documentation).\n\
8204 This function is used in example 31.\n\
8210plscolbga(r, g, b, alpha)\n\
8214 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8215 degree of red in the color.\n\
8217 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8218 degree of green in the color.\n\
8220 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8221 degree of blue in the color.\n\
8223 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8227Replays contents of plot buffer to current device/file\n\
8231 Replays contents of plot buffer to current device/file.\n\
8233 Redacted form: plreplot()\n\
8235 This function is used in example 1,20.\n\
8244Plot a glyph at the specified 3D points\n\
8248 Plot a glyph at the specified 3D points. (This function is largely\n\
8249 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8250 Set up the call to this function similar to what is done for plline3.\n\
8251 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8252 and a draw at the same place. Not ideal, since a sufficiently\n\
8253 intelligent output device may optimize it away, or there may be faster\n\
8254 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8255 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8256 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8257 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8258 code <= 127 the corresponding printable ASCII character is plotted.\n\
8260 Redacted form: plpoin3(x, y, z, code)\n\
8262 This function is not used in any example.\n\
8268plpoin3(n, x, y, z, code)\n\
8272 n (PLINT, input) : Number of points in the x and y vectors.\n\
8274 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8277 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8280 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8283 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8284 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8285 each of the n points.\n\
8288Set family, style and weight of the current font\n\
8292 Sets the current font. See the PLplot documentation for more\n\
8293 information on font selection.\n\
8295 Redacted form: plsfont(family, style, weight)\n\
8297 This function is used in example 23.\n\
8303plsfont(family, style, weight)\n\
8307 family (PLINT, input) : Font family to select for the current font.\n\
8308 The available values are given by the PL_FCI_* constants in\n\
8309 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8310 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8311 signifies that the font family should not be altered.\n\
8313 style (PLINT, input) : Font style to select for the current font.\n\
8314 The available values are given by the PL_FCI_* constants in\n\
8315 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8316 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8317 should not be altered.\n\
8319 weight (PLINT, input) : Font weight to select for the current font.\n\
8320 The available values are given by the PL_FCI_* constants in\n\
8321 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8322 negative value signifies that the font weight should not be\n\
8326Draw a box with axes, etc. with arbitrary origin\n\
8330 Draws a box around the currently defined viewport with arbitrary\n\
8331 world-coordinate origin specified by x0 and y0 and labels it with\n\
8332 world coordinate values appropriate to the window. Thus plaxes should\n\
8333 only be called after defining both viewport and window. The ascii\n\
8334 character strings xopt and yopt specify how the box should be drawn as\n\
8335 described below. If ticks and/or subticks are to be drawn for a\n\
8336 particular axis, the tick intervals and number of subintervals may be\n\
8337 specified explicitly, or they may be defaulted by setting the\n\
8338 appropriate arguments to zero.\n\
8340 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8344 This function is not used in any examples.\n\
8350plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8354 x0 (PLFLT, input) : World X coordinate of origin.\n\
8356 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8358 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8359 options for the x axis. The string can include any combination of\n\
8360 the following letters (upper or lower case) in any order: a: Draws\n\
8361 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8363 b: Draws bottom (X) or left (Y) edge of frame.\n\
8364 c: Draws top (X) or right (Y) edge of frame.\n\
8365 d: Plot labels as date / time. Values are assumed to be\n\
8366 seconds since the epoch (as used by gmtime).\n\
8367 f: Always use fixed point numeric labels.\n\
8368 g: Draws a grid at the major tick interval.\n\
8369 h: Draws a grid at the minor tick interval.\n\
8370 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8372 l: Labels axis logarithmically. This only affects the labels,\n\
8373 not the data, and so it is necessary to compute the logarithms\n\
8374 of data points before passing them to any of the drawing\n\
8376 m: Writes numeric labels at major tick intervals in the\n\
8377 unconventional location (above box for X, right of box for Y).\n\
8378 n: Writes numeric labels at major tick intervals in the\n\
8379 conventional location (below box for X, left of box for Y).\n\
8380 o: Use custom labelling function to generate axis label text.\n\
8381 The custom labelling function can be defined with the\n\
8382 plslabelfunc command.\n\
8383 s: Enables subticks between major ticks, only valid if t is\n\
8385 t: Draws major ticks.\n\
8386 u: Exactly like \"b\" except don\'t draw edge line.\n\
8387 w: Exactly like \"c\" except don\'t draw edge line.\n\
8388 x: Exactly like \"t\" (including the side effect of the\n\
8389 numerical labels for the major ticks) except exclude drawing\n\
8390 the major and minor tick marks.\n\
8393 xtick (PLFLT, input) : World coordinate interval between major\n\
8394 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8395 generates a suitable tick interval.\n\
8397 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8398 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8399 generates a suitable minor tick interval.\n\
8401 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8402 options for the y axis. The string can include any combination of\n\
8403 the letters defined above for xopt, and in addition may contain:\n\
8404 v: Write numeric labels for the y axis parallel to the base of the\n\
8405 graph, rather than parallel to the axis.\n\
8408 ytick (PLFLT, input) : World coordinate interval between major\n\
8409 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8410 generates a suitable tick interval.\n\
8412 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8413 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8414 generates a suitable minor tick interval.\n\
8421 Begins a new page. For a file driver, the output file is opened if\n\
8422 necessary. Advancing the page via pleop and plbop is useful when a\n\
8423 page break is desired at a particular point when plotting to subpages.\n\
8424 Another use for pleop and plbop is when plotting pages to different\n\
8425 files, since you can manually set the file name by calling plsfnam\n\
8426 after the call to pleop. (In fact some drivers may only support a\n\
8427 single page per file, making this a necessity.) One way to handle\n\
8428 this case automatically is to page advance via pladv, but enable\n\
8429 familying (see plsfam) with a small limit on the file size so that a\n\
8430 new family member file will be created on each page break.\n\
8432 Redacted form: plbop()\n\
8434 This function is used in examples 2 and 20.\n\
8443Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8447 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8448 and PLFLT alpha transparency value. This sets the entire color map --\n\
8449 only as many colors as specified will be allocated.\n\
8451 Redacted form: plscmap0a(r, g, b, alpha)\n\
8453 This function is used in examples 30.\n\
8459plscmap0a(r, g, b, alpha, ncol0)\n\
8463 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8464 integers (0-255) representing the degree of red in the color.\n\
8466 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8467 integers (0-255) representing the degree of green in the color.\n\
8469 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8470 integers (0-255) representing the degree of blue in the color.\n\
8472 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8473 representing the alpha transparency of the color.\n\
8475 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8479Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8483 This is a variant of plscmap1l that supports alpha channel\n\
8484 transparency. It sets cmap1 colors using a piece-wise linear\n\
8485 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8486 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8487 transparency value (0.0-1.0). It may be called at any time.\n\
8489 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8490 alpha, alt_hue_path)\n\
8492 This function is used in example 30.\n\
8498plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8502 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8504 npts (PLINT, input) : number of control points.\n\
8506 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8507 intensity index (0.0-1.0) in ascending order for each control\n\
8510 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8511 coordinate (H or R) for each control point.\n\
8513 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8514 coordinate (L or G) for each control point.\n\
8516 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8517 coordinate (S or B) for each control point.\n\
8519 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8520 transparency value (0.0-1.0) for each control point.\n\
8522 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8523 npts - 1 elements) containing the alternative interpolation method\n\
8524 Boolean value for each control point interval. (alt_hue_path[i]\n\
8525 refers to the interpolation interval between the i and i + 1\n\
8529Enter or leave xor mode\n\
8533 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8534 those drivers (e.g., the xwin driver) that support it. Enables\n\
8535 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8536 is not capable of xor operation it returns a status of false.\n\
8538 Redacted form: plxormod(mode, status)\n\
8540 This function is used in examples 1 and 20.\n\
8546plxormod(mode, status)\n\
8550 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8551 is false means leave xor mode.\n\
8553 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8554 modestatus of true (false) means driver is capable (incapable) of\n\
8558Eject current page\n\
8562 Clears the graphics screen of an interactive device, or ejects a page\n\
8563 on a plotter. See plbop for more information.\n\
8565 Redacted form: pleop()\n\
8567 This function is used in example 2,14.\n\
8576Draw a box with axes, etc\n\
8580 Draws a box around the currently defined viewport, and labels it with\n\
8581 world coordinate values appropriate to the window. Thus plbox should\n\
8582 only be called after defining both viewport and window. The ascii\n\
8583 character strings xopt and yopt specify how the box should be drawn as\n\
8584 described below. If ticks and/or subticks are to be drawn for a\n\
8585 particular axis, the tick intervals and number of subintervals may be\n\
8586 specified explicitly, or they may be defaulted by setting the\n\
8587 appropriate arguments to zero.\n\
8589 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8592 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8599plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8603 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8604 options for the x axis. The string can include any combination of\n\
8605 the following letters (upper or lower case) in any order: a: Draws\n\
8606 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8608 b: Draws bottom (X) or left (Y) edge of frame.\n\
8609 c: Draws top (X) or right (Y) edge of frame.\n\
8610 d: Plot labels as date / time. Values are assumed to be\n\
8611 seconds since the epoch (as used by gmtime).\n\
8612 f: Always use fixed point numeric labels.\n\
8613 g: Draws a grid at the major tick interval.\n\
8614 h: Draws a grid at the minor tick interval.\n\
8615 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8617 l: Labels axis logarithmically. This only affects the labels,\n\
8618 not the data, and so it is necessary to compute the logarithms\n\
8619 of data points before passing them to any of the drawing\n\
8621 m: Writes numeric labels at major tick intervals in the\n\
8622 unconventional location (above box for X, right of box for Y).\n\
8623 n: Writes numeric labels at major tick intervals in the\n\
8624 conventional location (below box for X, left of box for Y).\n\
8625 o: Use custom labelling function to generate axis label text.\n\
8626 The custom labelling function can be defined with the\n\
8627 plslabelfunc command.\n\
8628 s: Enables subticks between major ticks, only valid if t is\n\
8630 t: Draws major ticks.\n\
8631 u: Exactly like \"b\" except don\'t draw edge line.\n\
8632 w: Exactly like \"c\" except don\'t draw edge line.\n\
8633 x: Exactly like \"t\" (including the side effect of the\n\
8634 numerical labels for the major ticks) except exclude drawing\n\
8635 the major and minor tick marks.\n\
8638 xtick (PLFLT, input) : World coordinate interval between major\n\
8639 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8640 generates a suitable tick interval.\n\
8642 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8643 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8644 generates a suitable minor tick interval.\n\
8646 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8647 options for the y axis. The string can include any combination of\n\
8648 the letters defined above for xopt, and in addition may contain:\n\
8649 v: Write numeric labels for the y axis parallel to the base of the\n\
8650 graph, rather than parallel to the axis.\n\
8653 ytick (PLFLT, input) : World coordinate interval between major\n\
8654 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8655 generates a suitable tick interval.\n\
8657 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8658 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8659 generates a suitable minor tick interval.\n\
8662Get x axis parameters\n\
8666 Returns current values of the p_digmax and p_digits flags for the x\n\
8667 axis. p_digits is updated after the plot is drawn, so this routine\n\
8668 should only be called after the call to plbox (or plbox3) is complete.\n\
8669 See the PLplot documentation for more information.\n\
8671 Redacted form: plgxax(p_digmax, p_digits)\n\
8673 This function is used in example 31.\n\
8679plgxax(p_digmax, p_digits)\n\
8683 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8684 number of digits for the x axis. If nonzero, the printed label\n\
8685 has been switched to a floating-point representation when the\n\
8686 number of digits exceeds this value.\n\
8688 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8689 number of digits for the numeric labels (x axis) from the last\n\
8697 Sets the font used for subsequent text and symbols. For devices that\n\
8698 still use Hershey fonts this routine has no effect unless the Hershey\n\
8699 fonts with extended character set are loaded (see plfontld). For\n\
8700 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8701 this routine calls the plsfci routine with argument set up\n\
8702 appropriately for the various cases below. However, this method of\n\
8703 specifying the font for unicode-aware devices is deprecated, and the\n\
8704 much more flexible method of calling plsfont directly is recommended\n\
8705 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8707 Redacted form: plfont(ifont)\n\
8709 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8719 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8720 (simplest and fastest)\n\
8726Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8730 Routine for creating a discrete plot legend with a plotted filled box,\n\
8731 line, and/or line of symbols for each annotated legend entry. (See\n\
8732 plcolorbar for similar functionality for creating continuous color\n\
8733 bars.) The arguments of pllegend provide control over the location\n\
8734 and size of the legend as well as the location and characteristics of\n\
8735 the elements (most of which are optional) within that legend. The\n\
8736 resulting legend is clipped at the boundaries of the current subpage.\n\
8737 (N.B. the adopted coordinate system used for some of the parameters is\n\
8738 defined in the documentation of the position parameter.)\n\
8740 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8741 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8742 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8743 test_justification, text_colors, text, box_colors, box_patterns,\n\
8744 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8745 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8747 This function is used in examples 4, 26, and 33.\n\
8753pllegend(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\
8757 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8758 legend width in adopted coordinates. This quantity is calculated\n\
8759 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8760 the routine depending on nlegend and nrow), and the length\n\
8761 (calculated internally) of the longest text string.\n\
8763 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8764 legend height in adopted coordinates. This quantity is calculated\n\
8765 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8766 the routine depending on nlegend and nrow).\n\
8768 opt (PLINT, input) : opt contains bits controlling the overall\n\
8769 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8770 on the left of the legend and the plotted area on the right.\n\
8771 Otherwise, put the text area on the right of the legend and the\n\
8772 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8773 plot a (semitransparent) background for the legend. If the\n\
8774 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8775 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8776 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8777 plot the resulting array of legend entries in row-major order.\n\
8778 Otherwise, plot the legend entries in column-major order.\n\
8780 position (PLINT, input) : position contains bits which control the\n\
8781 overall position of the legend and the definition of the adopted\n\
8782 coordinates used for positions just like what is done for the\n\
8783 position argument for plcolorbar. However, note that the defaults\n\
8784 for the position bits (see below) are different than the\n\
8785 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8786 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8787 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8788 the 16 possible standard positions (the 4 corners and centers of\n\
8789 the 4 sides for both the inside and outside cases) of the legend\n\
8790 relative to the adopted coordinate system. The corner positions\n\
8791 are specified by the appropriate combination of two of the\n\
8792 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8793 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8794 value of one of those bits. The adopted coordinates are\n\
8795 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8796 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8797 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8798 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8799 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8800 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8801 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8802 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8804 x (PLFLT, input) : X offset of the legend position in adopted\n\
8805 coordinates from the specified standard position of the legend.\n\
8806 For positive x, the direction of motion away from the standard\n\
8807 position is inward/outward from the standard corner positions or\n\
8808 standard left or right positions if the\n\
8809 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8810 For the standard top or bottom positions, the direction of motion\n\
8811 is toward positive X.\n\
8813 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8814 coordinates from the specified standard position of the legend.\n\
8815 For positive y, the direction of motion away from the standard\n\
8816 position is inward/outward from the standard corner positions or\n\
8817 standard top or bottom positions if the\n\
8818 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8819 the standard left or right positions, the direction of motion is\n\
8820 toward positive Y.\n\
8822 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8823 of the plot area (where the colored boxes, lines, and/or lines of\n\
8824 symbols are drawn) of the legend.\n\
8826 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8827 legend (PL_LEGEND_BACKGROUND).\n\
8829 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8830 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8832 bb_style (PLINT, input) : The pllsty style number for the\n\
8833 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8835 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8837 nlegend legend entries. For internal transformations of\n\
8838 nrow, see further remarks under\n\
8841 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8843 nlegend legend entries. For internal transformations of\n\
8844 ncolumn, see further remarks under\n\
8847 nlegend (PLINT, input) : Number of legend entries. The above\n\
8849 ncolumn values are transformed internally to be consistent with\n\
8850 nlegend. If either\n\
8852 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8855 ncolumn is less than\n\
8856 nlegend, the smaller of the two (or\n\
8859 ncolumn) is increased so the product is >=\n\
8860 nlegend. Thus, for example, the common\n\
8862 ncolumn = 0 case is transformed internally to\n\
8865 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8868 opt_array (PLINT_VECTOR, input) : A vector of\n\
8869 nlegend values of options to control each individual plotted area\n\
8870 corresponding to a legend entry. If the\n\
8871 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8873 PL_LEGEND_COLOR_BOX,\n\
8874 PL_LEGEND_LINE, and/or\n\
8875 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8876 entry is plotted with a colored box; a line; and/or a line of\n\
8879 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8880 area in units of character width.\n\
8882 text_scale (PLFLT, input) : Character height scale for text\n\
8885 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8886 character height from one legend entry to the next.\n\
8888 text_justification (PLFLT, input) : Justification parameter used\n\
8889 for text justification. The most common values of\n\
8890 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8891 is left justified, centred, or right justified within the text\n\
8892 area, but other values are allowed as well.\n\
8894 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8895 nlegend cmap0 text colors.\n\
8897 text (PLCHAR_MATRIX, input) : A vector of\n\
8898 nlegend UTF-8 character strings containing the legend annotations.\n\
8900 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8901 nlegend cmap0 colors for the discrete colored boxes (\n\
8902 PL_LEGEND_COLOR_BOX).\n\
8904 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8905 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8906 PL_LEGEND_COLOR_BOX).\n\
8908 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8909 nlegend scales (units of fraction of character height) for the height\n\
8910 of the discrete colored boxes (\n\
8911 PL_LEGEND_COLOR_BOX).\n\
8913 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8914 nlegend line widths for the patterns specified by box_patterns (\n\
8915 PL_LEGEND_COLOR_BOX).\n\
8917 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8918 nlegend cmap0 line colors (\n\
8921 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8922 nlegend line styles (plsty indices) (\n\
8925 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8926 nlegend line widths (\n\
8929 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8930 nlegend cmap0 symbol colors (\n\
8931 PL_LEGEND_SYMBOL).\n\
8933 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8934 nlegend scale values for the symbol height (\n\
8935 PL_LEGEND_SYMBOL).\n\
8937 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8938 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8940 PL_LEGEND_SYMBOL).\n\
8942 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8943 nlegend UTF-8 character strings containing the legend symbols. (\n\
8944 PL_LEGEND_SYMBOL).\n\
8947Set the background color by 8-bit RGB value\n\
8951 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8952 the PLplot documentation).\n\
8954 Redacted form: plscolbg(r, g, b)\n\
8956 This function is used in examples 15 and 31.\n\
8966 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8967 degree of red in the color.\n\
8969 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8970 degree of green in the color.\n\
8972 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8973 degree of blue in the color.\n\
8976Set parameters that define current device-space window\n\
8980 Set relative margin width, aspect ratio, and relative justification\n\
8981 that define current device-space window. If you want to just use the\n\
8982 previous value for any of these, just pass in the magic value\n\
8983 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8984 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8985 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8986 to a device-specific value.\n\
8988 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8990 This function is used in example 31.\n\
8996plsdidev(mar, aspect, jx, jy)\n\
9000 mar (PLFLT, input) : Relative margin width.\n\
9002 aspect (PLFLT, input) : Aspect ratio.\n\
9004 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9005 the range -0.5 to 0.5.\n\
9007 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9008 the range -0.5 to 0.5.\n\
9011Specify viewport using aspect ratio only\n\
9015 Selects the largest viewport with the given aspect ratio within the\n\
9016 subpage that leaves a standard margin (left-hand margin of eight\n\
9017 character heights, and a margin around the other three sides of five\n\
9018 character heights).\n\
9020 Redacted form: plvasp(aspect)\n\
9022 This function is used in example 13.\n\
9032 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9033 axis of resulting viewport.\n\
9036Configure the transformations required for projecting a 3D surface on a 2D window\n\
9040 Configure the transformations required for projecting a 3D surface on\n\
9041 an existing 2D window. Those transformations (see the PLplot\n\
9042 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9043 surface which has its limits expressed in 3D world coordinates and\n\
9044 also normalized 3D coordinates (used for interpreting the altitude and\n\
9045 azimuth of the viewing angle). The transformations consist of the\n\
9046 linear transform from 3D world coordinates to normalized 3D\n\
9047 coordinates, and the 3D rotation of normalized coordinates required to\n\
9048 align the pole of the new 3D coordinate system with the viewing\n\
9049 direction specified by altitude and azimuth so that x and y of the\n\
9050 surface elements in that transformed coordinate system are the\n\
9051 projection of the 3D surface with given viewing direction on the 2D\n\
9054 The enclosing rectangular cuboid for the surface plot is defined by\n\
9055 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9056 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9057 sizes of basex by basey by height so that xmin maps to -\n\
9058 basex/2, xmax maps to basex/2, ymin maps to -\n\
9059 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9060 The resulting rectangular cuboid in normalized coordinates is then\n\
9061 viewed by an observer at altitude alt and azimuth az. This routine\n\
9062 must be called before plbox3 or any of the 3D surface plotting\n\
9063 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9064 plsurf3dl or plfill3.\n\
9066 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9067 zmin, zmax, alt, az)\n\
9069 This function is examples 8, 11, 18, and 21.\n\
9075plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9079 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9080 rectangular cuboid.\n\
9082 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9083 rectangular cuboid.\n\
9085 height (PLFLT, input) : The normalized z coordinate size of the\n\
9086 rectangular cuboid.\n\
9088 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9089 rectangular cuboid.\n\
9091 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9092 rectangular cuboid.\n\
9094 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9095 rectangular cuboid.\n\
9097 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9098 rectangular cuboid.\n\
9100 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9101 rectangular cuboid.\n\
9103 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9104 rectangular cuboid.\n\
9106 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9107 plane of the rectangular cuboid in normalized coordinates.\n\
9109 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9110 rectangular cuboid in normalized coordinates. When az=0, the\n\
9111 observer is looking face onto the zx plane of the rectangular\n\
9112 cuboid in normalized coordinates, and as az is increased, the\n\
9113 observer moves clockwise around that cuboid when viewed from above\n\
9117Wait for graphics input event and translate to world coordinates.\n\
9121 Wait for graphics input event and translate to world coordinates.\n\
9122 Returns 0 if no translation to world coordinates is possible.\n\
9124 This function returns 1 on success and 0 if no translation to world\n\
9125 coordinates is possible.\n\
9127 Redacted form: plGetCursor(gin)\n\
9129 This function is used in examples 1 and 20.\n\
9135PLINT plGetCursor(gin)\n\
9139 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9140 which will contain the output. The structure is not allocated by\n\
9141 the routine and must exist before the function is called.\n\
9144Set number of colors in cmap0\n\
9148 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9149 (or reallocate) cmap0, and fill with default values for those colors\n\
9150 not previously allocated. The first 16 default colors are given in\n\
9151 the plcol0 documentation. For larger indices the default color is\n\
9154 The drivers are not guaranteed to support more than 16 colors.\n\
9156 Redacted form: plscmap0n(ncol0)\n\
9158 This function is used in examples 15, 16, and 24.\n\
9168 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9169 the cmap0 palette. If this number is zero or less, then the value\n\
9170 from the previous call to plscmap0n is used and if there is no\n\
9171 previous call, then a default value is used.\n\
9174Set z axis parameters\n\
9178 Identical to plsxax, except that arguments are flags for z axis. See\n\
9179 the description of plsxax for more detail.\n\
9181 Redacted form: plszax(digmax, digits)\n\
9183 This function is used in example 31.\n\
9189plszax(digmax, digits)\n\
9193 digmax (PLINT, input) : Variable to set the maximum number of\n\
9194 digits for the z axis. If nonzero, the printed label will be\n\
9195 switched to a floating-point representation when the number of\n\
9196 digits exceeds digmax.\n\
9198 digits (PLINT, input) : Field digits value. Currently, changing\n\
9199 its value here has no effect since it is set only by plbox or\n\
9200 plbox3. However, the user may obtain its value after a call to\n\
9201 either of these functions by calling plgzax.\n\
9204Get FCI (font characterization integer)\n\
9208 Gets information about the current font using the FCI approach. See\n\
9209 the PLplot documentation for more information.\n\
9211 Redacted form: plgfci(p_fci)\n\
9213 This function is used in example 23.\n\
9223 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9227Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9231 Sets up plotter environment for simple graphs by calling pladv and\n\
9232 setting up viewport and window to sensible default values. plenv0\n\
9233 leaves a standard margin (left-hand margin of eight character heights,\n\
9234 and a margin around the other three sides of five character heights)\n\
9235 around most graphs for axis labels and a title. When these defaults\n\
9236 are not suitable, use the individual routines plvpas, plvpor, or\n\
9237 plvasp for setting up the viewport, plwind for defining the window,\n\
9238 and plbox for drawing the box.\n\
9240 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9242 This function is used in example 21.\n\
9248plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9252 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9253 world coordinates).\n\
9255 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9256 world coordinates).\n\
9258 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9261 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9264 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9265 scales will not be set, the user must set up the scale before\n\
9266 calling plenv0 using plsvpa, plvasp or other.\n\
9267 0: the x and y axes are scaled independently to use as much of\n\
9268 the screen as possible.\n\
9269 1: the scales of the x and y axes are made equal.\n\
9270 2: the axis of the x and y axes are made equal, and the plot\n\
9271 box will be square.\n\
9274 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9275 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9276 -1: draw box only.\n\
9277 0: draw box, ticks, and numeric tick labels.\n\
9278 1: also draw coordinate axes at x=0 and y=0.\n\
9279 2: also draw a grid at major tick positions in both\n\
9281 3: also draw a grid at minor tick positions in both\n\
9283 10: same as 0 except logarithmic x tick marks. (The x data\n\
9284 have to be converted to logarithms separately.)\n\
9285 11: same as 1 except logarithmic x tick marks. (The x data\n\
9286 have to be converted to logarithms separately.)\n\
9287 12: same as 2 except logarithmic x tick marks. (The x data\n\
9288 have to be converted to logarithms separately.)\n\
9289 13: same as 3 except logarithmic x tick marks. (The x data\n\
9290 have to be converted to logarithms separately.)\n\
9291 20: same as 0 except logarithmic y tick marks. (The y data\n\
9292 have to be converted to logarithms separately.)\n\
9293 21: same as 1 except logarithmic y tick marks. (The y data\n\
9294 have to be converted to logarithms separately.)\n\
9295 22: same as 2 except logarithmic y tick marks. (The y data\n\
9296 have to be converted to logarithms separately.)\n\
9297 23: same as 3 except logarithmic y tick marks. (The y data\n\
9298 have to be converted to logarithms separately.)\n\
9299 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9300 and y data have to be converted to logarithms separately.)\n\
9301 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9302 and y data have to be converted to logarithms separately.)\n\
9303 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9304 and y data have to be converted to logarithms separately.)\n\
9305 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9306 and y data have to be converted to logarithms separately.)\n\
9307 40: same as 0 except date / time x labels.\n\
9308 41: same as 1 except date / time x labels.\n\
9309 42: same as 2 except date / time x labels.\n\
9310 43: same as 3 except date / time x labels.\n\
9311 50: same as 0 except date / time y labels.\n\
9312 51: same as 1 except date / time y labels.\n\
9313 52: same as 2 except date / time y labels.\n\
9314 53: same as 3 except date / time y labels.\n\
9315 60: same as 0 except date / time x and y labels.\n\
9316 61: same as 1 except date / time x and y labels.\n\
9317 62: same as 2 except date / time x and y labels.\n\
9318 63: same as 3 except date / time x and y labels.\n\
9319 70: same as 0 except custom x and y labels.\n\
9320 71: same as 1 except custom x and y labels.\n\
9321 72: same as 2 except custom x and y labels.\n\
9322 73: same as 3 except custom x and y labels.\n\
9329 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9330 plsym. The actual height of a symbol is the product of the default\n\
9331 symbol size and a scaling factor as for the character height.\n\
9333 Redacted form: plssym(def, scale)\n\
9335 This function is used in example 29.\n\
9341plssym(def, scale)\n\
9345 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9346 should be set to zero if the default height is to remain\n\
9349 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9350 actual symbol height.\n\
9353Set plot orientation\n\
9357 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9358 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9359 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9360 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9361 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9362 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9363 not called the default value of rot is 0.\n\
9365 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9366 probably want to change the aspect ratio to a value suitable for the\n\
9367 plot orientation using a call to plsdidev or the command-line options\n\
9368 -a or -freeaspect. For more documentation of those options see the\n\
9369 PLplot documentation. Such command-line options can be set internally\n\
9370 using plsetopt or set directly using the command line and parsed using\n\
9371 a call to plparseopts.\n\
9373 Redacted form: plsdiori(rot)\n\
9375 This function is not used in any examples.\n\
9385 rot (PLFLT, input) : Plot orientation parameter.\n\
9388Advance the (sub-)page\n\
9392 Advances to the next subpage if sub=0, performing a page advance if\n\
9393 there are no remaining subpages on the current page. If subpages\n\
9394 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9395 PLplot switches to the specified subpage. Note that this allows you\n\
9396 to overwrite a plot on the specified subpage; if this is not what you\n\
9397 intended, use pleop followed by plbop to first advance the page. This\n\
9398 routine is called automatically (with page=0) by plenv, but if plenv\n\
9399 is not used, pladv must be called after initializing PLplot but before\n\
9400 defining the viewport.\n\
9402 Redacted form: pladv(page)\n\
9404 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9415 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9416 in the top left corner and increasing along the rows) to which to\n\
9417 advance. Set to zero to advance to the next subpage (or to the\n\
9418 next page if subpages are not being used).\n\
9421Set cmap0 colors by 8-bit RGB values\n\
9425 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9426 documentation). This sets the entire color map -- only as many colors\n\
9427 as specified will be allocated.\n\
9429 Redacted form: plscmap0(r, g, b)\n\
9431 This function is used in examples 2 and 24.\n\
9437plscmap0(r, g, b, ncol0)\n\
9441 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9442 integers (0-255) representing the degree of red in the color.\n\
9444 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9445 integers (0-255) representing the degree of green in the color.\n\
9447 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9448 integers (0-255) representing the degree of blue in the color.\n\
9450 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9453Get character default height and current (scaled) height\n\
9457 Get character default height and current (scaled) height.\n\
9459 Redacted form: plgchr(p_def, p_ht)\n\
9461 This function is used in example 23.\n\
9467plgchr(p_def, p_ht)\n\
9471 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9472 character height (mm).\n\
9474 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9475 character height (mm).\n\
9478Set opaque RGB cmap1 colors values\n\
9482 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9483 vector values. This function also sets the number of cmap1 colors.\n\
9484 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9485 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9486 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9488 ncol1-1. So in order for this continuous color model to work\n\
9489 properly, it is the responsibility of the user of plscmap1 to insure\n\
9490 that these RGB vectors are continuous functions of their integer\n\
9493 Redacted form: plscmap1(r, g, b)\n\
9495 This function is used in example 31.\n\
9501plscmap1(r, g, b, ncol1)\n\
9505 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9506 8-bit integers in the range from 0-255) the degree of red in the\n\
9507 color as a continuous function of the integer index of the vector.\n\
9509 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9510 8-bit integers in the range from 0-255) the degree of green in the\n\
9511 color as a continuous function of the integer index of the vector.\n\
9513 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9514 8-bit integers in the range from 0-255) the degree of blue in the\n\
9515 color as a continuous function of the integer index of the vector.\n\
9517 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9520Set any command-line option\n\
9524 Set any command-line option internally from a program before it\n\
9525 invokes plinit. opt is the name of the command-line option and optarg\n\
9526 is the corresponding command-line option argument.\n\
9528 This function returns 0 on success.\n\
9530 Redacted form: plsetopt(opt, optarg)\n\
9532 This function is used in example 14.\n\
9538PLINT plsetopt(opt, optarg)\n\
9542 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9543 the command-line option.\n\
9545 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9546 containing the argument of the command-line option.\n\
9549Draw linear gradient inside polygon\n\
9553 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9556 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9557 polygon coordinates and the gradient angle are all expressed in world\n\
9558 coordinates. The angle from the x axis for both the rotated\n\
9559 coordinate system and the gradient vector is specified by angle. The\n\
9560 magnitude of the gradient vector is the difference between the maximum\n\
9561 and minimum values of x for the vertices in the rotated coordinate\n\
9562 system. The origin of the gradient vector can be interpreted as being\n\
9563 anywhere on the line corresponding to the minimum x value for the\n\
9564 vertices in the rotated coordinate system. The distance along the\n\
9565 gradient vector is linearly transformed to the independent variable of\n\
9566 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9567 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9568 color corresponding to the independent variable of cmap1. For more\n\
9569 information about cmap1 (see the PLplot documentation).\n\
9571 Redacted form: plgradient(x,y,angle)\n\
9573 This function is used in examples 25 and 30.\n\
9579plgradient(n, x, y, angle)\n\
9583 n (PLINT, input) : Number of vertices in polygon.\n\
9585 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9588 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9591 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9595Set length of major ticks\n\
9599 This sets up the length of the major ticks. The actual length is the\n\
9600 product of the default length and a scaling factor as for character\n\
9603 Redacted form: plsmaj(def, scale)\n\
9605 This function is used in example 29.\n\
9611plsmaj(def, scale)\n\
9615 def (PLFLT, input) : The default length of a major tick in\n\
9616 millimeters, should be set to zero if the default length is to\n\
9617 remain unchanged.\n\
9619 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9620 actual tick length.\n\
9623Set a global coordinate transform function\n\
9627 This function can be used to define a coordinate transformation which\n\
9628 affects all elements drawn within the current plot window. The\n\
9629 coordinate_transform callback function is similar to that provided for\n\
9630 the plmap and plmeridians functions. The coordinate_transform_data\n\
9631 parameter may be used to pass extra data to coordinate_transform.\n\
9633 Redacted form: General: plstransform(coordinate_transform,\n\
9634 coordinate_transform_data)\n\
9637 This function is used in examples 19 and 22.\n\
9643plstransform(coordinate_transform, coordinate_transform_data)\n\
9647 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9648 function that defines the transformation from the input (x, y)\n\
9649 world coordinates to new PLplot world coordinates. If\n\
9650 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9651 case), then no transform is applied.\n\
9653 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9655 coordinate_transform.\n\
9658Configure the transformation between continuous and broken-down time for the current stream\n\
9662 Configure the transformation between continuous and broken-down time\n\
9663 for the current stream. This transformation is used by both plbtime\n\
9666 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9667 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9670 This function is used in example 29.\n\
9676plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9680 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9681 As a special case, if\n\
9682 scale is 0., then all other arguments are ignored, and the result (the\n\
9683 default used by PLplot) is the equivalent of a call to\n\
9684 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9685 That is, for this special case broken-down time is calculated with\n\
9686 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9687 and the continuous time is defined as the number of seconds since\n\
9688 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9690 offset1 (PLFLT, input) : If\n\
9691 ifbtime_offset is true, the parameters\n\
9693 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9694 (with units in days) specify the epoch of the continuous time\n\
9695 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9696 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9697 are used to specify the origin to allow users (by specifying\n\
9698 offset1 as an integer that can be exactly represented by a\n\
9699 floating-point variable and specifying\n\
9700 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9701 the numerical errors of the continuous time representation.\n\
9703 offset2 (PLFLT, input) : See documentation of\n\
9706 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9707 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9708 calendar is used for broken-down time rather than the proleptic\n\
9709 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9710 have been historically used to define UTC are inserted into the\n\
9711 broken-down time. Other possibilities for additional control bits\n\
9712 for ccontrol exist such as making the historical time corrections\n\
9713 in the broken-down time corresponding to ET (ephemeris time) or\n\
9714 making the (slightly non-constant) corrections from international\n\
9715 atomic time (TAI) to what astronomers define as terrestrial time\n\
9716 (TT). But those additional possibilities have not been\n\
9717 implemented yet in the qsastime library (one of the PLplot utility\n\
9720 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9721 epoch of the continuous time scale is specified by the user. If\n\
9722 ifbtime_offset is false, then\n\
9724 offset2 are used to specify the epoch, and the following broken-down\n\
9725 time parameters are completely ignored. If\n\
9726 ifbtime_offset is true, then\n\
9728 offset2 are completely ignored, and the following broken-down time\n\
9729 parameters are used to specify the epoch.\n\
9731 year (PLINT, input) : Year of epoch.\n\
9733 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9736 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9738 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9740 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9742 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9745Flushes the output stream\n\
9749 Flushes the output stream. Use sparingly, if at all.\n\
9751 Redacted form: plflush()\n\
9753 This function is used in examples 1 and 14.\n\
9762Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9766 This variant of plsurf3d (see that function\'s documentation for more\n\
9767 details) should be suitable for the case where the area of the x, y\n\
9768 coordinate grid where z is defined can be non-rectangular. The limits\n\
9769 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9770 indexymin, and indexymax.\n\
9772 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9775 This function is used in example 8.\n\
9781plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9785 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9786 which the function is evaluated.\n\
9788 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9789 which the function is evaluated.\n\
9791 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9792 plot. Should have dimensions of\n\
9796 nx (PLINT, input) : Number of x values at which function is\n\
9799 ny (PLINT, input) : Number of y values at which function is\n\
9802 opt (PLINT, input) : Determines the way in which the surface is\n\
9803 represented. To specify more than one option just add the options,\n\
9804 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9805 connecting points at which function is defined.\n\
9806 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9810 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9814 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9815 the borders of the plotted function.\n\
9816 opt=MAG_COLOR : the surface is colored according to the value\n\
9817 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9818 according to the intensity of the reflected light in the\n\
9819 surface from a light source whose position is set using\n\
9823 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9826 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9828 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9829 corresponds to the first x index where z is defined.\n\
9831 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9832 which corresponds (by convention) to one more than the last x\n\
9833 index value where z is defined.\n\
9835 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9836 values which all must be ≥ 0. These values are the first y index\n\
9837 where z is defined for a particular x index in the range from\n\
9838 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9841 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9842 values which all must be ≤ ny. These values correspond (by\n\
9843 convention) to one more than the last y index where z is defined\n\
9844 for a particular x index in the range from indexxmin to indexxmax\n\
9845 - 1. The dimension of indexymax is indexxmax.\n\
9848Set semitransparent cmap1 RGBA colors.\n\
9852 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9853 RGBA vector values. This function also sets the number of cmap1\n\
9854 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9855 floating-point index in the range from 0.0-1.0 which is linearly\n\
9856 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9857 vectors in the range from 0 to\n\
9858 ncol1-1. So in order for this continuous color model to work\n\
9859 properly, it is the responsibility of the user of plscmap1 to insure\n\
9860 that these RGBA vectors are continuous functions of their integer\n\
9863 Redacted form: plscmap1a(r, g, b, alpha)\n\
9865 This function is used in example 31.\n\
9871plscmap1a(r, g, b, alpha, ncol1)\n\
9875 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9876 8-bit integers in the range from 0-255) the degree of red in the\n\
9877 color as a continuous function of the integer index of the vector.\n\
9879 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9880 8-bit integers in the range from 0-255) the degree of green in the\n\
9881 color as a continuous function of the integer index of the vector.\n\
9883 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9884 8-bit integers in the range from 0-255) the degree of blue in the\n\
9885 color as a continuous function of the integer index of the vector.\n\
9887 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9888 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9889 completely transparent and 1.0 corresponds to completely opaque)\n\
9890 the alpha transparency of the color as a continuous function of\n\
9891 the integer index of the vector.\n\
9893 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9897Calculate broken-down time from continuous time for the current stream\n\
9901 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9902 continuous time, ctime for the current stream. This function is the\n\
9903 inverse of plctime.\n\
9905 The PLplot definition of broken-down time is a calendar time that\n\
9906 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9907 responsibility to apply those offsets (if so desired) before using the\n\
9908 PLplot time API. By default broken-down time is defined using the\n\
9909 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9910 continuous time is defined as the number of seconds since the Unix\n\
9911 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9912 broken-down and continuous time are possible, see plconfigtime.\n\
9914 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9918 This function is used in example 29.\n\
9924plbtime(year, month, day, hour, min, sec, ctime)\n\
9928 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9929 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9930 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9933 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9934 the year in the range from 0 (January) to 11 (December).\n\
9936 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9937 month in the range from 1 to 31.\n\
9939 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9940 day in the range from 0 to 23.\n\
9942 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9943 hour in the range from 0 to 59\n\
9945 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9946 minute in range from 0. to 60.\n\
9948 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9949 time is calculated.\n\
9952Convert RGB color to HLS\n\
9956 Convert RGB color coordinates to HLS\n\
9958 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9961 This function is used in example 2.\n\
9967plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9971 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9973 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9975 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9977 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9978 degrees (0.0-360.0) on the color cylinder.\n\
9980 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9981 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9984 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9985 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9989Get the current device (keyword) name\n\
9993 Get the current device (keyword) name. Note: you must have allocated\n\
9994 space for this (80 characters is safe).\n\
9996 Redacted form: plgdev(p_dev)\n\
9998 This function is used in example 14.\n\
10008 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10009 (with preallocated length of 80 characters or more) containing the\n\
10010 device (keyword) name.\n\
10013Set the number of subpages in x and y\n\
10017 Set the number of subpages in x and y.\n\
10019 Redacted form: plssub(nx, ny)\n\
10021 This function is examples 1,2,14,21,25,27.\n\
10031 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10032 of window columns).\n\
10034 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10035 of window rows).\n\
10038Get current stream number\n\
10042 Gets the number of the current output stream. See also plsstrm.\n\
10044 Redacted form: plgstrm(p_strm)\n\
10046 This function is used in example 1,20.\n\
10056 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10060Random number generator returning a real random number in the range [0,1]\n\
10064 Random number generator returning a real random number in the range\n\
10065 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10066 / compilers provide their own random number generator, and so this is\n\
10067 provided purely for convenience and to give a consistent random number\n\
10068 generator across all languages supported by PLplot. This is\n\
10069 particularly useful for comparing results from the test suite of\n\
10072 Redacted form: plrandd()\n\
10074 This function is used in examples 17 and 21.\n\
10083Add a point to a strip chart\n\
10087 Add a point to a given pen of a given strip chart. There is no need\n\
10088 for all pens to have the same number of points or to be equally\n\
10089 sampled in the x coordinate. Allocates memory and rescales as\n\
10092 Redacted form: plstripa(id, pen, x, y)\n\
10094 This function is used in example 17.\n\
10100plstripa(id, pen, x, y)\n\
10104 id (PLINT, input) : Identification number of the strip chart (set\n\
10105 up in plstripc).\n\
10107 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10109 x (PLFLT, input) : X coordinate of point to plot.\n\
10111 y (PLFLT, input) : Y coordinate of point to plot.\n\
10114Set device-compression level\n\
10118 Set device-compression level. Only used for drivers that provide\n\
10119 compression. This function, if used, should be invoked before a call\n\
10122 Redacted form: plscompression(compression)\n\
10124 This function is used in example 31.\n\
10130plscompression(compression)\n\
10134 compression (PLINT, input) : The desired compression level. This is\n\
10135 a device-dependent value. Currently only the jpeg and png devices\n\
10136 use these values. For jpeg value is the jpeg quality which should\n\
10137 normally be in the range 0-95. Higher values denote higher quality\n\
10138 and hence larger image sizes. For png values are in the range -1\n\
10139 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10140 A value of -1 denotes the default zlib compression level. Values\n\
10141 in the range 10-99 are divided by 10 and then used as the zlib\n\
10142 compression level. Higher compression levels correspond to greater\n\
10143 compression and small file sizes at the expense of more\n\
10147Specify viewport in absolute coordinates\n\
10151 Alternate routine to plvpor for setting up the viewport. This routine\n\
10152 should be used only if the viewport is required to have a definite\n\
10153 size in millimeters. The routine plgspa is useful for finding out the\n\
10154 size of the current subpage.\n\
10156 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10158 This function is used in example 10.\n\
10164plsvpa(xmin, xmax, ymin, ymax)\n\
10168 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10169 viewport from the left-hand edge of the subpage in millimeters.\n\
10171 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10172 viewport from the left-hand edge of the subpage in millimeters.\n\
10174 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10175 viewport from the bottom edge of the subpage in millimeters.\n\
10177 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10178 from the bottom edge of the subpage in millimeters.\n\
10181Draw a polygon in 3 space\n\
10185 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10186 like plline3, but differs from that function in that plpoly3 attempts\n\
10187 to determine if the polygon is viewable depending on the order of the\n\
10188 points within the vector and the value of ifcc. If the back of\n\
10189 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10190 you want, then use plline3 instead.\n\
10192 The points are assumed to be in a plane, and the directionality of the\n\
10193 plane is determined from the first three points. Additional points do\n\
10194 not have to lie on the plane defined by the first three, but if they\n\
10195 do not, then the determination of visibility obviously can\'t be 100%\n\
10196 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10197 consider breaking them into smaller polygons. 3 points define a plane\n\
10200 Bugs: If one of the first two segments is of zero length, or if they\n\
10201 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10202 being correct. Avoid such situations :-). See x18c.c for an example\n\
10203 of this problem. (Search for 20.1).\n\
10205 Redacted form: plpoly3(x, y, z, code)\n\
10207 This function is used in example 18.\n\
10213plpoly3(n, x, y, z, draw, ifcc)\n\
10217 n (PLINT, input) : Number of points defining line.\n\
10219 x (PLFLT_VECTOR, input) : A vector containing\n\
10220 n x coordinates of points.\n\
10222 y (PLFLT_VECTOR, input) : A vector containing\n\
10223 n y coordinates of points.\n\
10225 z (PLFLT_VECTOR, input) : A vector containing\n\
10226 n z coordinates of points.\n\
10228 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10229 n-1 Boolean values which control drawing the segments of the polygon.\n\
10230 If draw[i] is true, then the polygon segment from index [i] to\n\
10231 [i+1] is drawn, otherwise, not.\n\
10233 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10234 polygon is determined by assuming the points are laid out in a\n\
10235 counter-clockwise order. Otherwise, the directionality of the\n\
10236 polygon is determined by assuming the points are laid out in a\n\
10237 clockwise order.\n\
10240Magnitude colored plot surface with contour\n\
10244 Aside from dropping the\n\
10245 side functionality this is a more powerful form of plot3d: the surface\n\
10246 mesh can be colored accordingly to the current z value being plotted,\n\
10247 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10248 drawn between the plotted function border and the base XY plane. The\n\
10249 arguments are identical to those of plmeshc. The only difference\n\
10250 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10251 the surface, while plot3dc only draws the surface as viewed from the\n\
10254 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10257 This function is used in example 21.\n\
10263plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10267 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10268 which the function is evaluated.\n\
10270 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10271 which the function is evaluated.\n\
10273 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10274 plot. Should have dimensions of\n\
10278 nx (PLINT, input) : Number of x values at which function is\n\
10281 ny (PLINT, input) : Number of y values at which function is\n\
10284 opt (PLINT, input) : Determines the way in which the surface is\n\
10285 represented. To specify more than one option just add the options,\n\
10286 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10287 showing z as a function of x for each value of y[j] .\n\
10288 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10289 for each value of x[i] .\n\
10290 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10291 at which function is defined.\n\
10292 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10293 the z value being plotted. The color is used from the current\n\
10295 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10296 using parameters\n\
10299 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10300 the borders of the plotted function.\n\
10303 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10306 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10309Create a 4-pen strip chart\n\
10313 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10315 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10316 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10317 styline, legline, labx, laby, labz)\n\
10320 This function is used in example 17.\n\
10326plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10330 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10331 number of the strip chart to use on plstripa and plstripd.\n\
10333 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10334 the x-axis specification as in plbox.\n\
10336 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10337 the y-axis specification as in plbox.\n\
10339 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10340 change as data are added.\n\
10342 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10343 change as data are added.\n\
10345 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10346 is multiplied by the factor (1 +\n\
10349 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10350 change as data are added.\n\
10352 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10353 change as data are added.\n\
10355 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10357 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10359 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10360 true, otherwise not.\n\
10362 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10363 otherwise slide display.\n\
10365 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10367 collab (PLINT, input) : Legend color index (cmap0).\n\
10369 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10370 indices for the 4 pens.\n\
10372 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10373 indices for the 4 pens.\n\
10375 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10376 strings containing legends for the 4 pens.\n\
10378 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10379 the label for the x axis.\n\
10381 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10382 the label for the y axis.\n\
10384 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10388Deletes and releases memory used by a strip chart\n\
10392 Deletes and releases memory used by a strip chart.\n\
10394 Redacted form: plstripd(id)\n\
10396 This function is used in example 17.\n\
10406 id (PLINT, input) : Identification number of strip chart to delete.\n\
10409Set cmap1 colors using a piece-wise linear relationship\n\
10413 Set cmap1 colors using a piece-wise linear relationship between the\n\
10414 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10415 (see the PLplot documentation). May be called at any time.\n\
10417 The idea here is to specify a number of control points that define the\n\
10418 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10419 these points, linear interpolation is used which gives a smooth\n\
10420 variation of color with intensity index. Any number of control points\n\
10421 may be specified, located at arbitrary positions, although typically 2\n\
10422 - 4 are enough. Another way of stating this is that we are traversing\n\
10423 a given number of lines through HLS or RGB space as we move through\n\
10424 cmap1 intensity indices. The control points at the minimum and\n\
10425 maximum position (0 and 1) must always be specified. By adding more\n\
10426 control points you can get more variation. One good technique for\n\
10427 plotting functions that vary about some expected average is to use an\n\
10428 additional 2 control points in the center (position ~= 0.5) that are\n\
10429 the same lightness as the background (typically white for paper\n\
10430 output, black for crt), and same hue as the boundary control points.\n\
10431 This allows the highs and lows to be very easily distinguished.\n\
10433 Each control point must specify the cmap1 intensity index and the\n\
10434 associated three coordinates in HLS or RGB space. The first point\n\
10435 must correspond to position = 0, and the last to position = 1.\n\
10437 If RGB colors are provided then the interpolation takes place in RGB\n\
10438 space and is trivial. However if HLS colors are provided then, because\n\
10439 of the circular nature of the color wheel for the hue coordinate, the\n\
10440 interpolation could be performed in either direction around the color\n\
10441 wheel. The default behaviour is for the hue to be linearly\n\
10442 interpolated ignoring this circular property of hue. So for example,\n\
10443 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10444 green and cyan. If instead you wish to interpolate the other way\n\
10445 around the color wheel you have two options. You may provide hues\n\
10446 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10447 for red the interpolation will proceed via magenta. Alternatively you\n\
10448 can utilise the alt_hue_path variable to reverse the direction of\n\
10449 interpolation if you need to provide hues within the [0-360) range.\n\
10451 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10452 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10453 -120]falsegreen-yellow-red-magenta-blue[240\n\
10454 480]falseblue-magenta-red-yellow-green[120\n\
10455 240]truegreen-yellow-red-magenta-blue[240\n\
10456 120]trueblue-magenta-red-yellow-green\n\
10458 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10459 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10460 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10462 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10465 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10471plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10475 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10477 npts (PLINT, input) : number of control points\n\
10479 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10480 intensity index (0.0-1.0) in ascending order for each control\n\
10483 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10484 coordinate (H or R) for each control point.\n\
10486 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10487 coordinate (L or G) for each control point.\n\
10489 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10490 coordinate (S or B) for each control point.\n\
10492 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10493 npts - 1 elements), each containing either true to use the reversed\n\
10494 HLS interpolation or false to use the regular HLS interpolation.\n\
10495 (alt_hue_path[i] refers to the interpolation interval between the\n\
10496 i and i + 1 control points). This parameter is not used for RGB\n\
10501Shade individual region on the basis of value\n\
10505 Shade individual region on the basis of value. Use plshades if you\n\
10506 want to shade a number of contiguous regions using continuous colors.\n\
10507 In particular the edge contours are treated properly in plshades. If\n\
10508 you attempt to do contiguous regions with plshade the contours at the\n\
10509 edge of the shade are partially obliterated by subsequent plots of\n\
10510 contiguous shaded regions.\n\
10512 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10513 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10514 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10517 This function is used in example 15.\n\
10523plshade(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\
10527 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10528 plot. Should have dimensions of\n\
10532 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10534 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10536 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10537 the region that should be plotted in the shade plot. This\n\
10538 function accepts x and y coordinates as input arguments and must\n\
10539 return 1 if the point is to be included in the shade plot and 0\n\
10540 otherwise. If you want to plot the entire shade plot (the usual\n\
10541 case), this argument should be set to NULL.\n\
10543 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10544 pltr below for how these arguments are used (only for the special case\n\
10545 when the callback function\n\
10546 pltr is not supplied).\n\
10548 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10549 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10551 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10552 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10554 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10555 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10556 then sh_color is interpreted as a cmap1 argument in the range\n\
10559 sh_color (PLFLT, input) : Defines color map index with integer\n\
10560 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10562 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10564 min_color (PLINT, input) : Defines pen color, width used by the\n\
10565 boundary of shaded region. The min values are used for the\n\
10566 shade_min boundary, and the max values are used on the shade_max\n\
10567 boundary. Set color and width to zero for no plotted boundaries.\n\
10569 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10570 boundary of shaded region. The min values are used for the\n\
10571 shade_min boundary, and the max values are used on the shade_max\n\
10572 boundary. Set color and width to zero for no plotted boundaries.\n\
10574 max_color (PLINT, input) : Defines pen color, width used by the\n\
10575 boundary of shaded region. The min values are used for the\n\
10576 shade_min boundary, and the max values are used on the shade_max\n\
10577 boundary. Set color and width to zero for no plotted boundaries.\n\
10579 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10580 boundary of shaded region. The min values are used for the\n\
10581 shade_min boundary, and the max values are used on the shade_max\n\
10582 boundary. Set color and width to zero for no plotted boundaries.\n\
10584 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10585 Use plfill. Future version of PLplot may have other fill\n\
10588 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10589 map to rectangles after coordinate transformation with pltrl.\n\
10590 Otherwise, set rectangular to false. If rectangular is set to\n\
10591 true, plshade tries to save time by filling large rectangles.\n\
10592 This optimization fails if the coordinate transformation distorts\n\
10593 the shape of rectangles. For example a plot in polar coordinates\n\
10594 has to have rectangular set to false.\n\
10596 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10597 defines the transformation between the zero-based indices of the\n\
10598 matrix a and world coordinates. If\n\
10599 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10600 indices of a are mapped to the range\n\
10602 xmax and the y indices of a are mapped to the range\n\
10604 ymax.For the C case, transformation functions are provided in the\n\
10605 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10606 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10607 matrices. In addition, C callback routines for the transformation\n\
10608 can be supplied by the user such as the mypltr function in\n\
10609 examples/c/x09c.c which provides a general linear transformation\n\
10610 between index coordinates and world coordinates.For languages\n\
10611 other than C you should consult the PLplot documentation for the\n\
10612 details concerning how PLTRANSFORM_callback arguments are\n\
10613 interfaced. However, in general, a particular pattern of\n\
10614 callback-associated arguments such as a tr vector with 6 elements;\n\
10615 xg and yg vectors; or xg and yg matrices are respectively\n\
10616 interfaced to a linear-transformation routine similar to the above\n\
10617 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10618 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10619 support native language callbacks for handling index to\n\
10620 world-coordinate transformations. Examples of these various\n\
10621 approaches are given in examples/<language>x09*,\n\
10622 examples/<language>x16*, examples/<language>x20*,\n\
10623 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10624 supported languages.\n\
10626 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10627 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10628 externally supplied.\n\
10631Set number of colors in cmap1\n\
10635 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10636 values if this is the first allocation (see the PLplot documentation).\n\
10638 Redacted form: plscmap1n(ncol1)\n\
10640 This function is used in examples 8, 11, 20, and 21.\n\
10650 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10651 the cmap1 palette. If this number is zero or less, then the value\n\
10652 from the previous call to plscmap1n is used and if there is no\n\
10653 previous call, then a default value is used.\n\
10656Advance to the next family file on the next new page\n\
10660 Advance to the next family file on the next new page.\n\
10662 Redacted form: plfamadv()\n\
10664 This function is not used in any examples.\n\
10673Set the escape character for text strings\n\
10677 Set the escape character for text strings. From C (in contrast to\n\
10678 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10679 characters are allowed to prevent the user from shooting himself in\n\
10680 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10681 use of backslash as a character escape). Here are the allowed escape\n\
10682 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10693 Redacted form: General: plsesc(esc)\n\
10696 This function is used in example 29.\n\
10706 esc (char, input) : Escape character.\n\
10708static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10709Plot color bar for image, shade or gradient plots\n\
10713 Routine for creating a continuous color bar for image, shade, or\n\
10714 gradient plots. (See pllegend for similar functionality for creating\n\
10715 legends with discrete elements). The arguments of plcolorbar provide\n\
10716 control over the location and size of the color bar as well as the\n\
10717 location and characteristics of the elements (most of which are\n\
10718 optional) within that color bar. The resulting color bar is clipped\n\
10719 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10720 system used for some of the parameters is defined in the documentation\n\
10721 of the position parameter.)\n\
10723 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10724 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10725 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10726 labels, axis_opts, ticks, sub_ticks, values)\n\
10728 This function is used in examples 16 and 33.\n\
10734plcolorbar(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\
10738 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10739 labelled and decorated color bar width in adopted coordinates.\n\
10741 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10742 labelled and decorated color bar height in adopted coordinates.\n\
10744 opt (PLINT, input) : opt contains bits controlling the overall\n\
10745 color bar. The orientation (direction of the maximum value) of\n\
10746 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10747 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10748 specified, the default orientation is toward the top if the\n\
10749 colorbar is placed on the left or right of the viewport or toward\n\
10750 the right if the colorbar is placed on the top or bottom of the\n\
10751 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10752 (semitransparent) background for the color bar. If the\n\
10753 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10754 color bar. The type of color bar must be specified with one of\n\
10755 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10756 more than one of those bits is set only the first one in the above\n\
10757 list is honored. The position of the (optional) label/title can be\n\
10758 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10759 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10760 will be drawn. If more than one of this list of bits is specified,\n\
10761 only the first one on the list is honored. End-caps for the color\n\
10762 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10763 If a particular color bar cap option is not specified then no cap\n\
10764 will be drawn for that end. As a special case for\n\
10765 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10766 specified. If this option is provided then any tick marks and tick\n\
10767 labels will be placed at the breaks between shaded segments. TODO:\n\
10768 This should be expanded to support custom placement of tick marks\n\
10769 and tick labels at custom value locations for any color bar type.\n\
10771 position (PLINT, input) : position contains bits which control the\n\
10772 overall position of the color bar and the definition of the\n\
10773 adopted coordinates used for positions just like what is done for\n\
10774 the position argument for pllegend. However, note that the\n\
10775 defaults for the position bits (see below) are different than the\n\
10776 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10777 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10778 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10779 the 16 possible standard positions (the 4 corners and centers of\n\
10780 the 4 sides for both the inside and outside cases) of the color\n\
10781 bar relative to the adopted coordinate system. The corner\n\
10782 positions are specified by the appropriate combination of two of\n\
10783 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10784 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10785 value of one of those bits. The adopted coordinates are\n\
10786 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10787 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10788 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10789 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10790 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10791 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10792 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10793 PL_POSITION_VIEWPORT.\n\
10795 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10796 coordinates from the specified standard position of the color bar.\n\
10797 For positive x, the direction of motion away from the standard\n\
10798 position is inward/outward from the standard corner positions or\n\
10799 standard left or right positions if the\n\
10800 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10801 For the standard top or bottom positions, the direction of motion\n\
10802 is toward positive X.\n\
10804 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10805 coordinates from the specified standard position of the color bar.\n\
10806 For positive y, the direction of motion away from the standard\n\
10807 position is inward/outward from the standard corner positions or\n\
10808 standard top or bottom positions if the\n\
10809 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10810 For the standard left or right positions, the direction of motion\n\
10811 is toward positive Y.\n\
10813 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10814 the X direction in adopted coordinates.\n\
10816 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10817 the Y direction in adopted coordinates.\n\
10819 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10820 color bar (PL_COLORBAR_BACKGROUND).\n\
10822 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10823 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10825 bb_style (PLINT, input) : The pllsty style number for the\n\
10826 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10828 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10829 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10831 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10832 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10834 cont_color (PLINT, input) : The cmap0 contour color for\n\
10835 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10836 it will be interpreted according to the design of plshades.\n\
10838 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10839 plots. This is passed directly to plshades, so it will be\n\
10840 interpreted according to the design of plshades.\n\
10842 n_labels (PLINT, input) : Number of labels to place around the\n\
10845 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10846 n_labels labels.\n\
10848 labels (PLCHAR_MATRIX, input) : A vector of\n\
10849 n_labels UTF-8 character strings containing the labels for the color\n\
10850 bar. Ignored if no label position is specified with one of the\n\
10851 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10852 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10853 corresponding label_opts field.\n\
10855 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10856 value must be greater than 0. It is typically 1 (numerical axis\n\
10857 labels are provided for one of the long edges of the color bar),\n\
10858 but it can be larger if multiple numerical axis labels for the\n\
10859 long edges of the color bar are desired.\n\
10861 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10862 n_axes ascii character strings containing options (interpreted as for\n\
10863 plbox) for the color bar\'s axis definitions.\n\
10865 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10866 spacing of the major tick marks (interpreted as for plbox) for the\n\
10867 color bar\'s axis definitions.\n\
10869 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10870 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10871 axis definitions.\n\
10873 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10874 elements in each of the n_axes rows of the values matrix.\n\
10876 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10877 values for the data range represented by the color bar. For a row\n\
10878 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10879 elements in the row is specified by n_values[i_axis]. For\n\
10880 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10881 is 2, and the corresponding row elements of the values matrix are\n\
10882 the minimum and maximum value represented by the colorbar. For\n\
10883 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10884 of the values matrix is interpreted the same as the nlevel and\n\
10885 clevel arguments of plshades.\n\
10887static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10888Set current output stream\n\
10892 Sets the number of the current output stream. The stream number\n\
10893 defaults to 0 unless changed by this routine. The first use of this\n\
10894 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10896 Redacted form: plsstrm(strm)\n\
10898 This function is examples 1,14,20.\n\
10908 strm (PLINT, input) : The current stream number.\n\
10910static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10911Get the current device-compression setting\n\
10915 Get the current device-compression setting. This parameter is only\n\
10916 used for drivers that provide compression.\n\
10918 Redacted form: plgcompression(compression)\n\
10920 This function is used in example 31.\n\
10926plgcompression(compression)\n\
10930 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10931 compression setting for the current device.\n\
10933static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10934Grid data from irregularly sampled data\n\
10938 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10939 require data organized as a grid, i.e., with x sample point values\n\
10940 independent of y coordinate and vice versa. This function takes\n\
10941 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10942 vectors; reads the desired grid location from the input vectors\n\
10943 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10944 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10945 interpolate the data to the grid is specified with the argument type\n\
10946 which can have one parameter specified in argument data.\n\
10948 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10949 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10952 This function is used in example 21.\n\
10958plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10962 x (PLFLT_VECTOR, input) : The input x vector.\n\
10964 y (PLFLT_VECTOR, input) : The input y vector.\n\
10966 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10967 y[i], z[i] represents one data sample coordinate.\n\
10969 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10972 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10973 in the x direction. Usually xg has nptsx equally spaced values\n\
10974 from the minimum to the maximum values of the x input vector.\n\
10976 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10978 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10979 in the y direction. Similar to the xg parameter.\n\
10981 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10983 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10984 where data lies in the grid specified by xg and yg. Therefore the\n\
10985 zg matrix must be dimensioned\n\
10989 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10990 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10991 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10992 GRID_NNI: Natural Neighbors Interpolation\n\
10993 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10994 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10995 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10997 For details of the algorithms read the source file plgridd.c.\n\
10999 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
11000 which can be specified through this argument. Currently, for\n\
11001 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11002 use, the lower the value, the noisier (more local) the\n\
11003 approximation is.\n\
11004 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11005 range [1. .. 2.]. High values enable the usage of very thin\n\
11006 triangles for interpolation, possibly resulting in error in\n\
11007 the approximation.\n\
11008 GRID_NNI, only weights greater than data will be accepted. If\n\
11009 0, all weights will be accepted.\n\
11015 char **arg3 = (
char **) 0 ;
11017 octave_value_list _out;
11018 octave_value_list *_outp=&_out;
11019 octave_value _outv;
11026 if (
_n_dims( args(0) ) > 1 )
11032 temp1 = args(0).matrix_value();
11036 charMatrix temp_matrix;
11040 size_t max_length = 0, non_blank_length;
11042 if (
_n_dims( args(1) ) > 2 )
11044 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
11046#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11047 if ( !args(1).isempty() )
11049 if ( !args(1).is_empty() )
11054 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
11056 arg3 =
new char*[
Alen];
11057#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11058 ifcell = args(1).iscell();
11060 ifcell = args(1).is_cell();
11064 temp_cell = args(1).cell_value();
11068 temp_matrix = args(1).char_matrix_value();
11070 max_length =
_dim( args(1), 1 ) + 1;
11073 for ( i = 0; i <
Alen; i++ )
11080 if ( temp_cell.elem( i ).is_string() )
11082 str = temp_cell.elem( i ).string_value();
11084 max_length = str.size() + 1;
11085 tmp_cstring = (
char *) str.c_str();
11095 tmp_cstring = (
char *)
"";
11100 str = temp_matrix.row_as_string( i );
11101 tmp_cstring = (
char *) str.c_str();
11103 arg3[i] =
new char[max_length];
11104 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11105 arg3[i][max_length - 1] =
'\0';
11120 non_blank_length = max_length - 2;
11121 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11123 non_blank_length--;
11125 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11127 non_blank_length--;
11129 arg3[i][non_blank_length + 1] =
'\0';
11138 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11139 _outv = octave_value();
11146 if ( arg3 != NULL )
11148 for ( i = 0; i <
Alen; i++ )
11162 if ( arg3 != NULL )
11164 for ( i = 0; i <
Alen; i++ )
11171 return octave_value_list();
11179 if ( arg3 != NULL )
11181 for ( i = 0; i <
Alen; i++ )
11194 int *arg1 = (
int *) 0 ;
11195 int *arg2 = (
int *) 0 ;
11196 int *arg3 = (
int *) 0 ;
11197 char *arg4 = (
char *) 0 ;
11198 int *arg5 = (
int *) 0 ;
11199 int *arg6 = (
int *) 0 ;
11204 int *arg11 = (
int *) 0 ;
11211 char local_string4[80] ;
11226 size_t local_string_length4 ;
11227 charMatrix local_charMatrix4 ;
11228 octave_value_list retval4 ;
11229 octave_value_list _out;
11230 octave_value_list *_outp=&_out;
11231 octave_value _outv;
11239 arg4 = local_string4;
11251 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11273 local_string_length4 = strlen( local_string4 );
11274 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11275 local_charMatrix4.insert( local_string4, 0, 0 );
11276 retval4( 0 ) = octave_value( local_charMatrix4 );
11323 return octave_value_list();
11344 octave_value_list _out;
11345 octave_value_list *_outp=&_out;
11346 octave_value _outv;
11359 arg3 =
static_cast< PLFLT >(val3);
11364 arg4 =
static_cast< PLFLT >(val4);
11382 return octave_value_list();
11392 char *arg2 = (
char *) 0 ;
11393 char *arg3 = (
char *) 0 ;
11407 char *arg17 = (
char *) 0 ;
11408 char *arg18 = (
char *) 0 ;
11409 char *arg19 = (
char *) 0 ;
11410 char *arg20 = (
char *) 0 ;
11411 char *arg21 = (
char *) 0 ;
11412 char *arg22 = (
char *) 0 ;
11413 char *arg23 = (
char *) 0 ;
11467 octave_value_list _out;
11468 octave_value_list *_outp=&_out;
11469 octave_value _outv;
11480 arg2 =
reinterpret_cast< char *
>(buf2);
11485 arg3 =
reinterpret_cast< char *
>(buf3);
11490 arg4 =
static_cast< PLFLT >(val4);
11495 arg5 =
static_cast< PLFLT >(val5);
11500 arg6 =
static_cast< PLFLT >(val6);
11505 arg7 =
static_cast< PLFLT >(val7);
11510 arg8 =
static_cast< PLFLT >(val8);
11515 arg9 =
static_cast< PLFLT >(val9);
11520 arg10 =
static_cast< PLFLT >(val10);
11525 arg11 =
static_cast< PLBOOL >(val11);
11530 arg12 =
static_cast< PLBOOL >(val12);
11535 arg13 =
static_cast< PLINT >(val13);
11540 arg14 =
static_cast< PLINT >(val14);
11542 if (
_n_dims( args(13) ) > 1 )
11547 temp15 = args(13).matrix_value();
11552 if (
_n_dims( args(14) ) > 1 )
11556 if (
_dim( args(14), 0 ) !=
Alen )
11560 temp16 = args(14).matrix_value();
11568 arg17 =
reinterpret_cast< char *
>(buf17);
11573 arg18 =
reinterpret_cast< char *
>(buf18);
11578 arg19 =
reinterpret_cast< char *
>(buf19);
11583 arg20 =
reinterpret_cast< char *
>(buf20);
11588 arg21 =
reinterpret_cast< char *
>(buf21);
11593 arg22 =
reinterpret_cast< char *
>(buf22);
11598 arg23 =
reinterpret_cast< char *
>(buf23);
11599 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);
11600 _outv = octave_value();
11640 return octave_value_list();
11685 octave_value_list _out;
11686 octave_value_list *_outp=&_out;
11687 octave_value _outv;
11694 if (
_n_dims( args(0) ) > 2 )
11696 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11698 temp1 = args(0).matrix_value();
11699 arg1 = &temp1( 0, 0 );
11707 arg4 =
static_cast< PLINT >(val4);
11712 arg5 =
static_cast< PLINT >(val5);
11717 arg6 =
static_cast< PLINT >(val6);
11722 arg7 =
static_cast< PLINT >(val7);
11724 if (
_n_dims( args(5) ) > 1 )
11728 temp8 = args(5).matrix_value();
11729 arg8 = &temp8( 0, 0 );
11733 if (
_n_dims( args(6) ) > 1 )
11737 if (
_dim( args(6), 0 ) != 6 )
11741 temp10 = args(6).matrix_value();
11742 arg10 = &temp10( 0, 0 );
11744 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11745 _outv = octave_value();
11767 return octave_value_list();
11804 octave_value_list _out;
11805 octave_value_list *_outp=&_out;
11806 octave_value _outv;
11813 if (
_n_dims( args(0) ) > 2 )
11815 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11817 temp1 = args(0).matrix_value();
11818 arg1 = &temp1( 0, 0 );
11826 arg4 =
static_cast< PLINT >(val4);
11831 arg5 =
static_cast< PLINT >(val5);
11836 arg6 =
static_cast< PLINT >(val6);
11841 arg7 =
static_cast< PLINT >(val7);
11843 if (
_n_dims( args(5) ) > 1 )
11847 temp8 = args(5).matrix_value();
11848 arg8 = &temp8( 0, 0 );
11851 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11852 _outv = octave_value();
11868 return octave_value_list();
11906 octave_value_list _out;
11907 octave_value_list *_outp=&_out;
11908 octave_value _outv;
11915 if (
_n_dims( args(0) ) > 2 )
11917 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11919 temp1 = args(0).matrix_value();
11920 arg1 = &temp1( 0, 0 );
11928 arg4 =
static_cast< PLINT >(val4);
11933 arg5 =
static_cast< PLINT >(val5);
11938 arg6 =
static_cast< PLINT >(val6);
11943 arg7 =
static_cast< PLINT >(val7);
11945 if (
_n_dims( args(5) ) > 1 )
11949 temp8 = args(5).matrix_value();
11950 arg8 = &temp8( 0, 0 );
11954 if (
_n_dims( args(6) ) > 1 )
11962 temp10 = args(6).matrix_value();
11963 arg10 = &temp10( 0, 0 );
11966 if (
_n_dims( args(7) ) > 1 )
11974 temp11 = args(7).matrix_value();
11975 arg11 = &temp11( 0, 0 );
11977 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11978 _outv = octave_value();
12006 return octave_value_list();
12050 octave_value_list _out;
12051 octave_value_list *_outp=&_out;
12052 octave_value _outv;
12059 if (
_n_dims( args(0) ) > 2 )
12061 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12063 temp1 = args(0).matrix_value();
12064 arg1 = &temp1( 0, 0 );
12072 arg4 =
static_cast< PLINT >(val4);
12077 arg5 =
static_cast< PLINT >(val5);
12082 arg6 =
static_cast< PLINT >(val6);
12087 arg7 =
static_cast< PLINT >(val7);
12089 if (
_n_dims( args(5) ) > 1 )
12093 temp8 = args(5).matrix_value();
12094 arg8 = &temp8( 0, 0 );
12098 if (
_n_dims( args(6) ) > 2 )
12100 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12104 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12108 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12110 temp10 = args(6).matrix_value();
12111 arg10 = &temp10( 0, 0 );
12114 if (
_n_dims( args(7) ) > 2 )
12116 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12120 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12124 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12126 temp11 = args(7).matrix_value();
12127 arg11 = &temp11( 0, 0 );
12129 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12130 _outv = octave_value();
12158 return octave_value_list();
12202 octave_value_list _out;
12203 octave_value_list *_outp=&_out;
12204 octave_value _outv;
12211 if (
_n_dims( args(0) ) > 2 )
12213 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12215 temp1 = args(0).matrix_value();
12216 arg1 = &temp1( 0, 0 );
12224 arg4 =
static_cast< PLINT >(val4);
12229 arg5 =
static_cast< PLINT >(val5);
12234 arg6 =
static_cast< PLINT >(val6);
12239 arg7 =
static_cast< PLINT >(val7);
12241 if (
_n_dims( args(5) ) > 1 )
12245 temp8 = args(5).matrix_value();
12246 arg8 = &temp8( 0, 0 );
12250 if (
_n_dims( args(6) ) > 2 )
12252 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12256 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12260 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12262 temp10 = args(6).matrix_value();
12263 arg10 = &temp10( 0, 0 );
12266 if (
_n_dims( args(7) ) > 2 )
12268 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12272 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12276 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12278 temp11 = args(7).matrix_value();
12279 arg11 = &temp11( 0, 0 );
12281 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12282 _outv = octave_value();
12310 return octave_value_list();
12347 octave_value_list retval7 ;
12352 octave_value_list _out;
12353 octave_value_list *_outp=&_out;
12354 octave_value _outv;
12361 if (
_n_dims( args(0) ) > 1 )
12366 temp1 = args(0).matrix_value();
12367 arg1 = &temp1( 0, 0 );
12370 if (
_n_dims( args(1) ) > 1 )
12378 temp2 = args(1).matrix_value();
12379 arg2 = &temp2( 0, 0 );
12382 if (
_n_dims( args(2) ) > 1 )
12390 temp3 = args(2).matrix_value();
12391 arg3 = &temp3( 0, 0 );
12395 if (
_n_dims( args(3) ) > 1 )
12399 temp5 = args(3).matrix_value();
12400 arg5 = &temp5( 0, 0 );
12404 if (
_n_dims( args(4) ) > 1 )
12408 temp7 = args(4).matrix_value();
12409 arg7 = &temp7( 0, 0 );
12411 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12412 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12418 arg10 =
static_cast< PLINT >(val10);
12423 arg11 =
static_cast< PLFLT >(val11);
12424 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12425 _outv = octave_value();
12462 return octave_value_list();
12497 octave_value_list _out;
12498 octave_value_list *_outp=&_out;
12499 octave_value _outv;
12506 if (
_n_dims( args(0) ) > 1 )
12510 temp1 = args(0).matrix_value();
12511 arg1 = &temp1( 0, 0 );
12515 if (
_n_dims( args(1) ) > 1 )
12519 temp2 = args(1).matrix_value();
12520 arg2 = &temp2( 0, 0 );
12524 if (
_n_dims( args(2) ) > 2 )
12526 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12530 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12534 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12536 temp3 = args(2).matrix_value();
12537 arg3 = &temp3( 0, 0 );
12545 arg6 =
static_cast< PLINT >(val6);
12546 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12547 _outv = octave_value();
12569 return octave_value_list();
12601 octave_value_list _out;
12602 octave_value_list *_outp=&_out;
12603 octave_value _outv;
12610 if (
_n_dims( args(0) ) > 1 )
12614 temp1 = args(0).matrix_value();
12615 arg1 = &temp1( 0, 0 );
12619 if (
_n_dims( args(1) ) > 1 )
12623 temp2 = args(1).matrix_value();
12624 arg2 = &temp2( 0, 0 );
12628 if (
_n_dims( args(2) ) > 2 )
12630 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12634 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12638 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12640 temp3 = args(2).matrix_value();
12641 arg3 = &temp3( 0, 0 );
12649 arg6 =
static_cast< PLINT >(val6);
12651 if (
_n_dims( args(4) ) > 1 )
12655 temp7 = args(4).matrix_value();
12656 arg7 = &temp7( 0, 0 );
12659 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12660 _outv = octave_value();
12688 return octave_value_list();
12723 octave_value_list _out;
12724 octave_value_list *_outp=&_out;
12725 octave_value _outv;
12732 if (
_n_dims( args(0) ) > 1 )
12736 temp1 = args(0).matrix_value();
12737 arg1 = &temp1( 0, 0 );
12741 if (
_n_dims( args(1) ) > 1 )
12745 temp2 = args(1).matrix_value();
12746 arg2 = &temp2( 0, 0 );
12750 if (
_n_dims( args(2) ) > 2 )
12752 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12756 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12760 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12762 temp3 = args(2).matrix_value();
12763 arg3 = &temp3( 0, 0 );
12771 arg6 =
static_cast< PLINT >(val6);
12776 arg7 =
static_cast< PLBOOL >(val7);
12777 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12778 _outv = octave_value();
12800 return octave_value_list();
12832 octave_value_list _out;
12833 octave_value_list *_outp=&_out;
12834 octave_value _outv;
12841 if (
_n_dims( args(0) ) > 1 )
12845 temp1 = args(0).matrix_value();
12846 arg1 = &temp1( 0, 0 );
12850 if (
_n_dims( args(1) ) > 1 )
12854 temp2 = args(1).matrix_value();
12855 arg2 = &temp2( 0, 0 );
12859 if (
_n_dims( args(2) ) > 2 )
12861 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12865 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12869 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12871 temp3 = args(2).matrix_value();
12872 arg3 = &temp3( 0, 0 );
12880 arg6 =
static_cast< PLINT >(val6);
12882 if (
_n_dims( args(4) ) > 1 )
12886 temp7 = args(4).matrix_value();
12887 arg7 = &temp7( 0, 0 );
12890 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12891 _outv = octave_value();
12919 return octave_value_list();
12962 octave_value_list _out;
12963 octave_value_list *_outp=&_out;
12964 octave_value _outv;
12971 if (
_n_dims( args(0) ) > 1 )
12975 temp1 = args(0).matrix_value();
12976 arg1 = &temp1( 0, 0 );
12980 if (
_n_dims( args(1) ) > 1 )
12984 temp2 = args(1).matrix_value();
12985 arg2 = &temp2( 0, 0 );
12989 if (
_n_dims( args(2) ) > 2 )
12991 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12995 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12999 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13001 temp3 = args(2).matrix_value();
13002 arg3 = &temp3( 0, 0 );
13010 arg6 =
static_cast< PLINT >(val6);
13012 if (
_n_dims( args(4) ) > 1 )
13016 temp7 = args(4).matrix_value();
13017 arg7 = &temp7( 0, 0 );
13024 arg9 =
static_cast< PLINT >(val9);
13026 if (
_n_dims( args(6) ) > 1 )
13032 temp10 = args(6).matrix_value();
13036 if (
_n_dims( args(7) ) > 1 )
13044 temp12 = args(7).matrix_value();
13048 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);
13049 _outv = octave_value();
13089 return octave_value_list();
13130 octave_value_list _out;
13131 octave_value_list *_outp=&_out;
13132 octave_value _outv;
13139 if (
_n_dims( args(0) ) > 1 )
13143 temp1 = args(0).matrix_value();
13144 arg1 = &temp1( 0, 0 );
13148 if (
_n_dims( args(1) ) > 1 )
13152 temp2 = args(1).matrix_value();
13153 arg2 = &temp2( 0, 0 );
13157 if (
_n_dims( args(2) ) > 2 )
13159 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13163 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13167 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13169 temp3 = args(2).matrix_value();
13170 arg3 = &temp3( 0, 0 );
13178 arg6 =
static_cast< PLINT >(val6);
13180 if (
_n_dims( args(4) ) > 1 )
13184 temp7 = args(4).matrix_value();
13185 arg7 = &temp7( 0, 0 );
13188 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13189 _outv = octave_value();
13217 return octave_value_list();
13260 octave_value_list _out;
13261 octave_value_list *_outp=&_out;
13262 octave_value _outv;
13269 if (
_n_dims( args(0) ) > 1 )
13273 temp1 = args(0).matrix_value();
13274 arg1 = &temp1( 0, 0 );
13278 if (
_n_dims( args(1) ) > 1 )
13282 temp2 = args(1).matrix_value();
13283 arg2 = &temp2( 0, 0 );
13287 if (
_n_dims( args(2) ) > 2 )
13289 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13293 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13297 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13299 temp3 = args(2).matrix_value();
13300 arg3 = &temp3( 0, 0 );
13308 arg6 =
static_cast< PLINT >(val6);
13310 if (
_n_dims( args(4) ) > 1 )
13314 temp7 = args(4).matrix_value();
13315 arg7 = &temp7( 0, 0 );
13322 arg9 =
static_cast< PLINT >(val9);
13324 if (
_n_dims( args(6) ) > 1 )
13330 temp10 = args(6).matrix_value();
13334 if (
_n_dims( args(7) ) > 1 )
13342 temp12 = args(7).matrix_value();
13346 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);
13347 _outv = octave_value();
13387 return octave_value_list();
13464 octave_value_list _out;
13465 octave_value_list *_outp=&_out;
13466 octave_value _outv;
13473 if (
_n_dims( args(0) ) > 2 )
13475 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13477 temp1 = args(0).matrix_value();
13478 arg1 = &temp1( 0, 0 );
13483 if (
_n_dims( args(1) ) > 1 )
13488 temp4 = args(1).matrix_value();
13489 arg4 = &temp4( 0, 0 );
13495 arg5 =
static_cast< PLFLT >(val5);
13500 arg6 =
static_cast< PLFLT >(val6);
13505 arg7 =
static_cast< PLFLT >(val7);
13510 arg8 =
static_cast< PLFLT >(val8);
13515 arg9 =
static_cast< PLFLT >(val9);
13520 arg10 =
static_cast< PLFLT >(val10);
13525 arg11 =
static_cast< PLINT >(val11);
13530 arg12 =
static_cast< PLFLT >(val12);
13535 arg13 =
static_cast< PLINT >(val13);
13540 arg14 =
static_cast< PLINT >(val14);
13545 arg15 =
static_cast< PLINT >(val15);
13550 arg16 =
static_cast< PLINT >(val16);
13555 arg17 =
static_cast< PLINT >(val17);
13560 arg18 =
static_cast< PLBOOL >(val18);
13562 if (
_n_dims( args(16) ) > 1 )
13566 if (
_dim( args(16), 0 ) != 6 )
13570 temp19 = args(16).matrix_value();
13571 arg19 = &temp19( 0, 0 );
13573 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);
13574 _outv = octave_value();
13596 return octave_value_list();
13617 char *arg4 = (
char *) 0 ;
13668 octave_value_list _out;
13669 octave_value_list *_outp=&_out;
13670 octave_value _outv;
13677 if (
_n_dims( args(0) ) > 2 )
13679 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13681 temp1 = args(0).matrix_value();
13682 arg1 = &temp1( 0, 0 );
13690 arg4 =
reinterpret_cast< char *
>(buf4);
13695 arg5 =
static_cast< PLFLT >(val5);
13700 arg6 =
static_cast< PLFLT >(val6);
13705 arg7 =
static_cast< PLFLT >(val7);
13710 arg8 =
static_cast< PLFLT >(val8);
13715 arg9 =
static_cast< PLFLT >(val9);
13720 arg10 =
static_cast< PLFLT >(val10);
13725 arg11 =
static_cast< PLINT >(val11);
13730 arg12 =
static_cast< PLFLT >(val12);
13735 arg13 =
static_cast< PLINT >(val13);
13740 arg14 =
static_cast< PLINT >(val14);
13745 arg15 =
static_cast< PLINT >(val15);
13750 arg16 =
static_cast< PLINT >(val16);
13755 arg17 =
static_cast< PLINT >(val17);
13760 arg18 =
static_cast< PLBOOL >(val18);
13762 if (
_n_dims( args(16) ) > 1 )
13766 if (
_dim( args(16), 0 ) !=
Xlen )
13770 temp19 = args(16).matrix_value();
13771 arg19 = &temp19( 0, 0 );
13774 if (
_n_dims( args(17) ) > 1 )
13778 if (
_dim( args(17), 0 ) !=
Ylen )
13782 temp20 = args(17).matrix_value();
13783 arg20 = &temp20( 0, 0 );
13785 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);
13786 _outv = octave_value();
13810 return octave_value_list();
13832 char *arg4 = (
char *) 0 ;
13883 octave_value_list _out;
13884 octave_value_list *_outp=&_out;
13885 octave_value _outv;
13892 if (
_n_dims( args(0) ) > 2 )
13894 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13896 temp1 = args(0).matrix_value();
13897 arg1 = &temp1( 0, 0 );
13905 arg4 =
reinterpret_cast< char *
>(buf4);
13910 arg5 =
static_cast< PLFLT >(val5);
13915 arg6 =
static_cast< PLFLT >(val6);
13920 arg7 =
static_cast< PLFLT >(val7);
13925 arg8 =
static_cast< PLFLT >(val8);
13930 arg9 =
static_cast< PLFLT >(val9);
13935 arg10 =
static_cast< PLFLT >(val10);
13940 arg11 =
static_cast< PLINT >(val11);
13945 arg12 =
static_cast< PLFLT >(val12);
13950 arg13 =
static_cast< PLINT >(val13);
13955 arg14 =
static_cast< PLINT >(val14);
13960 arg15 =
static_cast< PLINT >(val15);
13965 arg16 =
static_cast< PLINT >(val16);
13970 arg17 =
static_cast< PLINT >(val17);
13975 arg18 =
static_cast< PLBOOL >(val18);
13977 if (
_n_dims( args(16) ) > 2 )
13979 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13981 temp19 = args(16).matrix_value();
13982 arg19 = &temp19( 0, 0 );
13987 if (
_n_dims( args(17) ) > 2 )
13989 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13991 temp20 = args(17).matrix_value();
13992 arg20 = &temp20( 0, 0 );
13996 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);
13997 _outv = octave_value();
14021 return octave_value_list();
14071 octave_value_list _out;
14072 octave_value_list *_outp=&_out;
14073 octave_value _outv;
14080 if (
_n_dims( args(0) ) > 2 )
14082 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14084 temp1 = args(0).matrix_value();
14085 arg1 = &temp1( 0, 0 );
14093 arg4 =
static_cast< PLFLT >(val4);
14098 arg5 =
static_cast< PLFLT >(val5);
14103 arg6 =
static_cast< PLFLT >(val6);
14108 arg7 =
static_cast< PLFLT >(val7);
14110 if (
_n_dims( args(5) ) > 1 )
14114 temp8 = args(5).matrix_value();
14115 arg8 = &temp8( 0, 0 );
14122 arg10 =
static_cast< PLINT >(val10);
14127 arg11 =
static_cast< PLINT >(val11);
14132 arg12 =
static_cast< PLINT >(val12);
14137 arg13 =
static_cast< PLBOOL >(val13);
14138 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14139 _outv = octave_value();
14155 return octave_value_list();
14203 octave_value_list _out;
14204 octave_value_list *_outp=&_out;
14205 octave_value _outv;
14212 if (
_n_dims( args(0) ) > 2 )
14214 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14216 temp1 = args(0).matrix_value();
14217 arg1 = &temp1( 0, 0 );
14225 arg4 =
static_cast< PLFLT >(val4);
14230 arg5 =
static_cast< PLFLT >(val5);
14235 arg6 =
static_cast< PLFLT >(val6);
14240 arg7 =
static_cast< PLFLT >(val7);
14242 if (
_n_dims( args(5) ) > 1 )
14246 temp8 = args(5).matrix_value();
14247 arg8 = &temp8( 0, 0 );
14254 arg10 =
static_cast< PLINT >(val10);
14259 arg11 =
static_cast< PLINT >(val11);
14264 arg12 =
static_cast< PLINT >(val12);
14269 arg13 =
static_cast< PLBOOL >(val13);
14271 if (
_n_dims( args(10) ) > 1 )
14275 if (
_dim( args(10), 0 ) != 6 )
14279 temp14 = args(10).matrix_value();
14280 arg14 = &temp14( 0, 0 );
14282 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14283 _outv = octave_value();
14305 return octave_value_list();
14358 octave_value_list _out;
14359 octave_value_list *_outp=&_out;
14360 octave_value _outv;
14367 if (
_n_dims( args(0) ) > 2 )
14369 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14371 temp1 = args(0).matrix_value();
14372 arg1 = &temp1( 0, 0 );
14380 arg4 =
static_cast< PLFLT >(val4);
14385 arg5 =
static_cast< PLFLT >(val5);
14390 arg6 =
static_cast< PLFLT >(val6);
14395 arg7 =
static_cast< PLFLT >(val7);
14397 if (
_n_dims( args(5) ) > 1 )
14401 temp8 = args(5).matrix_value();
14402 arg8 = &temp8( 0, 0 );
14409 arg10 =
static_cast< PLINT >(val10);
14414 arg11 =
static_cast< PLINT >(val11);
14419 arg12 =
static_cast< PLINT >(val12);
14424 arg13 =
static_cast< PLBOOL >(val13);
14426 if (
_n_dims( args(10) ) > 1 )
14430 if (
_dim( args(10), 0 ) !=
Xlen )
14434 temp14 = args(10).matrix_value();
14435 arg14 = &temp14( 0, 0 );
14438 if (
_n_dims( args(11) ) > 1 )
14442 if (
_dim( args(11), 0 ) !=
Ylen )
14446 temp15 = args(11).matrix_value();
14447 arg15 = &temp15( 0, 0 );
14449 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);
14450 _outv = octave_value();
14478 return octave_value_list();
14534 octave_value_list _out;
14535 octave_value_list *_outp=&_out;
14536 octave_value _outv;
14543 if (
_n_dims( args(0) ) > 2 )
14545 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14547 temp1 = args(0).matrix_value();
14548 arg1 = &temp1( 0, 0 );
14556 arg4 =
static_cast< PLFLT >(val4);
14561 arg5 =
static_cast< PLFLT >(val5);
14566 arg6 =
static_cast< PLFLT >(val6);
14571 arg7 =
static_cast< PLFLT >(val7);
14573 if (
_n_dims( args(5) ) > 1 )
14577 temp8 = args(5).matrix_value();
14578 arg8 = &temp8( 0, 0 );
14585 arg10 =
static_cast< PLINT >(val10);
14590 arg11 =
static_cast< PLINT >(val11);
14595 arg12 =
static_cast< PLINT >(val12);
14600 arg13 =
static_cast< PLBOOL >(val13);
14602 if (
_n_dims( args(10) ) > 2 )
14604 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14606 temp14 = args(10).matrix_value();
14607 arg14 = &temp14( 0, 0 );
14612 if (
_n_dims( args(11) ) > 2 )
14614 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14616 temp15 = args(11).matrix_value();
14617 arg15 = &temp15( 0, 0 );
14621 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);
14622 _outv = octave_value();
14650 return octave_value_list();
14682 octave_value_list _out;
14683 octave_value_list *_outp=&_out;
14684 octave_value _outv;
14691 if (
_n_dims( args(0) ) > 2 )
14693 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14695 temp1 = args(0).matrix_value();
14696 arg1 = &temp1( 0, 0 );
14701 if (
_n_dims( args(1) ) > 2 )
14703 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14707 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14711 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14713 temp2 = args(1).matrix_value();
14714 arg2 = &temp2( 0, 0 );
14722 arg5 =
static_cast< PLFLT >(val5);
14724 if (
_n_dims( args(3) ) > 1 )
14728 if (
_dim( args(3), 0 ) != 6 )
14732 temp6 = args(3).matrix_value();
14733 arg6 = &temp6( 0, 0 );
14735 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14736 _outv = octave_value();
14758 return octave_value_list();
14789 octave_value_list _out;
14790 octave_value_list *_outp=&_out;
14791 octave_value _outv;
14798 if (
_n_dims( args(0) ) > 2 )
14800 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14802 temp1 = args(0).matrix_value();
14803 arg1 = &temp1( 0, 0 );
14808 if (
_n_dims( args(1) ) > 2 )
14810 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14814 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14818 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14820 temp2 = args(1).matrix_value();
14821 arg2 = &temp2( 0, 0 );
14829 arg5 =
static_cast< PLFLT >(val5);
14831 if (
_n_dims( args(3) ) > 1 )
14839 temp6 = args(3).matrix_value();
14840 arg6 = &temp6( 0, 0 );
14843 if (
_n_dims( args(4) ) > 1 )
14851 temp7 = args(4).matrix_value();
14852 arg7 = &temp7( 0, 0 );
14854 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14855 _outv = octave_value();
14883 return octave_value_list();
14917 octave_value_list _out;
14918 octave_value_list *_outp=&_out;
14919 octave_value _outv;
14926 if (
_n_dims( args(0) ) > 2 )
14928 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14930 temp1 = args(0).matrix_value();
14931 arg1 = &temp1( 0, 0 );
14936 if (
_n_dims( args(1) ) > 2 )
14938 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14942 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14946 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14948 temp2 = args(1).matrix_value();
14949 arg2 = &temp2( 0, 0 );
14957 arg5 =
static_cast< PLFLT >(val5);
14959 if (
_n_dims( args(3) ) > 2 )
14961 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14963 temp6 = args(3).matrix_value();
14964 arg6 = &temp6( 0, 0 );
14969 if (
_n_dims( args(4) ) > 2 )
14971 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14973 temp7 = args(4).matrix_value();
14974 arg7 = &temp7( 0, 0 );
14978 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14979 _outv = octave_value();
15007 return octave_value_list();
15062 octave_value_list _out;
15063 octave_value_list *_outp=&_out;
15064 octave_value _outv;
15071 if (
_n_dims( args(0) ) > 2 )
15073 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15075 temp1 = args(0).matrix_value();
15076 arg1 = &temp1( 0, 0 );
15084 arg4 =
static_cast< PLFLT >(val4);
15089 arg5 =
static_cast< PLFLT >(val5);
15094 arg6 =
static_cast< PLFLT >(val6);
15099 arg7 =
static_cast< PLFLT >(val7);
15104 arg8 =
static_cast< PLFLT >(val8);
15109 arg9 =
static_cast< PLFLT >(val9);
15114 arg10 =
static_cast< PLFLT >(val10);
15119 arg11 =
static_cast< PLFLT >(val11);
15124 arg12 =
static_cast< PLFLT >(val12);
15129 arg13 =
static_cast< PLFLT >(val13);
15130 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15131 _outv = octave_value();
15141 return octave_value_list();
15181 octave_value_list _out;
15182 octave_value_list *_outp=&_out;
15183 octave_value _outv;
15190 if (
_n_dims( args(0) ) > 2 )
15192 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15194 temp1 = args(0).matrix_value();
15195 arg1 = &temp1( 0, 0 );
15203 arg4 =
static_cast< PLFLT >(val4);
15208 arg5 =
static_cast< PLFLT >(val5);
15213 arg6 =
static_cast< PLFLT >(val6);
15218 arg7 =
static_cast< PLFLT >(val7);
15223 arg8 =
static_cast< PLFLT >(val8);
15228 arg9 =
static_cast< PLFLT >(val9);
15233 arg10 =
static_cast< PLFLT >(val10);
15238 arg11 =
static_cast< PLFLT >(val11);
15239 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15240 _outv = octave_value();
15250 return octave_value_list();
15292 octave_value_list _out;
15293 octave_value_list *_outp=&_out;
15294 octave_value _outv;
15301 if (
_n_dims( args(0) ) > 2 )
15303 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15305 temp1 = args(0).matrix_value();
15306 arg1 = &temp1( 0, 0 );
15314 arg4 =
static_cast< PLFLT >(val4);
15319 arg5 =
static_cast< PLFLT >(val5);
15324 arg6 =
static_cast< PLFLT >(val6);
15329 arg7 =
static_cast< PLFLT >(val7);
15334 arg8 =
static_cast< PLFLT >(val8);
15339 arg9 =
static_cast< PLFLT >(val9);
15344 arg10 =
static_cast< PLFLT >(val10);
15349 arg11 =
static_cast< PLFLT >(val11);
15351 if (
_n_dims( args(9) ) > 1 )
15355 if (
_dim( args(9), 0 ) != 6 )
15359 temp12 = args(9).matrix_value();
15360 arg12 = &temp12( 0, 0 );
15362 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15363 _outv = octave_value();
15379 return octave_value_list();
15426 octave_value_list _out;
15427 octave_value_list *_outp=&_out;
15428 octave_value _outv;
15435 if (
_n_dims( args(0) ) > 2 )
15437 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15439 temp1 = args(0).matrix_value();
15440 arg1 = &temp1( 0, 0 );
15448 arg4 =
static_cast< PLFLT >(val4);
15453 arg5 =
static_cast< PLFLT >(val5);
15458 arg6 =
static_cast< PLFLT >(val6);
15463 arg7 =
static_cast< PLFLT >(val7);
15468 arg8 =
static_cast< PLFLT >(val8);
15473 arg9 =
static_cast< PLFLT >(val9);
15478 arg10 =
static_cast< PLFLT >(val10);
15483 arg11 =
static_cast< PLFLT >(val11);
15485 if (
_n_dims( args(9) ) > 1 )
15493 temp12 = args(9).matrix_value();
15494 arg12 = &temp12( 0, 0 );
15497 if (
_n_dims( args(10) ) > 1 )
15501 if (
_dim( args(10), 0 ) !=
Ylen )
15505 temp13 = args(10).matrix_value();
15506 arg13 = &temp13( 0, 0 );
15508 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15509 _outv = octave_value();
15531 return octave_value_list();
15581 octave_value_list _out;
15582 octave_value_list *_outp=&_out;
15583 octave_value _outv;
15590 if (
_n_dims( args(0) ) > 2 )
15592 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15594 temp1 = args(0).matrix_value();
15595 arg1 = &temp1( 0, 0 );
15603 arg4 =
static_cast< PLFLT >(val4);
15608 arg5 =
static_cast< PLFLT >(val5);
15613 arg6 =
static_cast< PLFLT >(val6);
15618 arg7 =
static_cast< PLFLT >(val7);
15623 arg8 =
static_cast< PLFLT >(val8);
15628 arg9 =
static_cast< PLFLT >(val9);
15633 arg10 =
static_cast< PLFLT >(val10);
15638 arg11 =
static_cast< PLFLT >(val11);
15640 if (
_n_dims( args(9) ) > 2 )
15642 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15644 temp12 = args(9).matrix_value();
15645 arg12 = &temp12( 0, 0 );
15650 if (
_n_dims( args(10) ) > 2 )
15652 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15654 temp13 = args(10).matrix_value();
15655 arg13 = &temp13( 0, 0 );
15659 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15660 _outv = octave_value();
15682 return octave_value_list();
15717 char **arg18 = (
char **) 0 ;
15719 char **arg20 = (
char **) 0 ;
15759 octave_value_list _out;
15760 octave_value_list *_outp=&_out;
15761 octave_value _outv;
15773 arg3 =
static_cast< PLINT >(val3);
15778 arg4 =
static_cast< PLINT >(val4);
15783 arg5 =
static_cast< PLFLT >(val5);
15788 arg6 =
static_cast< PLFLT >(val6);
15793 arg7 =
static_cast< PLFLT >(val7);
15798 arg8 =
static_cast< PLFLT >(val8);
15803 arg9 =
static_cast< PLINT >(val9);
15808 arg10 =
static_cast< PLINT >(val10);
15813 arg11 =
static_cast< PLINT >(val11);
15818 arg12 =
static_cast< PLFLT >(val12);
15823 arg13 =
static_cast< PLFLT >(val13);
15828 arg14 =
static_cast< PLINT >(val14);
15833 arg15 =
static_cast< PLFLT >(val15);
15835 if (
_n_dims( args(13) ) > 1 )
15841 temp16 = args(13).matrix_value();
15845 charMatrix temp_matrix;
15849 size_t max_length = 0, non_blank_length;
15851 if (
_n_dims( args(14) ) > 2 )
15853 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15856 if ( !args(14).isempty() )
15858 if ( !args(14).is_empty() )
15861 if (
_dim( args(14), 0 ) !=
Alen )
15863 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15865 arg18 =
new char*[
Alen];
15866#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15867 ifcell = args(14).iscell();
15869 ifcell = args(14).is_cell();
15873 temp_cell = args(14).cell_value();
15877 temp_matrix = args(14).char_matrix_value();
15879 max_length =
_dim( args(14), 1 ) + 1;
15882 for ( i = 0; i <
Alen; i++ )
15889 if ( temp_cell.elem( i ).is_string() )
15891 str = temp_cell.elem( i ).string_value();
15893 max_length = str.size() + 1;
15894 tmp_cstring = (
char *) str.c_str();
15904 tmp_cstring = (
char *)
"";
15909 str = temp_matrix.row_as_string( i );
15910 tmp_cstring = (
char *) str.c_str();
15912 arg18[i] =
new char[max_length];
15913 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15914 arg18[i][max_length - 1] =
'\0';
15929 non_blank_length = max_length - 2;
15930 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15932 non_blank_length--;
15934 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15936 non_blank_length--;
15938 arg18[i][non_blank_length + 1] =
'\0';
15948 charMatrix temp_matrix;
15952 size_t max_length = 0, non_blank_length;
15954 if (
_n_dims( args(15) ) > 2 )
15956 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15958#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15959 if ( !args(15).isempty() )
15961 if ( !args(15).is_empty() )
15966 arg20 =
new char*[
Alen];
15967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15968 ifcell = args(15).iscell();
15970 ifcell = args(15).is_cell();
15974 temp_cell = args(15).cell_value();
15978 temp_matrix = args(15).char_matrix_value();
15980 max_length =
_dim( args(15), 1 ) + 1;
15983 for ( i = 0; i <
Alen; i++ )
15990 if ( temp_cell.elem( i ).is_string() )
15992 str = temp_cell.elem( i ).string_value();
15994 max_length = str.size() + 1;
15995 tmp_cstring = (
char *) str.c_str();
16005 tmp_cstring = (
char *)
"";
16010 str = temp_matrix.row_as_string( i );
16011 tmp_cstring = (
char *) str.c_str();
16013 arg20[i] =
new char[max_length];
16014 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16015 arg20[i][max_length - 1] =
'\0';
16030 non_blank_length = max_length - 2;
16031 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16033 non_blank_length--;
16035 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16037 non_blank_length--;
16039 arg20[i][non_blank_length + 1] =
'\0';
16050 if (
_n_dims( args(16) ) > 1 )
16054 if (
_dim( args(16), 0 ) !=
Alen )
16058 temp21 = args(16).matrix_value();
16059 arg21 = &temp21( 0, 0 );
16062 if (
_n_dims( args(17) ) > 1 )
16066 if (
_dim( args(17), 0 ) !=
Alen )
16070 temp22 = args(17).matrix_value();
16076 if (
_n_dims( args(18) ) > 1 )
16080 if (
_dim( args(18), 0 ) !=
Alen )
16085 temp23 = args(18).matrix_value();
16089 for ( i = 0; i <
Xlen; i++ )
16090 if ( arg23[i] >
Ylen )
16094 if (
_n_dims( args(19) ) > 2 )
16096 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16098 if (
_dim( args(19), 0 ) !=
Xlen )
16100 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16102 if (
_dim( args(19), 1 ) !=
Ylen )
16104 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16106 temp24 = args(19).matrix_value();
16107 arg24 = &temp24( 0, 0 );
16109 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);
16110 _outv = octave_value();
16129 if ( arg18 != NULL )
16131 for ( i = 0; i <
Alen; i++ )
16140 if ( arg20 != NULL )
16142 for ( i = 0; i <
Alen; i++ )
16168 if ( arg18 != NULL )
16170 for ( i = 0; i <
Alen; i++ )
16179 if ( arg20 != NULL )
16181 for ( i = 0; i <
Alen; i++ )
16200 return octave_value_list();
16208 if ( arg18 != NULL )
16210 for ( i = 0; i <
Alen; i++ )
16219 if ( arg20 != NULL )
16221 for ( i = 0; i <
Alen; i++ )
16252 octave_value_list _out;
16253 octave_value_list *_outp=&_out;
16254 octave_value _outv;
16269 arg2 =
static_cast< int >(val2);
16270 if (arg1) (arg1)->type = arg2;
16271 _outv = octave_value();
16275 return octave_value_list();
16287 octave_value_list _out;
16288 octave_value_list *_outp=&_out;
16289 octave_value _outv;
16301 result = (int) ((arg1)->type);
16306 return octave_value_list();
16316 unsigned int arg2 ;
16319 unsigned int val2 ;
16321 octave_value_list _out;
16322 octave_value_list *_outp=&_out;
16323 octave_value _outv;
16338 arg2 =
static_cast< unsigned int >(val2);
16339 if (arg1) (arg1)->state = arg2;
16340 _outv = octave_value();
16344 return octave_value_list();
16356 octave_value_list _out;
16357 octave_value_list *_outp=&_out;
16358 octave_value _outv;
16359 unsigned int result;
16370 result = (
unsigned int) ((arg1)->state);
16375 return octave_value_list();
16385 unsigned int arg2 ;
16388 unsigned int val2 ;
16390 octave_value_list _out;
16391 octave_value_list *_outp=&_out;
16392 octave_value _outv;
16407 arg2 =
static_cast< unsigned int >(val2);
16408 if (arg1) (arg1)->keysym = arg2;
16409 _outv = octave_value();
16413 return octave_value_list();
16425 octave_value_list _out;
16426 octave_value_list *_outp=&_out;
16427 octave_value _outv;
16428 unsigned int result;
16439 result = (
unsigned int) ((arg1)->keysym);
16444 return octave_value_list();
16454 unsigned int arg2 ;
16457 unsigned int val2 ;
16459 octave_value_list _out;
16460 octave_value_list *_outp=&_out;
16461 octave_value _outv;
16476 arg2 =
static_cast< unsigned int >(val2);
16477 if (arg1) (arg1)->button = arg2;
16478 _outv = octave_value();
16482 return octave_value_list();
16494 octave_value_list _out;
16495 octave_value_list *_outp=&_out;
16496 octave_value _outv;
16497 unsigned int result;
16508 result = (
unsigned int) ((arg1)->button);
16513 return octave_value_list();
16528 octave_value_list _out;
16529 octave_value_list *_outp=&_out;
16530 octave_value _outv;
16545 arg2 =
static_cast< PLINT >(val2);
16546 if (arg1) (arg1)->subwindow = arg2;
16547 _outv = octave_value();
16551 return octave_value_list();
16563 octave_value_list _out;
16564 octave_value_list *_outp=&_out;
16565 octave_value _outv;
16577 result = (
PLINT) ((arg1)->subwindow);
16582 return octave_value_list();
16592 char *arg2 = (
char *) (
char *)0 ;
16597 octave_value_list _out;
16598 octave_value_list *_outp=&_out;
16599 octave_value _outv;
16614 arg2 =
reinterpret_cast< char *
>(temp2);
16615 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16616 else memset(arg1->
string,0,16*
sizeof(
char));
16617 _outv = octave_value();
16621 return octave_value_list();
16633 octave_value_list _out;
16634 octave_value_list *_outp=&_out;
16635 octave_value _outv;
16647 result = (
char *)(
char *) ((arg1)->string);
16658 return octave_value_list();
16673 octave_value_list _out;
16674 octave_value_list *_outp=&_out;
16675 octave_value _outv;
16690 arg2 =
static_cast< int >(val2);
16691 if (arg1) (arg1)->pX = arg2;
16692 _outv = octave_value();
16696 return octave_value_list();
16708 octave_value_list _out;
16709 octave_value_list *_outp=&_out;
16710 octave_value _outv;
16722 result = (int) ((arg1)->pX);
16727 return octave_value_list();
16742 octave_value_list _out;
16743 octave_value_list *_outp=&_out;
16744 octave_value _outv;
16759 arg2 =
static_cast< int >(val2);
16760 if (arg1) (arg1)->pY = arg2;
16761 _outv = octave_value();
16765 return octave_value_list();
16777 octave_value_list _out;
16778 octave_value_list *_outp=&_out;
16779 octave_value _outv;
16791 result = (int) ((arg1)->pY);
16796 return octave_value_list();
16811 octave_value_list _out;
16812 octave_value_list *_outp=&_out;
16813 octave_value _outv;
16828 arg2 =
static_cast< PLFLT >(val2);
16829 if (arg1) (arg1)->dX = arg2;
16830 _outv = octave_value();
16834 return octave_value_list();
16846 octave_value_list _out;
16847 octave_value_list *_outp=&_out;
16848 octave_value _outv;
16860 result = (
PLFLT) ((arg1)->dX);
16865 return octave_value_list();
16880 octave_value_list _out;
16881 octave_value_list *_outp=&_out;
16882 octave_value _outv;
16897 arg2 =
static_cast< PLFLT >(val2);
16898 if (arg1) (arg1)->dY = arg2;
16899 _outv = octave_value();
16903 return octave_value_list();
16915 octave_value_list _out;
16916 octave_value_list *_outp=&_out;
16917 octave_value _outv;
16929 result = (
PLFLT) ((arg1)->dY);
16934 return octave_value_list();
16949 octave_value_list _out;
16950 octave_value_list *_outp=&_out;
16951 octave_value _outv;
16966 arg2 =
static_cast< PLFLT >(val2);
16967 if (arg1) (arg1)->wX = arg2;
16968 _outv = octave_value();
16972 return octave_value_list();
16984 octave_value_list _out;
16985 octave_value_list *_outp=&_out;
16986 octave_value _outv;
16998 result = (
PLFLT) ((arg1)->wX);
17003 return octave_value_list();
17018 octave_value_list _out;
17019 octave_value_list *_outp=&_out;
17020 octave_value _outv;
17035 arg2 =
static_cast< PLFLT >(val2);
17036 if (arg1) (arg1)->wY = arg2;
17037 _outv = octave_value();
17041 return octave_value_list();
17053 octave_value_list _out;
17054 octave_value_list *_outp=&_out;
17055 octave_value _outv;
17067 result = (
PLFLT) ((arg1)->wY);
17072 return octave_value_list();
17081 octave_value_list _out;
17082 octave_value_list *_outp=&_out;
17083 octave_value _outv;
17095 return octave_value_list();
17107 octave_value_list _out;
17108 octave_value_list *_outp=&_out;
17109 octave_value _outv;
17121 _outv = octave_value();
17125 return octave_value_list();
17159 octave_value_list _out;
17160 octave_value_list *_outp=&_out;
17161 octave_value _outv;
17171 arg1 =
static_cast< PLINT >(val1);
17176 arg2 =
static_cast< PLINT >(val2);
17178 _outv = octave_value();
17182 return octave_value_list();
17203 octave_value_list _out;
17204 octave_value_list *_outp=&_out;
17205 octave_value _outv;
17215 arg1 =
static_cast< PLFLT >(val1);
17220 arg2 =
static_cast< PLFLT >(val2);
17225 arg3 =
static_cast< PLFLT >(val3);
17230 arg4 =
static_cast< PLINT >(val4);
17232 _outv = octave_value();
17236 return octave_value_list();
17248 octave_value_list _out;
17249 octave_value_list *_outp=&_out;
17250 octave_value _outv;
17260 arg1 =
static_cast< PLINT >(val1);
17262 _outv = octave_value();
17266 return octave_value_list();
17299 octave_value_list _out;
17300 octave_value_list *_outp=&_out;
17301 octave_value _outv;
17311 arg1 =
static_cast< PLFLT >(val1);
17316 arg2 =
static_cast< PLFLT >(val2);
17321 arg3 =
static_cast< PLFLT >(val3);
17326 arg4 =
static_cast< PLFLT >(val4);
17331 arg5 =
static_cast< PLFLT >(val5);
17336 arg6 =
static_cast< PLFLT >(val6);
17341 arg7 =
static_cast< PLFLT >(val7);
17346 arg8 =
static_cast< PLBOOL >(val8);
17347 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17348 _outv = octave_value();
17352 return octave_value_list();
17363 char *arg3 = (
char *) 0 ;
17366 char *arg6 = (
char *) 0 ;
17387 octave_value_list _out;
17388 octave_value_list *_outp=&_out;
17389 octave_value _outv;
17399 arg1 =
static_cast< PLFLT >(val1);
17404 arg2 =
static_cast< PLFLT >(val2);
17409 arg3 =
reinterpret_cast< char *
>(buf3);
17414 arg4 =
static_cast< PLFLT >(val4);
17419 arg5 =
static_cast< PLINT >(val5);
17424 arg6 =
reinterpret_cast< char *
>(buf6);
17429 arg7 =
static_cast< PLFLT >(val7);
17434 arg8 =
static_cast< PLINT >(val8);
17435 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17436 _outv = octave_value();
17444 return octave_value_list();
17463 octave_value_list _out;
17464 octave_value_list *_outp=&_out;
17465 octave_value _outv;
17472 if (
_n_dims( args(0) ) > 1 )
17477 temp1 = args(0).matrix_value();
17478 arg2 = &temp1( 0, 0 );
17481 if (
_n_dims( args(1) ) > 1 )
17489 temp3 = args(1).matrix_value();
17490 arg3 = &temp3( 0, 0 );
17496 arg4 =
static_cast< PLINT >(val4);
17497 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17498 _outv = octave_value();
17514 return octave_value_list();
17550 octave_value_list _out;
17551 octave_value_list *_outp=&_out;
17552 octave_value _outv;
17568 arg7 =
static_cast< PLFLT >(val7);
17569 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17570 _outv = octave_value();
17610 return octave_value_list();
17619 octave_value_list _out;
17620 octave_value_list *_outp=&_out;
17621 octave_value _outv;
17628 _outv = octave_value();
17632 return octave_value_list();
17641 char *arg1 = (
char *) 0 ;
17644 char *arg4 = (
char *) 0 ;
17661 octave_value_list _out;
17662 octave_value_list *_outp=&_out;
17663 octave_value _outv;
17673 arg1 =
reinterpret_cast< char *
>(buf1);
17678 arg2 =
static_cast< PLFLT >(val2);
17683 arg3 =
static_cast< PLINT >(val3);
17688 arg4 =
reinterpret_cast< char *
>(buf4);
17693 arg5 =
static_cast< PLFLT >(val5);
17698 arg6 =
static_cast< PLINT >(val6);
17699 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17700 _outv = octave_value();
17708 return octave_value_list();
17719 char *arg1 = (
char *) 0 ;
17720 char *arg2 = (
char *) 0 ;
17723 char *arg5 = (
char *) 0 ;
17724 char *arg6 = (
char *) 0 ;
17727 char *arg9 = (
char *) 0 ;
17728 char *arg10 = (
char *) 0 ;
17761 octave_value_list _out;
17762 octave_value_list *_outp=&_out;
17763 octave_value _outv;
17773 arg1 =
reinterpret_cast< char *
>(buf1);
17778 arg2 =
reinterpret_cast< char *
>(buf2);
17783 arg3 =
static_cast< PLFLT >(val3);
17788 arg4 =
static_cast< PLINT >(val4);
17793 arg5 =
reinterpret_cast< char *
>(buf5);
17798 arg6 =
reinterpret_cast< char *
>(buf6);
17803 arg7 =
static_cast< PLFLT >(val7);
17808 arg8 =
static_cast< PLINT >(val8);
17813 arg9 =
reinterpret_cast< char *
>(buf9);
17818 arg10 =
reinterpret_cast< char *
>(buf10);
17823 arg11 =
static_cast< PLFLT >(val11);
17828 arg12 =
static_cast< PLINT >(val12);
17829 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);
17830 _outv = octave_value();
17846 return octave_value_list();
17876 octave_value_list _out;
17877 octave_value_list *_outp=&_out;
17878 octave_value _outv;
17891 arg1 =
static_cast< PLFLT >(val1);
17896 arg2 =
static_cast< PLFLT >(val2);
17898 _outv = octave_value();
17920 return octave_value_list();
17929 octave_value_list _out;
17930 octave_value_list *_outp=&_out;
17931 octave_value _outv;
17938 _outv = octave_value();
17942 return octave_value_list();
17954 octave_value_list _out;
17955 octave_value_list *_outp=&_out;
17956 octave_value _outv;
17966 arg1 =
static_cast< PLINT >(val1);
17968 _outv = octave_value();
17972 return octave_value_list();
17984 octave_value_list _out;
17985 octave_value_list *_outp=&_out;
17986 octave_value _outv;
17996 arg1 =
static_cast< PLFLT >(val1);
17998 _outv = octave_value();
18002 return octave_value_list();
18044 octave_value_list _out;
18045 octave_value_list *_outp=&_out;
18046 octave_value _outv;
18056 arg1 =
static_cast< PLFLT >(val1);
18061 arg2 =
static_cast< PLFLT >(val2);
18066 arg3 =
static_cast< PLFLT >(val3);
18071 arg4 =
static_cast< PLINT >(val4);
18076 arg5 =
static_cast< PLBOOL >(val5);
18081 arg6 =
static_cast< PLINT >(val6);
18086 arg7 =
static_cast< PLINT >(val7);
18091 arg8 =
static_cast< PLINT >(val8);
18096 arg9 =
static_cast< PLINT >(val9);
18101 arg10 =
static_cast< PLINT >(val10);
18106 arg11 =
static_cast< PLFLT >(val11);
18107 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18108 _outv = octave_value();
18112 return octave_value_list();
18142 octave_value_list _out;
18143 octave_value_list *_outp=&_out;
18144 octave_value _outv;
18155 arg1 =
static_cast< PLINT >(val1);
18160 arg2 =
static_cast< PLINT >(val2);
18165 arg3 =
static_cast< PLINT >(val3);
18170 arg4 =
static_cast< PLINT >(val4);
18175 arg5 =
static_cast< PLINT >(val5);
18180 arg6 =
static_cast< PLFLT >(val6);
18181 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18182 _outv = octave_value();
18192 return octave_value_list();
18207 octave_value_list _out;
18208 octave_value_list *_outp=&_out;
18209 octave_value _outv;
18219 arg1 =
static_cast< PLINT >(val1);
18224 arg2 =
static_cast< PLBOOL >(val2);
18226 _outv = octave_value();
18230 return octave_value_list();
18239 octave_value_list _out;
18240 octave_value_list *_outp=&_out;
18241 octave_value _outv;
18248 _outv = octave_value();
18252 return octave_value_list();
18261 octave_value_list _out;
18262 octave_value_list *_outp=&_out;
18263 octave_value _outv;
18270 _outv = octave_value();
18274 return octave_value_list();
18301 octave_value_list _out;
18302 octave_value_list *_outp=&_out;
18303 octave_value _outv;
18313 arg1 =
static_cast< PLFLT >(val1);
18318 arg2 =
static_cast< PLFLT >(val2);
18323 arg3 =
static_cast< PLFLT >(val3);
18328 arg4 =
static_cast< PLFLT >(val4);
18333 arg5 =
static_cast< PLINT >(val5);
18338 arg6 =
static_cast< PLINT >(val6);
18339 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18340 _outv = octave_value();
18344 return octave_value_list();
18371 octave_value_list _out;
18372 octave_value_list *_outp=&_out;
18373 octave_value _outv;
18383 arg1 =
static_cast< PLFLT >(val1);
18388 arg2 =
static_cast< PLFLT >(val2);
18393 arg3 =
static_cast< PLFLT >(val3);
18398 arg4 =
static_cast< PLFLT >(val4);
18403 arg5 =
static_cast< PLINT >(val5);
18408 arg6 =
static_cast< PLINT >(val6);
18409 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18410 _outv = octave_value();
18414 return octave_value_list();
18423 octave_value_list _out;
18424 octave_value_list *_outp=&_out;
18425 octave_value _outv;
18432 _outv = octave_value();
18436 return octave_value_list();
18452 octave_value_list _out;
18453 octave_value_list *_outp=&_out;
18454 octave_value _outv;
18461 if (
_n_dims( args(0) ) > 1 )
18466 temp1 = args(0).matrix_value();
18467 arg2 = &temp1( 0, 0 );
18470 if (
_n_dims( args(1) ) > 1 )
18478 temp3 = args(1).matrix_value();
18479 arg3 = &temp3( 0, 0 );
18482 if (
_n_dims( args(2) ) > 1 )
18490 temp4 = args(2).matrix_value();
18491 arg4 = &temp4( 0, 0 );
18493 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18494 _outv = octave_value();
18516 return octave_value_list();
18541 octave_value_list _out;
18542 octave_value_list *_outp=&_out;
18543 octave_value _outv;
18550 if (
_n_dims( args(0) ) > 1 )
18555 temp1 = args(0).matrix_value();
18556 arg2 = &temp1( 0, 0 );
18559 if (
_n_dims( args(1) ) > 1 )
18567 temp3 = args(1).matrix_value();
18568 arg3 = &temp3( 0, 0 );
18571 if (
_n_dims( args(2) ) > 1 )
18579 temp4 = args(2).matrix_value();
18580 arg4 = &temp4( 0, 0 );
18582 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18583 _outv = octave_value();
18605 return octave_value_list();
18623 octave_value_list _out;
18624 octave_value_list *_outp=&_out;
18625 octave_value _outv;
18632 _outv = octave_value();
18636 return octave_value_list();
18650 octave_value_list _out;
18651 octave_value_list *_outp=&_out;
18652 octave_value _outv;
18659 if (
_n_dims( args(0) ) > 1 )
18664 temp1 = args(0).matrix_value();
18665 arg2 = &temp1( 0, 0 );
18668 if (
_n_dims( args(1) ) > 1 )
18676 temp3 = args(1).matrix_value();
18677 arg3 = &temp3( 0, 0 );
18679 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18680 _outv = octave_value();
18696 return octave_value_list();
18718 octave_value_list _out;
18719 octave_value_list *_outp=&_out;
18720 octave_value _outv;
18727 if (
_n_dims( args(0) ) > 1 )
18732 temp1 = args(0).matrix_value();
18733 arg2 = &temp1( 0, 0 );
18736 if (
_n_dims( args(1) ) > 1 )
18744 temp3 = args(1).matrix_value();
18745 arg3 = &temp3( 0, 0 );
18748 if (
_n_dims( args(2) ) > 1 )
18756 temp4 = args(2).matrix_value();
18757 arg4 = &temp4( 0, 0 );
18759 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18760 _outv = octave_value();
18782 return octave_value_list();
18808 octave_value_list _out;
18809 octave_value_list *_outp=&_out;
18810 octave_value _outv;
18817 if (
_n_dims( args(0) ) > 1 )
18822 temp1 = args(0).matrix_value();
18823 arg2 = &temp1( 0, 0 );
18826 if (
_n_dims( args(1) ) > 1 )
18834 temp3 = args(1).matrix_value();
18835 arg3 = &temp3( 0, 0 );
18841 arg4 =
static_cast< PLFLT >(val4);
18842 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18843 _outv = octave_value();
18859 return octave_value_list();
18874 octave_value_list _out;
18875 octave_value_list *_outp=&_out;
18876 octave_value _outv;
18883 _outv = octave_value();
18887 return octave_value_list();
18899 octave_value_list _out;
18900 octave_value_list *_outp=&_out;
18901 octave_value _outv;
18911 arg1 =
static_cast< PLINT >(val1);
18913 _outv = octave_value();
18917 return octave_value_list();
18929 octave_value_list _out;
18930 octave_value_list *_outp=&_out;
18931 octave_value _outv;
18941 arg1 =
static_cast< PLINT >(val1);
18943 _outv = octave_value();
18947 return octave_value_list();
18962 octave_value_list _out;
18963 octave_value_list *_outp=&_out;
18964 octave_value _outv;
18973 _outv = octave_value();
18989 return octave_value_list();
19010 octave_value_list _out;
19011 octave_value_list *_outp=&_out;
19012 octave_value _outv;
19025 arg1 =
static_cast< PLINT >(val1);
19026 plgcol0(arg1,arg2,arg3,arg4);
19027 _outv = octave_value();
19049 return octave_value_list();
19073 octave_value_list _out;
19074 octave_value_list *_outp=&_out;
19075 octave_value _outv;
19089 arg1 =
static_cast< PLINT >(val1);
19090 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19091 _outv = octave_value();
19119 return octave_value_list();
19137 octave_value_list _out;
19138 octave_value_list *_outp=&_out;
19139 octave_value _outv;
19149 _outv = octave_value();
19171 return octave_value_list();
19192 octave_value_list _out;
19193 octave_value_list *_outp=&_out;
19194 octave_value _outv;
19205 _outv = octave_value();
19233 return octave_value_list();
19245 octave_value_list _out;
19246 octave_value_list *_outp=&_out;
19247 octave_value _outv;
19255 _outv = octave_value();
19265 return octave_value_list();
19274 char *arg1 = (
char *) 0 ;
19275 char local_string1[80] ;
19276 size_t local_string_length1 ;
19277 charMatrix local_charMatrix1 ;
19278 octave_value_list retval1 ;
19279 octave_value_list _out;
19280 octave_value_list *_outp=&_out;
19281 octave_value _outv;
19285 arg1 = local_string1;
19291 _outv = octave_value();
19294 local_string_length1 = strlen( local_string1 );
19295 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19296 local_charMatrix1.insert( local_string1, 0, 0 );
19297 retval1( 0 ) = octave_value( local_charMatrix1 );
19302 return octave_value_list();
19323 octave_value_list _out;
19324 octave_value_list *_outp=&_out;
19325 octave_value _outv;
19336 _outv = octave_value();
19364 return octave_value_list();
19376 octave_value_list _out;
19377 octave_value_list *_outp=&_out;
19378 octave_value _outv;
19386 _outv = octave_value();
19396 return octave_value_list();
19417 octave_value_list _out;
19418 octave_value_list *_outp=&_out;
19419 octave_value _outv;
19430 _outv = octave_value();
19458 return octave_value_list();
19476 octave_value_list _out;
19477 octave_value_list *_outp=&_out;
19478 octave_value _outv;
19488 _outv = octave_value();
19510 return octave_value_list();
19522 octave_value_list _out;
19523 octave_value_list *_outp=&_out;
19524 octave_value _outv;
19532 _outv = octave_value();
19542 return octave_value_list();
19551 char *arg1 = (
char *) 0 ;
19552 char local_string1[80] ;
19553 size_t local_string_length1 ;
19554 charMatrix local_charMatrix1 ;
19555 octave_value_list retval1 ;
19556 octave_value_list _out;
19557 octave_value_list *_outp=&_out;
19558 octave_value _outv;
19562 arg1 = local_string1;
19568 _outv = octave_value();
19571 local_string_length1 = strlen( local_string1 );
19572 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19573 local_charMatrix1.insert( local_string1, 0, 0 );
19574 retval1( 0 ) = octave_value( local_charMatrix1 );
19579 return octave_value_list();
19597 octave_value_list _out;
19598 octave_value_list *_outp=&_out;
19599 octave_value _outv;
19609 _outv = octave_value();
19631 return octave_value_list();
19643 octave_value_list _out;
19644 octave_value_list *_outp=&_out;
19645 octave_value _outv;
19653 _outv = octave_value();
19663 return octave_value_list();
19690 octave_value_list _out;
19691 octave_value_list *_outp=&_out;
19692 octave_value _outv;
19704 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19705 _outv = octave_value();
19745 return octave_value_list();
19754 octave_value_list _out;
19755 octave_value_list *_outp=&_out;
19756 octave_value _outv;
19763 _outv = octave_value();
19767 return octave_value_list();
19788 octave_value_list _out;
19789 octave_value_list *_outp=&_out;
19790 octave_value _outv;
19800 plgspa(arg1,arg2,arg3,arg4);
19801 _outv = octave_value();
19829 return octave_value_list();
19841 octave_value_list _out;
19842 octave_value_list *_outp=&_out;
19843 octave_value _outv;
19851 _outv = octave_value();
19861 return octave_value_list();
19870 char *arg1 = (
char *) 0 ;
19871 char local_string1[80] ;
19872 size_t local_string_length1 ;
19873 charMatrix local_charMatrix1 ;
19874 octave_value_list retval1 ;
19875 octave_value_list _out;
19876 octave_value_list *_outp=&_out;
19877 octave_value _outv;
19881 arg1 = local_string1;
19887 _outv = octave_value();
19890 local_string_length1 = strlen( local_string1 );
19891 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19892 local_charMatrix1.insert( local_string1, 0, 0 );
19893 retval1( 0 ) = octave_value( local_charMatrix1 );
19898 return octave_value_list();
19919 octave_value_list _out;
19920 octave_value_list *_outp=&_out;
19921 octave_value _outv;
19931 plgvpd(arg1,arg2,arg3,arg4);
19932 _outv = octave_value();
19960 return octave_value_list();
19981 octave_value_list _out;
19982 octave_value_list *_outp=&_out;
19983 octave_value _outv;
19993 plgvpw(arg1,arg2,arg3,arg4);
19994 _outv = octave_value();
20022 return octave_value_list();
20037 octave_value_list _out;
20038 octave_value_list *_outp=&_out;
20039 octave_value _outv;
20048 _outv = octave_value();
20064 return octave_value_list();
20079 octave_value_list _out;
20080 octave_value_list *_outp=&_out;
20081 octave_value _outv;
20090 _outv = octave_value();
20106 return octave_value_list();
20121 octave_value_list _out;
20122 octave_value_list *_outp=&_out;
20123 octave_value _outv;
20132 _outv = octave_value();
20148 return octave_value_list();
20172 octave_value_list _out;
20173 octave_value_list *_outp=&_out;
20174 octave_value _outv;
20181 if (
_n_dims( args(0) ) > 1 )
20186 temp1 = args(0).matrix_value();
20187 arg2 = &temp1( 0, 0 );
20193 arg3 =
static_cast< PLFLT >(val3);
20198 arg4 =
static_cast< PLFLT >(val4);
20203 arg5 =
static_cast< PLINT >(val5);
20208 arg6 =
static_cast< PLINT >(val6);
20209 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20210 _outv = octave_value();
20220 return octave_value_list();
20250 octave_value_list _out;
20251 octave_value_list *_outp=&_out;
20252 octave_value _outv;
20265 arg1 =
static_cast< PLFLT >(val1);
20270 arg2 =
static_cast< PLFLT >(val2);
20275 arg3 =
static_cast< PLFLT >(val3);
20276 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20277 _outv = octave_value();
20299 return octave_value_list();
20308 octave_value_list _out;
20309 octave_value_list *_outp=&_out;
20310 octave_value _outv;
20317 _outv = octave_value();
20321 return octave_value_list();
20342 octave_value_list _out;
20343 octave_value_list *_outp=&_out;
20344 octave_value _outv;
20354 arg1 =
static_cast< PLFLT >(val1);
20359 arg2 =
static_cast< PLFLT >(val2);
20364 arg3 =
static_cast< PLFLT >(val3);
20369 arg4 =
static_cast< PLFLT >(val4);
20370 pljoin(arg1,arg2,arg3,arg4);
20371 _outv = octave_value();
20375 return octave_value_list();
20384 char *arg1 = (
char *) 0 ;
20385 char *arg2 = (
char *) 0 ;
20386 char *arg3 = (
char *) 0 ;
20396 octave_value_list _out;
20397 octave_value_list *_outp=&_out;
20398 octave_value _outv;
20408 arg1 =
reinterpret_cast< char *
>(buf1);
20413 arg2 =
reinterpret_cast< char *
>(buf2);
20418 arg3 =
reinterpret_cast< char *
>(buf3);
20419 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20420 _outv = octave_value();
20430 return octave_value_list();
20461 char **arg20 = (
char **) 0 ;
20472 char **arg31 = (
char **) 0 ;
20517 octave_value_list _out;
20518 octave_value_list *_outp=&_out;
20519 octave_value _outv;
20531 arg3 =
static_cast< PLINT >(val3);
20536 arg4 =
static_cast< PLINT >(val4);
20541 arg5 =
static_cast< PLFLT >(val5);
20546 arg6 =
static_cast< PLFLT >(val6);
20551 arg7 =
static_cast< PLFLT >(val7);
20556 arg8 =
static_cast< PLINT >(val8);
20561 arg9 =
static_cast< PLINT >(val9);
20566 arg10 =
static_cast< PLINT >(val10);
20571 arg11 =
static_cast< PLINT >(val11);
20576 arg12 =
static_cast< PLINT >(val12);
20578 if (
_n_dims( args(10) ) > 1 )
20584 temp13 = args(10).matrix_value();
20591 arg15 =
static_cast< PLFLT >(val15);
20596 arg16 =
static_cast< PLFLT >(val16);
20601 arg17 =
static_cast< PLFLT >(val17);
20606 arg18 =
static_cast< PLFLT >(val18);
20608 if (
_n_dims( args(15) ) > 1 )
20612 if (
_dim( args(15), 0 ) !=
Alen )
20616 temp19 = args(15).matrix_value();
20621 charMatrix temp_matrix;
20625 size_t max_length = 0, non_blank_length;
20627 if (
_n_dims( args(16) ) > 2 )
20629 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20631#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20632 if ( !args(16).isempty() )
20634 if ( !args(16).is_empty() )
20637 if (
_dim( args(16), 0 ) !=
Alen )
20639 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20641 arg20 =
new char*[
Alen];
20642#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20643 ifcell = args(16).iscell();
20645 ifcell = args(16).is_cell();
20649 temp_cell = args(16).cell_value();
20653 temp_matrix = args(16).char_matrix_value();
20655 max_length =
_dim( args(16), 1 ) + 1;
20658 for ( i = 0; i <
Alen; i++ )
20665 if ( temp_cell.elem( i ).is_string() )
20667 str = temp_cell.elem( i ).string_value();
20669 max_length = str.size() + 1;
20670 tmp_cstring = (
char *) str.c_str();
20680 tmp_cstring = (
char *)
"";
20685 str = temp_matrix.row_as_string( i );
20686 tmp_cstring = (
char *) str.c_str();
20688 arg20[i] =
new char[max_length];
20689 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20690 arg20[i][max_length - 1] =
'\0';
20705 non_blank_length = max_length - 2;
20706 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20708 non_blank_length--;
20710 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20712 non_blank_length--;
20714 arg20[i][non_blank_length + 1] =
'\0';
20724 if (
_n_dims( args(17) ) > 1 )
20728#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20729 if ( !args(17).isempty() )
20731 if ( !args(17).is_empty() )
20734 if (
_dim( args(17), 0 ) !=
Alen )
20738 temp21 = args(17).matrix_value();
20748 if (
_n_dims( args(18) ) > 1 )
20752#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20753 if ( !args(18).isempty() )
20755 if ( !args(18).is_empty() )
20758 if (
_dim( args(18), 0 ) !=
Alen )
20762 temp22 = args(18).matrix_value();
20772 if (
_n_dims( args(19) ) > 1 )
20776#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20777 if ( !args(19).isempty() )
20779 if ( !args(19).is_empty() )
20782 if (
_dim( args(19), 0 ) !=
Alen )
20786 temp23 = args(19).matrix_value();
20787 arg23 = &temp23( 0, 0 );
20795 if (
_n_dims( args(20) ) > 1 )
20799#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20800 if ( !args(20).isempty() )
20802 if ( !args(20).is_empty() )
20805 if (
_dim( args(20), 0 ) !=
Alen )
20809 temp24 = args(20).matrix_value();
20810 arg24 = &temp24( 0, 0 );
20818 if (
_n_dims( args(21) ) > 1 )
20822#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20823 if ( !args(21).isempty() )
20825 if ( !args(21).is_empty() )
20828 if (
_dim( args(21), 0 ) !=
Alen )
20832 temp25 = args(21).matrix_value();
20842 if (
_n_dims( args(22) ) > 1 )
20846#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20847 if ( !args(22).isempty() )
20849 if ( !args(22).is_empty() )
20852 if (
_dim( args(22), 0 ) !=
Alen )
20856 temp26 = args(22).matrix_value();
20866 if (
_n_dims( args(23) ) > 1 )
20870#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20871 if ( !args(23).isempty() )
20873 if ( !args(23).is_empty() )
20876 if (
_dim( args(23), 0 ) !=
Alen )
20880 temp27 = args(23).matrix_value();
20881 arg27 = &temp27( 0, 0 );
20889 if (
_n_dims( args(24) ) > 1 )
20893#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20894 if ( !args(24).isempty() )
20896 if ( !args(24).is_empty() )
20899 if (
_dim( args(24), 0 ) !=
Alen )
20903 temp28 = args(24).matrix_value();
20913 if (
_n_dims( args(25) ) > 1 )
20917#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20918 if ( !args(25).isempty() )
20920 if ( !args(25).is_empty() )
20923 if (
_dim( args(25), 0 ) !=
Alen )
20927 temp29 = args(25).matrix_value();
20928 arg29 = &temp29( 0, 0 );
20936 if (
_n_dims( args(26) ) > 1 )
20940#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20941 if ( !args(26).isempty() )
20943 if ( !args(26).is_empty() )
20946 if (
_dim( args(26), 0 ) !=
Alen )
20950 temp30 = args(26).matrix_value();
20960 charMatrix temp_matrix;
20964 size_t max_length = 0, non_blank_length;
20966 if (
_n_dims( args(27) ) > 2 )
20968 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20971 if ( !args(27).isempty() )
20973 if ( !args(27).is_empty() )
20976 if (
_dim( args(27), 0 ) !=
Alen )
20978 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20980 arg31 =
new char*[
Alen];
20981#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20982 ifcell = args(27).iscell();
20984 ifcell = args(27).is_cell();
20988 temp_cell = args(27).cell_value();
20992 temp_matrix = args(27).char_matrix_value();
20994 max_length =
_dim( args(27), 1 ) + 1;
20997 for ( i = 0; i <
Alen; i++ )
21004 if ( temp_cell.elem( i ).is_string() )
21006 str = temp_cell.elem( i ).string_value();
21008 max_length = str.size() + 1;
21009 tmp_cstring = (
char *) str.c_str();
21019 tmp_cstring = (
char *)
"";
21024 str = temp_matrix.row_as_string( i );
21025 tmp_cstring = (
char *) str.c_str();
21027 arg31[i] =
new char[max_length];
21028 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21029 arg31[i][max_length - 1] =
'\0';
21044 non_blank_length = max_length - 2;
21045 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
21047 non_blank_length--;
21049 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
21051 non_blank_length--;
21053 arg31[i][non_blank_length + 1] =
'\0';
21062 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);
21063 _outv = octave_value();
21085 if ( arg20 != NULL )
21087 for ( i = 0; i <
Alen; i++ )
21095 if ( arg21 != NULL )
21099 if ( arg22 != NULL )
21109 if ( arg25 != NULL )
21113 if ( arg26 != NULL )
21120 if ( arg28 != NULL )
21127 if ( arg30 != NULL )
21132 if ( arg31 != NULL )
21134 for ( i = 0; i <
Alen; i++ )
21151 if ( arg20 != NULL )
21153 for ( i = 0; i <
Alen; i++ )
21161 if ( arg21 != NULL )
21165 if ( arg22 != NULL )
21175 if ( arg25 != NULL )
21179 if ( arg26 != NULL )
21186 if ( arg28 != NULL )
21193 if ( arg30 != NULL )
21198 if ( arg31 != NULL )
21200 for ( i = 0; i <
Alen; i++ )
21207 return octave_value_list();
21218 if ( arg20 != NULL )
21220 for ( i = 0; i <
Alen; i++ )
21228 if ( arg21 != NULL )
21232 if ( arg22 != NULL )
21242 if ( arg25 != NULL )
21246 if ( arg26 != NULL )
21253 if ( arg28 != NULL )
21260 if ( arg30 != NULL )
21265 if ( arg31 != NULL )
21267 for ( i = 0; i <
Alen; i++ )
21289 octave_value_list _out;
21290 octave_value_list *_outp=&_out;
21291 octave_value _outv;
21301 arg1 =
static_cast< PLFLT >(val1);
21306 arg2 =
static_cast< PLFLT >(val2);
21311 arg3 =
static_cast< PLFLT >(val3);
21313 _outv = octave_value();
21317 return octave_value_list();
21331 octave_value_list _out;
21332 octave_value_list *_outp=&_out;
21333 octave_value _outv;
21340 if (
_n_dims( args(0) ) > 1 )
21345 temp1 = args(0).matrix_value();
21346 arg2 = &temp1( 0, 0 );
21349 if (
_n_dims( args(1) ) > 1 )
21357 temp3 = args(1).matrix_value();
21358 arg3 = &temp3( 0, 0 );
21360 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21361 _outv = octave_value();
21377 return octave_value_list();
21399 octave_value_list _out;
21400 octave_value_list *_outp=&_out;
21401 octave_value _outv;
21408 if (
_n_dims( args(0) ) > 1 )
21413 temp1 = args(0).matrix_value();
21414 arg2 = &temp1( 0, 0 );
21417 if (
_n_dims( args(1) ) > 1 )
21425 temp3 = args(1).matrix_value();
21426 arg3 = &temp3( 0, 0 );
21429 if (
_n_dims( args(2) ) > 1 )
21437 temp4 = args(2).matrix_value();
21438 arg4 = &temp4( 0, 0 );
21440 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21441 _outv = octave_value();
21463 return octave_value_list();
21484 octave_value_list _out;
21485 octave_value_list *_outp=&_out;
21486 octave_value _outv;
21496 arg1 =
static_cast< PLINT >(val1);
21498 _outv = octave_value();
21502 return octave_value_list();
21514 octave_value_list _out;
21515 octave_value_list *_outp=&_out;
21516 octave_value _outv;
21524 _outv = octave_value();
21534 return octave_value_list();
21543 char *arg1 = (
char *) 0 ;
21547 char *arg5 = (
char *) 0 ;
21560 octave_value_list _out;
21561 octave_value_list *_outp=&_out;
21562 octave_value _outv;
21572 arg1 =
reinterpret_cast< char *
>(buf1);
21577 arg2 =
static_cast< PLFLT >(val2);
21582 arg3 =
static_cast< PLFLT >(val3);
21587 arg4 =
static_cast< PLFLT >(val4);
21592 arg5 =
reinterpret_cast< char *
>(buf5);
21593 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21594 _outv = octave_value();
21602 return octave_value_list();
21613 char *arg1 = (
char *) 0 ;
21617 char *arg5 = (
char *) 0 ;
21630 octave_value_list _out;
21631 octave_value_list *_outp=&_out;
21632 octave_value _outv;
21642 arg1 =
reinterpret_cast< char *
>(buf1);
21647 arg2 =
static_cast< PLFLT >(val2);
21652 arg3 =
static_cast< PLFLT >(val3);
21657 arg4 =
static_cast< PLFLT >(val4);
21662 arg5 =
reinterpret_cast< char *
>(buf5);
21663 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21664 _outv = octave_value();
21672 return octave_value_list();
21683 int *arg1 = (
int *) 0 ;
21684 char **arg2 = (
char **) 0 ;
21692 octave_value_list _out;
21693 octave_value_list *_outp=&_out;
21694 octave_value _outv;
21705 arg1 =
reinterpret_cast< int *
>(argp1);
21710 arg2 =
reinterpret_cast< char **
>(argp2);
21715 arg3 =
static_cast< PLINT >(val3);
21721 return octave_value_list();
21735 octave_value_list _out;
21736 octave_value_list *_outp=&_out;
21737 octave_value _outv;
21744 if (
_n_dims( args(0) ) > 1 )
21750 temp1 = args(0).matrix_value();
21754 if (
_n_dims( args(1) ) > 1 )
21762 temp3 = args(1).matrix_value();
21766 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21767 _outv = octave_value();
21783 return octave_value_list();
21813 octave_value_list _out;
21814 octave_value_list *_outp=&_out;
21815 octave_value _outv;
21825 arg1 =
static_cast< PLINT >(val1);
21830 arg2 =
static_cast< PLFLT >(val2);
21835 arg3 =
static_cast< PLFLT >(val3);
21840 arg4 =
static_cast< PLFLT >(val4);
21845 arg5 =
static_cast< PLFLT >(val5);
21846 plpath(arg1,arg2,arg3,arg4,arg5);
21847 _outv = octave_value();
21851 return octave_value_list();
21868 octave_value_list _out;
21869 octave_value_list *_outp=&_out;
21870 octave_value _outv;
21877 if (
_n_dims( args(0) ) > 1 )
21882 temp1 = args(0).matrix_value();
21883 arg2 = &temp1( 0, 0 );
21886 if (
_n_dims( args(1) ) > 1 )
21894 temp3 = args(1).matrix_value();
21895 arg3 = &temp3( 0, 0 );
21901 arg4 =
static_cast< PLINT >(val4);
21902 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21903 _outv = octave_value();
21919 return octave_value_list();
21944 octave_value_list _out;
21945 octave_value_list *_outp=&_out;
21946 octave_value _outv;
21953 if (
_n_dims( args(0) ) > 1 )
21958 temp1 = args(0).matrix_value();
21959 arg2 = &temp1( 0, 0 );
21962 if (
_n_dims( args(1) ) > 1 )
21970 temp3 = args(1).matrix_value();
21971 arg3 = &temp3( 0, 0 );
21974 if (
_n_dims( args(2) ) > 1 )
21982 temp4 = args(2).matrix_value();
21983 arg4 = &temp4( 0, 0 );
21989 arg5 =
static_cast< PLINT >(val5);
21990 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21991 _outv = octave_value();
22013 return octave_value_list();
22043 octave_value_list _out;
22044 octave_value_list *_outp=&_out;
22045 octave_value _outv;
22052 if (
_n_dims( args(0) ) > 1 )
22057 temp1 = args(0).matrix_value();
22058 arg2 = &temp1( 0, 0 );
22061 if (
_n_dims( args(1) ) > 1 )
22069 temp3 = args(1).matrix_value();
22070 arg3 = &temp3( 0, 0 );
22073 if (
_n_dims( args(2) ) > 1 )
22081 temp4 = args(2).matrix_value();
22082 arg4 = &temp4( 0, 0 );
22085 if (
_n_dims( args(3) ) > 1 )
22091 error(
"argument vector must be same length or one less" );
SWIG_fail;
22093 temp5 = args(3).matrix_value();
22101 arg6 =
static_cast< PLBOOL >(val6);
22102 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22103 _outv = octave_value();
22131 return octave_value_list();
22158 octave_value_list _out;
22159 octave_value_list *_outp=&_out;
22160 octave_value _outv;
22170 arg1 =
static_cast< PLINT >(val1);
22175 arg2 =
static_cast< PLINT >(val2);
22177 _outv = octave_value();
22181 return octave_value_list();
22193 octave_value_list _out;
22194 octave_value_list *_outp=&_out;
22195 octave_value _outv;
22205 arg1 =
static_cast< PLINT >(val1);
22207 _outv = octave_value();
22211 return octave_value_list();
22225 char *arg6 = (
char *) 0 ;
22239 octave_value_list _out;
22240 octave_value_list *_outp=&_out;
22241 octave_value _outv;
22251 arg1 =
static_cast< PLFLT >(val1);
22256 arg2 =
static_cast< PLFLT >(val2);
22261 arg3 =
static_cast< PLFLT >(val3);
22266 arg4 =
static_cast< PLFLT >(val4);
22271 arg5 =
static_cast< PLFLT >(val5);
22276 arg6 =
reinterpret_cast< char *
>(buf6);
22277 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22278 _outv = octave_value();
22284 return octave_value_list();
22304 char *arg11 = (
char *) 0 ;
22328 octave_value_list _out;
22329 octave_value_list *_outp=&_out;
22330 octave_value _outv;
22340 arg1 =
static_cast< PLFLT >(val1);
22345 arg2 =
static_cast< PLFLT >(val2);
22350 arg3 =
static_cast< PLFLT >(val3);
22355 arg4 =
static_cast< PLFLT >(val4);
22360 arg5 =
static_cast< PLFLT >(val5);
22365 arg6 =
static_cast< PLFLT >(val6);
22370 arg7 =
static_cast< PLFLT >(val7);
22375 arg8 =
static_cast< PLFLT >(val8);
22380 arg9 =
static_cast< PLFLT >(val9);
22385 arg10 =
static_cast< PLFLT >(val10);
22390 arg11 =
reinterpret_cast< char *
>(buf11);
22391 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22392 _outv = octave_value();
22398 return octave_value_list();
22408 octave_value_list _out;
22409 octave_value_list *_outp=&_out;
22410 octave_value _outv;
22422 return octave_value_list();
22431 octave_value_list _out;
22432 octave_value_list *_outp=&_out;
22433 octave_value _outv;
22440 _outv = octave_value();
22444 return octave_value_list();
22471 octave_value_list _out;
22472 octave_value_list *_outp=&_out;
22473 octave_value _outv;
22486 arg1 =
static_cast< PLFLT >(val1);
22491 arg2 =
static_cast< PLFLT >(val2);
22496 arg3 =
static_cast< PLFLT >(val3);
22497 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22498 _outv = octave_value();
22520 return octave_value_list();
22535 octave_value_list _out;
22536 octave_value_list *_outp=&_out;
22537 octave_value _outv;
22547 arg1 =
static_cast< PLFLT >(val1);
22552 arg2 =
static_cast< PLFLT >(val2);
22554 _outv = octave_value();
22558 return octave_value_list();
22574 octave_value_list _out;
22575 octave_value_list *_outp=&_out;
22576 octave_value _outv;
22583 if (
_n_dims( args(0) ) > 1 )
22588 temp1 = args(0).matrix_value();
22593 if (
_n_dims( args(1) ) > 1 )
22601 temp2 = args(1).matrix_value();
22606 if (
_n_dims( args(2) ) > 1 )
22614 temp3 = args(2).matrix_value();
22619 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22620 _outv = octave_value();
22642 return octave_value_list();
22669 octave_value_list _out;
22670 octave_value_list *_outp=&_out;
22671 octave_value _outv;
22678 if (
_n_dims( args(0) ) > 1 )
22683 temp1 = args(0).matrix_value();
22688 if (
_n_dims( args(1) ) > 1 )
22696 temp2 = args(1).matrix_value();
22701 if (
_n_dims( args(2) ) > 1 )
22709 temp3 = args(2).matrix_value();
22714 if (
_n_dims( args(3) ) > 1 )
22722 temp4 = args(3).matrix_value();
22723 arg4 = &temp4( 0, 0 );
22726 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22727 _outv = octave_value();
22755 return octave_value_list();
22779 octave_value_list _out;
22780 octave_value_list *_outp=&_out;
22781 octave_value _outv;
22791 arg1 =
static_cast< PLINT >(val1);
22793 _outv = octave_value();
22797 return octave_value_list();
22813 octave_value_list _out;
22814 octave_value_list *_outp=&_out;
22815 octave_value _outv;
22822 if (
_n_dims( args(0) ) > 1 )
22827 temp1 = args(0).matrix_value();
22832 if (
_n_dims( args(1) ) > 1 )
22840 temp2 = args(1).matrix_value();
22845 if (
_n_dims( args(2) ) > 1 )
22853 temp3 = args(2).matrix_value();
22858 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22859 _outv = octave_value();
22881 return octave_value_list();
22908 octave_value_list _out;
22909 octave_value_list *_outp=&_out;
22910 octave_value _outv;
22917 if (
_n_dims( args(0) ) > 1 )
22922 temp1 = args(0).matrix_value();
22927 if (
_n_dims( args(1) ) > 1 )
22935 temp2 = args(1).matrix_value();
22940 if (
_n_dims( args(2) ) > 1 )
22948 temp3 = args(2).matrix_value();
22953 if (
_n_dims( args(3) ) > 1 )
22961 temp4 = args(3).matrix_value();
22962 arg4 = &temp4( 0, 0 );
22965 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22966 _outv = octave_value();
22994 return octave_value_list();
23029 octave_value_list _out;
23030 octave_value_list *_outp=&_out;
23031 octave_value _outv;
23041 arg1 =
static_cast< PLBOOL >(val1);
23043 if (
_n_dims( args(1) ) > 1 )
23048 temp2 = args(1).matrix_value();
23049 arg3 = &temp2( 0, 0 );
23052 if (
_n_dims( args(2) ) > 1 )
23060 temp4 = args(2).matrix_value();
23061 arg4 = &temp4( 0, 0 );
23064 if (
_n_dims( args(3) ) > 1 )
23072 temp5 = args(3).matrix_value();
23073 arg5 = &temp5( 0, 0 );
23076 if (
_n_dims( args(4) ) > 1 )
23084 temp6 = args(4).matrix_value();
23085 arg6 = &temp6( 0, 0 );
23088 if (
_n_dims( args(5) ) > 1 )
23094 error(
"argument vector must be same length or one less" );
SWIG_fail;
23096 temp7 = args(5).matrix_value();
23100 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23101 _outv = octave_value();
23135 return octave_value_list();
23175 octave_value_list _out;
23176 octave_value_list *_outp=&_out;
23177 octave_value _outv;
23187 arg1 =
static_cast< PLBOOL >(val1);
23189 if (
_n_dims( args(1) ) > 1 )
23194 temp2 = args(1).matrix_value();
23195 arg3 = &temp2( 0, 0 );
23198 if (
_n_dims( args(2) ) > 1 )
23206 temp4 = args(2).matrix_value();
23207 arg4 = &temp4( 0, 0 );
23210 if (
_n_dims( args(3) ) > 1 )
23218 temp5 = args(3).matrix_value();
23219 arg5 = &temp5( 0, 0 );
23222 if (
_n_dims( args(4) ) > 1 )
23230 temp6 = args(4).matrix_value();
23231 arg6 = &temp6( 0, 0 );
23234 if (
_n_dims( args(5) ) > 1 )
23242 temp7 = args(5).matrix_value();
23243 arg7 = &temp7( 0, 0 );
23246 if (
_n_dims( args(6) ) > 1 )
23252 error(
"argument vector must be same length or one less" );
SWIG_fail;
23254 temp8 = args(6).matrix_value();
23258 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23259 _outv = octave_value();
23299 return octave_value_list();
23329 octave_value_list _out;
23330 octave_value_list *_outp=&_out;
23331 octave_value _outv;
23341 arg1 =
static_cast< PLINT >(val1);
23343 _outv = octave_value();
23347 return octave_value_list();
23362 octave_value_list _out;
23363 octave_value_list *_outp=&_out;
23364 octave_value _outv;
23374 arg1 =
static_cast< PLFLT >(val1);
23379 arg2 =
static_cast< PLFLT >(val2);
23381 _outv = octave_value();
23385 return octave_value_list();
23400 octave_value_list _out;
23401 octave_value_list *_outp=&_out;
23402 octave_value _outv;
23411 _outv = octave_value();
23427 return octave_value_list();
23448 octave_value_list _out;
23449 octave_value_list *_outp=&_out;
23450 octave_value _outv;
23460 arg1 =
static_cast< PLINT >(val1);
23465 arg2 =
static_cast< PLINT >(val2);
23470 arg3 =
static_cast< PLINT >(val3);
23475 arg4 =
static_cast< PLINT >(val4);
23476 plscol0(arg1,arg2,arg3,arg4);
23477 _outv = octave_value();
23481 return octave_value_list();
23505 octave_value_list _out;
23506 octave_value_list *_outp=&_out;
23507 octave_value _outv;
23517 arg1 =
static_cast< PLINT >(val1);
23522 arg2 =
static_cast< PLINT >(val2);
23527 arg3 =
static_cast< PLINT >(val3);
23532 arg4 =
static_cast< PLINT >(val4);
23537 arg5 =
static_cast< PLFLT >(val5);
23538 plscol0a(arg1,arg2,arg3,arg4,arg5);
23539 _outv = octave_value();
23543 return octave_value_list();
23561 octave_value_list _out;
23562 octave_value_list *_outp=&_out;
23563 octave_value _outv;
23573 arg1 =
static_cast< PLINT >(val1);
23578 arg2 =
static_cast< PLINT >(val2);
23583 arg3 =
static_cast< PLINT >(val3);
23585 _outv = octave_value();
23589 return octave_value_list();
23610 octave_value_list _out;
23611 octave_value_list *_outp=&_out;
23612 octave_value _outv;
23622 arg1 =
static_cast< PLINT >(val1);
23627 arg2 =
static_cast< PLINT >(val2);
23632 arg3 =
static_cast< PLINT >(val3);
23637 arg4 =
static_cast< PLFLT >(val4);
23639 _outv = octave_value();
23643 return octave_value_list();
23655 octave_value_list _out;
23656 octave_value_list *_outp=&_out;
23657 octave_value _outv;
23667 arg1 =
static_cast< PLINT >(val1);
23669 _outv = octave_value();
23673 return octave_value_list();
23685 octave_value_list _out;
23686 octave_value_list *_outp=&_out;
23687 octave_value _outv;
23697 arg1 =
static_cast< PLINT >(val1);
23699 _outv = octave_value();
23703 return octave_value_list();
23712 char *arg1 = (
char *) 0 ;
23716 octave_value_list _out;
23717 octave_value_list *_outp=&_out;
23718 octave_value _outv;
23728 arg1 =
reinterpret_cast< char *
>(buf1);
23729 plsdev((
char const *)arg1);
23730 _outv = octave_value();
23736 return octave_value_list();
23758 octave_value_list _out;
23759 octave_value_list *_outp=&_out;
23760 octave_value _outv;
23770 arg1 =
static_cast< PLFLT >(val1);
23775 arg2 =
static_cast< PLFLT >(val2);
23780 arg3 =
static_cast< PLFLT >(val3);
23785 arg4 =
static_cast< PLFLT >(val4);
23787 _outv = octave_value();
23791 return octave_value_list();
23818 octave_value_list _out;
23819 octave_value_list *_outp=&_out;
23820 octave_value _outv;
23830 arg1 =
static_cast< PLINT >(val1);
23835 arg2 =
static_cast< PLINT >(val2);
23840 arg3 =
static_cast< PLINT >(val3);
23845 arg4 =
static_cast< PLINT >(val4);
23850 arg5 =
static_cast< PLFLT >(val5);
23855 arg6 =
static_cast< PLFLT >(val6);
23856 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23857 _outv = octave_value();
23861 return octave_value_list();
23873 octave_value_list _out;
23874 octave_value_list *_outp=&_out;
23875 octave_value _outv;
23885 arg1 =
static_cast< PLFLT >(val1);
23887 _outv = octave_value();
23891 return octave_value_list();
23912 octave_value_list _out;
23913 octave_value_list *_outp=&_out;
23914 octave_value _outv;
23924 arg1 =
static_cast< PLFLT >(val1);
23929 arg2 =
static_cast< PLFLT >(val2);
23934 arg3 =
static_cast< PLFLT >(val3);
23939 arg4 =
static_cast< PLFLT >(val4);
23941 _outv = octave_value();
23945 return octave_value_list();
23966 octave_value_list _out;
23967 octave_value_list *_outp=&_out;
23968 octave_value _outv;
23978 arg1 =
static_cast< PLFLT >(val1);
23983 arg2 =
static_cast< PLFLT >(val2);
23988 arg3 =
static_cast< PLFLT >(val3);
23993 arg4 =
static_cast< PLFLT >(val4);
23995 _outv = octave_value();
23999 return octave_value_list();
24008 unsigned int arg1 ;
24009 unsigned int val1 ;
24011 octave_value_list _out;
24012 octave_value_list *_outp=&_out;
24013 octave_value _outv;
24023 arg1 =
static_cast< unsigned int >(val1);
24025 _outv = octave_value();
24029 return octave_value_list();
24041 octave_value_list _out;
24042 octave_value_list *_outp=&_out;
24043 octave_value _outv;
24053 arg1 =
static_cast< char >(val1);
24055 _outv = octave_value();
24059 return octave_value_list();
24068 char *arg1 = (
char *) 0 ;
24069 char *arg2 = (
char *) 0 ;
24076 octave_value_list _out;
24077 octave_value_list *_outp=&_out;
24078 octave_value _outv;
24089 arg1 =
reinterpret_cast< char *
>(buf1);
24094 arg2 =
reinterpret_cast< char *
>(buf2);
24095 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24104 return octave_value_list();
24124 octave_value_list _out;
24125 octave_value_list *_outp=&_out;
24126 octave_value _outv;
24136 arg1 =
static_cast< PLINT >(val1);
24141 arg2 =
static_cast< PLINT >(val2);
24146 arg3 =
static_cast< PLINT >(val3);
24148 _outv = octave_value();
24152 return octave_value_list();
24162 unsigned int val1 ;
24164 octave_value_list _out;
24165 octave_value_list *_outp=&_out;
24166 octave_value _outv;
24178 _outv = octave_value();
24182 return octave_value_list();
24191 char *arg1 = (
char *) 0 ;
24195 octave_value_list _out;
24196 octave_value_list *_outp=&_out;
24197 octave_value _outv;
24207 arg1 =
reinterpret_cast< char *
>(buf1);
24209 _outv = octave_value();
24215 return octave_value_list();
24234 octave_value_list _out;
24235 octave_value_list *_outp=&_out;
24236 octave_value _outv;
24246 arg1 =
static_cast< PLINT >(val1);
24251 arg2 =
static_cast< PLINT >(val2);
24256 arg3 =
static_cast< PLINT >(val3);
24258 _outv = octave_value();
24262 return octave_value_list();
24274 octave_value_list _out;
24275 octave_value_list *_outp=&_out;
24276 octave_value _outv;
24283 octave_value obj = args(0);
24284#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24285 if ( !obj.isempty() )
24287 if ( !obj.is_empty() )
24290 if ( obj.is_function_handle() || obj.is_inline_function() )
24294 else if ( obj.is_string() )
24311 _outv = octave_value();
24315 return octave_value_list();
24330 octave_value_list _out;
24331 octave_value_list *_outp=&_out;
24332 octave_value _outv;
24342 arg1 =
static_cast< PLFLT >(val1);
24347 arg2 =
static_cast< PLFLT >(val2);
24349 _outv = octave_value();
24353 return octave_value_list();
24368 octave_value_list _out;
24369 octave_value_list *_outp=&_out;
24370 octave_value _outv;
24380 arg1 =
static_cast< PLFLT >(val1);
24385 arg2 =
static_cast< PLFLT >(val2);
24387 _outv = octave_value();
24391 return octave_value_list();
24403 octave_value_list _out;
24404 octave_value_list *_outp=&_out;
24405 octave_value _outv;
24415 arg1 =
static_cast< PLINT >(val1);
24417 _outv = octave_value();
24421 return octave_value_list();
24448 octave_value_list _out;
24449 octave_value_list *_outp=&_out;
24450 octave_value _outv;
24460 arg1 =
static_cast< PLFLT >(val1);
24465 arg2 =
static_cast< PLFLT >(val2);
24470 arg3 =
static_cast< PLINT >(val3);
24475 arg4 =
static_cast< PLINT >(val4);
24480 arg5 =
static_cast< PLINT >(val5);
24485 arg6 =
static_cast< PLINT >(val6);
24486 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24487 _outv = octave_value();
24491 return octave_value_list();
24500 char *arg1 = (
char *) 0 ;
24504 octave_value_list _out;
24505 octave_value_list *_outp=&_out;
24506 octave_value _outv;
24516 arg1 =
reinterpret_cast< char *
>(buf1);
24518 _outv = octave_value();
24524 return octave_value_list();
24534 char *arg1 = (
char *) 0 ;
24541 octave_value_list _out;
24542 octave_value_list *_outp=&_out;
24543 octave_value _outv;
24553 arg1 =
reinterpret_cast< char *
>(buf1);
24558 arg2 =
static_cast< PLBOOL >(val2);
24559 plspal1((
char const *)arg1,arg2);
24560 _outv = octave_value();
24566 return octave_value_list();
24579 octave_value_list _out;
24580 octave_value_list *_outp=&_out;
24581 octave_value _outv;
24591 arg1 =
static_cast< PLBOOL >(val1);
24593 _outv = octave_value();
24597 return octave_value_list();
24609 octave_value_list _out;
24610 octave_value_list *_outp=&_out;
24611 octave_value _outv;
24621 arg1 =
static_cast< PLINT >(val1);
24623 _outv = octave_value();
24627 return octave_value_list();
24642 octave_value_list _out;
24643 octave_value_list *_outp=&_out;
24644 octave_value _outv;
24654 arg1 =
static_cast< PLINT >(val1);
24659 arg2 =
static_cast< PLINT >(val2);
24661 _outv = octave_value();
24665 return octave_value_list();
24680 octave_value_list _out;
24681 octave_value_list *_outp=&_out;
24682 octave_value _outv;
24692 arg1 =
static_cast< PLFLT >(val1);
24697 arg2 =
static_cast< PLFLT >(val2);
24699 _outv = octave_value();
24703 return octave_value_list();
24718 octave_value_list _out;
24719 octave_value_list *_outp=&_out;
24720 octave_value _outv;
24730 arg1 =
static_cast< PLINT >(val1);
24735 arg2 =
static_cast< PLINT >(val2);
24737 _outv = octave_value();
24741 return octave_value_list();
24750 char *arg1 = (
char *) 0 ;
24760 octave_value_list _out;
24761 octave_value_list *_outp=&_out;
24762 octave_value _outv;
24772 arg1 =
reinterpret_cast< char *
>(buf1);
24777 arg2 =
static_cast< PLINT >(val2);
24782 arg3 =
static_cast< PLINT >(val3);
24783 plstart((
char const *)arg1,arg2,arg3);
24784 _outv = octave_value();
24790 return octave_value_list();
24803 octave_value_list _out;
24804 octave_value_list *_outp=&_out;
24805 octave_value _outv;
24812 octave_value obj = args(0);
24813#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24814 if ( !obj.isempty() )
24816 if ( !obj.is_empty() )
24819 if ( obj.is_function_handle() || obj.is_inline_function() )
24823 else if ( obj.is_string() )
24840 _outv = octave_value();
24844 return octave_value_list();
24856 char *arg4 = (
char *) 0 ;
24862 octave_value_list _out;
24863 octave_value_list *_outp=&_out;
24864 octave_value _outv;
24871 if (
_n_dims( args(0) ) > 1 )
24876 temp1 = args(0).matrix_value();
24877 arg2 = &temp1( 0, 0 );
24880 if (
_n_dims( args(1) ) > 1 )
24888 temp3 = args(1).matrix_value();
24889 arg3 = &temp3( 0, 0 );
24895 arg4 =
reinterpret_cast< char *
>(buf4);
24896 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24897 _outv = octave_value();
24915 return octave_value_list();
24935 char *arg5 = (
char *) 0 ;
24942 octave_value_list _out;
24943 octave_value_list *_outp=&_out;
24944 octave_value _outv;
24951 if (
_n_dims( args(0) ) > 1 )
24956 temp1 = args(0).matrix_value();
24957 arg2 = &temp1( 0, 0 );
24960 if (
_n_dims( args(1) ) > 1 )
24968 temp3 = args(1).matrix_value();
24969 arg3 = &temp3( 0, 0 );
24972 if (
_n_dims( args(2) ) > 1 )
24980 temp4 = args(2).matrix_value();
24981 arg4 = &temp4( 0, 0 );
24987 arg5 =
reinterpret_cast< char *
>(buf5);
24988 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24989 _outv = octave_value();
25013 return octave_value_list();
25044 octave_value_list _out;
25045 octave_value_list *_outp=&_out;
25046 octave_value _outv;
25056 arg1 =
static_cast< PLINT >(val1);
25061 arg2 =
static_cast< PLINT >(val2);
25066 arg3 =
static_cast< PLFLT >(val3);
25071 arg4 =
static_cast< PLFLT >(val4);
25073 _outv = octave_value();
25077 return octave_value_list();
25089 octave_value_list _out;
25090 octave_value_list *_outp=&_out;
25091 octave_value _outv;
25101 arg1 =
static_cast< PLINT >(val1);
25103 _outv = octave_value();
25107 return octave_value_list();
25121 octave_value_list _out;
25122 octave_value_list *_outp=&_out;
25123 octave_value _outv;
25130 if (
_n_dims( args(0) ) > 1 )
25136 temp1 = args(0).matrix_value();
25140 if (
_n_dims( args(1) ) > 1 )
25148 temp3 = args(1).matrix_value();
25152 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25153 _outv = octave_value();
25169 return octave_value_list();
25192 octave_value_list _out;
25193 octave_value_list *_outp=&_out;
25194 octave_value _outv;
25201 if (
_n_dims( args(0) ) > 1 )
25205#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25206 if ( !args(0).isempty() )
25208 if ( !args(0).is_empty() )
25212 temp1 = args(0).matrix_value();
25213 arg1 = &temp1( 0, 0 );
25222 if (
_n_dims( args(1) ) > 1 )
25226#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25227 if ( !args(1).isempty() )
25229 if ( !args(1).is_empty() )
25236 temp2 = args(1).matrix_value();
25237 arg2 = &temp2( 0, 0 );
25250 arg4 =
static_cast< PLBOOL >(val4);
25251 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25252 _outv = octave_value();
25268 return octave_value_list();
25295 octave_value_list _out;
25296 octave_value_list *_outp=&_out;
25297 octave_value _outv;
25307 arg1 =
static_cast< PLFLT >(val1);
25312 arg2 =
static_cast< PLFLT >(val2);
25317 arg3 =
static_cast< PLFLT >(val3);
25322 arg4 =
static_cast< PLFLT >(val4);
25323 plsvpa(arg1,arg2,arg3,arg4);
25324 _outv = octave_value();
25328 return octave_value_list();
25343 octave_value_list _out;
25344 octave_value_list *_outp=&_out;
25345 octave_value _outv;
25355 arg1 =
static_cast< PLINT >(val1);
25360 arg2 =
static_cast< PLINT >(val2);
25362 _outv = octave_value();
25366 return octave_value_list();
25381 octave_value_list _out;
25382 octave_value_list *_outp=&_out;
25383 octave_value _outv;
25393 arg1 =
static_cast< PLINT >(val1);
25398 arg2 =
static_cast< PLINT >(val2);
25400 _outv = octave_value();
25404 return octave_value_list();
25421 octave_value_list _out;
25422 octave_value_list *_outp=&_out;
25423 octave_value _outv;
25430 if (
_n_dims( args(0) ) > 1 )
25435 temp1 = args(0).matrix_value();
25436 arg2 = &temp1( 0, 0 );
25439 if (
_n_dims( args(1) ) > 1 )
25447 temp3 = args(1).matrix_value();
25448 arg3 = &temp3( 0, 0 );
25454 arg4 =
static_cast< PLINT >(val4);
25455 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25456 _outv = octave_value();
25472 return octave_value_list();
25493 octave_value_list _out;
25494 octave_value_list *_outp=&_out;
25495 octave_value _outv;
25505 arg1 =
static_cast< PLINT >(val1);
25510 arg2 =
static_cast< PLINT >(val2);
25512 _outv = octave_value();
25516 return octave_value_list();
25525 octave_value_list _out;
25526 octave_value_list *_outp=&_out;
25527 octave_value _outv;
25534 _outv = octave_value();
25538 return octave_value_list();
25547 char *arg1 = (
char *) 0 ;
25551 octave_value_list _out;
25552 octave_value_list *_outp=&_out;
25553 octave_value _outv;
25563 arg1 =
reinterpret_cast< char *
>(buf1);
25565 _outv = octave_value();
25571 return octave_value_list();
25584 octave_value_list _out;
25585 octave_value_list *_outp=&_out;
25586 octave_value _outv;
25596 arg1 =
static_cast< PLFLT >(val1);
25598 _outv = octave_value();
25602 return octave_value_list();
25626 octave_value_list _out;
25627 octave_value_list *_outp=&_out;
25628 octave_value _outv;
25638 arg1 =
static_cast< PLFLT >(val1);
25643 arg2 =
static_cast< PLFLT >(val2);
25648 arg3 =
static_cast< PLFLT >(val3);
25653 arg4 =
static_cast< PLFLT >(val4);
25658 arg5 =
static_cast< PLFLT >(val5);
25659 plvpas(arg1,arg2,arg3,arg4,arg5);
25660 _outv = octave_value();
25664 return octave_value_list();
25685 octave_value_list _out;
25686 octave_value_list *_outp=&_out;
25687 octave_value _outv;
25697 arg1 =
static_cast< PLFLT >(val1);
25702 arg2 =
static_cast< PLFLT >(val2);
25707 arg3 =
static_cast< PLFLT >(val3);
25712 arg4 =
static_cast< PLFLT >(val4);
25713 plvpor(arg1,arg2,arg3,arg4);
25714 _outv = octave_value();
25718 return octave_value_list();
25727 octave_value_list _out;
25728 octave_value_list *_outp=&_out;
25729 octave_value _outv;
25736 _outv = octave_value();
25740 return octave_value_list();
25782 octave_value_list _out;
25783 octave_value_list *_outp=&_out;
25784 octave_value _outv;
25794 arg1 =
static_cast< PLFLT >(val1);
25799 arg2 =
static_cast< PLFLT >(val2);
25804 arg3 =
static_cast< PLFLT >(val3);
25809 arg4 =
static_cast< PLFLT >(val4);
25814 arg5 =
static_cast< PLFLT >(val5);
25819 arg6 =
static_cast< PLFLT >(val6);
25824 arg7 =
static_cast< PLFLT >(val7);
25829 arg8 =
static_cast< PLFLT >(val8);
25834 arg9 =
static_cast< PLFLT >(val9);
25839 arg10 =
static_cast< PLFLT >(val10);
25844 arg11 =
static_cast< PLFLT >(val11);
25845 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25846 _outv = octave_value();
25850 return octave_value_list();
25862 octave_value_list _out;
25863 octave_value_list *_outp=&_out;
25864 octave_value _outv;
25874 arg1 =
static_cast< PLFLT >(val1);
25876 _outv = octave_value();
25880 return octave_value_list();
25901 octave_value_list _out;
25902 octave_value_list *_outp=&_out;
25903 octave_value _outv;
25913 arg1 =
static_cast< PLFLT >(val1);
25918 arg2 =
static_cast< PLFLT >(val2);
25923 arg3 =
static_cast< PLFLT >(val3);
25928 arg4 =
static_cast< PLFLT >(val4);
25929 plwind(arg1,arg2,arg3,arg4);
25930 _outv = octave_value();
25934 return octave_value_list();
25949 octave_value_list _out;
25950 octave_value_list *_outp=&_out;
25951 octave_value _outv;
25962 arg1 =
static_cast< PLBOOL >(val1);
25964 _outv = octave_value();
25974 return octave_value_list();
25984 char *arg2 = (
char *) 0 ;
26000 octave_value_list _out;
26001 octave_value_list *_outp=&_out;
26002 octave_value _outv;
26009 octave_value obj = args(0);
26010#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26011 if ( !obj.isempty() )
26013 if ( !obj.is_empty() )
26016 if ( obj.is_function_handle() || obj.is_inline_function() )
26020 else if ( obj.is_string() )
26036 arg2 =
reinterpret_cast< char *
>(buf2);
26041 arg3 =
static_cast< PLFLT >(val3);
26046 arg4 =
static_cast< PLFLT >(val4);
26051 arg5 =
static_cast< PLFLT >(val5);
26056 arg6 =
static_cast< PLFLT >(val6);
26057 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
26058 _outv = octave_value();
26064 return octave_value_list();
26075 char *arg2 = (
char *) 0 ;
26094 octave_value_list _out;
26095 octave_value_list *_outp=&_out;
26096 octave_value _outv;
26103 octave_value obj = args(0);
26104#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26105 if ( !obj.isempty() )
26107 if ( !obj.is_empty() )
26110 if ( obj.is_function_handle() || obj.is_inline_function() )
26114 else if ( obj.is_string() )
26130 arg2 =
reinterpret_cast< char *
>(buf2);
26135 arg3 =
static_cast< PLFLT >(val3);
26140 arg4 =
static_cast< PLFLT >(val4);
26145 arg5 =
static_cast< PLFLT >(val5);
26150 arg6 =
static_cast< PLFLT >(val6);
26152 if (
_n_dims( args(6) ) > 1 )
26156#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26157 if ( !args(6).isempty() )
26159 if ( !args(6).is_empty() )
26163 temp7 = args(6).matrix_value();
26164 arg7 =
new PLINT[arg8];
26173 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26174 _outv = octave_value();
26186 return octave_value_list();
26200 char *arg2 = (
char *) 0 ;
26201 char *arg3 = (
char *) 0 ;
26223 octave_value_list _out;
26224 octave_value_list *_outp=&_out;
26225 octave_value _outv;
26232 octave_value obj = args(0);
26233#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26234 if ( !obj.isempty() )
26236 if ( !obj.is_empty() )
26239 if ( obj.is_function_handle() || obj.is_inline_function() )
26243 else if ( obj.is_string() )
26259 arg2 =
reinterpret_cast< char *
>(buf2);
26264 arg3 =
reinterpret_cast< char *
>(buf3);
26269 arg4 =
static_cast< PLFLT >(val4);
26274 arg5 =
static_cast< PLFLT >(val5);
26279 arg6 =
static_cast< PLFLT >(val6);
26284 arg7 =
static_cast< PLFLT >(val7);
26286 if (
_n_dims( args(7) ) > 1 )
26290#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26291 if ( !args(7).isempty() )
26293 if ( !args(7).is_empty() )
26297 temp8 = args(7).matrix_value();
26298 arg8 =
new PLINT[arg9];
26307 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26308 _outv = octave_value();
26322 return octave_value_list();
26337 char *arg2 = (
char *) 0 ;
26341 char *arg6 = (
char *) 0 ;
26369 octave_value_list _out;
26370 octave_value_list *_outp=&_out;
26371 octave_value _outv;
26378 octave_value obj = args(0);
26379#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26380 if ( !obj.isempty() )
26382 if ( !obj.is_empty() )
26385 if ( obj.is_function_handle() || obj.is_inline_function() )
26389 else if ( obj.is_string() )
26405 arg2 =
reinterpret_cast< char *
>(buf2);
26410 arg3 =
static_cast< PLFLT >(val3);
26415 arg4 =
static_cast< PLFLT >(val4);
26420 arg5 =
static_cast< PLFLT >(val5);
26425 arg6 =
reinterpret_cast< char *
>(buf6);
26430 arg7 =
static_cast< PLFLT >(val7);
26435 arg8 =
static_cast< PLFLT >(val8);
26440 arg9 =
static_cast< PLFLT >(val9);
26445 arg10 =
static_cast< PLFLT >(val10);
26450 arg11 =
static_cast< PLINT >(val11);
26451 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26452 _outv = octave_value();
26460 return octave_value_list();
26472 char *arg2 = (
char *) 0 ;
26491 octave_value_list _out;
26492 octave_value_list *_outp=&_out;
26493 octave_value _outv;
26500 octave_value obj = args(0);
26501#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26502 if ( !obj.isempty() )
26504 if ( !obj.is_empty() )
26507 if ( obj.is_function_handle() || obj.is_inline_function() )
26511 else if ( obj.is_string() )
26527 arg2 =
reinterpret_cast< char *
>(buf2);
26532 arg3 =
static_cast< PLFLT >(val3);
26537 arg4 =
static_cast< PLFLT >(val4);
26542 arg5 =
static_cast< PLFLT >(val5);
26547 arg6 =
static_cast< PLFLT >(val6);
26549 if (
_n_dims( args(6) ) > 1 )
26553#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26554 if ( !args(6).isempty() )
26556 if ( !args(6).is_empty() )
26560 temp7 = args(6).matrix_value();
26561 arg7 =
new PLINT[arg8];
26570 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26571 _outv = octave_value();
26583 return octave_value_list();
26615 octave_value_list _out;
26616 octave_value_list *_outp=&_out;
26617 octave_value _outv;
26624 octave_value obj = args(0);
26625#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26626 if ( !obj.isempty() )
26628 if ( !obj.is_empty() )
26631 if ( obj.is_function_handle() || obj.is_inline_function() )
26635 else if ( obj.is_string() )
26651 arg2 =
static_cast< PLFLT >(val2);
26656 arg3 =
static_cast< PLFLT >(val3);
26661 arg4 =
static_cast< PLFLT >(val4);
26666 arg5 =
static_cast< PLFLT >(val5);
26671 arg6 =
static_cast< PLFLT >(val6);
26676 arg7 =
static_cast< PLFLT >(val7);
26678 _outv = octave_value();
26682 return octave_value_list();
26691 octave_value_list _out;
26692 octave_value_list *_outp=&_out;
26693 octave_value _outv;
26700 _outv = octave_value();
26704 return octave_value_list();
26713 octave_value_list _out;
26714 octave_value_list *_outp=&_out;
26715 octave_value _outv;
26722 _outv = octave_value();
26726 return octave_value_list();
26735 char *arg1 = (
char *) 0 ;
26736 char *arg2 = (
char *) 0 ;
26743 octave_value_list _out;
26744 octave_value_list *_outp=&_out;
26745 octave_value _outv;
26755 arg1 =
reinterpret_cast< char *
>(buf1);
26760 arg2 =
reinterpret_cast< char *
>(buf2);
26761 plSetUsage((
char const *)arg1,(
char const *)arg2);
26762 _outv = octave_value();
26770 return octave_value_list();
26781 octave_value_list _out;
26782 octave_value_list *_outp=&_out;
26783 octave_value _outv;
26790 _outv = octave_value();
26794 return octave_value_list();
26804{
"testppchar",_wrap_testppchar,0,0,2,0},
26806{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26809{
"plcont0",_wrap_plcont0,0,0,2,0},
26810{
"plcont1",_wrap_plcont1,0,0,2,0},
26811{
"plcont2",_wrap_plcont2,0,0,2,0},
26812{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26822{
"plshade1",_wrap_plshade1,0,0,2,0},
26823{
"plshade2",_wrap_plshade2,0,0,2,0},
26825{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26826{
"plshades1",_wrap_plshades1,0,0,2,0},
26827{
"plshades2",_wrap_plshades2,0,0,2,0},
26829{
"plvect1",_wrap_plvect1,0,0,2,0},
26830{
"plvect2",_wrap_plvect2,0,0,2,0},
26831{
"pplimage",_wrap_pplimage,0,0,2,0},
26833{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26834{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26835{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27121#define SWIGRUNTIME_DEBUG
27124#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27125#define SWIG_INIT_CLIENT_DATA_TYPE void *
27147 if (!module_head) {
27160 }
while (iter!= module_head);
27171 if (init == 0)
return;
27174#ifdef SWIGRUNTIME_DEBUG
27175 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
27182#ifdef SWIGRUNTIME_DEBUG
27192#ifdef SWIGRUNTIME_DEBUG
27193 printf(
"SWIG_InitializeModule: found type %s\n", type->name);
27197#ifdef SWIGRUNTIME_DEBUG
27198 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27207 while (cast->
type) {
27211#ifdef SWIGRUNTIME_DEBUG
27212 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27216#ifdef SWIGRUNTIME_DEBUG
27217 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27222#ifdef SWIGRUNTIME_DEBUG
27223 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27230#ifdef SWIGRUNTIME_DEBUG
27231 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27233 if (!ocast) ret = 0;
27238#ifdef SWIGRUNTIME_DEBUG
27239 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27242 type->cast->prev = cast;
27243 cast->
next = type->cast;
27254#ifdef SWIGRUNTIME_DEBUG
27255 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27260 while (cast->
type) {
27261 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27265 printf(
"---- Total casts: %d\n",j);
27267 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27280 static int init_run = 0;
27282 if (init_run)
return;
27293 equiv = equiv->
next;
27313#if SWIG_OCTAVE_PREREQ(6,0,0)
27314#elif SWIG_OCTAVE_PREREQ(4,2,0)
27315 octave::unwind_protect frame;
27316 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27317 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27318#elif SWIG_OCTAVE_PREREQ(3,3,50)
27319 unwind_protect frame;
27320 frame.protect_var(error_state); error_state = 0;
27321 frame.protect_var(warning_state); warning_state = 0;
27322 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27323 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27325 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27326 unwind_protect_int(error_state); error_state = 0;
27327 unwind_protect_int(warning_state); warning_state = 0;
27328 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27329 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27331#if SWIG_OCTAVE_PREREQ(4,2,0)
27333#if SWIG_OCTAVE_PREREQ(4,4,0)
27334 octave::feval(
name, octave_value_list(), 0);
27336 feval(
name, octave_value_list(), 0);
27339 }
catch (octave::execution_exception&) { }
27341 feval(
name, octave_value_list(), 0);
27342 retn = (error_state == 0);
27344#if !SWIG_OCTAVE_PREREQ(3,3,50)
27345 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27357#if SWIG_OCTAVE_PREREQ(6,0,0)
27358#elif SWIG_OCTAVE_PREREQ(4,2,0)
27359 octave::unwind_protect frame;
27360 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27361 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27362#elif SWIG_OCTAVE_PREREQ(3,3,50)
27363 unwind_protect frame;
27364 frame.protect_var(error_state); error_state = 0;
27365 frame.protect_var(warning_state); warning_state = 0;
27366 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27367 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27369 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27370 unwind_protect_int(error_state); error_state = 0;
27371 unwind_protect_int(warning_state); warning_state = 0;
27372 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27373 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27375 octave_value_list args;
27377 args.append(octloadfcn->fcn_file_name());
27378#if SWIG_OCTAVE_PREREQ(4,2,0)
27380#if SWIG_OCTAVE_PREREQ(4,4,0)
27381 octave::feval(
"autoload", args, 0);
27383 feval(
"autoload", args, 0);
27386 }
catch (octave::execution_exception&) { }
27388 feval(
"autoload", args, 0);
27389 retn = (error_state == 0);
27391#if !SWIG_OCTAVE_PREREQ(3,3,50)
27392 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27402@deftypefn {Loadable Function} {} subclass()\n\
27403@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27404Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27406See the SWIG manual for usage examples.\n\
27411 for (
int j = 0; j < args.length(); ++j) {
27412 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27416 error(
"subclass: cannot subclass object not constructed on octave side");
27417 return octave_value_list();
27420 }
else if (args(j).is_function_handle()) {
27421 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27422 }
else if (args(j).is_string()) {
27423 if (j + 1 >= args.length()) {
27424 error(
"subclass: member assignments must be of string,value form");
27425 return octave_value_list();
27427 top->
assign(args(j).string_value(), args(j + 1));
27430 error(
"subclass: invalid arguments to subclass()");
27431 return octave_value_list();
27438@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27439Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27443 if (args.length() != 1) {
27444 error(
"swig_type: must be called with only a single object");
27445 return octave_value_list();
27449 error(
"swig_type: object is not a swig_ref");
27450 return octave_value_list();
27456@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27457Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27458otherwise return `<unknown>'.\n\
27462 if (args.length() != 1 || !args(0).is_string()) {
27463 error(
"swig_typequery: must be called with single string argument");
27464 return octave_value_list();
27469 return octave_value(
"<unknown>");
27470 return octave_value(type->name);
27474@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27475Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27479 if (args.length() != 1) {
27480 error(
"swig_this: must be called with only a single object");
27481 return octave_value_list();
27483 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27484 return octave_value(octave_uint64(0));
27487 error(
"swig_this: object is not a swig_ref");
27488 return octave_value_list();
27490 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27494@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27495Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27499 if (args.length() != 3) {
27500 error(
"swig_octave_prereq: must be called with 3 arguments");
27501 return octave_value_list();
27503 const int major = args(0).int_value();
27504 const int minor = args(1).int_value();
27505 const int patch = args(2).int_value();
27507 return octave_value(prereq);
27511@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27512Exit Octave without performing any memory cleanup.\n\
27516 if (args.length() > 1) {
27517 error(
"swig_exit: must be called with at most one arguments");
27518 return octave_value_list();
27520 int exit_status = 0;
27521 if (args.length() == 1) {
27522 exit_status = args(0).int_value();
27524 ::_Exit(exit_status);
27525 return octave_value();
27529@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27530Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27543#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27544#if !SWIG_OCTAVE_PREREQ(4,4,0)
27545#if SWIG_OCTAVE_PREREQ(3,2,0)
27546 octave_exit = ::_Exit;
27552 if (args.length() != 0 || nargout != 0) {
27554 return octave_value_list();
27562#if SWIG_OCTAVE_PREREQ(3,2,0)
27563 octave_value_list eval_args;
27564 eval_args.append(
"base");
27565 eval_args.append(
"function __swig_atexit__; "
27572 "__swig_atexit__; "
27573 "atexit(\"__swig_atexit__\", false); "
27574 "atexit(\"__swig_atexit__\")");
27575#if SWIG_OCTAVE_PREREQ(4,4,0)
27576 octave::feval(
"evalin", eval_args, 0);
27578 feval(
"evalin", eval_args, 0);
27582#if SWIG_OCTAVE_PREREQ(4,4,0)
27584 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27585 string_vector types = typeinfo.installed_type_names();
27586 bool register_octave_swig_ref =
true;
27587 bool register_octave_swig_packed =
true;
27588 for (
int i = 0; i < types.numel(); ++i) {
27589 if (types(i) == octave_swig_ref::static_type_name()) {
27590 register_octave_swig_ref =
false;
27591 octave_swig_ref::set_type_id(i);
27593 if (types(i) == octave_swig_packed::static_type_name()) {
27594 register_octave_swig_packed =
false;
27595 octave_swig_packed::set_type_id(i);
27598 if (register_octave_swig_ref) {
27599 octave_swig_ref::register_type();
27601 if (register_octave_swig_packed) {
27602 octave_swig_packed::register_type();
27606 octave_swig_ref::register_type();
27607 octave_swig_packed::register_type();
27612#if SWIG_OCTAVE_PREREQ(8,0,0)
27613 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27614 octave_function *me = tree_eval.current_function();
27615#elif SWIG_OCTAVE_PREREQ(6,0,0)
27616 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27617 octave::call_stack& stack = tree_eval.get_call_stack();
27618 octave_function *me = stack.current_function();
27619#elif SWIG_OCTAVE_PREREQ(4,4,0)
27620 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27621 octave_function *me = stack.current();
27623 octave_function *me = octave_call_stack::current();
27627 return octave_value_list();
27630 return octave_value_list();
27633 return octave_value_list();
27636 return octave_value_list();
27639 return octave_value_list();
27642 return octave_value_list();
27680 return octave_value_list();
27687 if (mb->second.first && mb->second.first->method) {
27689 return octave_value_list();
27694#if SWIG_OCTAVE_PREREQ(4,4,0)
27695 octave::interpreter::the_interpreter()->mlock();
27696#elif SWIG_OCTAVE_PREREQ(3,2,0)
27706 if (mb->second.second.is_defined()) {
27715 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
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
swig_member_const_iterator swig_members_begin()
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
octave_base_value * empty_clone() const
std::map< std::string, member_value_pair > member_map
dim_vector dims(void) const
octave_base_value * clone() const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
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)
member_map::const_iterator swig_member_const_iterator
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
int cast(void **vptr, swig_type_info *type, int *own, int flags)
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
void merge(octave_swig_type &rhs)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
const swig_type_info * construct_type
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
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
#define SWIG_RuntimeError
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plend1_texinfo
static const char * _wrap_plgcolbga_texinfo
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plprec_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
static const char *const SWIG_name_usage
static const char * _wrap_plgpage_texinfo
static const char * _wrap_plschr_texinfo
static int _arraylen(const octave_value &o_obj)
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
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
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static int _n_dims(const octave_value &o_obj)
static const char * _wrap_plot3d_texinfo
static const char * _wrap_plmtex_texinfo
static const char * _wrap_plmap_texinfo
#define swigreg_unary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plaxes_texinfo
static const char * _wrap_plscmap0n_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
static const char * _wrap_plsesc_texinfo
static const char * _wrap_plgvpw_texinfo
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type)
static const char * _wrap_plsdiplz_texinfo
static const char * _wrap_pllsty_texinfo
static const char *const subclass_usage
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static const char * _wrap_plgstrm_texinfo
static const char * _wrap_plconfigtime_texinfo
static const char * _wrap_plssub_texinfo
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
static const char * _wrap_plline_texinfo
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static const char *const swig_type_usage
static const char * _wrap_plshade_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
static const char *const swig_exit_usage
static const char * _wrap_plsdev_texinfo
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plinit_texinfo
plgriddata(x, y, z, xg, yg, type, data)\n\ \n\ \n\ This function is used in example 21.\n\ \n\ \n\ \n\ SYNOPSIS:\n\ \n\ plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ \n\ ARGUMENTS:\n\ \n\ x(PLFLT_VECTOR, input) : The input x vector.\n\ \n\ y(PLFLT_VECTOR, input) : The input y vector.\n\ \n\ z(PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\ y[i], z[i] represents one data sample coordinate.\n\ \n\ npts(PLINT, input) : The number of data samples in the x, y and z\n\ vectors.\n\ \n\ xg(PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ in the x direction. Usually xg has nptsx equally spaced values\n\ from the minimum to the maximum values of the x input vector.\n\ \n\ nptsx(PLINT, input) : The number of points in the xg vector.\n\ \n\ yg(PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ in the y direction. Similar to the xg parameter.\n\ \n\ nptsy(PLINT, input) : The number of points in the yg vector.\n\ \n\ zg(PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\ where data lies in the grid specified by xg and yg. Therefore the\n\ zg matrix must be dimensioned\n\ nptsx by\n\ nptsy.\n\ \n\ type(PLINT, input) : The type of grid interpolation algorithm to\n\ use, which can be:GRID_CSA:Bivariate Cubic Spline approximation\n\ GRID_DTLI:Delaunay Triangulation Linear Interpolation\n\ GRID_NNI:Natural Neighbors Interpolation\n\ GRID_NNIDW:Nearest Neighbors Inverse Distance Weighted\n\ GRID_NNLI:Nearest Neighbors Linear Interpolation\n\ GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\ Weighted\n\ For details of the algorithms read the source file plgridd.c.\n\ \n\ data(PLFLT, input) : Some gridding algorithms require extra data,\n\ which can be specified through this argument. Currently, for\n\ algorithm:GRID_NNIDW, data specifies the number of neighbors to\n\ use, the lower the value, the noisier(more local) the\n\ approximation is.\n\ GRID_NNLI, data specifies what a thin triangle is, in the\n\ range[1. .. 2.]. High values enable the usage of very thin\n\ triangles for interpolation, possibly resulting in error in\n\ the approximation.\n\ GRID_NNI, only weights greater than data will be accepted. If\n\ 0, all weights will be accepted.\n\ " zg
static const char * _wrap_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plcpstrm_texinfo
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plvect_texinfo
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
static const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plscmap1a_texinfo
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
static int _dim(const octave_value &o_obj, int dim_idx)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
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
#define SWIG_NullReferenceError
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
struct swig_type_info swig_type_info
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)
static const char *const swig_octave_prereq_usage
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscmap1l_texinfo
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
octave_function * fcnMapForm
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
static const char * _wrap_pllab_texinfo
static const char * _wrap_plspage_texinfo
static int my_plGetCursor(int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plpoin_texinfo
static const char * _wrap_plspause_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static const char * _wrap_plclear_texinfo
struct swig_module_info swig_module_info
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plpath_texinfo
static const char * _wrap_plimagefr_texinfo
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
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
#define SWIG_DivisionByZero
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
static const char * _wrap_plssym_texinfo
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
#define SWIG_OverflowError
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
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
#define SWIGRUNTIMEINLINE
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
#define SWIG_Error(code, msg)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
#define SWIG_ErrorType(code)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
static swig_cast_info * swig_cast_initial[]
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
#define SWIG_TypeQuery(name)
static int _wrap_plend(lua_State *L)
static swig_cast_info _swigc__p_int[]
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
static int _wrap_plGetCursor(lua_State *L)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIG_ConvertPtr(L, idx, ptr, type, flags)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
#define 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[]
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
#define SWIG_POINTER_RELEASE
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
static swig_type_info _swigt__p_p_char
static int _wrap_plend1(lua_State *L)
#define SWIG_POINTER_CLEAR
#define 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)
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
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_ERROR_RELEASE_NOT_OWNED
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
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 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