10#define SWIG_VERSION 0x040201
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
157#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
158 (defined __cplusplus && __cplusplus >= 201103L) || \
159 defined SWIG_HAVE_SNPRINTF) && \
160 !defined SWIG_NO_SNPRINTF
161# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
162# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
168# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
169# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
183#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
184#define SWIG_OCTAVE_OCTHEADERS_HPP
198#include <octave/oct.h>
199#include <octave/version.h>
203#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
204 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
207#if !defined(OCTAVE_MAJOR_VERSION)
209# if !defined(OCTAVE_API_VERSION_NUMBER)
213# include <octave/ov.h>
214# if defined(octave_ov_h)
215# define OCTAVE_MAJOR_VERSION 3
216# define OCTAVE_MINOR_VERSION 8
217# define OCTAVE_PATCH_VERSION 0
221# define ComplexLU __ignore
222# include <octave/CmplxLU.h>
224# if defined(octave_Complex_LU_h)
227# define OCTAVE_MAJOR_VERSION 3
228# define OCTAVE_MINOR_VERSION 1
229# define OCTAVE_PATCH_VERSION 99
234# define OCTAVE_MAJOR_VERSION 3
235# define OCTAVE_MINOR_VERSION 2
236# define OCTAVE_PATCH_VERSION 0
244# elif OCTAVE_API_VERSION_NUMBER >= 48
245# define OCTAVE_MAJOR_VERSION 3
246# define OCTAVE_MINOR_VERSION 6
247# define OCTAVE_PATCH_VERSION 0
249# elif OCTAVE_API_VERSION_NUMBER >= 45
250# define OCTAVE_MAJOR_VERSION 3
251# define OCTAVE_MINOR_VERSION 4
252# define OCTAVE_PATCH_VERSION 1
254# elif OCTAVE_API_VERSION_NUMBER >= 42
255# define OCTAVE_MAJOR_VERSION 3
256# define OCTAVE_MINOR_VERSION 3
257# define OCTAVE_PATCH_VERSION 54
259# elif OCTAVE_API_VERSION_NUMBER >= 41
260# define OCTAVE_MAJOR_VERSION 3
261# define OCTAVE_MINOR_VERSION 3
262# define OCTAVE_PATCH_VERSION 53
264# elif OCTAVE_API_VERSION_NUMBER >= 40
265# define OCTAVE_MAJOR_VERSION 3
266# define OCTAVE_MINOR_VERSION 3
267# define OCTAVE_PATCH_VERSION 52
269# elif OCTAVE_API_VERSION_NUMBER >= 39
270# define OCTAVE_MAJOR_VERSION 3
271# define OCTAVE_MINOR_VERSION 3
272# define OCTAVE_PATCH_VERSION 51
275# define OCTAVE_MAJOR_VERSION 3
276# define OCTAVE_MINOR_VERSION 3
277# define OCTAVE_PATCH_VERSION 50
284#include <octave/Cell.h>
285#include <octave/dynamic-ld.h>
286#include <octave/oct-env.h>
287#include <octave/oct-map.h>
288#include <octave/ov-scalar.h>
289#include <octave/ov-fcn-handle.h>
290#include <octave/parse.h>
291#if SWIG_OCTAVE_PREREQ(4,2,0)
292#include <octave/interpreter.h>
294#include <octave/toplev.h>
296#include <octave/unwind-prot.h>
297#if SWIG_OCTAVE_PREREQ(4,2,0)
298#include <octave/call-stack.h>
312#define SWIG_RUNTIME_VERSION "4"
315#ifdef SWIG_TYPE_TABLE
316# define SWIG_QUOTE_STRING(x) #x
317# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
318# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
320# define SWIG_TYPE_TABLE_NAME
333# define SWIGRUNTIME SWIGINTERN
336#ifndef SWIGRUNTIMEINLINE
337# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
341#ifndef SWIG_BUFFER_SIZE
342# define SWIG_BUFFER_SIZE 1024
346#define SWIG_POINTER_DISOWN 0x1
347#define SWIG_CAST_NEW_MEMORY 0x2
348#define SWIG_POINTER_NO_NULL 0x4
349#define SWIG_POINTER_CLEAR 0x8
350#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
353#define SWIG_POINTER_OWN 0x1
437#define SWIG_ERROR (-1)
441#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
443#define SWIG_IsOK(r) (r >= 0)
444#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
447#define SWIG_CASTRANKLIMIT (1 << 8)
449#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
451#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
453#define SWIG_BADOBJ (SWIG_ERROR)
454#define SWIG_OLDOBJ (SWIG_OK)
455#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
456#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
458#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
459#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
460#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
461#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
462#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
463#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
466#if defined(SWIG_CASTRANK_MODE)
467# ifndef SWIG_TypeRank
468# define SWIG_TypeRank unsigned long
470# ifndef SWIG_MAXCASTRANK
471# define SWIG_MAXCASTRANK (2)
473# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
474# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
479 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
482# define SWIG_AddCast(r) (r)
483# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
493typedef void *(*swig_converter_func)(
void *,
int *);
535 const char *f2,
const char *l2) {
536 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
537 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
538 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
539 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
541 return (
int)((l1 - f1) - (l2 - f2));
551 const char* te = tb + strlen(tb);
553 while (equiv != 0 && *ne) {
554 for (nb = ne; *ne; ++ne) {
555 if (*ne ==
'|')
break;
580 if (strcmp(iter->type->name, c) == 0) {
581 if (iter == ty->
cast)
584 iter->prev->next = iter->next;
586 iter->next->prev = iter->prev;
587 iter->next = ty->
cast;
589 if (ty->
cast) ty->
cast->prev = iter;
607 if (iter->type == from) {
608 if (iter == ty->
cast)
611 iter->prev->next = iter->next;
613 iter->next->prev = iter->prev;
614 iter->next = ty->
cast;
616 if (ty->
cast) ty->
cast->prev = iter;
640 if (!ty || !ty->
dcast)
return ty;
641 while (ty && (ty->
dcast)) {
642 ty = (*ty->
dcast)(ptr);
666 if (!type)
return NULL;
667 if (type->str != NULL) {
668 const char *last_name = type->str;
670 for (s = type->str; *s; s++)
671 if (*s ==
'|') last_name = s+1;
690 if (!tc->clientdata) {
719 size_t r = iter->
size - 1;
722 size_t i = (l + r) >> 1;
723 const char *iname = iter->types[i]->name;
725 int compare = strcmp(
name, iname);
727 return iter->types[i];
728 }
else if (compare < 0) {
734 }
else if (compare > 0) {
743 }
while (iter != end);
770 for (; i < iter->size; ++i) {
772 return iter->
types[i];
775 }
while (iter != end);
787 static const char hex[17] =
"0123456789abcdef";
788 const unsigned char *u = (
unsigned char *) ptr;
789 const unsigned char *eu = u + sz;
790 for (; u != eu; ++u) {
791 unsigned char uu = *u;
792 *(c++) = hex[(uu & 0xf0) >> 4];
793 *(c++) = hex[uu & 0xf];
803 unsigned char *u = (
unsigned char *) ptr;
804 const unsigned char *eu = u + sz;
805 for (; u != eu; ++u) {
808 if ((d >=
'0') && (d <=
'9'))
809 uu = (
unsigned char)((d -
'0') << 4);
810 else if ((d >=
'a') && (d <=
'f'))
811 uu = (
unsigned char)((d - (
'a'-10)) << 4);
815 if ((d >=
'0') && (d <=
'9'))
816 uu |= (
unsigned char)(d -
'0');
817 else if ((d >=
'a') && (d <=
'f'))
818 uu |= (
unsigned char)(d - (
'a'-10));
832 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
835 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
843 if (strcmp(c,
"NULL") == 0) {
856 size_t lname = (
name ? strlen(
name) : 0);
857 if ((2*sz + 2 + lname) > bsz)
return 0;
861 strncpy(r,
name,lname+1);
871 if (strcmp(c,
"NULL") == 0) {
886#define SWIG_UnknownError -1
887#define SWIG_IOError -2
888#define SWIG_RuntimeError -3
889#define SWIG_IndexError -4
890#define SWIG_TypeError -5
891#define SWIG_DivisionByZero -6
892#define SWIG_OverflowError -7
893#define SWIG_SyntaxError -8
894#define SWIG_ValueError -9
895#define SWIG_SystemError -10
896#define SWIG_AttributeError -11
897#define SWIG_MemoryError -12
898#define SWIG_NullReferenceError -13
901#if !SWIG_OCTAVE_PREREQ(3,2,0)
902#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
904#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
908 if (num_args > max_args && !varargs)
909 error(
"function %s takes at most %i arguments", func_name, max_args);
910 else if (num_args < min_args)
911 error(
"function %s requires at least %i arguments", func_name, min_args);
925 return "SWIG_MemoryError";
927 return "SWIG_IOError";
929 return "SWIG_RuntimeError";
931 return "SWIG_IndexError";
933 return "SWIG_TypeError";
935 return "SWIG_DivisionByZero";
937 return "SWIG_OverflowError";
939 return "SWIG_SyntaxError";
941 return "SWIG_ValueError";
943 return "SWIG_SystemError";
945 return "SWIG_AttributeError";
947 return "SWIG unknown error";
953 r +=
" (" + type.string_value() +
")";
954 error(
"%s", r.c_str());
955 return octave_value(r);
958#define SWIG_fail goto fail
960#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
961#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
962#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
963#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
964#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
965#define swig_owntype int
967#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
968#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
970#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
971#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
973#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
974#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
976#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
977#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
978#define SWIG_MODULE_CLIENTDATA_TYPE void*
980#define Octave_Error_Occurred() 0
981#define SWIG_Octave_AddErrorMsg(msg) {;}
987#define SWIG_POINTER_EXCEPTION 0
988#define SWIG_arg_fail(arg) 0
992typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
1001 typedef std::map < void *, Director * > rtdir_map;
1018#ifdef SWIG_DIRECTORS
1019SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
1020SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
1021SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1050#if SWIG_OCTAVE_PREREQ(4,4,0)
1053#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1054 class octave_swig_bound_func :
public octave_function {
1057 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1060 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1061 : octave_function(
"",
""), method(_method), first_args(_first_args)
1064 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1066 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1068 ~octave_swig_bound_func(
void) =
default;
1070 bool is_function(
void)
const {
return true; }
1072 octave_function* function_value(
bool =
false) {
return this; }
1074#if SWIG_OCTAVE_PREREQ(6,0,0)
1075 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1076 return execute(tw,nargout,args);
1079#if SWIG_OCTAVE_PREREQ(6,0,0)
1080 octave_value_list execute(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1082 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1084 octave_value_list all_args;
1085 all_args.append(first_args);
1086 all_args.append(args);
1087 return method->call(tw, nargout, all_args);
1090 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1091 octave_value_list ovl = subsref(ops, idx, 1);
1092 return ovl.length() ? ovl(0) : octave_value();
1095 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1096 assert(ops.size() > 0);
1097 assert(ops.size() == idx.size());
1099 error(
"invalid function call");
1100 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1101 return call(tw, nargout, *idx.begin());
1106 octave_function* method;
1107 octave_value_list first_args;
1109 std::set<std::string> dispatch_classes;
1113#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1143 if (!type->clientdata)
1147 for (m = c->members; m->name; ++m)
1148 if (m->name ==
name)
1150 for (
int j = 0; c->base_names[j]; ++j) {
1153 module = SWIG_GetModule(0);
1159 if ((m = find_member(c->base[j],
name)))
1166 member_map::iterator it = members.find(
name);
1167 if (it != members.end())
1170 for (
unsigned int j = 0; j < types.size(); ++j)
1171 if ((m = find_member(types[j].first,
name)))
1172 return &members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1173 if (!insert_if_not_found)
1175 return &members[
name];
1180 for (
unsigned int j = 0; j < types.size(); ++j) {
1181 assert(types[j].first->clientdata);
1183 if (cj->name ==
name)
1184 return types[j].first;
1190 for (
int j = 0; c->base_names[j]; ++j) {
1193 module = SWIG_GetModule(0);
1199 assert(c->base[j]->clientdata);
1201 if (cj->name ==
name)
1209 if (out.find(m->name) == out.end())
1210 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1212 for (
int j = 0; c->base_names[j]; ++j) {
1215 module = SWIG_GetModule(0);
1221 assert(c->base[j]->clientdata);
1224 load_members(cj,out);
1230 for (
unsigned int j = 0; j < types.size(); ++j)
1231 if (types[j].first->clientdata)
1236 if (m->second.is_defined())
1237 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1238 else if (m->first && m->first->method)
1239 return m->first->method(args, nargout);
1240 error(
"member not defined or not invocable");
1241 return octave_value_list();
1247 if (!m || m->first->is_static() || m->first->is_global())
1249 octave_value_list args;
1250 args.append(nc_this->as_value());
1251 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1252 if (argout.length() < 1)
1258 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1261 if (!m || m->first->is_static() || m->first->is_global())
1263 octave_value_list args;
1264 args.append(nc_this->as_value());
1265 args.append(make_value_hack(rhs));
1266 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1267 if (argout.length() < 1)
1273 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1276 if (!m || m->first->is_static() || m->first->is_global())
1278 octave_value_list args;
1279 args.append(nc_this->as_value());
1281 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1282 if (argout.length() >= 1)
1288 if (m->second.is_defined()) {
1289 if (m->second.is_function() || m->second.is_function_handle()) {
1294 }
else if (m->first) {
1295 if (m->first->get_method)
1296 return m->first->get_method(args, 1);
1297 else if (m->first->method)
1300 error(
"undefined member");
1301 return octave_value_list();
1305#if SWIG_OCTAVE_PREREQ(9,0,0)
1310 return octave_value((octave_base_value *) &x);
1318 bool _always_static =
false)
1319 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1320 always_static(_always_static) {
1322 types.push_back(std::make_pair(_type, _ptr));
1323#ifdef SWIG_DIRECTORS
1325 Swig::Director *d = Swig::get_rtdir(_ptr);
1327 Swig::swig_director_set_self(d,
this);
1334#if SWIG_OCTAVE_PREREQ(9,0,0)
1339 for (
unsigned int j = 0; j < types.size(); ++j) {
1340 if (!types[j].first || !types[j].first->clientdata)
1343 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1344 c->destructor(as_value(), 0);
1348#ifdef SWIG_DIRECTORS
1349 for (
unsigned int j = 0; j < types.size(); ++j)
1350 Swig::erase_rtdir(types[j].second.ptr);
1356 if (!dispatch_unary_op(
"__dims__", out))
1357 return dim_vector(1,1);
1360#if SWIG_OCTAVE_PREREQ(4,4,0)
1363 if (out.is_cell()) {
1365 const Cell & c=out.cell_value();
1366 int ndim = c.rows();
1367 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1370 d.resize(ndim < 2 ? 2 : ndim);
1374 for (
int k=0;k<ndim;k++) {
1375 const octave_value& obj = c(k);
1376#if SWIG_OCTAVE_PREREQ(6,0,0)
1378 d.elem(k) = obj.int_value();
1380 catch (octave::execution_exception& oee) {
1382 return dim_vector(1,1);
1385 d.elem(k) = obj.int_value();
1388 if (error_state)
return dim_vector(1,1);
1392#if SWIG_OCTAVE_PREREQ(4,4,0)
1393 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1395 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1397 if (out.rows()==1 || out.columns()==1) {
1398#if SWIG_OCTAVE_PREREQ(6,0,0)
1401 a = out.int_vector_value();
1403 catch (octave::execution_exception& oee) {
1404 return dim_vector(1,1);
1407 Array<int> a = out.int_vector_value();
1408 if (error_state)
return dim_vector(1,1);
1411 d.resize(a.numel() < 2 ? 2 : a.numel());
1413 for (
int k=0;k<a.numel();k++) {
1418 return dim_vector(1,1);
1421 return dim_vector(1,1);
1426#if SWIG_OCTAVE_PREREQ(9,0,0)
1435#if SWIG_OCTAVE_PREREQ(9,0,0)
1443#if SWIG_OCTAVE_PREREQ(9,0,0)
1453 return (
size_t)
this;
1454 return (
size_t) types[0].second.ptr;
1459 if (!types[0].first->clientdata)
1462 return c->constructor_doc;
1469 for (
unsigned int j = 0; j < types.size(); ++j) {
1472 if (types[j].first->clientdata) {
1476 ret += types[j].first->name;
1483 for (
unsigned int j = 0; j < rhs.types.size(); ++j) {
1484 assert(!rhs.types[j].second.destroyed);
1485#ifdef SWIG_DIRECTORS
1486 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1488 Swig::swig_director_set_self(d,
this);
1491 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1492 members.insert(rhs.members.begin(), rhs.members.end());
1493#if SWIG_OCTAVE_PREREQ(4,4,0)
1494 assign(rhs.swig_type_name(), rhs.as_value());
1497 rhs.members.clear();
1507 int clear_pointer = 0;
1515 *own = *own | thisown;
1524 if (!type && types.size()) {
1526 *vptr = types[0].second.ptr;
1528 types[0].second.ptr = 0;
1532 for (
unsigned int j = 0; j < types.size(); ++j)
1533 if (type == types[j].first) {
1535 *vptr = types[j].second.ptr;
1537 types[j].second.ptr = 0;
1541 for (
unsigned int j = 0; j < types.size(); ++j) {
1554 types[j].second.ptr = 0;
1566#ifdef SWIG_DIRECTORS
1567 void director_destroyed(Swig::Director *d) {
1569 for (
unsigned int j = 0; j < types.size(); ++j) {
1570 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1572 types[j].second.destroyed =
true;
1585 members[
name] = std::make_pair(m, octave_value());
1604#if SWIG_OCTAVE_PREREQ(6,0,0)
1605 virtual bool isstruct()
const {
1612 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1613 octave_value_list ovl = subsref(ops, idx, 1);
1614 return ovl.length()? ovl(0) : octave_value();
1617 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1618 assert(ops.size() > 0);
1619 assert(ops.size() == idx.size());
1621 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1623 octave_value_list sub_ovl;
1626 if (ops[skip] ==
'(' && construct_type) {
1629 if (!c->constructor) {
1630 error(
"cannot create instance");
1631 return octave_value_list();
1633 octave_value_list args;
1636 args.append(*idx_it++);
1638 sub_ovl = c->constructor(args, nargout);
1641 else if (ops[skip] ==
'.') {
1642 std::string subname;
1645 octave_value_list subname_ovl(*idx_it++);
1647 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1648 subname = subname_ovl(0).string_value();
1651 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1657 if (!base || !(m->first = find_member(base, subname)))
1658 m = find_member(subname,
false);
1660 error(
"member not found");
1661 return octave_value_list();
1664 octave_value_list args;
1665 if (!always_static &&
1666 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1667 args.append(as_value());
1668 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1669 ((m->first && m->first->method) || m->second.is_function() ||
1670 m->second.is_function_handle())) {
1671 args.append(*idx_it++);
1673 sub_ovl = member_invoke(m, args, nargout);
1675 sub_ovl = member_deref(m, args);
1680 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1681 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1682 octave_value_list args;
1683 args.append(*idx_it++);
1685 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1686 error(
"error evaluating index operator");
1687 return octave_value_list();
1690 error(
"unsupported subsref");
1691 return octave_value_list();
1695 if (skip >= (
int) ops.size())
1697 if (sub_ovl.length() < 1) {
1698 error(
"bad subs ref");
1699 return octave_value_list();
1701 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1704 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1705 assert(ops.size() > 0);
1706 assert(ops.size() == idx.size());
1708 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1711 if (ops.size() > 1) {
1712 std::list < octave_value_list >::const_iterator last = idx.end();
1714 std::list < octave_value_list > next_idx(idx.begin(), last);
1715 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1716 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1719 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1720 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1723 octave_value_list args;
1724 args.append(as_value());
1725 args.append(*idx_it);
1727 member_invoke(m, args, 1);
1729 error(
"%s member not found", op_name);
1732 else if (ops[skip] ==
'.') {
1733 octave_value_list subname_ovl(*idx_it++);
1735 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1736 std::string subname = subname_ovl(0).string_value();
1739 if (!m->first || !m->first->set_method) {
1742 }
else if (m->first->set_method) {
1743 octave_value_list args;
1744 if (!m->first->is_static() && !m->first->is_global())
1745 args.append(as_value());
1747 m->first->set_method(args, 1);
1749 error(
"member not assignable");
1751 error(
"unsupported subsasgn");
1756#if SWIG_OCTAVE_PREREQ(4,4,0)
1757 virtual bool isobject()
const {
1771 if (!dispatch_unary_op(
"__str__", ret)) {
1772 error(
"__str__ method not defined");
1773 return std::string();
1775 if (!ret.is_string()) {
1776 error(
"__str__ method did not return a string");
1777 return std::string();
1779 return ret.string_value();
1784 if (!dispatch_unary_op(
"__float__", ret)) {
1785 error(
"__float__ method not defined");
1787 return ret.scalar_value();
1790#if SWIG_OCTAVE_PREREQ(4,2,0)
1791 virtual octave_value as_double(
void)
const {
1793 if (!dispatch_unary_op(
"__float__", ret)) {
1794 error(
"__float__ method not defined");
1796 return ret.as_double();
1799 virtual octave_value as_single(
void)
const {
1801 if (!dispatch_unary_op(
"__float__", ret)) {
1802 error(
"__float__ method not defined");
1804 return ret.as_single();
1808#if SWIG_OCTAVE_PREREQ(3,8,0)
1809 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1810 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1812 if (!dispatch_unary_op(opname, ret)) {
1813 error(
"%s", (opname + std::string(
" method not found")).c_str());
1814 return octave_value();
1820#if SWIG_OCTAVE_PREREQ(3,3,52)
1821 virtual octave_map map_value()
const {
1822 return octave_map();
1826 return Octave_map();
1834 string_vector keys(tmp.size());
1836 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1837 keys(k++) = it->first;
1856 octave::mach_info::float_format fmt) {
1858 oct_mach_info::float_format fmt) {
1863#if defined (HAVE_HDF5)
1864# if SWIG_OCTAVE_PREREQ(4,0,0)
1866 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1871 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1876 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1881 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1887 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1888 return string_value();
1892 return string_value();
1895 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1899 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1902#if SWIG_OCTAVE_PREREQ(4,4,0)
1903 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1904 octave_value_list retval = fcn->call(tw, 1, args);
1905 if (retval.length() == 1)
1908 ret = fcn->do_multi_index_op(1, args)(0);
1918 if (ost->dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1920 std::string symbol =
SWIG_op_prefix + ost->swig_type_name() +
"_" + op_name;
1921 octave_value_list args;
1922 args.append(make_value_hack(x));
1923 if (dispatch_global_op(symbol, args, ret))
1926 error(
"could not dispatch unary operator");
1927 return octave_value();
1930 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1935 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1938 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1939 if (op_name[0] ==
'l' && rhs_ost->dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1941 if (op_name[0] ==
'g' && rhs_ost->dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1944 if (rhs_ost->dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1949 octave_value_list args;
1950 args.append(make_value_hack(lhs));
1951 args.append(make_value_hack(rhs));
1954 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1958 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1959 if (dispatch_global_op(symbol, args, ret))
1963 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1968 if (dispatch_global_op(symbol, args, ret))
1976 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1977 if (dispatch_global_op(symbol, args, ret))
1980 error(
"could not dispatch binary operator");
1981 return octave_value();
1984#if SWIG_OCTAVE_PREREQ(4,0,0)
1985 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1987 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
1991 os << string_value();
1999 os <<
"{"; newline(os);
2000 increment_indent_level();
2001 for (
unsigned int j = 0; j < types.size(); ++j) {
2003 if (types[j].first->clientdata) {
2005 os << c->name <<
", ptr = " << types[j].second.ptr; newline(os);
2007 os << types[j].first->name <<
", ptr = " << types[j].second.ptr; newline(os);
2010 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2012 if (it->second.first) {
2013 const char *objtype = it->second.first->method ?
"method" :
"variable";
2014 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
2015 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
2016 assert(it->second.first->name == it->first);
2018 os << it->first; newline(os);
2021 decrement_indent_level();
2023 os <<
"}"; newline(os);
2046#if SWIG_OCTAVE_PREREQ(9,0,0)
2048 s_t_id = octave_swig_ref::static_type_id();
2051 t_id = octave_swig_ref::static_type_id();
2057 {
if (ptr) ptr->
decref(); }
2069 {
return ptr->
dims(); }
2074#if SWIG_OCTAVE_PREREQ(6,0,0)
2075 virtual bool isstruct()
const
2076 {
return ptr->isstruct(); }
2079 {
return ptr->
is_map(); }
2082 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
2083 {
return ptr->
subsref(ops, idx); }
2085 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
2086 {
return ptr->
subsref(ops, idx, nargout); }
2088 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
2089 {
return ptr->
subsasgn(ops, idx, rhs); }
2091#if SWIG_OCTAVE_PREREQ(4,4,0)
2092 virtual bool isobject()
const
2093 {
return ptr->isobject(); }
2108#if SWIG_OCTAVE_PREREQ(4,2,0)
2109 virtual octave_value as_double(
void)
const
2110 {
return ptr->as_double(); }
2112 virtual octave_value as_single(
void)
const
2113 {
return ptr->as_single(); }
2116#if SWIG_OCTAVE_PREREQ(3,8,0)
2117 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
2118 {
return ptr->map(umap); }
2121#if SWIG_OCTAVE_PREREQ(3,3,52)
2122 virtual octave_map map_value()
const
2143 octave::mach_info::float_format fmt)
2145 oct_mach_info::float_format fmt)
2149#if defined (HAVE_HDF5)
2150# if SWIG_OCTAVE_PREREQ(4,0,0)
2152 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2153 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2156 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2157 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2160 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2161 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2164 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2165 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2169 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2175#if SWIG_OCTAVE_PREREQ(4,0,0)
2176 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2178 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2180 {
return ptr->
print(os, pr_as_read_syntax); }
2182#if SWIG_OCTAVE_PREREQ(9,0,0)
2183 static void set_type_id(
int type_id) { s_t_id=type_id; }
2185# if SWIG_OCTAVE_PREREQ(4,4,0)
2186 static void set_type_id(
int type_id) { t_id=type_id; }
2191 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2192 octave_scalar::static_type_id ());
2201#if !SWIG_OCTAVE_PREREQ(4,0,0)
2206#if !SWIG_OCTAVE_PREREQ(4,0,0)
2217 : type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len)
2220#if SWIG_OCTAVE_PREREQ(9,0,0)
2222 s_t_id = octave_swig_packed::static_type_id();
2225 t_id = octave_swig_packed::static_type_id();
2231 if (outtype && outtype != type)
2233 assert(sz <=
buf.size());
2234 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2250#if SWIG_OCTAVE_PREREQ(4,0,0)
2251 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2253 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2257 os <<
"swig packed type: name = " << (type ? type->name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2275 octave::mach_info::float_format fmt) {
2277 oct_mach_info::float_format fmt) {
2282#if defined (HAVE_HDF5)
2283# if SWIG_OCTAVE_PREREQ(4,0,0)
2285 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2290 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2295 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2300 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2306#if SWIG_OCTAVE_PREREQ(9,0,0)
2307 static void set_type_id(
int type_id) { s_t_id=type_id; }
2309# if SWIG_OCTAVE_PREREQ(4,4,0)
2310 static void set_type_id(
int type_id) { t_id=type_id; }
2315#if !SWIG_OCTAVE_PREREQ(4,0,0)
2320#if !SWIG_OCTAVE_PREREQ(4,0,0)
2326 error(
"attempt to set immutable member variable");
2327 return octave_value_list();
2335 :ovl(_ovl), j(_j) { }
2337 operator octave_value()
const {
2360 && ov.rows() == 1 && ov.columns() == 1)
2361 ov = ov.cell_value()(0);
2366 if (ov.type_id() != octave_swig_ref::static_type_id())
2375#define swig_unary_op(name) \
2376SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2377 return octave_swig_type::dispatch_unary_op(x,#name); \
2379#define swig_binary_op(name) \
2380SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2381 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2383#if SWIG_OCTAVE_PREREQ(4,4,0)
2384#define swigreg_unary_op(name) \
2385if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2386typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2388#define swigreg_unary_op(name) \
2389if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2390octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2392#if SWIG_OCTAVE_PREREQ(4,4,0)
2393#define swigreg_binary_op(name) \
2394if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2395typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2397#define swigreg_binary_op(name) \
2398if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2399octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2416#if !SWIG_OCTAVE_PREREQ(4,2,0)
2434#if SWIG_OCTAVE_PREREQ(4,4,0)
2435 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2446#if SWIG_OCTAVE_PREREQ(4,4,0)
2447 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2455#if !SWIG_OCTAVE_PREREQ(4,2,0)
2479 for (
int j = 0; j < tid; ++j) {
2489#ifdef SWIG_DIRECTORS
2490 Swig::Director *d = Swig::get_rtdir(ptr);
2491 if (d && Swig::swig_director_get_self(d))
2492 return Swig::swig_director_get_self(d)->as_value();
2496 return octave_value(Matrix());
2506 && ov.rows() == 1 && ov.columns() == 1)
2507 ov = ov.cell_value()(0);
2508 if (!ov.is_defined() ||
2509 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2514 if (ov.type_id() != octave_swig_ref::static_type_id())
2518 return ost->
cast(ptr, type, own, flags);
2526 if (!ov.is_defined())
2528 if (ov.type_id() != octave_swig_packed::static_type_id())
2535 module_ns->assign(
name, ov);
2539#if SWIG_OCTAVE_PREREQ(6,0,0)
2540 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2543#if SWIG_OCTAVE_PREREQ(4,4,0)
2544 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2545 return symtab.global_varval(
name);
2547 return get_global_value(
name,
true);
2553#if SWIG_OCTAVE_PREREQ(6,0,0)
2554 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2556#elif SWIG_OCTAVE_PREREQ(4,4,0)
2557 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2565#if SWIG_OCTAVE_PREREQ(4,4,0)
2566 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2567#if SWIG_OCTAVE_PREREQ(6,0,0)
2568 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2570 octave::tree_evaluator& tree_eval =
interp->get_evaluator();
2571#if SWIG_OCTAVE_PREREQ(8,0,0)
2572 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2574 octave::call_stack& callStack = tree_eval.get_call_stack();
2575 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2577 octave::symbol_record sym=symscope.lookup_symbol(
name);
2578 stackFrame->mark_global(sym);
2580 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2581 symscope.assign(
name, symtab.global_varval(
name));
2582 symscope.mark_global(
name);
2585#if !SWIG_OCTAVE_PREREQ(3,2,0)
2586 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2588#if !SWIG_OCTAVE_PREREQ(3,8,0)
2589 symbol_table::varref(
name);
2591 symbol_table::mark_global(
name);
2598 if (!ov.is_defined() ||
2599 ov.type_id() != octave_swig_packed::static_type_id())
2615 if (obj.is_string())
2616 error(
"%s", obj.string_value().c_str());
2618 error(
"C++ side threw an exception of type %s", type);
2623#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2625#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2631#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2632#define SWIGTYPE_p_char swig_types[1]
2633#define SWIGTYPE_p_double swig_types[2]
2634#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2635#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2636#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2637#define SWIGTYPE_p_int swig_types[6]
2638#define SWIGTYPE_p_p_char swig_types[7]
2639#define SWIGTYPE_p_unsigned_int swig_types[8]
2642#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2651template<
typename T>
class SwigValueWrapper {
2652 struct SwigSmartPointer {
2654 SwigSmartPointer(T *p) : ptr(p) { }
2655 ~SwigSmartPointer() {
delete ptr; }
2656 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
2657 void reset(T *p) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
2659 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
2660 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
2662 SwigValueWrapper() : pointer(0) { }
2663 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
2664#if __cplusplus >=201103L
2665 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
2666 operator T&&()
const {
return std::move(*pointer.ptr); }
2668 operator T&()
const {
return *pointer.ptr; }
2670 T *operator&()
const {
return pointer.ptr; }
2671 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2683template <
typename T> T SwigValueInit() {
2687#if __cplusplus >=201103L
2688# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2690# define SWIG_STD_MOVE(OBJ) OBJ
2696#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2697#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2711 #if defined ( __GNUC__ ) && __GNUC__ > 3
2712 #undef OCTAVE_EXPORT
2713 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2731 inline int max(
int a,
int b )
2733 return a >= b ? a : b;
2735 inline int min(
int a,
int b )
2737 return a >= b ? a : b;
2751 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2763 if (
max( o_obj.columns(), 1 ) > 1 )
2768 else if (
max( o_obj.rows(), 1 ) > 1 )
2778 _dim(
const octave_value &o_obj,
int dim_idx )
2781 return max( o_obj.rows(), 0 );
2785 else if ( dim_idx == 1 )
2786 return max( o_obj.columns(), 0 );
2799 template <
class FLOAT>
2803 while ( n_el-- > 0 )
2804 *out_arr++ = (FLOAT) ( *in_arr++ );
2823 template <
class FLOAT>
2827 while ( n_el-- > 0 )
2828 *d_arr++ = double(*arr++);
2859 octave_value_list functionArguments;
2860 octave_value_list retval;
2867 for ( i = 0; i < n; i++ )
2873 functionArguments( 0 ) = xin;
2874 functionArguments( 1 ) = yin;
2877#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2878 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2880 retval = feval(
fcnMapForm, functionArguments, 1 );
2883#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2884 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2886 retval = feval(
nameMapForm, functionArguments, 1 );
2889 if ( retval.length() >= 2 )
2891 xout = retval( 0 ).matrix_value();
2892 yout = retval( 1 ).matrix_value();
2894 for ( i = 0; i < n; i++ )
2896 x[i] = xout( i, 0 );
2897 y[i] = yout( i, 0 );
2909 octave_value_list functionArguments;
2910 octave_value_list retval;
2912 Matrix inAxis( 1, 1 );
2913 Matrix inValue( 1, 1 );
2914 inAxis( 0, 0 ) = axis;
2915 inValue( 0, 0 ) =
value;
2917 functionArguments( 0 ) = inAxis;
2918 functionArguments( 1 ) = inValue;
2921#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2922 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2928 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2933 strncpy( label, retval( 0 ).string_value().c_str(), length );
2943 octave_value_list functionArguments;
2944 octave_value_list retval;
2954 functionArguments( 0 ) = xin;
2955 functionArguments( 1 ) = yin;
2958#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2959 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2964#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2970 if ( retval.length() >= 2 )
2972 xout = retval( 0 ).matrix_value();
2973 yout = retval( 1 ).matrix_value();
2984 printf(
"nlegend =%d\n", nlegend );
2985 for ( i = 0; i < nlegend; i++ )
2987 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2988 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2989 printf(
"text[%d] =%s\n", i,
text[i] );
2995#if !defined(SWIG_NO_LLONG_MAX)
2996# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2997# define LLONG_MAX __LONG_LONG_MAX__
2998# define LLONG_MIN (-LLONG_MAX - 1LL)
2999# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3006 if (!ov.is_scalar_type())
3008 if (ov.is_complex_scalar())
3010 if (ov.is_double_type()||ov.is_single_type()) {
3011 double v=ov.double_value();
3016 *val = ov.long_value();
3027 if ((v < INT_MIN || v > INT_MAX)) {
3030 if (val) *val =
static_cast< int >(v);
3037 static int my_plGetCursor(
int *state,
int *keysym,
int *button,
char *
string,
int *pX,
int *pY,
PLFLT *dX,
PLFLT *dY,
PLFLT *wX,
PLFLT *wY,
int *subwin )
3045 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
3059 && ov.rows() == 1 && ov.columns() == 1)
3060 ov = ov.cell_value()(0);
3061 if (!ov.is_string())
3064 std::string str=ov.string_value();
3065 size_t len=str.size();
3066 char* cstr=(
char*)str.c_str();
3068 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
3083 return octave_value(
value);
3096 return octave_value(
value);
3105 gin.
dX = x_in; gin.
dY = y_in;
3107 *x = gin.
wX; *y = gin.
wY;
3114 if (!ov.is_scalar_type())
3116 if (ov.is_complex_scalar())
3119 *val = ov.double_value();
3132 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3133 const char *labx,
const char *laby,
const char *labtop )
3135 const char *legline[4];
3136 legline[0] = legline1; legline[1] = legline2;
3137 legline[2] = legline3; legline[3] = legline4;
3138 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3139 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3140 labx, laby, labtop );
3158 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3159 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3164#define f2c( f, ff, nx, ny ) \
3166 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3167 for ( int i = 0; i < nx; i++ ) { \
3168 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3169 for ( int j = 0; j < ny; j++ ) \
3170 *( ff[i] + j ) = *( f + nx * j + i );}
3177 f2c( f, ff, nx, ny );
3178 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3186 f2c( f, ff, nx, ny );
3187 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3196 grid1.
nx = nx; grid1.ny = ny;
3197 grid1.xg = (
PLFLT *) xg; grid1.yg = (
PLFLT *) yg;
3198 f2c( f, ff, nx, ny );
3199 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3207 f2c( xg, xgg, nx, ny );
3208 f2c( yg, ygg, nx, ny );
3209 grid2.nx = nx; grid2.ny = ny;
3210 grid2.xg = xgg; grid2.yg = ygg;
3211 f2c( f, ff, nx, ny );
3212 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3221 f2c( xg, xgg, nx, ny );
3222 f2c( yg, ygg, nx, ny );
3223 grid2.nx = nx; grid2.ny = ny;
3224 grid2.xg = xgg; grid2.yg = ygg;
3225 f2c( f, ff, nx, ny );
3226 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3231 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
3234 f2c(
zg, zgg, nptsx, nptsy );
3235 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3236 for (
int i = 0; i < nptsx; i++ )
3237 for (
int j = 0; j < nptsy; j++ )
3238 *(
zg + nptsx * j + i ) = zgg[i][j];
3246 f2c( z, zz, nx, ny );
3254 f2c( z, zz, nx, ny );
3255 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3263 f2c( z, zz, nx, ny );
3272 f2c( z, zz, nx, ny );
3273 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3282 f2c( z, zz, nx, ny );
3284 indexxmin, indexxmax, indexymin, indexymax );
3291 f2c( z, zz, nx, ny );
3299 f2c( z, zz, nx, ny );
3301 indexxmin, indexxmax, indexymin, indexymax );
3319 f2c( a, aa, nx, ny );
3320 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3321 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3322 min_color, min_width, max_color, max_width,
3336 grid1.
nx = nx; grid1.ny = ny;
3337 grid1.xg = (
PLFLT *) xg; grid1.yg = (
PLFLT *) yg;
3338 f2c( a, aa, nx, ny );
3339 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3340 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3341 min_color, min_width, max_color, max_width,
3355 f2c( xg, xgg, nx, ny );
3356 f2c( yg, ygg, nx, ny );
3357 grid2.nx = nx; grid2.ny = ny;
3358 grid2.xg = xgg; grid2.yg = ygg;
3359 f2c( a, aa, nx, ny );
3360 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3361 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3362 min_color, min_width, max_color, max_width,
3374 f2c( a, aa, nx, ny );
3375 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3376 clevel, nlevel, fill_width, cont_color, cont_width,
3377 plfill, rectangular, NULL, NULL );
3386 f2c( a, aa, nx, ny );
3387 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3388 clevel, nlevel, fill_width, cont_color, cont_width,
3399 grid1.
nx = nx; grid1.ny = ny;
3400 grid1.xg = (
PLFLT *) xg; grid1.yg = (
PLFLT *) yg;
3402 f2c( a, aa, nx, ny );
3403 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3404 clevel, nlevel, fill_width, cont_color, cont_width,
3415 f2c( xg, xgg, nx, ny );
3416 f2c( yg, ygg, nx, ny );
3417 grid2.nx = nx; grid2.ny = ny;
3418 grid2.xg = xgg; grid2.yg = ygg;
3419 f2c( a, aa, nx, ny );
3420 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3421 clevel, nlevel, fill_width, cont_color, cont_width,
3431 f2c( u, uu, nx, ny );
3432 f2c( v, vv, nx, ny );
3440 grid1.
nx = nx; grid1.ny = ny;
3441 grid1.xg = (
PLFLT *) xg; grid1.yg = (
PLFLT *) yg;
3442 f2c( u, uu, nx, ny );
3443 f2c( v, vv, nx, ny );
3451 f2c( xg, xgg, nx, ny );
3452 f2c( yg, ygg, nx, ny );
3453 grid2.nx = nx; grid2.ny = ny;
3454 grid2.xg = xgg; grid2.yg = ygg;
3455 f2c( u, uu, nx, ny );
3456 f2c( v, vv, nx, ny );
3467 f2c( a, aa, nx, ny );
3468 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3478 f2c( a, aa, nx, ny );
3479 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3487 f2c( a, aa, nx, ny );
3488 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3498 grid1.
nx = nx + 1; grid1.ny = ny + 1;
3499 grid1.xg = (
PLFLT *) xg; grid1.yg = (
PLFLT *) yg;
3500 f2c( a, aa, nx, ny );
3501 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3511 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3512 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3513 grid2.nx = nx + 1; grid2.ny = ny + 1;
3514 grid2.xg = xgg; grid2.yg = ygg;
3515 f2c( a, aa, nx, ny );
3516 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3527 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3528 PLINT n_axes,
const char ** axis_opts,
3535 for ( i = 0; i < nx; i++ )
3536 if ( n_values[i] > ny )
3538 f2c( a, aa, nx, ny );
3540 opt, position, x, y,
3542 bg_color, bb_color, bb_style,
3543 low_cap_color, high_cap_color,
3544 cont_color, cont_width,
3545 n_labels, label_opts, label,
3555 if (!ov.is_scalar_type())
3557 if (ov.is_complex_scalar())
3559 if (ov.is_double_type()||ov.is_single_type()) {
3560 double v=ov.double_value();
3566 if (ov.is_int8_type()||ov.is_int16_type()||
3567 ov.is_int32_type()) {
3568 long v=ov.long_value();
3572 if (ov.is_int64_type()) {
3573 long long v=ov.int64_scalar_value().value();
3578 *val = ov.ulong_value();
3589 if ((v > UINT_MAX)) {
3592 if (val) *val =
static_cast< unsigned int >(v);
3601 return octave_value(
value);
3615 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3619 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3620 if (csize <= size) {
3622 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3623 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3640 static int init = 0;
3653 return std::string(carray,carray+size);
3661 for (p = s; maxlen-- && *p; p++)
3675 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3676 if (val) *val =
static_cast< char >(v);
3686Set up transformation from metafile coordinates\n\
3690 Set up transformation from metafile coordinates. The size of the plot\n\
3691 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3692 general-purpose facility just yet (not sure why the user would need\n\
3695 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3698 This function is not used in any examples.\n\
3704plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3708 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3710 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3712 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3714 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3716 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3718 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3721Set the cmap0 palette using the specified cmap0*.pal format file\n\
3725 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3727 Redacted form: plspal0(filename)\n\
3729 This function is in example 16.\n\
3739 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3740 containing the name of the cmap0*.pal file. If this string is\n\
3741 empty, use the default cmap0*.pal file.\n\
3744Set the cmap1 palette using the specified cmap1*.pal format file\n\
3748 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3750 Redacted form: plspal1(filename, interpolate)\n\
3752 This function is used in example 16.\n\
3758plspal1(filename, interpolate)\n\
3762 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3763 containing the name of the cmap1*.pal file. If this string is\n\
3764 empty, use the default cmap1*.pal file.\n\
3766 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3767 columns containing the intensity index, r, g, b, alpha and\n\
3768 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3769 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3770 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3771 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3772 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3773 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3774 are used instead to set the cmap1 palette directly with a call to\n\
3778Draw a line in 3 space\n\
3782 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3783 first set up the viewport, the 2d viewing window (in world\n\
3784 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3787 Redacted form: plline3(x, y, z)\n\
3789 This function is used in example 18.\n\
3795plline3(n, x, y, z)\n\
3799 n (PLINT, input) : Number of points defining line.\n\
3801 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3804 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3807 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3811Magnitude colored plot surface mesh with contour\n\
3815 A more powerful form of plmesh: the surface mesh can be colored\n\
3816 accordingly to the current z value being plotted, a contour plot can\n\
3817 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3818 plotted function border and the base XY plane.\n\
3820 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3822 This function is used in example 11.\n\
3828plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3832 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3833 which the function is evaluated.\n\
3835 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3836 which the function is evaluated.\n\
3838 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3839 plot. Should have dimensions of\n\
3843 nx (PLINT, input) : Number of x values at which function is\n\
3846 ny (PLINT, input) : Number of y values at which function is\n\
3849 opt (PLINT, input) : Determines the way in which the surface is\n\
3850 represented. To specify more than one option just add the options,\n\
3851 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3852 showing z as a function of x for each value of y[j] .\n\
3853 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3854 for each value of x[i] .\n\
3855 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3856 at which function is defined.\n\
3857 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3858 the z value being plotted. The color is used from the current\n\
3860 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3864 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3865 the borders of the plotted function.\n\
3868 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3871 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3874Draw a line between two points, accounting for coordinate transforms\n\
3878 Joins the point (\n\
3882 y2) . If a global coordinate transform is defined then the line is\n\
3883 broken in to n segments to approximate the path. If no transform is\n\
3884 defined then this simply acts like a call to pljoin.\n\
3886 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3888 This function is used in example 22.\n\
3894plpath(n, x1, y1, x2, y2)\n\
3898 n (PLINT, input) : number of points to use to approximate the path.\n\
3900 x1 (PLFLT, input) : x coordinate of first point.\n\
3902 y1 (PLFLT, input) : y coordinate of first point.\n\
3904 x2 (PLFLT, input) : x coordinate of second point.\n\
3906 y2 (PLFLT, input) : y coordinate of second point.\n\
3909Write text inside the viewport\n\
3913 Writes text at a specified position and inclination within the\n\
3914 viewport. Text is clipped at the viewport boundaries. The reference\n\
3915 point of a string lies along a line passing through the string at half\n\
3916 the height of a capital letter. The position of the reference point\n\
3917 along this line is determined by just, the reference point is placed\n\
3918 at world coordinates (\n\
3920 y) within the viewport. The inclination of the string is specified\n\
3921 in terms of differences of world coordinates making it easy to write\n\
3922 text parallel to a line in a graph.\n\
3924 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3926 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3932plptex(x, y, dx, dy, just, text)\n\
3936 x (PLFLT, input) : x coordinate of reference point of string.\n\
3938 y (PLFLT, input) : y coordinate of reference point of string.\n\
3940 dx (PLFLT, input) : Together with dy, this specifies the\n\
3941 inclination of the string. The baseline of the string is parallel\n\
3942 to a line joining (\n\
3950 dy (PLFLT, input) : Together with dx, this specifies the\n\
3951 inclination of the string.\n\
3953 just (PLFLT, input) : Specifies the position of the string relative\n\
3954 to its reference point. If just=0. , the reference point is at\n\
3955 the left and if just=1. , it is at the right of the string. Other\n\
3956 values of just give intermediate justifications.\n\
3958 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3962Set family file parameters\n\
3966 Sets variables dealing with output file familying. Does nothing if\n\
3967 familying not supported by the driver. This routine, if used, must be\n\
3968 called before initializing PLplot. See the PLplot documentation for\n\
3969 more information.\n\
3971 Redacted form: plsfam(fam, num, bmax)\n\
3973 This function is used in examples 14 and 31.\n\
3979plsfam(fam, num, bmax)\n\
3983 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3986 num (PLINT, input) : Current family file number.\n\
3988 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3992Set y axis parameters\n\
3996 Identical to plsxax, except that arguments are flags for y axis. See\n\
3997 the description of plsxax for more detail.\n\
3999 Redacted form: plsyax(digmax, digits)\n\
4001 This function is used in examples 1, 14, and 31.\n\
4007plsyax(digmax, digits)\n\
4011 digmax (PLINT, input) : Variable to set the maximum number of\n\
4012 digits for the y axis. If nonzero, the printed label will be\n\
4013 switched to a floating-point representation when the number of\n\
4014 digits exceeds digmax.\n\
4016 digits (PLINT, input) : Field digits value. Currently, changing\n\
4017 its value here has no effect since it is set only by plbox or\n\
4018 plbox3. However, the user may obtain its value after a call to\n\
4019 either of these functions by calling plgyax.\n\
4022Get z axis parameters\n\
4026 Identical to plgxax, except that arguments are flags for z axis. See\n\
4027 the description of plgxax for more detail.\n\
4029 Redacted form: plgzax(p_digmax, p_digits)\n\
4031 This function is used in example 31.\n\
4037plgzax(p_digmax, p_digits)\n\
4041 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4042 number of digits for the z axis. If nonzero, the printed label\n\
4043 has been switched to a floating-point representation when the\n\
4044 number of digits exceeds this value.\n\
4046 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4047 number of digits for the numeric labels (z axis) from the last\n\
4051Set format of numerical label for contours\n\
4055 Set format of numerical label for contours.\n\
4057 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4059 This function is used example 9.\n\
4065pl_setcontlabelformat(lexp, sigdig)\n\
4069 lexp (PLINT, input) : If the contour numerical label is greater\n\
4070 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4071 format is used. Default value of lexp is 4.\n\
4073 sigdig (PLINT, input) : Number of significant digits. Default\n\
4081 Sets the pen width.\n\
4083 Redacted form: plwidth(width)\n\
4085 This function is used in examples 1 and 2.\n\
4095 width (PLFLT, input) : The desired pen width. If width is negative\n\
4096 or the same as the previous value no action is taken. width = 0.\n\
4097 should be interpreted as as the minimum valid pen width for the\n\
4098 device. The interpretation of positive width values is also\n\
4099 device dependent.\n\
4102Get parameters that define current plot-space window\n\
4106 Get relative minima and maxima that define current plot-space window.\n\
4107 If plsdiplt has not been called the default values pointed to by\n\
4108 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4110 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4112 This function is used in example 31.\n\
4118plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4122 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4125 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4128 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4131 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4135Set the cmap1 argument range for continuous color plots\n\
4139 Set the cmap1 argument range for continuous color plots that\n\
4140 corresponds to the range of data values. The maximum range\n\
4141 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4142 the cmap1 argument range that is specified with this routine, the\n\
4143 smaller the subset of the cmap1 color palette that is used to\n\
4144 represent the continuous data being plotted. If\n\
4145 min_color is greater than\n\
4147 max_color is greater than 1.0 or\n\
4148 min_color is less than 0.0 then no change is made to the cmap1\n\
4149 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4151 Redacted form: plscmap1_range(min_color, max_color)\n\
4153 This function is currently used in example 33.\n\
4159plscmap1_range(min_color, max_color)\n\
4163 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4164 than 0.0, then 0.0 is used instead.\n\
4166 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4167 than 1.0, then 1.0 is used instead.\n\
4170Select standard viewport\n\
4174 Selects the largest viewport within the subpage that leaves a standard\n\
4175 margin (left-hand margin of eight character heights, and a margin\n\
4176 around the other three sides of five character heights).\n\
4178 Redacted form: plvsta()\n\
4180 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4189Load Hershey fonts\n\
4193 Loads the Hershey fonts used for text and symbols. This routine may\n\
4194 be called before or after initializing PLplot. If not explicitly\n\
4195 called before PLplot initialization, then by default that\n\
4196 initialization loads Hershey fonts with the extended character set.\n\
4197 This routine only has a practical effect for devices that still use\n\
4198 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4199 system fonts instead of Hershey fonts).\n\
4201 Redacted form: plfontld(fnt)\n\
4203 This function is used in examples 1 and 7.\n\
4213 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4214 A zero value specifies Hershey fonts with the standard character\n\
4215 set and a non-zero value (the default assumed if plfontld is never\n\
4216 called) specifies Hershey fonts with the extended character set.\n\
4219Draw error bars in x direction\n\
4223 Draws a set of n error bars in x direction, the i\'th error bar\n\
4224 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4225 of the error bars are of length equal to the minor tick length\n\
4226 (settable using plsmin).\n\
4228 Redacted form: General: plerrx(xmin, ymax, y)\n\
4231 This function is used in example 29.\n\
4237plerrx(n, xmin, xmax, y)\n\
4241 n (PLINT, input) : Number of error bars to draw.\n\
4243 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4244 of the left-hand endpoints of the error bars.\n\
4246 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4247 of the right-hand endpoints of the error bars.\n\
4249 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4253Plot shaded 3-d surface plot\n\
4257 Plots a three-dimensional shaded surface plot within the environment\n\
4258 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4261 ny], the point z[i][j] being the value of the function at (\n\
4263 y[j]). Note that the points in vectors x and y do not need to be\n\
4264 equally spaced, but must be stored in ascending order. For further\n\
4265 details see the PLplot documentation.\n\
4267 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4269 This function is not used in any examples.\n\
4275plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4279 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4280 which the function is evaluated.\n\
4282 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4283 which the function is evaluated.\n\
4285 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4286 plot. Should have dimensions of\n\
4290 nx (PLINT, input) : Number of x values at which function is\n\
4293 ny (PLINT, input) : Number of y values at which function is\n\
4296 opt (PLINT, input) : Determines the way in which the surface is\n\
4297 represented. To specify more than one option just add the options,\n\
4298 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4299 connecting points at which function is defined.\n\
4300 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4304 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4308 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4309 the borders of the plotted function.\n\
4310 opt=MAG_COLOR : the surface is colored according to the value\n\
4311 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4312 according to the intensity of the reflected light in the\n\
4313 surface from a light source whose position is set using\n\
4317 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4320 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4323Get the current library version number\n\
4327 Get the current library version number. Note: you must have allocated\n\
4328 space for this (80 characters is safe).\n\
4330 Redacted form: plgver(p_ver)\n\
4332 This function is used in example 1.\n\
4342 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4343 (with preallocated length of 80 characters or more) containing the\n\
4344 PLplot version number.\n\
4347End plotting session for current stream\n\
4351 Ends a plotting session for the current output stream only. See\n\
4352 plsstrm for more info.\n\
4354 Redacted form: plend1()\n\
4356 This function is used in examples 1 and 20.\n\
4365Draw error bars in the y direction\n\
4369 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4370 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4371 of the error bars are of length equal to the minor tick length\n\
4372 (settable using plsmin).\n\
4374 Redacted form: General: plerry(x, ymin, ymax)\n\
4377 This function is used in example 29.\n\
4383plerry(n, x, ymin, ymax)\n\
4387 n (PLINT, input) : Number of error bars to draw.\n\
4389 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4392 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4393 of the lower endpoints of the error bars.\n\
4395 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4396 of the upper endpoints of the error bars.\n\
4399Set seed for internal random number generator.\n\
4403 Set the seed for the internal random number generator. See plrandd for\n\
4406 Redacted form: plseed(seed)\n\
4408 This function is used in example 21.\n\
4418 seed (unsigned int, input) : Seed for random number generator.\n\
4421Specify viewport using normalized subpage coordinates\n\
4425 Device-independent routine for setting up the viewport. This defines\n\
4426 the viewport in terms of normalized subpage coordinates which run from\n\
4427 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4428 current subpage. Use the alternate routine plsvpa in order to create\n\
4429 a viewport of a definite size.\n\
4431 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4433 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4434 24, 26, 27, and 31.\n\
4440plvpor(xmin, xmax, ymin, ymax)\n\
4444 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4445 left-hand edge of the viewport.\n\
4447 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4448 right-hand edge of the viewport.\n\
4450 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4451 bottom edge of the viewport.\n\
4453 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4454 edge of the viewport.\n\
4461 Plots a surface mesh within the environment set up by plw3d. The\n\
4462 surface is defined by the matrix z[\n\
4464 ny] , the point z[i][j] being the value of the function at (\n\
4466 y[j]). Note that the points in vectors x and y do not need to be\n\
4467 equally spaced, but must be stored in ascending order. The parameter\n\
4468 opt controls the way in which the surface is displayed. For further\n\
4469 details see the PLplot documentation.\n\
4471 Redacted form: plmesh(x, y, z, opt)\n\
4473 This function is used in example 11.\n\
4479plmesh(x, y, z, nx, ny, opt)\n\
4483 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4484 which the function is evaluated.\n\
4486 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4487 which the function is evaluated.\n\
4489 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4490 plot. Should have dimensions of\n\
4494 nx (PLINT, input) : Number of x values at which function has been\n\
4497 ny (PLINT, input) : Number of y values at which function has been\n\
4500 opt (PLINT, input) : Determines the way in which the surface is\n\
4501 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4502 function of x for each value of y[j] .\n\
4503 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4504 for each value of x[i] .\n\
4505 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4506 at which function is defined.\n\
4509Get the cmap1 argument range for continuous color plots\n\
4513 Get the cmap1 argument range for continuous color plots. (Use\n\
4514 plscmap1_range to set the cmap1 argument range.)\n\
4516 Redacted form: plgcmap1_range(min_color, max_color)\n\
4518 This function is currently not used in any example.\n\
4524plgcmap1_range(min_color, max_color)\n\
4528 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4529 minimum cmap1 argument.\n\
4531 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4532 maximum cmap1 argument.\n\
4535Set arrow style for vector plots\n\
4539 Set the style for the arrow used by plvect to plot vectors.\n\
4541 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4543 This function is used in example 22.\n\
4549plsvect(arrowx, arrowy, npts, fill)\n\
4553 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4554 the x and y points which make up the arrow. The arrow is plotted\n\
4555 by joining these points to form a polygon. The scaling assumes\n\
4556 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4557 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4558 will be reset to its default.\n\
4560 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4563 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4564 fill is false then the arrow is open.\n\
4567Draw filled polygon\n\
4571 Fills the polygon defined by the n points (\n\
4573 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4574 style is a solid fill. The routine will automatically close the\n\
4575 polygon between the last and first vertices. If multiple closed\n\
4576 polygons are passed in x and y then plfill will fill in between them.\n\
4578 Redacted form: plfill(x,y)\n\
4580 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4590 n (PLINT, input) : Number of vertices in polygon.\n\
4592 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4595 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4599Convert HLS color to RGB\n\
4603 Convert HLS color coordinates to RGB.\n\
4605 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4608 This function is used in example 2.\n\
4614plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4618 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4621 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4622 the axis of the color cylinder.\n\
4624 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4625 the radius of the color cylinder.\n\
4627 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4628 (0.0-1.0) of the color.\n\
4630 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4631 intensity (0.0-1.0) of the color.\n\
4633 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4634 intensity (0.0-1.0) of the color.\n\
4637Set format for date / time labels\n\
4641 Sets the format for date / time labels. To enable date / time format\n\
4642 labels see the options to plbox, plbox3, and plenv.\n\
4644 Redacted form: pltimefmt(fmt)\n\
4646 This function is used in example 29.\n\
4656 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4657 interpreted similarly to the format specifier of typical system\n\
4658 strftime routines except that PLplot ignores locale and also\n\
4659 supplies some useful extensions in the context of plotting. All\n\
4660 text in the string is printed as-is other than conversion\n\
4661 specifications which take the form of a \'%\' character followed by\n\
4662 further conversion specification character. The conversion\n\
4663 specifications which are similar to those provided by system\n\
4664 strftime routines are the following: %a: The abbreviated (English)\n\
4666 %A: The full (English) weekday name.\n\
4667 %b: The abbreviated (English) month name.\n\
4668 %B: The full (English) month name.\n\
4669 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4670 %C: The century number (year/100) as a 2-digit integer.\n\
4671 %d: The day of the month as a decimal number (range 01 to 31).\n\
4672 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4673 %e: Like %d, but a leading zero is replaced by a space.\n\
4674 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4675 %h: Equivalent to %b.\n\
4676 %H: The hour as a decimal number using a 24-hour clock (range\n\
4678 %I: The hour as a decimal number using a 12-hour clock (range\n\
4680 %j: The day of the year as a decimal number (range 001 to\n\
4682 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4683 23); single digits are preceded by a blank. (See also %H.)\n\
4684 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4685 12); single digits are preceded by a blank. (See also %I.)\n\
4686 %m: The month as a decimal number (range 01 to 12).\n\
4687 %M: The minute as a decimal number (range 00 to 59).\n\
4688 %n: A newline character.\n\
4689 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4690 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4691 %r: Equivalent to %I:%M:%S %p.\n\
4692 %R: The time in 24-hour notation (%H:%M). For a version\n\
4693 including the seconds, see %T below.\n\
4694 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4696 %S: The second as a decimal number (range 00 to 60). (The\n\
4697 range is up to 60 to allow for occasional leap seconds.)\n\
4698 %t: A tab character.\n\
4699 %T: The time in 24-hour notation (%H:%M:%S).\n\
4700 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4701 being 1. See also %w.\n\
4702 %U: The week number of the current year as a decimal number,\n\
4703 range 00 to 53, starting with the first Sunday as the first\n\
4704 day of week 01. See also %V and %W.\n\
4705 %v: Equivalent to %e-%b-%Y.\n\
4706 %V: The ISO 8601 week number of the current year as a decimal\n\
4707 number, range 01 to 53, where week 1 is the first week that\n\
4708 has at least 4 days in the new year. See also %U and %W.\n\
4709 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4710 being 0. See also %u.\n\
4711 %W: The week number of the current year as a decimal number,\n\
4712 range 00 to 53, starting with the first Monday as the first\n\
4714 %x: Equivalent to %a %b %d %Y.\n\
4715 %X: Equivalent to %T.\n\
4716 %y: The year as a decimal number without a century (range 00\n\
4718 %Y: The year as a decimal number including a century.\n\
4719 %z: The UTC time-zone string = \"+0000\".\n\
4720 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4721 %+: The UTC date and time in default format of the Unix date\n\
4722 command which is equivalent to %a %b %d %T %Z %Y.\n\
4723 %%: A literal \"%\" character.\n\
4724 The conversion specifications which are extensions to those normally\n\
4725 provided by system strftime routines are the following: %(0-9):\n\
4726 The fractional part of the seconds field (including leading\n\
4727 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4728 seconds to millisecond accuracy (00.000).\n\
4729 %.: The fractional part of the seconds field (including\n\
4730 leading decimal point) to the maximum available accuracy. Thus\n\
4731 %S%. would give seconds with fractional part up to 9 decimal\n\
4732 places if available.\n\
4735Get current subpage parameters\n\
4739 Gets the size of the current subpage in millimeters measured from the\n\
4740 bottom left hand corner of the output device page or screen. Can be\n\
4741 used in conjunction with plsvpa for setting the size of a viewport in\n\
4742 absolute coordinates (millimeters).\n\
4744 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4746 This function is used in example 23.\n\
4752plgspa(xmin, xmax, ymin, ymax)\n\
4756 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4757 the left hand edge of the subpage in millimeters.\n\
4759 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4760 the right hand edge of the subpage in millimeters.\n\
4762 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4763 the bottom edge of the subpage in millimeters.\n\
4765 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4766 the top edge of the subpage in millimeters.\n\
4769Calculate world coordinates and corresponding window index from relative device coordinates\n\
4773 Calculate world coordinates, wx and wy, and corresponding window index\n\
4774 from relative device coordinates, rx and ry.\n\
4776 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4779 This function is used in example 31.\n\
4785plcalc_world(rx, ry, wx, wy, window)\n\
4789 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4790 the x coordinate.\n\
4792 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4793 the y coordinate.\n\
4795 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4796 coordinate corresponding to the relative device coordinates rx and\n\
4799 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4800 coordinate corresponding to the relative device coordinates rx and\n\
4803 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4804 defined window index that corresponds to the input relative device\n\
4805 coordinates (and the returned world coordinates). To give some\n\
4806 background on the window index, for each page the initial window\n\
4807 index is set to zero, and each time plwind is called within the\n\
4808 page, world and device coordinates are stored for the window and\n\
4809 the window index is incremented. Thus, for a simple page layout\n\
4810 with non-overlapping viewports and one window per viewport, window\n\
4811 corresponds to the viewport index (in the order which the\n\
4812 viewport/windows were created) of the only viewport/window\n\
4813 corresponding to rx and ry. However, for more complicated layouts\n\
4814 with potentially overlapping viewports and possibly more than one\n\
4815 window (set of world coordinates) per viewport, window and the\n\
4816 corresponding output world coordinates corresponds to the last\n\
4817 window created that fulfills the criterion that the relative\n\
4818 device coordinates are inside it. Finally, in all cases where the\n\
4819 input relative device coordinates are not inside any\n\
4820 viewport/window, then the returned value of the last defined\n\
4821 window index is set to -1.\n\
4824Get output file name\n\
4828 Gets the current output file name, if applicable.\n\
4830 Redacted form: plgfnam(fnam)\n\
4832 This function is used in example 31.\n\
4842 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4843 (with preallocated length of 80 characters or more) containing the\n\
4851 Draws a plot of vector data contained in the matrices (\n\
4857 ny]) . The scaling factor for the vectors is given by scale. A\n\
4858 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4859 additional data required by the transformation routine to map indices\n\
4860 within the matrices to the world coordinates. The style of the vector\n\
4861 arrow may be set using plsvect.\n\
4863 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4864 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4865 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4866 with either one or two dimensions.\n\
4868 This function is used in example 22.\n\
4874plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4878 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4879 and y components of the vector data to be plotted.\n\
4881 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4883 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4884 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4885 automatically calculated for the data. If scale < 0 then the\n\
4886 scaling factor is automatically calculated for the data and then\n\
4888 scale. If scale > 0 then the scaling factor is set to scale.\n\
4890 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4891 defines the transformation between the zero-based indices of the\n\
4892 matrices u and v and world coordinates.For the C case,\n\
4893 transformation functions are provided in the PLplot library: pltr0\n\
4894 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4895 mappings respectively defined by vectors and matrices. In\n\
4896 addition, C callback routines for the transformation can be\n\
4897 supplied by the user such as the mypltr function in\n\
4898 examples/c/x09c.c which provides a general linear transformation\n\
4899 between index coordinates and world coordinates.For languages\n\
4900 other than C you should consult the PLplot documentation for the\n\
4901 details concerning how PLTRANSFORM_callback arguments are\n\
4902 interfaced. However, in general, a particular pattern of\n\
4903 callback-associated arguments such as a tr vector with 6 elements;\n\
4904 xg and yg vectors; or xg and yg matrices are respectively\n\
4905 interfaced to a linear-transformation routine similar to the above\n\
4906 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4907 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4908 support native language callbacks for handling index to\n\
4909 world-coordinate transformations. Examples of these various\n\
4910 approaches are given in examples/<language>x09*,\n\
4911 examples/<language>x16*, examples/<language>x20*,\n\
4912 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4913 supported languages.\n\
4915 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4916 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4917 that is externally supplied.\n\
4920Plot a glyph at the specified points\n\
4924 Plot a glyph at the specified points. (This function is largely\n\
4925 superseded by plstring which gives access to many[!] more glyphs.)\n\
4927 Redacted form: plsym(x, y, code)\n\
4929 This function is used in example 7.\n\
4935plsym(n, x, y, code)\n\
4939 n (PLINT, input) : Number of points in the x and y vectors.\n\
4941 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4944 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4947 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4948 to be plotted at each of the n points.\n\
4951Get viewport limits in normalized device coordinates\n\
4955 Get viewport limits in normalized device coordinates.\n\
4957 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4960 This function is used in example 31.\n\
4966plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4970 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4971 viewport limit of the normalized device coordinate in x.\n\
4973 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4974 viewport limit of the normalized device coordinate in x.\n\
4976 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4977 viewport limit of the normalized device coordinate in y.\n\
4979 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4980 viewport limit of the normalized device coordinate in y.\n\
4983Get page parameters\n\
4987 Gets the current page configuration. The length and offset values are\n\
4988 expressed in units that are specific to the current driver. For\n\
4989 instance: screen drivers will usually interpret them as number of\n\
4990 pixels, whereas printer drivers will usually use mm.\n\
4992 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4994 This function is used in examples 14 and 31.\n\
5000plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5004 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5005 pixels/inch (DPI) in x.\n\
5007 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5008 pixels/inch (DPI) in y.\n\
5010 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5013 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5016 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5019 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5023Plot a glyph at the specified 3D points\n\
5027 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5028 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5029 this function similar to what is done for plline3. The glyph is\n\
5030 specified with a PLplot user string. Note that the user string is not\n\
5031 actually limited to one glyph so it is possible (but not normally\n\
5032 useful) to plot more than one glyph at the specified points with this\n\
5033 function. As with plmtex and plptex, the user string can contain FCI\n\
5034 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5035 else PLplot escapes for Hershey or unicode text to determine the\n\
5038 Redacted form: plstring3(x, y, z, string)\n\
5040 This function is used in example 18.\n\
5046plstring3(n, x, y, z, string)\n\
5050 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5052 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5055 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5058 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5061 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5062 the glyph(s) to be plotted at each of the n points. points.\n\
5065Shade regions on the basis of value\n\
5069 Shade regions on the basis of value. This is the high-level routine\n\
5070 for making continuous color shaded plots with cmap1 while plshade\n\
5071 should be used to plot individual shaded regions using either cmap0 or\n\
5072 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5073 our supported languages.\n\
5075 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5076 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5080 This function is used in examples 16, 21, and 22.\n\
5086plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5090 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5091 plot. Should have dimensions of\n\
5095 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5097 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5099 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5100 the region that should be plotted in the shade plot. This\n\
5101 function accepts x and y coordinates as input arguments and must\n\
5102 return 1 if the point is to be included in the shade plot and 0\n\
5103 otherwise. If you want to plot the entire shade plot (the usual\n\
5104 case), this argument should be set to NULL.\n\
5106 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5107 pltr below for how these arguments are used (only for the special case\n\
5108 when the callback function\n\
5109 pltr is not supplied).\n\
5111 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5112 corresponding to the edges of each shaded region that will be\n\
5113 plotted by this function. To work properly the levels should be\n\
5116 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5117 of shade edge values in clevel).\n\
5119 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5122 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5123 contours defining edges of shaded regions. The pen color is only\n\
5124 temporary set for the contour drawing. Set this value to zero or\n\
5125 less if no shade edge contours are wanted.\n\
5127 cont_width (PLFLT, input) : Defines line width used for contours\n\
5128 defining edges of shaded regions. This value may not be honored\n\
5129 by all drivers. The pen width is only temporary set for the\n\
5130 contour drawing. Set this value to zero or less if no shade edge\n\
5131 contours are wanted.\n\
5133 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5134 region. Use plfill for this purpose.\n\
5136 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5137 map to rectangles after coordinate transformation with pltrl.\n\
5138 Otherwise, set rectangular to false. If rectangular is set to\n\
5139 true, plshade tries to save time by filling large rectangles.\n\
5140 This optimization fails if the coordinate transformation distorts\n\
5141 the shape of rectangles. For example a plot in polar coordinates\n\
5142 has to have rectangular set to false.\n\
5144 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5145 defines the transformation between the zero-based indices of the\n\
5146 matrix a and world coordinates. If\n\
5147 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5148 indices of a are mapped to the range\n\
5150 xmax and the y indices of a are mapped to the range\n\
5152 ymax.For the C case, transformation functions are provided in the\n\
5153 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5154 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5155 matrices. In addition, C callback routines for the transformation\n\
5156 can be supplied by the user such as the mypltr function in\n\
5157 examples/c/x09c.c which provides a general linear transformation\n\
5158 between index coordinates and world coordinates.For languages\n\
5159 other than C you should consult the PLplot documentation for the\n\
5160 details concerning how PLTRANSFORM_callback arguments are\n\
5161 interfaced. However, in general, a particular pattern of\n\
5162 callback-associated arguments such as a tr vector with 6 elements;\n\
5163 xg and yg vectors; or xg and yg matrices are respectively\n\
5164 interfaced to a linear-transformation routine similar to the above\n\
5165 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5166 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5167 support native language callbacks for handling index to\n\
5168 world-coordinate transformations. Examples of these various\n\
5169 approaches are given in examples/<language>x09*,\n\
5170 examples/<language>x16*, examples/<language>x20*,\n\
5171 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5172 supported languages.\n\
5174 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5175 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5176 externally supplied.\n\
5179Set output file name\n\
5183 Sets the current output file name, if applicable. If the file name\n\
5184 has not been specified and is required by the driver, the user will be\n\
5185 prompted for it. If using the X-windows output driver, this sets the\n\
5186 display name. This routine, if used, must be called before\n\
5187 initializing PLplot.\n\
5189 Redacted form: plsfnam(fnam)\n\
5191 This function is used in examples 1 and 20.\n\
5201 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5209 Draws a contour plot of the data in f[\n\
5211 ny], using the nlevel contour levels specified by clevel. Only the\n\
5212 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5213 where all these index ranges are interpreted as one-based for\n\
5214 historical reasons. A transformation routine pointed to by pltr with\n\
5215 a generic pointer pltr_data for additional data required by the\n\
5216 transformation routine is used to map indices within the matrix to the\n\
5217 world coordinates.\n\
5219 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5220 where (see above discussion) the pltr, pltr_data callback arguments\n\
5221 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5222 vectors; or xg and yg matrices.\n\
5224 This function is used in examples 9, 14, 16, and 22.\n\
5230plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5234 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5236 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5238 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5239 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5240 zero-based for historical backwards-compatibility reasons.\n\
5242 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5243 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5244 zero-based for historical backwards-compatibility reasons.\n\
5246 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5247 which to draw contours.\n\
5249 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5251 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5252 defines the transformation between the zero-based indices of the\n\
5253 matrix f and the world coordinates.For the C case, transformation\n\
5254 functions are provided in the PLplot library: pltr0 for the\n\
5255 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5256 respectively defined by vectors and matrices. In addition, C\n\
5257 callback routines for the transformation can be supplied by the\n\
5258 user such as the mypltr function in examples/c/x09c.c which\n\
5259 provides a general linear transformation between index coordinates\n\
5260 and world coordinates.For languages other than C you should\n\
5261 consult the PLplot documentation for the details concerning how\n\
5262 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5263 general, a particular pattern of callback-associated arguments\n\
5264 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5265 yg matrices are respectively interfaced to a linear-transformation\n\
5266 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5267 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5268 the PLplot documentation) support native language callbacks for\n\
5269 handling index to world-coordinate transformations. Examples of\n\
5270 these various approaches are given in examples/<language>x09*,\n\
5271 examples/<language>x16*, examples/<language>x20*,\n\
5272 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5273 supported languages.\n\
5275 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5276 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5277 that is externally supplied.\n\
5280Set parameters that define current plot-space window\n\
5284 Set relative minima and maxima that define the current plot-space\n\
5285 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5286 xmax, and ymax are 0., 0., 1., and 1.\n\
5288 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5290 This function is used in example 31.\n\
5296plsdiplt(xmin, ymin, xmax, ymax)\n\
5300 xmin (PLFLT, input) : Relative minimum in x.\n\
5302 ymin (PLFLT, input) : Relative minimum in y.\n\
5304 xmax (PLFLT, input) : Relative maximum in x.\n\
5306 ymax (PLFLT, input) : Relative maximum in y.\n\
5309Write text inside the viewport of a 3D plot\n\
5313 Writes text at a specified position and inclination and with a\n\
5314 specified shear within the viewport. Text is clipped at the viewport\n\
5315 boundaries. The reference point of a string lies along a line passing\n\
5316 through the string at half the height of a capital letter. The\n\
5317 position of the reference point along this line is determined by just,\n\
5318 and the reference point is placed at world coordinates (\n\
5321 wz) within the viewport. The inclination and shear of the string is\n\
5322 specified in terms of differences of world coordinates making it easy\n\
5323 to write text parallel to a line in a graph.\n\
5325 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5327 This function is used in example 28.\n\
5333plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5337 wx (PLFLT, input) : x world coordinate of reference point of\n\
5340 wy (PLFLT, input) : y world coordinate of reference point of\n\
5343 wz (PLFLT, input) : z world coordinate of reference point of\n\
5346 dx (PLFLT, input) : Together with dy and\n\
5347 dz , this specifies the inclination of the string. The baseline of\n\
5348 the string is parallel to a line joining (\n\
5359 dy (PLFLT, input) : Together with dx and\n\
5360 dz, this specifies the inclination of the string.\n\
5362 dz (PLFLT, input) : Together with dx and\n\
5363 dy, this specifies the inclination of the string.\n\
5365 sx (PLFLT, input) : Together with sy and\n\
5366 sz , this specifies the shear of the string. The string is sheared so\n\
5367 that the characters are vertically parallel to a line joining (\n\
5378 sz = 0.) then the text is not sheared.\n\
5380 sy (PLFLT, input) : Together with sx and\n\
5381 sz, this specifies shear of the string.\n\
5383 sz (PLFLT, input) : Together with sx and\n\
5384 sy, this specifies shear of the string.\n\
5386 just (PLFLT, input) : Specifies the position of the string relative\n\
5387 to its reference point. If just=0. , the reference point is at\n\
5388 the left and if just=1. , it is at the right of the string. Other\n\
5389 values of just give intermediate justifications.\n\
5391 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5395Plot continental outline or shapefile data in world coordinates\n\
5399 Plots continental outlines or shapefile data in world coordinates. A\n\
5400 demonstration of how to use this function to create different\n\
5401 projections can be found in examples/c/x19c. PLplot is provided with\n\
5402 basic coastal outlines and USA state borders. To use the map\n\
5403 functionality PLplot must be compiled with the shapelib library.\n\
5404 Shapefiles have become a popular standard for geographical data and\n\
5405 data in this format can be easily found from a number of online\n\
5406 sources. Shapefile data is actually provided as three or more files\n\
5407 with the same filename, but different extensions. The .shp and .shx\n\
5408 files are required for plotting Shapefile data with PLplot.\n\
5410 PLplot currently supports the point, multipoint, polyline and polygon\n\
5411 objects within shapefiles. However holes in polygons are not\n\
5412 supported. When plmap is used the type of object is derived from the\n\
5413 shapefile, if you wish to override the type then use one of the other\n\
5414 plmap variants. The built in maps have line data only.\n\
5416 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5418 This function is used in example 19.\n\
5424plmap(mapform, name, minx, maxx, miny, maxy)\n\
5428 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5429 transform the original map data coordinates to a new coordinate\n\
5430 system. The PLplot-supplied map data is provided as latitudes and\n\
5431 longitudes; other Shapefile data may be provided in other\n\
5432 coordinate systems as can be found in their .prj plain text files.\n\
5433 For example, by using this transform we can change from a\n\
5434 longitude, latitude coordinate to a polar stereographic\n\
5435 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5436 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5437 corresponding y coordinates (latitudes for the PLplot supplied\n\
5438 data). After the call to mapform(), x[] and y[] should be\n\
5439 replaced by the corresponding plot coordinates. If no transform is\n\
5440 desired, mapform can be replaced by NULL.\n\
5442 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5443 the type of map plotted. This is either one of the PLplot built-in\n\
5444 maps or the file name of a set of Shapefile files without the file\n\
5445 extensions. For the PLplot built-in maps the possible values are:\n\
5446 \"globe\" -- continental outlines\n\
5447 \"usa\" -- USA and state boundaries\n\
5448 \"cglobe\" -- continental outlines and countries\n\
5449 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5452 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5453 drawn. The units must match the shapefile (built in maps are\n\
5454 degrees lat/lon). Objects in the file which do not encroach on the\n\
5455 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5456 note this is simply an optimisation, not a clipping so for objects\n\
5457 with some points inside the box and some points outside the box\n\
5458 all the points will be rendered. These parameters also define\n\
5459 latitude and longitude wrapping for shapefiles using these units.\n\
5460 Longitude points will be wrapped by integer multiples of 360\n\
5461 degrees to place them in the box. This allows the same data to be\n\
5462 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5463 you plot from -180-540 you will get two cycles of data drawn. The\n\
5464 value of minx must be less than the value of maxx. Passing in a\n\
5465 nan, max/-max floating point number or +/-infinity will case the\n\
5466 bounding box from the shapefile to be used.\n\
5468 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5469 drawn - see minx.\n\
5471 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5472 drawn - see minx.\n\
5474 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5475 drawn - see minx.\n\
5478Specify viewport using coordinates and aspect ratio\n\
5482 Device-independent routine for setting up the viewport. The viewport\n\
5483 is chosen to be the largest with the given aspect ratio that fits\n\
5484 within the specified region (in terms of normalized subpage\n\
5485 coordinates). This routine is functionally equivalent to plvpor when\n\
5486 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5487 routine reserves no extra space at the edges for labels.\n\
5489 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5491 This function is used in example 9.\n\
5497plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5501 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5502 left-hand edge of the viewport.\n\
5504 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5505 right-hand edge of the viewport.\n\
5507 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5508 bottom edge of the viewport.\n\
5510 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5511 edge of the viewport.\n\
5513 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5517Set the pause (on end-of-page) status\n\
5521 Set the pause (on end-of-page) status.\n\
5523 Redacted form: plspause(pause)\n\
5525 This function is in examples 14,20.\n\
5535 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5536 end-of-page for those drivers which support this. Otherwise there\n\
5540Plot 3-d surface plot\n\
5544 Plots a three-dimensional surface plot within the environment set up\n\
5545 by plw3d. The surface is defined by the matrix z[\n\
5547 ny] , the point z[i][j] being the value of the function at (\n\
5549 y[j]). Note that the points in vectors x and y do not need to be\n\
5550 equally spaced, but must be stored in ascending order. The parameter\n\
5551 opt controls the way in which the surface is displayed. For further\n\
5552 details see the PLplot documentation. The only difference between\n\
5553 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5554 while plot3d only draws the surface as viewed from the top.\n\
5556 Redacted form: plot3d(x, y, z, opt, side)\n\
5558 This function is used in examples 11 and 21.\n\
5564plot3d(x, y, z, nx, ny, opt, side)\n\
5568 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5569 which the function is evaluated.\n\
5571 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5572 which the function is evaluated.\n\
5574 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5575 plot. Should have dimensions of\n\
5579 nx (PLINT, input) : Number of x values at which function is\n\
5582 ny (PLINT, input) : Number of y values at which function is\n\
5585 opt (PLINT, input) : Determines the way in which the surface is\n\
5586 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5587 function of x for each value of y[j] .\n\
5588 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5589 for each value of x[i] .\n\
5590 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5591 at which function is defined.\n\
5594 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5595 should be draw on the figure. If side is true sides are drawn,\n\
5596 otherwise no sides are drawn.\n\
5599Copy state parameters from the reference stream to the current stream\n\
5603 Copies state parameters from the reference stream to the current\n\
5604 stream. Tell driver interface to map device coordinates unless flags\n\
5607 This function is used for making save files of selected plots (e.g.\n\
5608 from the TK driver). After initializing, you can get a copy of the\n\
5609 current plot to the specified device by switching to this stream and\n\
5610 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5611 appropriate. The plot buffer must have previously been enabled (done\n\
5612 automatically by some display drivers, such as X).\n\
5614 Redacted form: plcpstrm(iplsr, flags)\n\
5616 This function is used in example 1,20.\n\
5622plcpstrm(iplsr, flags)\n\
5626 iplsr (PLINT, input) : Number of reference stream.\n\
5628 flags (PLBOOL, input) : If flags is set to true the device\n\
5629 coordinates are not copied from the reference to current stream.\n\
5632Set page parameters\n\
5636 Sets the page configuration (optional). If an individual parameter is\n\
5637 zero then that parameter value is not updated. Not all parameters are\n\
5638 recognized by all drivers and the interpretation is device-dependent.\n\
5639 The X-window driver uses the length and offset parameters to determine\n\
5640 the window size and location. The length and offset values are\n\
5641 expressed in units that are specific to the current driver. For\n\
5642 instance: screen drivers will usually interpret them as number of\n\
5643 pixels, whereas printer drivers will usually use mm.\n\
5645 This routine, if used, must be called before initializing PLplot. It\n\
5646 may be called at later times for interactive drivers to change only\n\
5647 the dpi for subsequent redraws which you can force via a call to\n\
5648 plreplot. If this function is not called then the page size defaults\n\
5649 to landscape A4 for drivers which use real world page sizes and 744\n\
5650 pixels wide by 538 pixels high for raster drivers. The default value\n\
5651 for dx and dy is 90 pixels per inch for raster drivers.\n\
5655 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5657 This function is used in examples 14 and 31.\n\
5663plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5667 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5668 by raster drivers, ignored by drivers which use \"real world\" units\n\
5671 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5672 by raster drivers, ignored by drivers which use \"real world\" units\n\
5675 xleng (PLINT, input) : Page length, x.\n\
5677 yleng (PLINT, input) : Page length, y.\n\
5679 xoff (PLINT, input) : Page offset, x.\n\
5681 yoff (PLINT, input) : Page offset, y.\n\
5684Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5688 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5689 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5690 Values are negative if an invalid color id is given.\n\
5692 Redacted form: plgcola(r, g, b)\n\
5694 This function is used in example 30.\n\
5700plgcol0a(icol0, r, g, b, alpha)\n\
5704 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5706 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5707 in the range from 0 to 255.\n\
5709 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5710 in the range from 0 to 255.\n\
5712 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5713 in the range from 0 to 255.\n\
5715 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5716 transparency in the range from (0.0-1.0).\n\
5719Returns 8-bit RGB values for given color index from cmap0\n\
5723 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5724 PLplot documentation). Values are negative if an invalid color id is\n\
5727 Redacted form: plgcol0(icol0, r, g, b)\n\
5729 This function is used in example 2.\n\
5735plgcol0(icol0, r, g, b)\n\
5739 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5741 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5744 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5747 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5751Set parameters incrementally (zoom mode) that define current plot-space window\n\
5755 Set relative minima and maxima incrementally (zoom mode) that define\n\
5756 the current plot-space window. This function has the same effect as\n\
5757 plsdiplt if that function has not been previously called. Otherwise,\n\
5758 this function implements zoom mode using the transformation min_used =\n\
5759 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5760 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5761 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5763 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5765 This function is used in example 31.\n\
5771plsdiplz(xmin, ymin, xmax, ymax)\n\
5775 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5777 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5779 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5781 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5784Plot all or a subset of Shapefile data, filling the polygons\n\
5788 As per plmapline, however the items are filled in the same way as\n\
5791 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5794 This function is used in example 19.\n\
5800plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5804 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5805 transform the coordinates given in the shapefile into a plot\n\
5806 coordinate system. By using this transform, we can change from a\n\
5807 longitude, latitude coordinate to a polar stereographic project,\n\
5808 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5809 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5810 mapform(), x[] and y[] should be replaced by the corresponding\n\
5811 plot coordinates. If no transform is desired, mapform can be\n\
5812 replaced by NULL.\n\
5814 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5815 the file name of a set of Shapefile files without the file\n\
5818 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5819 be in the same units as used by the Shapefile. You could use a\n\
5820 very large negative number to plot everything, but you can improve\n\
5821 performance by limiting the area drawn. The units must match those\n\
5822 of the Shapefile projection, which may be for example longitude or\n\
5823 distance. The value of minx must be less than the value of maxx.\n\
5825 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5826 use a very large number to plot everything, but you can improve\n\
5827 performance by limiting the area drawn.\n\
5829 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5830 be in the same units as used by the Shapefile. You could use a\n\
5831 very large negative number to plot everything, but you can improve\n\
5832 performance by limiting the area drawn. The units must match those\n\
5833 of the Shapefile projection, which may be for example latitude or\n\
5834 distance. The value of miny must be less than the value of maxy.\n\
5836 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5837 use a very large number to plot everything, but you can improve\n\
5838 performance by limiting the area drawn.\n\
5840 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5841 zero-based indices of the Shapefile elements which will be drawn.\n\
5843 plotentries to NULL will plot all elements of the Shapefile.\n\
5845 nplotentries (PLINT, input) : The number of items in\n\
5846 plotentries. Ignored if\n\
5847 plotentries is NULL.\n\
5854 Draws line defined by n points in x and y.\n\
5856 Redacted form: plline(x, y)\n\
5858 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5869 n (PLINT, input) : Number of points defining line.\n\
5871 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5874 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5878Get viewport limits in world coordinates\n\
5882 Get viewport limits in world coordinates.\n\
5884 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5887 This function is used in example 31.\n\
5893plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5897 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5898 viewport limit of the world coordinate in x.\n\
5900 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5901 viewport limit of the world coordinate in x.\n\
5903 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5904 viewport limit of the world coordinate in y.\n\
5906 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5907 viewport limit of the world coordinate in y.\n\
5910Set area line fill pattern\n\
5914 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5915 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5916 inclinations and spacings. The arguments to this routine are the\n\
5917 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5918 elements) specifying the inclinations in tenths of a degree and the\n\
5919 spacing in micrometers. (See also plpsty)\n\
5921 Redacted form: General: plpat(inc, del)\n\
5924 This function is used in example 15.\n\
5930plpat(nlin, inc, del)\n\
5934 nlin (PLINT, input) : Number of sets of lines making up the\n\
5935 pattern, either 1 or 2.\n\
5937 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5938 inclination in tenths of a degree. (Should be between -900 and\n\
5941 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5942 spacing in micrometers between the lines making up the pattern.\n\
5945Set x axis parameters\n\
5949 Sets values of the digmax and digits flags for the x axis. See the\n\
5950 PLplot documentation for more information.\n\
5952 Redacted form: plsxax(digmax, digits)\n\
5954 This function is used in example 31.\n\
5960plsxax(digmax, digits)\n\
5964 digmax (PLINT, input) : Variable to set the maximum number of\n\
5965 digits for the x axis. If nonzero, the printed label will be\n\
5966 switched to a floating-point representation when the number of\n\
5967 digits exceeds digmax.\n\
5969 digits (PLINT, input) : Field digits value. Currently, changing\n\
5970 its value here has no effect since it is set only by plbox or\n\
5971 plbox3. However, the user may obtain its value after a call to\n\
5972 either of these functions by calling plgxax.\n\
5975Get family file parameters\n\
5979 Gets information about current family file, if familying is enabled.\n\
5980 See the PLplot documentation for more information.\n\
5982 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5984 This function is used in examples 14 and 31.\n\
5990plgfam(p_fam, p_num, p_bmax)\n\
5994 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5995 family flag value. If nonzero, familying is enabled for the\n\
5998 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5999 family file number.\n\
6001 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6002 file size (in bytes) for a family file.\n\
6005Get y axis parameters\n\
6009 Identical to plgxax, except that arguments are flags for y axis. See\n\
6010 the description of plgxax for more detail.\n\
6012 Redacted form: plgyax(p_digmax, p_digits)\n\
6014 This function is used in example 31.\n\
6020plgyax(p_digmax, p_digits)\n\
6024 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6025 number of digits for the y axis. If nonzero, the printed label\n\
6026 has been switched to a floating-point representation when the\n\
6027 number of digits exceeds this value.\n\
6029 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6030 number of digits for the numeric labels (y axis) from the last\n\
6034Plot a glyph at the specified points\n\
6038 Plot a glyph at the specified points. (This function is largely\n\
6039 superseded by plstring which gives access to many[!] more glyphs.)\n\
6040 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6041 and a draw at the same place. Not ideal, since a sufficiently\n\
6042 intelligent output device may optimize it away, or there may be faster\n\
6043 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6044 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6045 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6046 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6047 code <= 127 the corresponding printable ASCII character is plotted.\n\
6049 Redacted form: plpoin(x, y, code)\n\
6051 This function is used in examples 1, 6, 14, and 29.\n\
6057plpoin(n, x, y, code)\n\
6061 n (PLINT, input) : Number of points in the x and y vectors.\n\
6063 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6066 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6069 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6070 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6071 each of the n points.\n\
6074Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6078 As per plmapline, however the items are plotted as strings or points\n\
6079 in the same way as plstring.\n\
6081 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6082 maxy, plotentries)\n\
6084 This function is not used in any examples.\n\
6090plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6094 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6095 transform the coordinates given in the shapefile into a plot\n\
6096 coordinate system. By using this transform, we can change from a\n\
6097 longitude, latitude coordinate to a polar stereographic project,\n\
6098 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6099 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6100 mapform(), x[] and y[] should be replaced by the corresponding\n\
6101 plot coordinates. If no transform is desired, mapform can be\n\
6102 replaced by NULL.\n\
6104 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6105 the file name of a set of Shapefile files without the file\n\
6108 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6111 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6112 be in the same units as used by the Shapefile. You could use a\n\
6113 very large negative number to plot everything, but you can improve\n\
6114 performance by limiting the area drawn. The units must match those\n\
6115 of the Shapefile projection, which may be for example longitude or\n\
6116 distance. The value of minx must be less than the value of maxx.\n\
6118 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6119 use a very large number to plot everything, but you can improve\n\
6120 performance by limiting the area drawn.\n\
6122 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6123 be in the same units as used by the Shapefile. You could use a\n\
6124 very large negative number to plot everything, but you can improve\n\
6125 performance by limiting the area drawn. The units must match those\n\
6126 of the Shapefile projection, which may be for example latitude or\n\
6127 distance. The value of miny must be less than the value of maxy.\n\
6129 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6130 use a very large number to plot everything, but you can improve\n\
6131 performance by limiting the area drawn.\n\
6133 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6134 zero-based indices of the Shapefile elements which will be drawn.\n\
6136 plotentries to NULL will plot all elements of the Shapefile.\n\
6138 nplotentries (PLINT, input) : The number of items in\n\
6139 plotentries. Ignored if\n\
6140 plotentries is NULL.\n\
6143Select area fill pattern\n\
6148 patt is zero or less use either a hardware solid fill if the drivers\n\
6149 have that capability (virtually all do) or fall back to a software\n\
6150 emulation of a solid fill using the eighth area line fill pattern. If\n\
6152 patt <= 8, then select one of eight predefined area line fill patterns\n\
6153 to use (see plpat if you desire other patterns).\n\
6155 Redacted form: plpsty(patt)\n\
6157 This function is used in examples 12, 13, 15, 16, and 25.\n\
6167 patt (PLINT, input) : The desired pattern index. If\n\
6168 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6170 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6171 line fill capability itself (most deliberately do not so that line\n\
6172 fill patterns look identical for those drivers), the patterns\n\
6173 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6174 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6175 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6176 (8) lines at both 45 degrees and -45 degrees.\n\
6179Set 8-bit RGB values for given cmap0 color index\n\
6183 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6184 index. Overwrites the previous color value for the given index and,\n\
6185 thus, does not result in any additional allocation of space for\n\
6188 Redacted form: plscol0(icol0, r, g, b)\n\
6190 This function is used in any example 31.\n\
6196plscol0(icol0, r, g, b)\n\
6200 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6201 number of colors (which is set by default, by plscmap0n, or even\n\
6204 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6205 degree of red in the color.\n\
6207 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6208 degree of green in the color.\n\
6210 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6211 degree of blue in the color.\n\
6214Used to globally turn color output on/off\n\
6218 Used to globally turn color output on/off for those drivers/devices\n\
6221 Redacted form: plscolor(color)\n\
6223 This function is used in example 31.\n\
6233 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6234 turned off. If non-zero, color is turned on.\n\
6237End plotting session\n\
6241 Ends a plotting session, tidies up all the output files, switches\n\
6242 interactive devices back into text mode and frees up any memory that\n\
6243 was allocated. Must be called before end of program.\n\
6245 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6246 wait state after a call to plend or other functions which trigger the\n\
6247 end of a plot page. To avoid this, use the plspause function.\n\
6249 Redacted form: plend()\n\
6251 This function is used in all of the examples.\n\
6260Plot a histogram from binned data\n\
6264 Plots a histogram consisting of nbin bins. The value associated with\n\
6265 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6266 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6267 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6268 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6269 placed midway between the values in the x vector. Also see plhist for\n\
6270 drawing histograms from unbinned data.\n\
6272 Redacted form: General: plbin(x, y, opt)\n\
6273 Python: plbin(nbin, x, y, opt)\n\
6276 This function is not used in any examples.\n\
6282plbin(nbin, x, y, opt)\n\
6286 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6289 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6290 with bins. These must form a strictly increasing sequence.\n\
6292 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6293 proportional to the number of points in each bin. This is a PLFLT\n\
6294 (instead of PLINT) vector so as to allow histograms of\n\
6295 probabilities, etc.\n\
6297 opt (PLINT, input) : Is a combination of several flags:\n\
6298 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6299 outer bins are expanded to fill up the entire x-axis and bins of\n\
6300 zero height are simply drawn.\n\
6301 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6302 between the x values. If the values in x are equally spaced,\n\
6303 the values are the center values of the bins.\n\
6304 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6305 size as the ones inside.\n\
6306 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6307 (there is a gap for such bins).\n\
6310Plot a 2D matrix using cmap1\n\
6314 Plot a 2D matrix using cmap1.\n\
6316 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6317 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6320 This function is used in example 20.\n\
6326plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6330 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6331 plot. Should have dimensions of\n\
6335 nx, ny (PLINT, input) : Dimensions of idata\n\
6337 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6338 pltr below for how these arguments are used (only for the special case\n\
6339 when the callback function\n\
6340 pltr is not supplied).\n\
6342 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6343 (inclusive) will be plotted.\n\
6345 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6346 values to use for value to color mappings. A datum equal to or\n\
6347 less than valuemin will be plotted with color 0.0, while a datum\n\
6348 equal to or greater than valuemax will be plotted with color 1.0.\n\
6349 Data between valuemin and valuemax map linearly to colors in the\n\
6352 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6353 defines the transformation between the zero-based indices of the\n\
6354 matrix idata and world coordinates. If\n\
6355 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6356 indices of idata are mapped to the range\n\
6358 xmax and the y indices of idata are mapped to the range\n\
6360 ymax.For the C case, transformation functions are provided in the\n\
6361 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6362 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6363 matrices. In addition, C callback routines for the transformation\n\
6364 can be supplied by the user such as the mypltr function in\n\
6365 examples/c/x09c.c which provides a general linear transformation\n\
6366 between index coordinates and world coordinates.For languages\n\
6367 other than C you should consult the PLplot documentation for the\n\
6368 details concerning how PLTRANSFORM_callback arguments are\n\
6369 interfaced. However, in general, a particular pattern of\n\
6370 callback-associated arguments such as a tr vector with 6 elements;\n\
6371 xg and yg vectors; or xg and yg matrices are respectively\n\
6372 interfaced to a linear-transformation routine similar to the above\n\
6373 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6374 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6375 support native language callbacks for handling index to\n\
6376 world-coordinate transformations. Examples of these various\n\
6377 approaches are given in examples/<language>x09*,\n\
6378 examples/<language>x16*, examples/<language>x20*,\n\
6379 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6380 supported languages.\n\
6382 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6383 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6384 externally supplied.\n\
6387Sets the 3D position of the light source\n\
6391 Sets the 3D position of the light source for use with plsurf3d and\n\
6394 Redacted form: pllightsource(x, y, z)\n\
6396 This function is used in example 8.\n\
6402pllightsource(x, y, z)\n\
6406 x (PLFLT, input) : X-coordinate of the light source.\n\
6408 y (PLFLT, input) : Y-coordinate of the light source.\n\
6410 z (PLFLT, input) : Z-coordinate of the light source.\n\
6413Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6417 When the implementation is completed this variant of plot3dc (see that\n\
6418 function\'s documentation for more details) should be suitable for the\n\
6419 case where the area of the x, y coordinate grid where z is defined can\n\
6420 be non-rectangular. The implementation is incomplete so the last 4\n\
6421 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6422 indexymax; are currently ignored and the functionality is otherwise\n\
6423 identical to that of plot3dc.\n\
6425 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6426 indexymin, indexymax)\n\
6429 This function is not used in any example.\n\
6435plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6439 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6440 which the function is evaluated.\n\
6442 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6443 which the function is evaluated.\n\
6445 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6446 plot. Should have dimensions of\n\
6450 nx (PLINT, input) : Number of x values at which the function is\n\
6453 ny (PLINT, input) : Number of y values at which the function is\n\
6456 opt (PLINT, input) : Determines the way in which the surface is\n\
6457 represented. To specify more than one option just add the options,\n\
6458 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6459 showing z as a function of x for each value of y[j] .\n\
6460 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6461 for each value of x[i] .\n\
6462 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6463 at which function is defined.\n\
6464 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6465 the z value being plotted. The color is used from the current\n\
6467 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6471 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6472 the borders of the plotted function.\n\
6475 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6478 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6480 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6481 corresponds to the first x index where z is defined.\n\
6483 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6484 which corresponds (by convention) to one more than the last x\n\
6485 index value where z is defined.\n\
6487 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6488 values which all must be ≥ 0. These values are the first y index\n\
6489 where z is defined for a particular x index in the range from\n\
6490 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6493 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6494 values which all must be ≤ ny. These values correspond (by\n\
6495 convention) to one more than the last y index where z is defined\n\
6496 for a particular x index in the range from indexxmin to indexxmax\n\
6497 - 1. The dimension of indexymax is indexxmax.\n\
6500Creates a new stream and makes it the default\n\
6504 Creates a new stream and makes it the default. Differs from using\n\
6505 plsstrm, in that a free stream number is found, and returned.\n\
6506 Unfortunately, I have to start at stream 1 and work upward, since\n\
6507 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6508 that no initial, library-opening call is required. So stream 0 must\n\
6509 be preallocated, and there is no simple way of determining whether it\n\
6510 is already in use or not.\n\
6512 Redacted form: plmkstrm(p_strm)\n\
6514 This function is used in examples 1 and 20.\n\
6524 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6525 number of the created stream.\n\
6528Set FCI (font characterization integer)\n\
6532 Sets font characteristics to be used at the start of the next string\n\
6533 using the FCI approach. See the PLplot documentation for more\n\
6534 information. Note, plsfont (which calls plsfci internally) provides a\n\
6535 more user-friendly API for setting the font characterisitics.\n\
6537 Redacted form: General: plsfci(fci)\n\
6540 This function is used in example 23.\n\
6550 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6558 Initializing the plotting package. The program prompts for the device\n\
6559 keyword or number of the desired output device. Hitting a RETURN in\n\
6560 response to the prompt is the same as selecting the first device.\n\
6561 plinit will issue no prompt if either the device was specified\n\
6562 previously (via command line flag, the plsetopt function, or the\n\
6563 plsdev function), or if only one device is enabled when PLplot is\n\
6564 installed. If subpages have been specified, the output device is\n\
6565 divided into nx by ny subpages, each of which may be used\n\
6566 independently. If plinit is called again during a program, the\n\
6567 previously opened file will be closed. The subroutine pladv is used\n\
6568 to advance from one subpage to the next.\n\
6570 Redacted form: plinit()\n\
6572 This function is used in all of the examples.\n\
6585 This sets up the line style for all lines subsequently drawn. A line\n\
6586 consists of segments in which the pen is alternately down and up. The\n\
6587 lengths of these segments are passed in the vectors mark and space\n\
6588 respectively. The number of mark-space pairs is specified by nms. In\n\
6589 order to return the line style to the default continuous line, plstyl\n\
6590 should be called with nms =0 .(see also pllsty)\n\
6592 Redacted form: plstyl(mark, space)\n\
6594 This function is used in examples 1, 9, and 14.\n\
6600plstyl(nms, mark, space)\n\
6604 nms (PLINT, input) : The number of mark and space elements in a\n\
6605 line. Thus a simple broken line can be obtained by setting nms=1\n\
6606 . A continuous line is specified by setting nms=0 .\n\
6608 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6609 segments during which the pen is down, measured in micrometers.\n\
6611 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6612 the segments during which the pen is up, measured in micrometers.\n\
6615Set length of minor ticks\n\
6619 This sets up the length of the minor ticks and the length of the\n\
6620 terminals on error bars. The actual length is the product of the\n\
6621 default length and a scaling factor as for character height.\n\
6623 Redacted form: plsmin(def, scale)\n\
6625 This function is used in example 29.\n\
6631plsmin(def, scale)\n\
6635 def (PLFLT, input) : The default length of a minor tick in\n\
6636 millimeters, should be set to zero if the default length is to\n\
6637 remain unchanged.\n\
6639 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6640 actual tick length.\n\
6643Draw a box with axes, etc, in 3-d\n\
6647 Draws axes, numeric and text labels for a three-dimensional surface\n\
6648 plot. For a more complete description of three-dimensional plotting\n\
6649 see the PLplot documentation.\n\
6651 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6652 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6655 This function is used in examples 8, 11, 18, and 21.\n\
6661plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6665 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6666 options for the x axis. The string can include any combination of\n\
6667 the following letters (upper or lower case) in any order: b: Draws\n\
6668 axis at base, at height z=\n\
6669 zmin where zmin is defined by call to plw3d. This character must be\n\
6670 specified in order to use any of the other options.\n\
6671 d: Plot labels as date / time. Values are assumed to be\n\
6672 seconds since the epoch (as used by gmtime).\n\
6673 f: Always use fixed point numeric labels.\n\
6674 i: Inverts tick marks, so they are drawn downwards, rather\n\
6676 l: Labels axis logarithmically. This only affects the labels,\n\
6677 not the data, and so it is necessary to compute the logarithms\n\
6678 of data points before passing them to any of the drawing\n\
6680 n: Writes numeric labels at major tick intervals.\n\
6681 o: Use custom labelling function to generate axis label text.\n\
6682 The custom labelling function can be defined with the\n\
6683 plslabelfunc command.\n\
6684 s: Enables subticks between major ticks, only valid if t is\n\
6686 t: Draws major ticks.\n\
6687 u: If this is specified, the text label for the axis is\n\
6688 written under the axis.\n\
6691 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6692 the text label for the x axis. It is only drawn if u is in the\n\
6695 xtick (PLFLT, input) : World coordinate interval between major\n\
6696 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6697 generates a suitable tick interval.\n\
6699 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6700 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6701 generates a suitable minor tick interval.\n\
6703 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6704 options for the y axis. The string is interpreted in the same way\n\
6707 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6708 the text label for the y axis. It is only drawn if u is in the\n\
6711 ytick (PLFLT, input) : World coordinate interval between major\n\
6712 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6713 generates a suitable tick interval.\n\
6715 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6716 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6717 generates a suitable minor tick interval.\n\
6719 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6720 options for the z axis. The string can include any combination of\n\
6721 the following letters (upper or lower case) in any order: b: Draws\n\
6722 z axis to the left of the surface plot.\n\
6723 c: Draws z axis to the right of the surface plot.\n\
6724 d: Draws grid lines parallel to the x-y plane behind the\n\
6725 figure. These lines are not drawn until after plot3d or\n\
6726 plmesh are called because of the need for hidden line removal.\n\
6727 e: Plot labels as date / time. Values are assumed to be\n\
6728 seconds since the epoch (as used by gmtime). Note this\n\
6729 suboption is interpreted the same as the d suboption for xopt\n\
6730 and yopt, but it has to be identified as e for zopt since d\n\
6731 has already been used for the different purpose above.\n\
6732 f: Always use fixed point numeric labels.\n\
6733 i: Inverts tick marks, so they are drawn away from the center.\n\
6734 l: Labels axis logarithmically. This only affects the labels,\n\
6735 not the data, and so it is necessary to compute the logarithms\n\
6736 of data points before passing them to any of the drawing\n\
6738 m: Writes numeric labels at major tick intervals on the\n\
6739 right-hand z axis.\n\
6740 n: Writes numeric labels at major tick intervals on the\n\
6741 left-hand z axis.\n\
6742 o: Use custom labelling function to generate axis label text.\n\
6743 The custom labelling function can be defined with the\n\
6744 plslabelfunc command.\n\
6745 s: Enables subticks between major ticks, only valid if t is\n\
6747 t: Draws major ticks.\n\
6748 u: If this is specified, the text label is written beside the\n\
6750 v: If this is specified, the text label is written beside the\n\
6754 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6755 the text label for the z axis. It is only drawn if u or v are in\n\
6758 ztick (PLFLT, input) : World coordinate interval between major\n\
6759 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6760 generates a suitable tick interval.\n\
6762 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6763 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6764 generates a suitable minor tick interval.\n\
6767Set character size\n\
6771 This sets up the size of all subsequent characters drawn. The actual\n\
6772 height of a character is the product of the default character size and\n\
6773 a scaling factor.\n\
6775 Redacted form: plschr(def, scale)\n\
6777 This function is used in examples 2, 13, 23, and 24.\n\
6783plschr(def, scale)\n\
6787 def (PLFLT, input) : The default height of a character in\n\
6788 millimeters, should be set to zero if the default height is to\n\
6789 remain unchanged. For rasterized drivers the dx and dy values\n\
6790 specified in plspage are used to convert from mm to pixels (note\n\
6791 the different unit systems used). This dpi aware scaling is not\n\
6792 implemented for all drivers yet.\n\
6794 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6795 actual character height.\n\
6798Calculate continuous time from broken-down time for the current stream\n\
6802 Calculate continuous time, ctime, from broken-down time for the\n\
6803 current stream. The broken-down\n\
6804 time is specified by the following parameters: year, month, day, hour,\n\
6805 min, and sec. This function is the inverse of plbtime.\n\
6807 The PLplot definition of broken-down time is a calendar time that\n\
6808 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6809 responsibility to apply those offsets (if so desired) before using the\n\
6810 PLplot time API. By default broken-down time is defined using the\n\
6811 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6812 continuous time is defined as the number of seconds since the Unix\n\
6813 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6814 broken-down and continuous time are possible, see plconfigtime which\n\
6815 specifies that transformation for the current stream.\n\
6817 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6821 This function is used in example 29.\n\
6827plctime(year, month, day, hour, min, sec, ctime)\n\
6831 year (PLINT, input) : Input year.\n\
6833 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6836 day (PLINT, input) : Input day in range from 1 to 31.\n\
6838 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6840 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6842 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6844 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6845 time calculated from the broken-down time specified by the\n\
6846 previous parameters.\n\
6853 Sets the color index for cmap0 (see the PLplot documentation).\n\
6855 Redacted form: plcol0(icol0)\n\
6857 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6867 icol0 (PLINT, input) : Integer representing the color. The\n\
6868 defaults at present are (these may change):\n\
6869 0 black (default background)\n\
6870 1 red (default foreground)\n\
6886 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6887 change an individual color in the cmap0 color palette.\n\
6894 Sets the color for cmap1 (see the PLplot documentation).\n\
6896 Redacted form: plcol1(col1)\n\
6898 This function is used in examples 12 and 21.\n\
6908 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6909 is mapped to color using the continuous cmap1 palette which by\n\
6910 default ranges from blue to the background color to red. The\n\
6911 cmap1 palette can also be straightforwardly changed by the user\n\
6912 with plscmap1 or plscmap1l.\n\
6915Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6919 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6921 Redacted form: plgcolbg(r, g, b)\n\
6923 This function is used in example 31.\n\
6933 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6934 in the range from 0 to 255.\n\
6936 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6937 in the range from 0 to 255.\n\
6939 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6940 in the range from 0 to 255.\n\
6943Draw a circular or elliptical arc\n\
6947 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6948 semiminor axis b, starting at angle1 and ending at angle2.\n\
6950 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6954 This function is used in examples 3 and 27.\n\
6960plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6964 x (PLFLT, input) : X coordinate of arc center.\n\
6966 y (PLFLT, input) : Y coordinate of arc center.\n\
6968 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6970 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6972 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6975 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6978 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6981 fill (PLBOOL, input) : Draw a filled arc.\n\
6984Parse command-line arguments\n\
6988 Parse command-line arguments.\n\
6990 plparseopts removes all recognized flags (decreasing argc\n\
6991 accordingly), so that invalid input may be readily detected. It can\n\
6992 also be used to process user command line flags. The user can merge\n\
6993 an option table of type PLOptionTable into the internal option table\n\
6994 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6995 the external table(s) be parsed by calling plClearOpts before\n\
6998 The default action taken by plparseopts is as follows:\n\
6999 Returns with an error if an unrecognized option or badly formed\n\
7000 option-value pair are encountered.\n\
7001 Returns immediately (return code 0) when the first non-option command\n\
7002 line argument is found.\n\
7003 Returns with the return code of the option handler, if one was called.\n\
7005 Deletes command line arguments from argv list as they are found, and\n\
7006 decrements argc accordingly.\n\
7007 Does not show \"invisible\" options in usage or help messages.\n\
7008 Assumes the program name is contained in argv[0].\n\
7010 These behaviors may be controlled through the\n\
7013 Redacted form: General: plparseopts(argv, mode)\n\
7016 This function is used in all of the examples.\n\
7022PLINT plparseopts(p_argc, argv, mode)\n\
7026 p_argc (int *, input/output) : Number of arguments.\n\
7028 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7029 strings containing *p_argc command-line arguments.\n\
7031 mode (PLINT, input) : Parsing mode with the following\n\
7032 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7033 and all error messages enabled, including program exit when an\n\
7034 error occurs. Anything on the command line that isn\'t recognized\n\
7035 as a valid option or option argument is flagged as an error.\n\
7036 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7038 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7040 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7041 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7042 pointer to the program name.\n\
7043 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7044 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7045 unrecognized arguments.\n\
7048Get parameters that define current device-space window\n\
7052 Get relative margin width, aspect ratio, and relative justification\n\
7053 that define current device-space window. If plsdidev has not been\n\
7054 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7055 p_jy will all be 0.\n\
7057 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7059 This function is used in example 31.\n\
7065plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7069 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7072 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7075 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7076 justification in x.\n\
7078 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7079 justification in y.\n\
7082Assign a function to use for generating custom axis labels\n\
7086 This function allows a user to provide their own function to provide\n\
7087 axis label text. The user function is given the numeric value for a\n\
7088 point on an axis and returns a string label to correspond with that\n\
7089 value. Custom axis labels can be enabled by passing appropriate\n\
7090 arguments to plenv, plbox, plbox3 and similar functions.\n\
7092 This function is used in example 19.\n\
7098plslabelfunc(label_func, label_data)\n\
7102 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7103 label function. In order to reset to the default labelling, set\n\
7104 this to NULL. The labelling function parameters are, in order:\n\
7105 axis: This indicates which axis a label is being requested for.\n\
7106 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7108 value: This is the value along the axis which is being labelled.\n\
7110 label_text: The string representation of the label value.\n\
7112 length: The maximum length in characters allowed for label_text.\n\
7115 label_data (PLPointer, input) : This parameter may be used to pass\n\
7116 data to the label_func function.\n\
7119Get the (current) run level\n\
7123 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7125 2, viewport defined\n\
7126 3, world coordinates defined\n\
7129 Redacted form: plglevel(p_level)\n\
7131 This function is used in example 31.\n\
7141 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7149 This sets the line style according to one of eight predefined patterns\n\
7150 (also see plstyl).\n\
7152 Redacted form: pllsty(lin)\n\
7154 This function is used in examples 9, 12, 22, and 25.\n\
7164 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7165 a continuous line, line style 2 is a line with short dashes and\n\
7166 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7167 4 has long dashes and short gaps and so on.\n\
7170Set up standard window and draw box\n\
7174 Sets up plotter environment for simple graphs by calling pladv and\n\
7175 setting up viewport and window to sensible default values. plenv\n\
7176 leaves a standard margin (left-hand margin of eight character heights,\n\
7177 and a margin around the other three sides of five character heights)\n\
7178 around most graphs for axis labels and a title. When these defaults\n\
7179 are not suitable, use the individual routines plvpas, plvpor, or\n\
7180 plvasp for setting up the viewport, plwind for defining the window,\n\
7181 and plbox for drawing the box.\n\
7183 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7185 This function is used in example 1,3,9,13,14,19-22,29.\n\
7191plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7195 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7196 world coordinates).\n\
7198 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7199 world coordinates).\n\
7201 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7204 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7207 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7208 scales will not be set, the user must set up the scale before\n\
7209 calling plenv using plsvpa, plvasp or other.\n\
7210 0: the x and y axes are scaled independently to use as much of\n\
7211 the screen as possible.\n\
7212 1: the scales of the x and y axes are made equal.\n\
7213 2: the axis of the x and y axes are made equal, and the plot\n\
7214 box will be square.\n\
7217 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7218 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7219 -1: draw box only.\n\
7220 0: draw box, ticks, and numeric tick labels.\n\
7221 1: also draw coordinate axes at x=0 and y=0.\n\
7222 2: also draw a grid at major tick positions in both\n\
7224 3: also draw a grid at minor tick positions in both\n\
7226 10: same as 0 except logarithmic x tick marks. (The x data\n\
7227 have to be converted to logarithms separately.)\n\
7228 11: same as 1 except logarithmic x tick marks. (The x data\n\
7229 have to be converted to logarithms separately.)\n\
7230 12: same as 2 except logarithmic x tick marks. (The x data\n\
7231 have to be converted to logarithms separately.)\n\
7232 13: same as 3 except logarithmic x tick marks. (The x data\n\
7233 have to be converted to logarithms separately.)\n\
7234 20: same as 0 except logarithmic y tick marks. (The y data\n\
7235 have to be converted to logarithms separately.)\n\
7236 21: same as 1 except logarithmic y tick marks. (The y data\n\
7237 have to be converted to logarithms separately.)\n\
7238 22: same as 2 except logarithmic y tick marks. (The y data\n\
7239 have to be converted to logarithms separately.)\n\
7240 23: same as 3 except logarithmic y tick marks. (The y data\n\
7241 have to be converted to logarithms separately.)\n\
7242 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7243 and y data have to be converted to logarithms separately.)\n\
7244 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7245 and y data have to be converted to logarithms separately.)\n\
7246 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7247 and y data have to be converted to logarithms separately.)\n\
7248 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7249 and y data have to be converted to logarithms separately.)\n\
7250 40: same as 0 except date / time x labels.\n\
7251 41: same as 1 except date / time x labels.\n\
7252 42: same as 2 except date / time x labels.\n\
7253 43: same as 3 except date / time x labels.\n\
7254 50: same as 0 except date / time y labels.\n\
7255 51: same as 1 except date / time y labels.\n\
7256 52: same as 2 except date / time y labels.\n\
7257 53: same as 3 except date / time y labels.\n\
7258 60: same as 0 except date / time x and y labels.\n\
7259 61: same as 1 except date / time x and y labels.\n\
7260 62: same as 2 except date / time x and y labels.\n\
7261 63: same as 3 except date / time x and y labels.\n\
7262 70: same as 0 except custom x and y labels.\n\
7263 71: same as 1 except custom x and y labels.\n\
7264 72: same as 2 except custom x and y labels.\n\
7265 73: same as 3 except custom x and y labels.\n\
7272 Alternative to plstar for initializing the plotting package. The\n\
7273 device name keyword for the desired output device must be supplied as\n\
7274 an argument. These keywords are the same as those printed out by\n\
7275 plstar. If the requested device is not available, or if the input\n\
7276 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7277 is used. This routine also divides the output device page into nx by\n\
7278 ny subpages, each of which may be used independently. The subroutine\n\
7279 pladv is used to advance from one subpage to the next.\n\
7281 Redacted form: General: plstart(devname, nx, ny)\n\
7284 This function is not used in any examples.\n\
7290plstart(devname, nx, ny)\n\
7294 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7295 containing the device name keyword of the required output device.\n\
7297 devname is NULL or if the first character of the string is a ``?\'\',\n\
7298 the normal (prompted) start up is used.\n\
7300 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7303 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7307Plot a glyph at the specified points\n\
7311 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7312 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7313 is specified with a PLplot user string. Note that the user string is\n\
7314 not actually limited to one glyph so it is possible (but not normally\n\
7315 useful) to plot more than one glyph at the specified points with this\n\
7316 function. As with plmtex and plptex, the user string can contain FCI\n\
7317 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7318 else PLplot escapes for Hershey or unicode text to determine the\n\
7321 Redacted form: plstring(x, y, string)\n\
7323 This function is used in examples 4, 21 and 26.\n\
7329plstring(n, x, y, string)\n\
7333 n (PLINT, input) : Number of points in the x and y vectors.\n\
7335 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7338 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7341 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7342 the glyph(s) to be plotted at each of the n points.\n\
7345Write text relative to viewport boundaries in 3D plots\n\
7349 Writes text at a specified position relative to the viewport\n\
7350 boundaries. Text may be written inside or outside the viewport, but\n\
7351 is clipped at the subpage boundaries. The reference point of a string\n\
7352 lies along a line passing through the string at half the height of a\n\
7353 capital letter. The position of the reference point along this line\n\
7354 is determined by just, and the position of the reference point\n\
7355 relative to the viewport is set by disp and pos.\n\
7357 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7359 This function is used in example 28.\n\
7365plmtex3(side, disp, pos, just, text)\n\
7369 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7370 the side of the viewport along which the text is to be written.\n\
7371 The string should contain one or more of the following characters:\n\
7372 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7373 only label the X axis, not both the X and Y axes. x: Label the X\n\
7375 y: Label the Y axis.\n\
7376 z: Label the Z axis.\n\
7377 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7378 For X it is the axis that starts at y-min. For Y it is the\n\
7379 axis that starts at x-min.\n\
7380 s: Label the secondary axis.\n\
7381 v: Draw the text perpendicular to the axis.\n\
7384 disp (PLFLT, input) : Position of the reference point of string,\n\
7385 measured outwards from the specified viewport edge in units of the\n\
7386 current character height. Use negative disp to write within the\n\
7389 pos (PLFLT, input) : Position of the reference point of string\n\
7390 along the specified edge, expressed as a fraction of the length of\n\
7393 just (PLFLT, input) : Specifies the position of the string relative\n\
7394 to its reference point. If just=0. , the reference point is at\n\
7395 the left and if just=1. , it is at the right of the string. Other\n\
7396 values of just give intermediate justifications.\n\
7398 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7402Get plot orientation\n\
7406 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7407 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7408 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7409 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7410 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7411 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7412 not been called the default value pointed to by p_rot will be 0.\n\
7414 Redacted form: plgdiori(p_rot)\n\
7416 This function is not used in any examples.\n\
7426 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7430Simple routine to write labels\n\
7434 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7436 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7438 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7444pllab(xlabel, ylabel, tlabel)\n\
7448 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7449 the label for the x axis.\n\
7451 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7452 the label for the y axis.\n\
7454 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7455 the title of the plot.\n\
7458Switch to text screen\n\
7462 Sets an interactive device to text mode, used in conjunction with\n\
7463 plgra to allow graphics and text to be interspersed. On a device\n\
7464 which supports separate text and graphics windows, this command causes\n\
7465 control to be switched to the text window. This can be useful for\n\
7466 printing diagnostic messages or getting user input, which would\n\
7467 otherwise interfere with the plots. The program must switch back to\n\
7468 the graphics window before issuing plot commands, as the text (or\n\
7469 console) device will probably become quite confused otherwise. If\n\
7470 already in text mode, this command is ignored. It is also ignored on\n\
7471 devices which only support a single window or use a different method\n\
7472 for shifting focus (see also plgra).\n\
7474 Redacted form: pltext()\n\
7476 This function is used in example 1.\n\
7485Plot all or a subset of Shapefile data using lines in world coordinates\n\
7489 Plot all or a subset of Shapefile data using lines in world\n\
7490 coordinates. Our 19th standard example demonstrates how to use this\n\
7491 function. This function plots data from a Shapefile using lines as in\n\
7492 plmap, however it also has the option of also only drawing specified\n\
7493 elements from the Shapefile. The vector of indices of the required\n\
7494 elements are passed as a function argument. The Shapefile data should\n\
7495 include a metadata file (extension.dbf) listing all items within the\n\
7496 Shapefile. This file can be opened by most popular spreadsheet\n\
7497 programs and can be used to decide which indices to pass to this\n\
7500 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7503 This function is used in example 19.\n\
7509plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7513 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7514 transform the coordinates given in the shapefile into a plot\n\
7515 coordinate system. By using this transform, we can change from a\n\
7516 longitude, latitude coordinate to a polar stereographic project,\n\
7517 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7518 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7519 mapform(), x[] and y[] should be replaced by the corresponding\n\
7520 plot coordinates. If no transform is desired, mapform can be\n\
7521 replaced by NULL.\n\
7523 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7524 the file name of a set of Shapefile files without the file\n\
7527 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7528 be in the same units as used by the Shapefile. You could use a\n\
7529 very large negative number to plot everything, but you can improve\n\
7530 performance by limiting the area drawn. The units must match those\n\
7531 of the Shapefile projection, which may be for example longitude or\n\
7532 distance. The value of minx must be less than the value of maxx.\n\
7534 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7535 use a very large number to plot everything, but you can improve\n\
7536 performance by limiting the area drawn.\n\
7538 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7539 be in the same units as used by the Shapefile. You could use a\n\
7540 very large negative number to plot everything, but you can improve\n\
7541 performance by limiting the area drawn. The units must match those\n\
7542 of the Shapefile projection, which may be for example latitude or\n\
7543 distance. The value of miny must be less than the value of maxy.\n\
7545 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7546 use a very large number to plot everything, but you can improve\n\
7547 performance by limiting the area drawn.\n\
7549 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7550 zero-based indices of the Shapefile elements which will be drawn.\n\
7552 plotentries to NULL will plot all elements of the Shapefile.\n\
7554 nplotentries (PLINT, input) : The number of items in\n\
7555 plotentries. Ignored if\n\
7556 plotentries is NULL.\n\
7559Set precision in numeric labels\n\
7563 Sets the number of places after the decimal point in numeric labels.\n\
7565 Redacted form: plprec(setp, prec)\n\
7567 This function is used in example 29.\n\
7573plprec(setp, prec)\n\
7577 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7578 automatically determines the number of places to use after the\n\
7579 decimal point in numeric labels (like those used to label axes).\n\
7580 If setp is 1 then prec sets the number of places.\n\
7582 prec (PLINT, input) : The number of characters to draw after the\n\
7583 decimal point in numeric labels.\n\
7586Draw a line between two points\n\
7590 Joins the point (\n\
7596 Redacted form: pljoin(x1,y1,x2,y2)\n\
7598 This function is used in examples 3 and 14.\n\
7604pljoin(x1, y1, x2, y2)\n\
7608 x1 (PLFLT, input) : x coordinate of first point.\n\
7610 y1 (PLFLT, input) : y coordinate of first point.\n\
7612 x2 (PLFLT, input) : x coordinate of second point.\n\
7614 y2 (PLFLT, input) : y coordinate of second point.\n\
7617Set the device (keyword) name\n\
7621 Set the device (keyword) name.\n\
7623 Redacted form: plsdev(devname)\n\
7625 This function is used in examples 1, 14, and 20.\n\
7635 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7636 containing the device name keyword of the required output device.\n\
7638 devname is NULL or if the first character of the string is a ``?\'\',\n\
7639 the normal (prompted) start up is used.\n\
7642Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7646 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7647 (see the PLplot documentation) index. Overwrites the previous color\n\
7648 value for the given index and, thus, does not result in any additional\n\
7649 allocation of space for colors.\n\
7651 This function is used in example 30.\n\
7657plscol0a(icol0, r, g, b, alpha)\n\
7661 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7662 number of colors (which is set by default, by plscmap0n, or even\n\
7665 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7666 degree of red in the color.\n\
7668 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7669 degree of green in the color.\n\
7671 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7672 degree of blue in the color.\n\
7674 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7678Draw filled polygon in 3D\n\
7682 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7683 vectors using the pattern defined by plpsty or plpat. The routine\n\
7684 will automatically close the polygon between the last and first\n\
7685 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7686 plfill3 will fill in between them.\n\
7688 Redacted form: General: plfill3(x, y, z)\n\
7691 This function is used in example 15.\n\
7697plfill3(n, x, y, z)\n\
7701 n (PLINT, input) : Number of vertices in polygon.\n\
7703 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7706 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7709 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7717 Specify the window, i.e., the world coordinates of the edges of the\n\
7720 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7722 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7729plwind(xmin, xmax, ymin, ymax)\n\
7733 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7736 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7739 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7742 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7746Draw text at points defined by Shapefile data in world coordinates\n\
7750 As per plmapline, however the items are plotted as text in the same\n\
7753 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7754 miny, maxy, plotentry)\n\
7756 This function is used in example 19.\n\
7762plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7766 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7767 transform the coordinates given in the shapefile into a plot\n\
7768 coordinate system. By using this transform, we can change from a\n\
7769 longitude, latitude coordinate to a polar stereographic project,\n\
7770 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7771 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7772 mapform(), x[] and y[] should be replaced by the corresponding\n\
7773 plot coordinates. If no transform is desired, mapform can be\n\
7774 replaced by NULL.\n\
7776 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7777 the file name of a set of Shapefile files without the file\n\
7780 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7783 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7786 just (PLFLT, input) : Set the justification of the text. The value\n\
7787 given will be the fraction of the distance along the string that\n\
7788 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7789 centralized text and 1.0 gives right aligned text.\n\
7791 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7793 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7794 be in the same units as used by the Shapefile. You could use a\n\
7795 very large negative number to plot everything, but you can improve\n\
7796 performance by limiting the area drawn. The units must match those\n\
7797 of the Shapefile projection, which may be for example longitude or\n\
7798 distance. The value of minx must be less than the value of maxx.\n\
7800 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7801 use a very large number to plot everything, but you can improve\n\
7802 performance by limiting the area drawn.\n\
7804 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7805 be in the same units as used by the Shapefile. You could use a\n\
7806 very large negative number to plot everything, but you can improve\n\
7807 performance by limiting the area drawn. The units must match those\n\
7808 of the Shapefile projection, which may be for example latitude or\n\
7809 distance. The value of miny must be less than the value of maxy.\n\
7811 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7812 use a very large number to plot everything, but you can improve\n\
7813 performance by limiting the area drawn.\n\
7815 plotentry (PLINT, input) : An integer indicating which text string\n\
7816 of the Shapefile (zero indexed) will be drawn.\n\
7819Switch to graphics screen\n\
7823 Sets an interactive device to graphics mode, used in conjunction with\n\
7824 pltext to allow graphics and text to be interspersed. On a device\n\
7825 which supports separate text and graphics windows, this command causes\n\
7826 control to be switched to the graphics window. If already in graphics\n\
7827 mode, this command is ignored. It is also ignored on devices which\n\
7828 only support a single window or use a different method for shifting\n\
7829 focus. See also pltext.\n\
7831 Redacted form: plgra()\n\
7833 This function is used in example 1.\n\
7842Set parameters of contour labelling other than format of numerical label\n\
7846 Set parameters of contour labelling other than those handled by\n\
7847 pl_setcontlabelformat.\n\
7849 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7851 This function is used in example 9.\n\
7857pl_setcontlabelparam(offset, size, spacing, active)\n\
7861 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7862 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7864 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7865 Default value is 0.3.\n\
7867 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7868 Default value is 0.1.\n\
7870 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7871 contour labels on. Default is off (0).\n\
7874Get family, style and weight of the current font\n\
7878 Gets information about current font. See the PLplot documentation for\n\
7879 more information on font selection.\n\
7881 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7883 This function is used in example 23.\n\
7889plgfont(p_family, p_style, p_weight)\n\
7893 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7894 font family. The available values are given by the PL_FCI_*\n\
7895 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7896 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7897 p_family is NULL then the font family is not returned.\n\
7899 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7900 font style. The available values are given by the PL_FCI_*\n\
7901 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7902 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7903 style is not returned.\n\
7905 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7906 font weight. The available values are given by the PL_FCI_*\n\
7907 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7908 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7912Plot a histogram from unbinned data\n\
7916 Plots a histogram from n data points stored in the data vector. This\n\
7917 routine bins the data into nbin bins equally spaced between datmin and\n\
7918 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7919 opt allows, among other things, the histogram either to be plotted in\n\
7920 an existing window or causes plhist to call plenv with suitable limits\n\
7921 before plotting the histogram.\n\
7923 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7925 This function is used in example 5.\n\
7931plhist(n, data, datmin, datmax, nbin, opt)\n\
7935 n (PLINT, input) : Number of data points.\n\
7937 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7940 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7942 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7944 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7945 divide the interval xmin to xmax.\n\
7947 opt (PLINT, input) : Is a combination of several flags:\n\
7948 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7949 the histogram data, the outer bins are expanded to fill up the\n\
7950 entire x-axis, data outside the given extremes are assigned to the\n\
7951 outer bins and bins of zero height are simply drawn.\n\
7952 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7953 to fit the histogram data, without this flag, plenv is called\n\
7954 to set the world coordinates.\n\
7955 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7956 extremes are not taken into account. This option should\n\
7957 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7958 properly present the data.\n\
7959 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7960 size as the ones inside.\n\
7961 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7962 (there is a gap for such bins).\n\
7965Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7969 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7970 alpha transparency value.\n\
7972 This function is used in example 31.\n\
7978plgcolbga(r, g, b, alpha)\n\
7982 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7983 in the range from 0 to 255.\n\
7985 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7986 in the range from 0 to 255.\n\
7988 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7989 in the range from 0 to 255.\n\
7991 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7992 transparency in the range (0.0-1.0).\n\
7999 Set integer plot orientation parameter. This function is identical to\n\
8000 plsdiori except for the type of the argument, and should be used in\n\
8001 the same way. See the documentation of plsdiori for details.\n\
8003 Redacted form: plsori(ori)\n\
8005 This function is used in example 3.\n\
8015 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8016 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8020Plot latitude and longitude lines\n\
8024 Displays latitude and longitude on the current plot. The lines are\n\
8025 plotted in the current color and line style.\n\
8027 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8030 This function is used in example 19.\n\
8036plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8040 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8041 transform the coordinate longitudes and latitudes to a plot\n\
8042 coordinate system. By using this transform, we can change from a\n\
8043 longitude, latitude coordinate to a polar stereographic project,\n\
8044 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8045 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8046 mapform(), x[] and y[] should be replaced by the corresponding\n\
8047 plot coordinates. If no transform is desired, mapform can be\n\
8048 replaced by NULL.\n\
8050 dlong (PLFLT, input) : The interval in degrees at which the\n\
8051 longitude lines are to be plotted.\n\
8053 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8054 lines are to be plotted.\n\
8056 minlong (PLFLT, input) : The value of the longitude on the left\n\
8057 side of the plot. The value of minlong must be less than the value\n\
8058 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8061 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8062 side of the plot.\n\
8064 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8065 background. One can always use -90.0 as the boundary outside the\n\
8066 plot window will be automatically eliminated. However, the\n\
8067 program will be faster if one can reduce the size of the\n\
8068 background plotted.\n\
8070 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8071 background. One can always use 90.0 as the boundary outside the\n\
8072 plot window will be automatically eliminated.\n\
8075Clear current (sub)page\n\
8079 Clears the current page, effectively erasing everything that have been\n\
8080 drawn. This command only works with interactive drivers; if the\n\
8081 driver does not support this, the page is filled with the background\n\
8082 color in use. If the current page is divided into subpages, only the\n\
8083 current subpage is erased. The nth subpage can be selected with\n\
8086 Redacted form: General: plclear()\n\
8089 This function is not used in any examples.\n\
8102 Initializing the plotting package. The program prompts for the device\n\
8103 keyword or number of the desired output device. Hitting a RETURN in\n\
8104 response to the prompt is the same as selecting the first device. If\n\
8105 only one device is enabled when PLplot is installed, plstar will issue\n\
8106 no prompt. The output device is divided into nx by ny subpages, each\n\
8107 of which may be used independently. The subroutine pladv is used to\n\
8108 advance from one subpage to the next.\n\
8110 Redacted form: plstar(nx, ny)\n\
8112 This function is used in example 1.\n\
8122 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8125 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8129Write text relative to viewport boundaries\n\
8133 Writes text at a specified position relative to the viewport\n\
8134 boundaries. Text may be written inside or outside the viewport, but\n\
8135 is clipped at the subpage boundaries. The reference point of a string\n\
8136 lies along a line passing through the string at half the height of a\n\
8137 capital letter. The position of the reference point along this line\n\
8138 is determined by just, and the position of the reference point\n\
8139 relative to the viewport is set by disp and pos.\n\
8141 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8144 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8151plmtex(side, disp, pos, just, text)\n\
8155 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8156 the side of the viewport along which the text is to be written.\n\
8157 The string must be one of: b: Bottom of viewport, text written\n\
8158 parallel to edge.\n\
8159 bv: Bottom of viewport, text written at right angles to edge.\n\
8160 l: Left of viewport, text written parallel to edge.\n\
8161 lv: Left of viewport, text written at right angles to edge.\n\
8162 r: Right of viewport, text written parallel to edge.\n\
8163 rv: Right of viewport, text written at right angles to edge.\n\
8164 t: Top of viewport, text written parallel to edge.\n\
8165 tv: Top of viewport, text written at right angles to edge.\n\
8168 disp (PLFLT, input) : Position of the reference point of string,\n\
8169 measured outwards from the specified viewport edge in units of the\n\
8170 current character height. Use negative disp to write within the\n\
8173 pos (PLFLT, input) : Position of the reference point of string\n\
8174 along the specified edge, expressed as a fraction of the length of\n\
8177 just (PLFLT, input) : Specifies the position of the string relative\n\
8178 to its reference point. If just=0. , the reference point is at\n\
8179 the left and if just=1. , it is at the right of the string. Other\n\
8180 values of just give intermediate justifications.\n\
8182 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8186Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8190 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8191 PLFLT alpha transparency value (see the PLplot documentation).\n\
8193 This function is used in example 31.\n\
8199plscolbga(r, g, b, alpha)\n\
8203 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8204 degree of red in the color.\n\
8206 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8207 degree of green in the color.\n\
8209 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8210 degree of blue in the color.\n\
8212 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8216Replays contents of plot buffer to current device/file\n\
8220 Replays contents of plot buffer to current device/file.\n\
8222 Redacted form: plreplot()\n\
8224 This function is used in example 1,20.\n\
8233Plot a glyph at the specified 3D points\n\
8237 Plot a glyph at the specified 3D points. (This function is largely\n\
8238 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8239 Set up the call to this function similar to what is done for plline3.\n\
8240 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8241 and a draw at the same place. Not ideal, since a sufficiently\n\
8242 intelligent output device may optimize it away, or there may be faster\n\
8243 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8244 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8245 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8246 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8247 code <= 127 the corresponding printable ASCII character is plotted.\n\
8249 Redacted form: plpoin3(x, y, z, code)\n\
8251 This function is not used in any example.\n\
8257plpoin3(n, x, y, z, code)\n\
8261 n (PLINT, input) : Number of points in the x and y vectors.\n\
8263 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8266 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8269 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8272 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8273 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8274 each of the n points.\n\
8277Set family, style and weight of the current font\n\
8281 Sets the current font. See the PLplot documentation for more\n\
8282 information on font selection.\n\
8284 Redacted form: plsfont(family, style, weight)\n\
8286 This function is used in example 23.\n\
8292plsfont(family, style, weight)\n\
8296 family (PLINT, input) : Font family to select for the current font.\n\
8297 The available values are given by the PL_FCI_* constants in\n\
8298 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8299 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8300 signifies that the font family should not be altered.\n\
8302 style (PLINT, input) : Font style to select for the current font.\n\
8303 The available values are given by the PL_FCI_* constants in\n\
8304 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8305 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8306 should not be altered.\n\
8308 weight (PLINT, input) : Font weight to select for the current font.\n\
8309 The available values are given by the PL_FCI_* constants in\n\
8310 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8311 negative value signifies that the font weight should not be\n\
8315Draw a box with axes, etc. with arbitrary origin\n\
8319 Draws a box around the currently defined viewport with arbitrary\n\
8320 world-coordinate origin specified by x0 and y0 and labels it with\n\
8321 world coordinate values appropriate to the window. Thus plaxes should\n\
8322 only be called after defining both viewport and window. The ascii\n\
8323 character strings xopt and yopt specify how the box should be drawn as\n\
8324 described below. If ticks and/or subticks are to be drawn for a\n\
8325 particular axis, the tick intervals and number of subintervals may be\n\
8326 specified explicitly, or they may be defaulted by setting the\n\
8327 appropriate arguments to zero.\n\
8329 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8333 This function is not used in any examples.\n\
8339plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8343 x0 (PLFLT, input) : World X coordinate of origin.\n\
8345 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8347 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8348 options for the x axis. The string can include any combination of\n\
8349 the following letters (upper or lower case) in any order: a: Draws\n\
8350 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8352 b: Draws bottom (X) or left (Y) edge of frame.\n\
8353 c: Draws top (X) or right (Y) edge of frame.\n\
8354 d: Plot labels as date / time. Values are assumed to be\n\
8355 seconds since the epoch (as used by gmtime).\n\
8356 f: Always use fixed point numeric labels.\n\
8357 g: Draws a grid at the major tick interval.\n\
8358 h: Draws a grid at the minor tick interval.\n\
8359 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8361 l: Labels axis logarithmically. This only affects the labels,\n\
8362 not the data, and so it is necessary to compute the logarithms\n\
8363 of data points before passing them to any of the drawing\n\
8365 m: Writes numeric labels at major tick intervals in the\n\
8366 unconventional location (above box for X, right of box for Y).\n\
8367 n: Writes numeric labels at major tick intervals in the\n\
8368 conventional location (below box for X, left of box for Y).\n\
8369 o: Use custom labelling function to generate axis label text.\n\
8370 The custom labelling function can be defined with the\n\
8371 plslabelfunc command.\n\
8372 s: Enables subticks between major ticks, only valid if t is\n\
8374 t: Draws major ticks.\n\
8375 u: Exactly like \"b\" except don\'t draw edge line.\n\
8376 w: Exactly like \"c\" except don\'t draw edge line.\n\
8377 x: Exactly like \"t\" (including the side effect of the\n\
8378 numerical labels for the major ticks) except exclude drawing\n\
8379 the major and minor tick marks.\n\
8382 xtick (PLFLT, input) : World coordinate interval between major\n\
8383 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8384 generates a suitable tick interval.\n\
8386 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8387 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8388 generates a suitable minor tick interval.\n\
8390 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8391 options for the y axis. The string can include any combination of\n\
8392 the letters defined above for xopt, and in addition may contain:\n\
8393 v: Write numeric labels for the y axis parallel to the base of the\n\
8394 graph, rather than parallel to the axis.\n\
8397 ytick (PLFLT, input) : World coordinate interval between major\n\
8398 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8399 generates a suitable tick interval.\n\
8401 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8402 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8403 generates a suitable minor tick interval.\n\
8410 Begins a new page. For a file driver, the output file is opened if\n\
8411 necessary. Advancing the page via pleop and plbop is useful when a\n\
8412 page break is desired at a particular point when plotting to subpages.\n\
8413 Another use for pleop and plbop is when plotting pages to different\n\
8414 files, since you can manually set the file name by calling plsfnam\n\
8415 after the call to pleop. (In fact some drivers may only support a\n\
8416 single page per file, making this a necessity.) One way to handle\n\
8417 this case automatically is to page advance via pladv, but enable\n\
8418 familying (see plsfam) with a small limit on the file size so that a\n\
8419 new family member file will be created on each page break.\n\
8421 Redacted form: plbop()\n\
8423 This function is used in examples 2 and 20.\n\
8432Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8436 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8437 and PLFLT alpha transparency value. This sets the entire color map --\n\
8438 only as many colors as specified will be allocated.\n\
8440 Redacted form: plscmap0a(r, g, b, alpha)\n\
8442 This function is used in examples 30.\n\
8448plscmap0a(r, g, b, alpha, ncol0)\n\
8452 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8453 integers (0-255) representing the degree of red in the color.\n\
8455 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8456 integers (0-255) representing the degree of green in the color.\n\
8458 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8459 integers (0-255) representing the degree of blue in the color.\n\
8461 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8462 representing the alpha transparency of the color.\n\
8464 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8468Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8472 This is a variant of plscmap1l that supports alpha channel\n\
8473 transparency. It sets cmap1 colors using a piece-wise linear\n\
8474 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8475 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8476 transparency value (0.0-1.0). It may be called at any time.\n\
8478 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8479 alpha, alt_hue_path)\n\
8481 This function is used in example 30.\n\
8487plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8491 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8493 npts (PLINT, input) : number of control points.\n\
8495 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8496 intensity index (0.0-1.0) in ascending order for each control\n\
8499 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8500 coordinate (H or R) for each control point.\n\
8502 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8503 coordinate (L or G) for each control point.\n\
8505 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8506 coordinate (S or B) for each control point.\n\
8508 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8509 transparency value (0.0-1.0) for each control point.\n\
8511 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8512 npts - 1 elements) containing the alternative interpolation method\n\
8513 Boolean value for each control point interval. (alt_hue_path[i]\n\
8514 refers to the interpolation interval between the i and i + 1\n\
8518Enter or leave xor mode\n\
8522 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8523 those drivers (e.g., the xwin driver) that support it. Enables\n\
8524 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8525 is not capable of xor operation it returns a status of false.\n\
8527 Redacted form: plxormod(mode, status)\n\
8529 This function is used in examples 1 and 20.\n\
8535plxormod(mode, status)\n\
8539 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8540 is false means leave xor mode.\n\
8542 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8543 modestatus of true (false) means driver is capable (incapable) of\n\
8547Eject current page\n\
8551 Clears the graphics screen of an interactive device, or ejects a page\n\
8552 on a plotter. See plbop for more information.\n\
8554 Redacted form: pleop()\n\
8556 This function is used in example 2,14.\n\
8565Draw a box with axes, etc\n\
8569 Draws a box around the currently defined viewport, and labels it with\n\
8570 world coordinate values appropriate to the window. Thus plbox should\n\
8571 only be called after defining both viewport and window. The ascii\n\
8572 character strings xopt and yopt specify how the box should be drawn as\n\
8573 described below. If ticks and/or subticks are to be drawn for a\n\
8574 particular axis, the tick intervals and number of subintervals may be\n\
8575 specified explicitly, or they may be defaulted by setting the\n\
8576 appropriate arguments to zero.\n\
8578 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8581 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8588plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8592 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8593 options for the x axis. The string can include any combination of\n\
8594 the following letters (upper or lower case) in any order: a: Draws\n\
8595 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8597 b: Draws bottom (X) or left (Y) edge of frame.\n\
8598 c: Draws top (X) or right (Y) edge of frame.\n\
8599 d: Plot labels as date / time. Values are assumed to be\n\
8600 seconds since the epoch (as used by gmtime).\n\
8601 f: Always use fixed point numeric labels.\n\
8602 g: Draws a grid at the major tick interval.\n\
8603 h: Draws a grid at the minor tick interval.\n\
8604 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8606 l: Labels axis logarithmically. This only affects the labels,\n\
8607 not the data, and so it is necessary to compute the logarithms\n\
8608 of data points before passing them to any of the drawing\n\
8610 m: Writes numeric labels at major tick intervals in the\n\
8611 unconventional location (above box for X, right of box for Y).\n\
8612 n: Writes numeric labels at major tick intervals in the\n\
8613 conventional location (below box for X, left of box for Y).\n\
8614 o: Use custom labelling function to generate axis label text.\n\
8615 The custom labelling function can be defined with the\n\
8616 plslabelfunc command.\n\
8617 s: Enables subticks between major ticks, only valid if t is\n\
8619 t: Draws major ticks.\n\
8620 u: Exactly like \"b\" except don\'t draw edge line.\n\
8621 w: Exactly like \"c\" except don\'t draw edge line.\n\
8622 x: Exactly like \"t\" (including the side effect of the\n\
8623 numerical labels for the major ticks) except exclude drawing\n\
8624 the major and minor tick marks.\n\
8627 xtick (PLFLT, input) : World coordinate interval between major\n\
8628 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8629 generates a suitable tick interval.\n\
8631 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8632 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8633 generates a suitable minor tick interval.\n\
8635 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8636 options for the y axis. The string can include any combination of\n\
8637 the letters defined above for xopt, and in addition may contain:\n\
8638 v: Write numeric labels for the y axis parallel to the base of the\n\
8639 graph, rather than parallel to the axis.\n\
8642 ytick (PLFLT, input) : World coordinate interval between major\n\
8643 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8644 generates a suitable tick interval.\n\
8646 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8647 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8648 generates a suitable minor tick interval.\n\
8651Get x axis parameters\n\
8655 Returns current values of the p_digmax and p_digits flags for the x\n\
8656 axis. p_digits is updated after the plot is drawn, so this routine\n\
8657 should only be called after the call to plbox (or plbox3) is complete.\n\
8658 See the PLplot documentation for more information.\n\
8660 Redacted form: plgxax(p_digmax, p_digits)\n\
8662 This function is used in example 31.\n\
8668plgxax(p_digmax, p_digits)\n\
8672 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8673 number of digits for the x axis. If nonzero, the printed label\n\
8674 has been switched to a floating-point representation when the\n\
8675 number of digits exceeds this value.\n\
8677 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8678 number of digits for the numeric labels (x axis) from the last\n\
8686 Sets the font used for subsequent text and symbols. For devices that\n\
8687 still use Hershey fonts this routine has no effect unless the Hershey\n\
8688 fonts with extended character set are loaded (see plfontld). For\n\
8689 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8690 this routine calls the plsfci routine with argument set up\n\
8691 appropriately for the various cases below. However, this method of\n\
8692 specifying the font for unicode-aware devices is deprecated, and the\n\
8693 much more flexible method of calling plsfont directly is recommended\n\
8694 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8696 Redacted form: plfont(ifont)\n\
8698 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8708 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8709 (simplest and fastest)\n\
8715Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8719 Routine for creating a discrete plot legend with a plotted filled box,\n\
8720 line, and/or line of symbols for each annotated legend entry. (See\n\
8721 plcolorbar for similar functionality for creating continuous color\n\
8722 bars.) The arguments of pllegend provide control over the location\n\
8723 and size of the legend as well as the location and characteristics of\n\
8724 the elements (most of which are optional) within that legend. The\n\
8725 resulting legend is clipped at the boundaries of the current subpage.\n\
8726 (N.B. the adopted coordinate system used for some of the parameters is\n\
8727 defined in the documentation of the position parameter.)\n\
8729 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8730 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8731 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8732 test_justification, text_colors, text, box_colors, box_patterns,\n\
8733 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8734 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8736 This function is used in examples 4, 26, and 33.\n\
8742pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8746 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8747 legend width in adopted coordinates. This quantity is calculated\n\
8748 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8749 the routine depending on nlegend and nrow), and the length\n\
8750 (calculated internally) of the longest text string.\n\
8752 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8753 legend height in adopted coordinates. This quantity is calculated\n\
8754 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8755 the routine depending on nlegend and nrow).\n\
8757 opt (PLINT, input) : opt contains bits controlling the overall\n\
8758 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8759 on the left of the legend and the plotted area on the right.\n\
8760 Otherwise, put the text area on the right of the legend and the\n\
8761 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8762 plot a (semitransparent) background for the legend. If the\n\
8763 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8764 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8765 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8766 plot the resulting array of legend entries in row-major order.\n\
8767 Otherwise, plot the legend entries in column-major order.\n\
8769 position (PLINT, input) : position contains bits which control the\n\
8770 overall position of the legend and the definition of the adopted\n\
8771 coordinates used for positions just like what is done for the\n\
8772 position argument for plcolorbar. However, note that the defaults\n\
8773 for the position bits (see below) are different than the\n\
8774 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8775 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8776 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8777 the 16 possible standard positions (the 4 corners and centers of\n\
8778 the 4 sides for both the inside and outside cases) of the legend\n\
8779 relative to the adopted coordinate system. The corner positions\n\
8780 are specified by the appropriate combination of two of the\n\
8781 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8782 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8783 value of one of those bits. The adopted coordinates are\n\
8784 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8785 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8786 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8787 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8788 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8789 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8790 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8791 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8793 x (PLFLT, input) : X offset of the legend position in adopted\n\
8794 coordinates from the specified standard position of the legend.\n\
8795 For positive x, the direction of motion away from the standard\n\
8796 position is inward/outward from the standard corner positions or\n\
8797 standard left or right positions if the\n\
8798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8799 For the standard top or bottom positions, the direction of motion\n\
8800 is toward positive X.\n\
8802 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8803 coordinates from the specified standard position of the legend.\n\
8804 For positive y, the direction of motion away from the standard\n\
8805 position is inward/outward from the standard corner positions or\n\
8806 standard top or bottom positions if the\n\
8807 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8808 the standard left or right positions, the direction of motion is\n\
8809 toward positive Y.\n\
8811 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8812 of the plot area (where the colored boxes, lines, and/or lines of\n\
8813 symbols are drawn) of the legend.\n\
8815 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8816 legend (PL_LEGEND_BACKGROUND).\n\
8818 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8819 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8821 bb_style (PLINT, input) : The pllsty style number for the\n\
8822 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8824 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8826 nlegend legend entries. For internal transformations of\n\
8827 nrow, see further remarks under\n\
8830 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8832 nlegend legend entries. For internal transformations of\n\
8833 ncolumn, see further remarks under\n\
8836 nlegend (PLINT, input) : Number of legend entries. The above\n\
8838 ncolumn values are transformed internally to be consistent with\n\
8839 nlegend. If either\n\
8841 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8844 ncolumn is less than\n\
8845 nlegend, the smaller of the two (or\n\
8848 ncolumn) is increased so the product is >=\n\
8849 nlegend. Thus, for example, the common\n\
8851 ncolumn = 0 case is transformed internally to\n\
8854 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8857 opt_array (PLINT_VECTOR, input) : A vector of\n\
8858 nlegend values of options to control each individual plotted area\n\
8859 corresponding to a legend entry. If the\n\
8860 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8862 PL_LEGEND_COLOR_BOX,\n\
8863 PL_LEGEND_LINE, and/or\n\
8864 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8865 entry is plotted with a colored box; a line; and/or a line of\n\
8868 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8869 area in units of character width.\n\
8871 text_scale (PLFLT, input) : Character height scale for text\n\
8874 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8875 character height from one legend entry to the next.\n\
8877 text_justification (PLFLT, input) : Justification parameter used\n\
8878 for text justification. The most common values of\n\
8879 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8880 is left justified, centred, or right justified within the text\n\
8881 area, but other values are allowed as well.\n\
8883 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8884 nlegend cmap0 text colors.\n\
8886 text (PLCHAR_MATRIX, input) : A vector of\n\
8887 nlegend UTF-8 character strings containing the legend annotations.\n\
8889 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8890 nlegend cmap0 colors for the discrete colored boxes (\n\
8891 PL_LEGEND_COLOR_BOX).\n\
8893 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8894 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8895 PL_LEGEND_COLOR_BOX).\n\
8897 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8898 nlegend scales (units of fraction of character height) for the height\n\
8899 of the discrete colored boxes (\n\
8900 PL_LEGEND_COLOR_BOX).\n\
8902 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8903 nlegend line widths for the patterns specified by box_patterns (\n\
8904 PL_LEGEND_COLOR_BOX).\n\
8906 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8907 nlegend cmap0 line colors (\n\
8910 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8911 nlegend line styles (plsty indices) (\n\
8914 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8915 nlegend line widths (\n\
8918 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8919 nlegend cmap0 symbol colors (\n\
8920 PL_LEGEND_SYMBOL).\n\
8922 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8923 nlegend scale values for the symbol height (\n\
8924 PL_LEGEND_SYMBOL).\n\
8926 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8927 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8929 PL_LEGEND_SYMBOL).\n\
8931 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8932 nlegend UTF-8 character strings containing the legend symbols. (\n\
8933 PL_LEGEND_SYMBOL).\n\
8936Set the background color by 8-bit RGB value\n\
8940 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8941 the PLplot documentation).\n\
8943 Redacted form: plscolbg(r, g, b)\n\
8945 This function is used in examples 15 and 31.\n\
8955 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8956 degree of red in the color.\n\
8958 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8959 degree of green in the color.\n\
8961 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8962 degree of blue in the color.\n\
8965Set parameters that define current device-space window\n\
8969 Set relative margin width, aspect ratio, and relative justification\n\
8970 that define current device-space window. If you want to just use the\n\
8971 previous value for any of these, just pass in the magic value\n\
8972 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8973 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8974 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8975 to a device-specific value.\n\
8977 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8979 This function is used in example 31.\n\
8985plsdidev(mar, aspect, jx, jy)\n\
8989 mar (PLFLT, input) : Relative margin width.\n\
8991 aspect (PLFLT, input) : Aspect ratio.\n\
8993 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8994 the range -0.5 to 0.5.\n\
8996 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8997 the range -0.5 to 0.5.\n\
9000Specify viewport using aspect ratio only\n\
9004 Selects the largest viewport with the given aspect ratio within the\n\
9005 subpage that leaves a standard margin (left-hand margin of eight\n\
9006 character heights, and a margin around the other three sides of five\n\
9007 character heights).\n\
9009 Redacted form: plvasp(aspect)\n\
9011 This function is used in example 13.\n\
9021 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9022 axis of resulting viewport.\n\
9025Configure the transformations required for projecting a 3D surface on a 2D window\n\
9029 Configure the transformations required for projecting a 3D surface on\n\
9030 an existing 2D window. Those transformations (see the PLplot\n\
9031 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9032 surface which has its limits expressed in 3D world coordinates and\n\
9033 also normalized 3D coordinates (used for interpreting the altitude and\n\
9034 azimuth of the viewing angle). The transformations consist of the\n\
9035 linear transform from 3D world coordinates to normalized 3D\n\
9036 coordinates, and the 3D rotation of normalized coordinates required to\n\
9037 align the pole of the new 3D coordinate system with the viewing\n\
9038 direction specified by altitude and azimuth so that x and y of the\n\
9039 surface elements in that transformed coordinate system are the\n\
9040 projection of the 3D surface with given viewing direction on the 2D\n\
9043 The enclosing rectangular cuboid for the surface plot is defined by\n\
9044 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9045 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9046 sizes of basex by basey by height so that xmin maps to -\n\
9047 basex/2, xmax maps to basex/2, ymin maps to -\n\
9048 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9049 The resulting rectangular cuboid in normalized coordinates is then\n\
9050 viewed by an observer at altitude alt and azimuth az. This routine\n\
9051 must be called before plbox3 or any of the 3D surface plotting\n\
9052 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9053 plsurf3dl or plfill3.\n\
9055 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9056 zmin, zmax, alt, az)\n\
9058 This function is examples 8, 11, 18, and 21.\n\
9064plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9068 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9069 rectangular cuboid.\n\
9071 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9072 rectangular cuboid.\n\
9074 height (PLFLT, input) : The normalized z coordinate size of the\n\
9075 rectangular cuboid.\n\
9077 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9078 rectangular cuboid.\n\
9080 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9081 rectangular cuboid.\n\
9083 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9084 rectangular cuboid.\n\
9086 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9087 rectangular cuboid.\n\
9089 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9090 rectangular cuboid.\n\
9092 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9093 rectangular cuboid.\n\
9095 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9096 plane of the rectangular cuboid in normalized coordinates.\n\
9098 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9099 rectangular cuboid in normalized coordinates. When az=0, the\n\
9100 observer is looking face onto the zx plane of the rectangular\n\
9101 cuboid in normalized coordinates, and as az is increased, the\n\
9102 observer moves clockwise around that cuboid when viewed from above\n\
9106Wait for graphics input event and translate to world coordinates.\n\
9110 Wait for graphics input event and translate to world coordinates.\n\
9111 Returns 0 if no translation to world coordinates is possible.\n\
9113 This function returns 1 on success and 0 if no translation to world\n\
9114 coordinates is possible.\n\
9116 Redacted form: plGetCursor(gin)\n\
9118 This function is used in examples 1 and 20.\n\
9124PLINT plGetCursor(gin)\n\
9128 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9129 which will contain the output. The structure is not allocated by\n\
9130 the routine and must exist before the function is called.\n\
9133Set number of colors in cmap0\n\
9137 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9138 (or reallocate) cmap0, and fill with default values for those colors\n\
9139 not previously allocated. The first 16 default colors are given in\n\
9140 the plcol0 documentation. For larger indices the default color is\n\
9143 The drivers are not guaranteed to support more than 16 colors.\n\
9145 Redacted form: plscmap0n(ncol0)\n\
9147 This function is used in examples 15, 16, and 24.\n\
9157 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9158 the cmap0 palette. If this number is zero or less, then the value\n\
9159 from the previous call to plscmap0n is used and if there is no\n\
9160 previous call, then a default value is used.\n\
9163Set z axis parameters\n\
9167 Identical to plsxax, except that arguments are flags for z axis. See\n\
9168 the description of plsxax for more detail.\n\
9170 Redacted form: plszax(digmax, digits)\n\
9172 This function is used in example 31.\n\
9178plszax(digmax, digits)\n\
9182 digmax (PLINT, input) : Variable to set the maximum number of\n\
9183 digits for the z axis. If nonzero, the printed label will be\n\
9184 switched to a floating-point representation when the number of\n\
9185 digits exceeds digmax.\n\
9187 digits (PLINT, input) : Field digits value. Currently, changing\n\
9188 its value here has no effect since it is set only by plbox or\n\
9189 plbox3. However, the user may obtain its value after a call to\n\
9190 either of these functions by calling plgzax.\n\
9193Get FCI (font characterization integer)\n\
9197 Gets information about the current font using the FCI approach. See\n\
9198 the PLplot documentation for more information.\n\
9200 Redacted form: plgfci(p_fci)\n\
9202 This function is used in example 23.\n\
9212 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9216Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9220 Sets up plotter environment for simple graphs by calling pladv and\n\
9221 setting up viewport and window to sensible default values. plenv0\n\
9222 leaves a standard margin (left-hand margin of eight character heights,\n\
9223 and a margin around the other three sides of five character heights)\n\
9224 around most graphs for axis labels and a title. When these defaults\n\
9225 are not suitable, use the individual routines plvpas, plvpor, or\n\
9226 plvasp for setting up the viewport, plwind for defining the window,\n\
9227 and plbox for drawing the box.\n\
9229 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9231 This function is used in example 21.\n\
9237plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9241 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9242 world coordinates).\n\
9244 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9245 world coordinates).\n\
9247 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9250 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9253 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9254 scales will not be set, the user must set up the scale before\n\
9255 calling plenv0 using plsvpa, plvasp or other.\n\
9256 0: the x and y axes are scaled independently to use as much of\n\
9257 the screen as possible.\n\
9258 1: the scales of the x and y axes are made equal.\n\
9259 2: the axis of the x and y axes are made equal, and the plot\n\
9260 box will be square.\n\
9263 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9264 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9265 -1: draw box only.\n\
9266 0: draw box, ticks, and numeric tick labels.\n\
9267 1: also draw coordinate axes at x=0 and y=0.\n\
9268 2: also draw a grid at major tick positions in both\n\
9270 3: also draw a grid at minor tick positions in both\n\
9272 10: same as 0 except logarithmic x tick marks. (The x data\n\
9273 have to be converted to logarithms separately.)\n\
9274 11: same as 1 except logarithmic x tick marks. (The x data\n\
9275 have to be converted to logarithms separately.)\n\
9276 12: same as 2 except logarithmic x tick marks. (The x data\n\
9277 have to be converted to logarithms separately.)\n\
9278 13: same as 3 except logarithmic x tick marks. (The x data\n\
9279 have to be converted to logarithms separately.)\n\
9280 20: same as 0 except logarithmic y tick marks. (The y data\n\
9281 have to be converted to logarithms separately.)\n\
9282 21: same as 1 except logarithmic y tick marks. (The y data\n\
9283 have to be converted to logarithms separately.)\n\
9284 22: same as 2 except logarithmic y tick marks. (The y data\n\
9285 have to be converted to logarithms separately.)\n\
9286 23: same as 3 except logarithmic y tick marks. (The y data\n\
9287 have to be converted to logarithms separately.)\n\
9288 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9289 and y data have to be converted to logarithms separately.)\n\
9290 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9291 and y data have to be converted to logarithms separately.)\n\
9292 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9293 and y data have to be converted to logarithms separately.)\n\
9294 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9295 and y data have to be converted to logarithms separately.)\n\
9296 40: same as 0 except date / time x labels.\n\
9297 41: same as 1 except date / time x labels.\n\
9298 42: same as 2 except date / time x labels.\n\
9299 43: same as 3 except date / time x labels.\n\
9300 50: same as 0 except date / time y labels.\n\
9301 51: same as 1 except date / time y labels.\n\
9302 52: same as 2 except date / time y labels.\n\
9303 53: same as 3 except date / time y labels.\n\
9304 60: same as 0 except date / time x and y labels.\n\
9305 61: same as 1 except date / time x and y labels.\n\
9306 62: same as 2 except date / time x and y labels.\n\
9307 63: same as 3 except date / time x and y labels.\n\
9308 70: same as 0 except custom x and y labels.\n\
9309 71: same as 1 except custom x and y labels.\n\
9310 72: same as 2 except custom x and y labels.\n\
9311 73: same as 3 except custom x and y labels.\n\
9318 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9319 plsym. The actual height of a symbol is the product of the default\n\
9320 symbol size and a scaling factor as for the character height.\n\
9322 Redacted form: plssym(def, scale)\n\
9324 This function is used in example 29.\n\
9330plssym(def, scale)\n\
9334 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9335 should be set to zero if the default height is to remain\n\
9338 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9339 actual symbol height.\n\
9342Set plot orientation\n\
9346 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9347 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9348 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9349 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9350 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9351 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9352 not called the default value of rot is 0.\n\
9354 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9355 probably want to change the aspect ratio to a value suitable for the\n\
9356 plot orientation using a call to plsdidev or the command-line options\n\
9357 -a or -freeaspect. For more documentation of those options see the\n\
9358 PLplot documentation. Such command-line options can be set internally\n\
9359 using plsetopt or set directly using the command line and parsed using\n\
9360 a call to plparseopts.\n\
9362 Redacted form: plsdiori(rot)\n\
9364 This function is not used in any examples.\n\
9374 rot (PLFLT, input) : Plot orientation parameter.\n\
9377Advance the (sub-)page\n\
9381 Advances to the next subpage if sub=0, performing a page advance if\n\
9382 there are no remaining subpages on the current page. If subpages\n\
9383 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9384 PLplot switches to the specified subpage. Note that this allows you\n\
9385 to overwrite a plot on the specified subpage; if this is not what you\n\
9386 intended, use pleop followed by plbop to first advance the page. This\n\
9387 routine is called automatically (with page=0) by plenv, but if plenv\n\
9388 is not used, pladv must be called after initializing PLplot but before\n\
9389 defining the viewport.\n\
9391 Redacted form: pladv(page)\n\
9393 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9404 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9405 in the top left corner and increasing along the rows) to which to\n\
9406 advance. Set to zero to advance to the next subpage (or to the\n\
9407 next page if subpages are not being used).\n\
9410Set cmap0 colors by 8-bit RGB values\n\
9414 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9415 documentation). This sets the entire color map -- only as many colors\n\
9416 as specified will be allocated.\n\
9418 Redacted form: plscmap0(r, g, b)\n\
9420 This function is used in examples 2 and 24.\n\
9426plscmap0(r, g, b, ncol0)\n\
9430 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9431 integers (0-255) representing the degree of red in the color.\n\
9433 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9434 integers (0-255) representing the degree of green in the color.\n\
9436 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9437 integers (0-255) representing the degree of blue in the color.\n\
9439 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9442Get character default height and current (scaled) height\n\
9446 Get character default height and current (scaled) height.\n\
9448 Redacted form: plgchr(p_def, p_ht)\n\
9450 This function is used in example 23.\n\
9456plgchr(p_def, p_ht)\n\
9460 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9461 character height (mm).\n\
9463 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9464 character height (mm).\n\
9467Set opaque RGB cmap1 colors values\n\
9471 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9472 vector values. This function also sets the number of cmap1 colors.\n\
9473 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9474 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9475 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9477 ncol1-1. So in order for this continuous color model to work\n\
9478 properly, it is the responsibility of the user of plscmap1 to insure\n\
9479 that these RGB vectors are continuous functions of their integer\n\
9482 Redacted form: plscmap1(r, g, b)\n\
9484 This function is used in example 31.\n\
9490plscmap1(r, g, b, ncol1)\n\
9494 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9495 8-bit integers in the range from 0-255) the degree of red in the\n\
9496 color as a continuous function of the integer index of the vector.\n\
9498 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9499 8-bit integers in the range from 0-255) the degree of green in the\n\
9500 color as a continuous function of the integer index of the vector.\n\
9502 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9503 8-bit integers in the range from 0-255) the degree of blue in the\n\
9504 color as a continuous function of the integer index of the vector.\n\
9506 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9509Set any command-line option\n\
9513 Set any command-line option internally from a program before it\n\
9514 invokes plinit. opt is the name of the command-line option and optarg\n\
9515 is the corresponding command-line option argument.\n\
9517 This function returns 0 on success.\n\
9519 Redacted form: plsetopt(opt, optarg)\n\
9521 This function is used in example 14.\n\
9527PLINT plsetopt(opt, optarg)\n\
9531 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9532 the command-line option.\n\
9534 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9535 containing the argument of the command-line option.\n\
9538Draw linear gradient inside polygon\n\
9542 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9545 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9546 polygon coordinates and the gradient angle are all expressed in world\n\
9547 coordinates. The angle from the x axis for both the rotated\n\
9548 coordinate system and the gradient vector is specified by angle. The\n\
9549 magnitude of the gradient vector is the difference between the maximum\n\
9550 and minimum values of x for the vertices in the rotated coordinate\n\
9551 system. The origin of the gradient vector can be interpreted as being\n\
9552 anywhere on the line corresponding to the minimum x value for the\n\
9553 vertices in the rotated coordinate system. The distance along the\n\
9554 gradient vector is linearly transformed to the independent variable of\n\
9555 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9556 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9557 color corresponding to the independent variable of cmap1. For more\n\
9558 information about cmap1 (see the PLplot documentation).\n\
9560 Redacted form: plgradient(x,y,angle)\n\
9562 This function is used in examples 25 and 30.\n\
9568plgradient(n, x, y, angle)\n\
9572 n (PLINT, input) : Number of vertices in polygon.\n\
9574 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9577 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9580 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9584Set length of major ticks\n\
9588 This sets up the length of the major ticks. The actual length is the\n\
9589 product of the default length and a scaling factor as for character\n\
9592 Redacted form: plsmaj(def, scale)\n\
9594 This function is used in example 29.\n\
9600plsmaj(def, scale)\n\
9604 def (PLFLT, input) : The default length of a major tick in\n\
9605 millimeters, should be set to zero if the default length is to\n\
9606 remain unchanged.\n\
9608 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9609 actual tick length.\n\
9612Set a global coordinate transform function\n\
9616 This function can be used to define a coordinate transformation which\n\
9617 affects all elements drawn within the current plot window. The\n\
9618 coordinate_transform callback function is similar to that provided for\n\
9619 the plmap and plmeridians functions. The coordinate_transform_data\n\
9620 parameter may be used to pass extra data to coordinate_transform.\n\
9622 Redacted form: General: plstransform(coordinate_transform,\n\
9623 coordinate_transform_data)\n\
9626 This function is used in examples 19 and 22.\n\
9632plstransform(coordinate_transform, coordinate_transform_data)\n\
9636 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9637 function that defines the transformation from the input (x, y)\n\
9638 world coordinates to new PLplot world coordinates. If\n\
9639 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9640 case), then no transform is applied.\n\
9642 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9644 coordinate_transform.\n\
9647Configure the transformation between continuous and broken-down time for the current stream\n\
9651 Configure the transformation between continuous and broken-down time\n\
9652 for the current stream. This transformation is used by both plbtime\n\
9655 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9656 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9659 This function is used in example 29.\n\
9665plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9669 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9670 As a special case, if\n\
9671 scale is 0., then all other arguments are ignored, and the result (the\n\
9672 default used by PLplot) is the equivalent of a call to\n\
9673 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9674 That is, for this special case broken-down time is calculated with\n\
9675 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9676 and the continuous time is defined as the number of seconds since\n\
9677 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9679 offset1 (PLFLT, input) : If\n\
9680 ifbtime_offset is true, the parameters\n\
9682 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9683 (with units in days) specify the epoch of the continuous time\n\
9684 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9685 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9686 are used to specify the origin to allow users (by specifying\n\
9687 offset1 as an integer that can be exactly represented by a\n\
9688 floating-point variable and specifying\n\
9689 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9690 the numerical errors of the continuous time representation.\n\
9692 offset2 (PLFLT, input) : See documentation of\n\
9695 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9696 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9697 calendar is used for broken-down time rather than the proleptic\n\
9698 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9699 have been historically used to define UTC are inserted into the\n\
9700 broken-down time. Other possibilities for additional control bits\n\
9701 for ccontrol exist such as making the historical time corrections\n\
9702 in the broken-down time corresponding to ET (ephemeris time) or\n\
9703 making the (slightly non-constant) corrections from international\n\
9704 atomic time (TAI) to what astronomers define as terrestrial time\n\
9705 (TT). But those additional possibilities have not been\n\
9706 implemented yet in the qsastime library (one of the PLplot utility\n\
9709 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9710 epoch of the continuous time scale is specified by the user. If\n\
9711 ifbtime_offset is false, then\n\
9713 offset2 are used to specify the epoch, and the following broken-down\n\
9714 time parameters are completely ignored. If\n\
9715 ifbtime_offset is true, then\n\
9717 offset2 are completely ignored, and the following broken-down time\n\
9718 parameters are used to specify the epoch.\n\
9720 year (PLINT, input) : Year of epoch.\n\
9722 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9725 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9727 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9729 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9731 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9734Flushes the output stream\n\
9738 Flushes the output stream. Use sparingly, if at all.\n\
9740 Redacted form: plflush()\n\
9742 This function is used in examples 1 and 14.\n\
9751Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9755 This variant of plsurf3d (see that function\'s documentation for more\n\
9756 details) should be suitable for the case where the area of the x, y\n\
9757 coordinate grid where z is defined can be non-rectangular. The limits\n\
9758 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9759 indexymin, and indexymax.\n\
9761 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9764 This function is used in example 8.\n\
9770plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9774 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9775 which the function is evaluated.\n\
9777 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9778 which the function is evaluated.\n\
9780 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9781 plot. Should have dimensions of\n\
9785 nx (PLINT, input) : Number of x values at which function is\n\
9788 ny (PLINT, input) : Number of y values at which function is\n\
9791 opt (PLINT, input) : Determines the way in which the surface is\n\
9792 represented. To specify more than one option just add the options,\n\
9793 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9794 connecting points at which function is defined.\n\
9795 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9799 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9803 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9804 the borders of the plotted function.\n\
9805 opt=MAG_COLOR : the surface is colored according to the value\n\
9806 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9807 according to the intensity of the reflected light in the\n\
9808 surface from a light source whose position is set using\n\
9812 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9815 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9817 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9818 corresponds to the first x index where z is defined.\n\
9820 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9821 which corresponds (by convention) to one more than the last x\n\
9822 index value where z is defined.\n\
9824 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9825 values which all must be ≥ 0. These values are the first y index\n\
9826 where z is defined for a particular x index in the range from\n\
9827 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9830 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9831 values which all must be ≤ ny. These values correspond (by\n\
9832 convention) to one more than the last y index where z is defined\n\
9833 for a particular x index in the range from indexxmin to indexxmax\n\
9834 - 1. The dimension of indexymax is indexxmax.\n\
9837Set semitransparent cmap1 RGBA colors.\n\
9841 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9842 RGBA vector values. This function also sets the number of cmap1\n\
9843 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9844 floating-point index in the range from 0.0-1.0 which is linearly\n\
9845 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9846 vectors in the range from 0 to\n\
9847 ncol1-1. So in order for this continuous color model to work\n\
9848 properly, it is the responsibility of the user of plscmap1 to insure\n\
9849 that these RGBA vectors are continuous functions of their integer\n\
9852 Redacted form: plscmap1a(r, g, b, alpha)\n\
9854 This function is used in example 31.\n\
9860plscmap1a(r, g, b, alpha, ncol1)\n\
9864 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9865 8-bit integers in the range from 0-255) the degree of red in the\n\
9866 color as a continuous function of the integer index of the vector.\n\
9868 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9869 8-bit integers in the range from 0-255) the degree of green in the\n\
9870 color as a continuous function of the integer index of the vector.\n\
9872 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9873 8-bit integers in the range from 0-255) the degree of blue in the\n\
9874 color as a continuous function of the integer index of the vector.\n\
9876 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9877 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9878 completely transparent and 1.0 corresponds to completely opaque)\n\
9879 the alpha transparency of the color as a continuous function of\n\
9880 the integer index of the vector.\n\
9882 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9886Calculate broken-down time from continuous time for the current stream\n\
9890 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9891 continuous time, ctime for the current stream. This function is the\n\
9892 inverse of plctime.\n\
9894 The PLplot definition of broken-down time is a calendar time that\n\
9895 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9896 responsibility to apply those offsets (if so desired) before using the\n\
9897 PLplot time API. By default broken-down time is defined using the\n\
9898 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9899 continuous time is defined as the number of seconds since the Unix\n\
9900 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9901 broken-down and continuous time are possible, see plconfigtime.\n\
9903 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9907 This function is used in example 29.\n\
9913plbtime(year, month, day, hour, min, sec, ctime)\n\
9917 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9918 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9919 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9922 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9923 the year in the range from 0 (January) to 11 (December).\n\
9925 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9926 month in the range from 1 to 31.\n\
9928 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9929 day in the range from 0 to 23.\n\
9931 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9932 hour in the range from 0 to 59\n\
9934 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9935 minute in range from 0. to 60.\n\
9937 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9938 time is calculated.\n\
9941Convert RGB color to HLS\n\
9945 Convert RGB color coordinates to HLS\n\
9947 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9950 This function is used in example 2.\n\
9956plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9960 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9962 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9964 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9966 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9967 degrees (0.0-360.0) on the color cylinder.\n\
9969 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9970 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9973 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9974 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9978Get the current device (keyword) name\n\
9982 Get the current device (keyword) name. Note: you must have allocated\n\
9983 space for this (80 characters is safe).\n\
9985 Redacted form: plgdev(p_dev)\n\
9987 This function is used in example 14.\n\
9997 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9998 (with preallocated length of 80 characters or more) containing the\n\
9999 device (keyword) name.\n\
10002Set the number of subpages in x and y\n\
10006 Set the number of subpages in x and y.\n\
10008 Redacted form: plssub(nx, ny)\n\
10010 This function is examples 1,2,14,21,25,27.\n\
10020 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10021 of window columns).\n\
10023 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10024 of window rows).\n\
10027Get current stream number\n\
10031 Gets the number of the current output stream. See also plsstrm.\n\
10033 Redacted form: plgstrm(p_strm)\n\
10035 This function is used in example 1,20.\n\
10045 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10049Random number generator returning a real random number in the range [0,1]\n\
10053 Random number generator returning a real random number in the range\n\
10054 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10055 / compilers provide their own random number generator, and so this is\n\
10056 provided purely for convenience and to give a consistent random number\n\
10057 generator across all languages supported by PLplot. This is\n\
10058 particularly useful for comparing results from the test suite of\n\
10061 Redacted form: plrandd()\n\
10063 This function is used in examples 17 and 21.\n\
10072Add a point to a strip chart\n\
10076 Add a point to a given pen of a given strip chart. There is no need\n\
10077 for all pens to have the same number of points or to be equally\n\
10078 sampled in the x coordinate. Allocates memory and rescales as\n\
10081 Redacted form: plstripa(id, pen, x, y)\n\
10083 This function is used in example 17.\n\
10089plstripa(id, pen, x, y)\n\
10093 id (PLINT, input) : Identification number of the strip chart (set\n\
10094 up in plstripc).\n\
10096 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10098 x (PLFLT, input) : X coordinate of point to plot.\n\
10100 y (PLFLT, input) : Y coordinate of point to plot.\n\
10103Set device-compression level\n\
10107 Set device-compression level. Only used for drivers that provide\n\
10108 compression. This function, if used, should be invoked before a call\n\
10111 Redacted form: plscompression(compression)\n\
10113 This function is used in example 31.\n\
10119plscompression(compression)\n\
10123 compression (PLINT, input) : The desired compression level. This is\n\
10124 a device-dependent value. Currently only the jpeg and png devices\n\
10125 use these values. For jpeg value is the jpeg quality which should\n\
10126 normally be in the range 0-95. Higher values denote higher quality\n\
10127 and hence larger image sizes. For png values are in the range -1\n\
10128 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10129 A value of -1 denotes the default zlib compression level. Values\n\
10130 in the range 10-99 are divided by 10 and then used as the zlib\n\
10131 compression level. Higher compression levels correspond to greater\n\
10132 compression and small file sizes at the expense of more\n\
10136Specify viewport in absolute coordinates\n\
10140 Alternate routine to plvpor for setting up the viewport. This routine\n\
10141 should be used only if the viewport is required to have a definite\n\
10142 size in millimeters. The routine plgspa is useful for finding out the\n\
10143 size of the current subpage.\n\
10145 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10147 This function is used in example 10.\n\
10153plsvpa(xmin, xmax, ymin, ymax)\n\
10157 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10158 viewport from the left-hand edge of the subpage in millimeters.\n\
10160 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10161 viewport from the left-hand edge of the subpage in millimeters.\n\
10163 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10164 viewport from the bottom edge of the subpage in millimeters.\n\
10166 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10167 from the bottom edge of the subpage in millimeters.\n\
10170Draw a polygon in 3 space\n\
10174 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10175 like plline3, but differs from that function in that plpoly3 attempts\n\
10176 to determine if the polygon is viewable depending on the order of the\n\
10177 points within the vector and the value of ifcc. If the back of\n\
10178 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10179 you want, then use plline3 instead.\n\
10181 The points are assumed to be in a plane, and the directionality of the\n\
10182 plane is determined from the first three points. Additional points do\n\
10183 not have to lie on the plane defined by the first three, but if they\n\
10184 do not, then the determination of visibility obviously can\'t be 100%\n\
10185 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10186 consider breaking them into smaller polygons. 3 points define a plane\n\
10189 Bugs: If one of the first two segments is of zero length, or if they\n\
10190 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10191 being correct. Avoid such situations :-). See x18c.c for an example\n\
10192 of this problem. (Search for 20.1).\n\
10194 Redacted form: plpoly3(x, y, z, code)\n\
10196 This function is used in example 18.\n\
10202plpoly3(n, x, y, z, draw, ifcc)\n\
10206 n (PLINT, input) : Number of points defining line.\n\
10208 x (PLFLT_VECTOR, input) : A vector containing\n\
10209 n x coordinates of points.\n\
10211 y (PLFLT_VECTOR, input) : A vector containing\n\
10212 n y coordinates of points.\n\
10214 z (PLFLT_VECTOR, input) : A vector containing\n\
10215 n z coordinates of points.\n\
10217 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10218 n-1 Boolean values which control drawing the segments of the polygon.\n\
10219 If draw[i] is true, then the polygon segment from index [i] to\n\
10220 [i+1] is drawn, otherwise, not.\n\
10222 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10223 polygon is determined by assuming the points are laid out in a\n\
10224 counter-clockwise order. Otherwise, the directionality of the\n\
10225 polygon is determined by assuming the points are laid out in a\n\
10226 clockwise order.\n\
10229Magnitude colored plot surface with contour\n\
10233 Aside from dropping the\n\
10234 side functionality this is a more powerful form of plot3d: the surface\n\
10235 mesh can be colored accordingly to the current z value being plotted,\n\
10236 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10237 drawn between the plotted function border and the base XY plane. The\n\
10238 arguments are identical to those of plmeshc. The only difference\n\
10239 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10240 the surface, while plot3dc only draws the surface as viewed from the\n\
10243 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10246 This function is used in example 21.\n\
10252plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10256 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10257 which the function is evaluated.\n\
10259 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10260 which the function is evaluated.\n\
10262 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10263 plot. Should have dimensions of\n\
10267 nx (PLINT, input) : Number of x values at which function is\n\
10270 ny (PLINT, input) : Number of y values at which function is\n\
10273 opt (PLINT, input) : Determines the way in which the surface is\n\
10274 represented. To specify more than one option just add the options,\n\
10275 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10276 showing z as a function of x for each value of y[j] .\n\
10277 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10278 for each value of x[i] .\n\
10279 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10280 at which function is defined.\n\
10281 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10282 the z value being plotted. The color is used from the current\n\
10284 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10285 using parameters\n\
10288 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10289 the borders of the plotted function.\n\
10292 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10295 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10298Create a 4-pen strip chart\n\
10302 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10304 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10305 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10306 styline, legline, labx, laby, labz)\n\
10309 This function is used in example 17.\n\
10315plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10319 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10320 number of the strip chart to use on plstripa and plstripd.\n\
10322 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10323 the x-axis specification as in plbox.\n\
10325 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10326 the y-axis specification as in plbox.\n\
10328 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10329 change as data are added.\n\
10331 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10332 change as data are added.\n\
10334 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10335 is multiplied by the factor (1 +\n\
10338 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10339 change as data are added.\n\
10341 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10342 change as data are added.\n\
10344 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10346 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10348 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10349 true, otherwise not.\n\
10351 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10352 otherwise slide display.\n\
10354 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10356 collab (PLINT, input) : Legend color index (cmap0).\n\
10358 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10359 indices for the 4 pens.\n\
10361 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10362 indices for the 4 pens.\n\
10364 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10365 strings containing legends for the 4 pens.\n\
10367 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10368 the label for the x axis.\n\
10370 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10371 the label for the y axis.\n\
10373 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10377Deletes and releases memory used by a strip chart\n\
10381 Deletes and releases memory used by a strip chart.\n\
10383 Redacted form: plstripd(id)\n\
10385 This function is used in example 17.\n\
10395 id (PLINT, input) : Identification number of strip chart to delete.\n\
10398Set cmap1 colors using a piece-wise linear relationship\n\
10402 Set cmap1 colors using a piece-wise linear relationship between the\n\
10403 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10404 (see the PLplot documentation). May be called at any time.\n\
10406 The idea here is to specify a number of control points that define the\n\
10407 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10408 these points, linear interpolation is used which gives a smooth\n\
10409 variation of color with intensity index. Any number of control points\n\
10410 may be specified, located at arbitrary positions, although typically 2\n\
10411 - 4 are enough. Another way of stating this is that we are traversing\n\
10412 a given number of lines through HLS or RGB space as we move through\n\
10413 cmap1 intensity indices. The control points at the minimum and\n\
10414 maximum position (0 and 1) must always be specified. By adding more\n\
10415 control points you can get more variation. One good technique for\n\
10416 plotting functions that vary about some expected average is to use an\n\
10417 additional 2 control points in the center (position ~= 0.5) that are\n\
10418 the same lightness as the background (typically white for paper\n\
10419 output, black for crt), and same hue as the boundary control points.\n\
10420 This allows the highs and lows to be very easily distinguished.\n\
10422 Each control point must specify the cmap1 intensity index and the\n\
10423 associated three coordinates in HLS or RGB space. The first point\n\
10424 must correspond to position = 0, and the last to position = 1.\n\
10426 If RGB colors are provided then the interpolation takes place in RGB\n\
10427 space and is trivial. However if HLS colors are provided then, because\n\
10428 of the circular nature of the color wheel for the hue coordinate, the\n\
10429 interpolation could be performed in either direction around the color\n\
10430 wheel. The default behaviour is for the hue to be linearly\n\
10431 interpolated ignoring this circular property of hue. So for example,\n\
10432 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10433 green and cyan. If instead you wish to interpolate the other way\n\
10434 around the color wheel you have two options. You may provide hues\n\
10435 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10436 for red the interpolation will proceed via magenta. Alternatively you\n\
10437 can utilise the alt_hue_path variable to reverse the direction of\n\
10438 interpolation if you need to provide hues within the [0-360) range.\n\
10440 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10441 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10442 -120]falsegreen-yellow-red-magenta-blue[240\n\
10443 480]falseblue-magenta-red-yellow-green[120\n\
10444 240]truegreen-yellow-red-magenta-blue[240\n\
10445 120]trueblue-magenta-red-yellow-green\n\
10447 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10448 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10449 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10451 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10454 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10460plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10464 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10466 npts (PLINT, input) : number of control points\n\
10468 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10469 intensity index (0.0-1.0) in ascending order for each control\n\
10472 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10473 coordinate (H or R) for each control point.\n\
10475 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10476 coordinate (L or G) for each control point.\n\
10478 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10479 coordinate (S or B) for each control point.\n\
10481 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10482 npts - 1 elements), each containing either true to use the reversed\n\
10483 HLS interpolation or false to use the regular HLS interpolation.\n\
10484 (alt_hue_path[i] refers to the interpolation interval between the\n\
10485 i and i + 1 control points). This parameter is not used for RGB\n\
10490Shade individual region on the basis of value\n\
10494 Shade individual region on the basis of value. Use plshades if you\n\
10495 want to shade a number of contiguous regions using continuous colors.\n\
10496 In particular the edge contours are treated properly in plshades. If\n\
10497 you attempt to do contiguous regions with plshade the contours at the\n\
10498 edge of the shade are partially obliterated by subsequent plots of\n\
10499 contiguous shaded regions.\n\
10501 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10502 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10503 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10506 This function is used in example 15.\n\
10512plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10516 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10517 plot. Should have dimensions of\n\
10521 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10523 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10525 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10526 the region that should be plotted in the shade plot. This\n\
10527 function accepts x and y coordinates as input arguments and must\n\
10528 return 1 if the point is to be included in the shade plot and 0\n\
10529 otherwise. If you want to plot the entire shade plot (the usual\n\
10530 case), this argument should be set to NULL.\n\
10532 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10533 pltr below for how these arguments are used (only for the special case\n\
10534 when the callback function\n\
10535 pltr is not supplied).\n\
10537 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10538 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10540 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10541 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10543 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10544 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10545 then sh_color is interpreted as a cmap1 argument in the range\n\
10548 sh_color (PLFLT, input) : Defines color map index with integer\n\
10549 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10551 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10553 min_color (PLINT, input) : Defines pen color, width used by the\n\
10554 boundary of shaded region. The min values are used for the\n\
10555 shade_min boundary, and the max values are used on the shade_max\n\
10556 boundary. Set color and width to zero for no plotted boundaries.\n\
10558 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10559 boundary of shaded region. The min values are used for the\n\
10560 shade_min boundary, and the max values are used on the shade_max\n\
10561 boundary. Set color and width to zero for no plotted boundaries.\n\
10563 max_color (PLINT, input) : Defines pen color, width used by the\n\
10564 boundary of shaded region. The min values are used for the\n\
10565 shade_min boundary, and the max values are used on the shade_max\n\
10566 boundary. Set color and width to zero for no plotted boundaries.\n\
10568 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10569 boundary of shaded region. The min values are used for the\n\
10570 shade_min boundary, and the max values are used on the shade_max\n\
10571 boundary. Set color and width to zero for no plotted boundaries.\n\
10573 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10574 Use plfill. Future version of PLplot may have other fill\n\
10577 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10578 map to rectangles after coordinate transformation with pltrl.\n\
10579 Otherwise, set rectangular to false. If rectangular is set to\n\
10580 true, plshade tries to save time by filling large rectangles.\n\
10581 This optimization fails if the coordinate transformation distorts\n\
10582 the shape of rectangles. For example a plot in polar coordinates\n\
10583 has to have rectangular set to false.\n\
10585 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10586 defines the transformation between the zero-based indices of the\n\
10587 matrix a and world coordinates. If\n\
10588 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10589 indices of a are mapped to the range\n\
10591 xmax and the y indices of a are mapped to the range\n\
10593 ymax.For the C case, transformation functions are provided in the\n\
10594 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10595 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10596 matrices. In addition, C callback routines for the transformation\n\
10597 can be supplied by the user such as the mypltr function in\n\
10598 examples/c/x09c.c which provides a general linear transformation\n\
10599 between index coordinates and world coordinates.For languages\n\
10600 other than C you should consult the PLplot documentation for the\n\
10601 details concerning how PLTRANSFORM_callback arguments are\n\
10602 interfaced. However, in general, a particular pattern of\n\
10603 callback-associated arguments such as a tr vector with 6 elements;\n\
10604 xg and yg vectors; or xg and yg matrices are respectively\n\
10605 interfaced to a linear-transformation routine similar to the above\n\
10606 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10607 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10608 support native language callbacks for handling index to\n\
10609 world-coordinate transformations. Examples of these various\n\
10610 approaches are given in examples/<language>x09*,\n\
10611 examples/<language>x16*, examples/<language>x20*,\n\
10612 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10613 supported languages.\n\
10615 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10616 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10617 externally supplied.\n\
10620Set number of colors in cmap1\n\
10624 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10625 values if this is the first allocation (see the PLplot documentation).\n\
10627 Redacted form: plscmap1n(ncol1)\n\
10629 This function is used in examples 8, 11, 20, and 21.\n\
10639 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10640 the cmap1 palette. If this number is zero or less, then the value\n\
10641 from the previous call to plscmap1n is used and if there is no\n\
10642 previous call, then a default value is used.\n\
10645Advance to the next family file on the next new page\n\
10649 Advance to the next family file on the next new page.\n\
10651 Redacted form: plfamadv()\n\
10653 This function is not used in any examples.\n\
10662Set the escape character for text strings\n\
10666 Set the escape character for text strings. From C (in contrast to\n\
10667 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10668 characters are allowed to prevent the user from shooting himself in\n\
10669 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10670 use of backslash as a character escape). Here are the allowed escape\n\
10671 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10682 Redacted form: General: plsesc(esc)\n\
10685 This function is used in example 29.\n\
10695 esc (char, input) : Escape character.\n\
10697static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10698Plot color bar for image, shade or gradient plots\n\
10702 Routine for creating a continuous color bar for image, shade, or\n\
10703 gradient plots. (See pllegend for similar functionality for creating\n\
10704 legends with discrete elements). The arguments of plcolorbar provide\n\
10705 control over the location and size of the color bar as well as the\n\
10706 location and characteristics of the elements (most of which are\n\
10707 optional) within that color bar. The resulting color bar is clipped\n\
10708 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10709 system used for some of the parameters is defined in the documentation\n\
10710 of the position parameter.)\n\
10712 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10713 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10714 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10715 labels, axis_opts, ticks, sub_ticks, values)\n\
10717 This function is used in examples 16 and 33.\n\
10723plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n\
10727 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10728 labelled and decorated color bar width in adopted coordinates.\n\
10730 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10731 labelled and decorated color bar height in adopted coordinates.\n\
10733 opt (PLINT, input) : opt contains bits controlling the overall\n\
10734 color bar. The orientation (direction of the maximum value) of\n\
10735 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10736 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10737 specified, the default orientation is toward the top if the\n\
10738 colorbar is placed on the left or right of the viewport or toward\n\
10739 the right if the colorbar is placed on the top or bottom of the\n\
10740 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10741 (semitransparent) background for the color bar. If the\n\
10742 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10743 color bar. The type of color bar must be specified with one of\n\
10744 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10745 more than one of those bits is set only the first one in the above\n\
10746 list is honored. The position of the (optional) label/title can be\n\
10747 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10748 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10749 will be drawn. If more than one of this list of bits is specified,\n\
10750 only the first one on the list is honored. End-caps for the color\n\
10751 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10752 If a particular color bar cap option is not specified then no cap\n\
10753 will be drawn for that end. As a special case for\n\
10754 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10755 specified. If this option is provided then any tick marks and tick\n\
10756 labels will be placed at the breaks between shaded segments. TODO:\n\
10757 This should be expanded to support custom placement of tick marks\n\
10758 and tick labels at custom value locations for any color bar type.\n\
10760 position (PLINT, input) : position contains bits which control the\n\
10761 overall position of the color bar and the definition of the\n\
10762 adopted coordinates used for positions just like what is done for\n\
10763 the position argument for pllegend. However, note that the\n\
10764 defaults for the position bits (see below) are different than the\n\
10765 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10766 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10767 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10768 the 16 possible standard positions (the 4 corners and centers of\n\
10769 the 4 sides for both the inside and outside cases) of the color\n\
10770 bar relative to the adopted coordinate system. The corner\n\
10771 positions are specified by the appropriate combination of two of\n\
10772 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10773 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10774 value of one of those bits. The adopted coordinates are\n\
10775 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10776 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10777 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10778 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10779 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10780 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10781 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10782 PL_POSITION_VIEWPORT.\n\
10784 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10785 coordinates from the specified standard position of the color bar.\n\
10786 For positive x, the direction of motion away from the standard\n\
10787 position is inward/outward from the standard corner positions or\n\
10788 standard left or right positions if the\n\
10789 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10790 For the standard top or bottom positions, the direction of motion\n\
10791 is toward positive X.\n\
10793 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10794 coordinates from the specified standard position of the color bar.\n\
10795 For positive y, the direction of motion away from the standard\n\
10796 position is inward/outward from the standard corner positions or\n\
10797 standard top or bottom positions if the\n\
10798 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10799 For the standard left or right positions, the direction of motion\n\
10800 is toward positive Y.\n\
10802 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10803 the X direction in adopted coordinates.\n\
10805 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10806 the Y direction in adopted coordinates.\n\
10808 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10809 color bar (PL_COLORBAR_BACKGROUND).\n\
10811 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10812 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10814 bb_style (PLINT, input) : The pllsty style number for the\n\
10815 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10817 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10818 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10820 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10821 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10823 cont_color (PLINT, input) : The cmap0 contour color for\n\
10824 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10825 it will be interpreted according to the design of plshades.\n\
10827 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10828 plots. This is passed directly to plshades, so it will be\n\
10829 interpreted according to the design of plshades.\n\
10831 n_labels (PLINT, input) : Number of labels to place around the\n\
10834 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10835 n_labels labels.\n\
10837 labels (PLCHAR_MATRIX, input) : A vector of\n\
10838 n_labels UTF-8 character strings containing the labels for the color\n\
10839 bar. Ignored if no label position is specified with one of the\n\
10840 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10841 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10842 corresponding label_opts field.\n\
10844 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10845 value must be greater than 0. It is typically 1 (numerical axis\n\
10846 labels are provided for one of the long edges of the color bar),\n\
10847 but it can be larger if multiple numerical axis labels for the\n\
10848 long edges of the color bar are desired.\n\
10850 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10851 n_axes ascii character strings containing options (interpreted as for\n\
10852 plbox) for the color bar\'s axis definitions.\n\
10854 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10855 spacing of the major tick marks (interpreted as for plbox) for the\n\
10856 color bar\'s axis definitions.\n\
10858 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10859 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10860 axis definitions.\n\
10862 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10863 elements in each of the n_axes rows of the values matrix.\n\
10865 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10866 values for the data range represented by the color bar. For a row\n\
10867 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10868 elements in the row is specified by n_values[i_axis]. For\n\
10869 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10870 is 2, and the corresponding row elements of the values matrix are\n\
10871 the minimum and maximum value represented by the colorbar. For\n\
10872 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10873 of the values matrix is interpreted the same as the nlevel and\n\
10874 clevel arguments of plshades.\n\
10876static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10877Set current output stream\n\
10881 Sets the number of the current output stream. The stream number\n\
10882 defaults to 0 unless changed by this routine. The first use of this\n\
10883 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10885 Redacted form: plsstrm(strm)\n\
10887 This function is examples 1,14,20.\n\
10897 strm (PLINT, input) : The current stream number.\n\
10899static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10900Get the current device-compression setting\n\
10904 Get the current device-compression setting. This parameter is only\n\
10905 used for drivers that provide compression.\n\
10907 Redacted form: plgcompression(compression)\n\
10909 This function is used in example 31.\n\
10915plgcompression(compression)\n\
10919 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10920 compression setting for the current device.\n\
10922static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10923Grid data from irregularly sampled data\n\
10927 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10928 require data organized as a grid, i.e., with x sample point values\n\
10929 independent of y coordinate and vice versa. This function takes\n\
10930 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10931 vectors; reads the desired grid location from the input vectors\n\
10932 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10933 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10934 interpolate the data to the grid is specified with the argument type\n\
10935 which can have one parameter specified in argument data.\n\
10937 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10938 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10941 This function is used in example 21.\n\
10947plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10951 x (PLFLT_VECTOR, input) : The input x vector.\n\
10953 y (PLFLT_VECTOR, input) : The input y vector.\n\
10955 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10956 y[i], z[i] represents one data sample coordinate.\n\
10958 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10961 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10962 in the x direction. Usually xg has nptsx equally spaced values\n\
10963 from the minimum to the maximum values of the x input vector.\n\
10965 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10967 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10968 in the y direction. Similar to the xg parameter.\n\
10970 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10972 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10973 where data lies in the grid specified by xg and yg. Therefore the\n\
10974 zg matrix must be dimensioned\n\
10978 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10979 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10980 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10981 GRID_NNI: Natural Neighbors Interpolation\n\
10982 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10983 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10984 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10986 For details of the algorithms read the source file plgridd.c.\n\
10988 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10989 which can be specified through this argument. Currently, for\n\
10990 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10991 use, the lower the value, the noisier (more local) the\n\
10992 approximation is.\n\
10993 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10994 range [1. .. 2.]. High values enable the usage of very thin\n\
10995 triangles for interpolation, possibly resulting in error in\n\
10996 the approximation.\n\
10997 GRID_NNI, only weights greater than data will be accepted. If\n\
10998 0, all weights will be accepted.\n\
11004 char **arg3 = (
char **) 0 ;
11006 octave_value_list _out;
11007 octave_value_list *_outp=&_out;
11008 octave_value _outv;
11015 if (
_n_dims( args(0) ) > 1 )
11021 temp1 = args(0).matrix_value();
11025 charMatrix temp_matrix;
11029 size_t max_length = 0, non_blank_length;
11031 if (
_n_dims( args(1) ) > 2 )
11033 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
11035#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11036 if ( !args(1).isempty() )
11038 if ( !args(1).is_empty() )
11043 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
11045 arg3 =
new char*[
Alen];
11046#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11047 ifcell = args(1).iscell();
11049 ifcell = args(1).is_cell();
11053 temp_cell = args(1).cell_value();
11057 temp_matrix = args(1).char_matrix_value();
11059 max_length =
_dim( args(1), 1 ) + 1;
11062 for ( i = 0; i <
Alen; i++ )
11069 if ( temp_cell.elem( i ).is_string() )
11071 str = temp_cell.elem( i ).string_value();
11073 max_length = str.size() + 1;
11074 tmp_cstring = (
char *) str.c_str();
11084 tmp_cstring = (
char *)
"";
11089 str = temp_matrix.row_as_string( i );
11090 tmp_cstring = (
char *) str.c_str();
11092 arg3[i] =
new char[max_length];
11093 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11094 arg3[i][max_length - 1] =
'\0';
11109 non_blank_length = max_length - 2;
11110 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11112 non_blank_length--;
11114 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11116 non_blank_length--;
11118 arg3[i][non_blank_length + 1] =
'\0';
11127 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11128 _outv = octave_value();
11135 if ( arg3 != NULL )
11137 for ( i = 0; i <
Alen; i++ )
11151 if ( arg3 != NULL )
11153 for ( i = 0; i <
Alen; i++ )
11160 return octave_value_list();
11168 if ( arg3 != NULL )
11170 for ( i = 0; i <
Alen; i++ )
11183 int *arg1 = (
int *) 0 ;
11184 int *arg2 = (
int *) 0 ;
11185 int *arg3 = (
int *) 0 ;
11186 char *arg4 = (
char *) 0 ;
11187 int *arg5 = (
int *) 0 ;
11188 int *arg6 = (
int *) 0 ;
11193 int *arg11 = (
int *) 0 ;
11200 char local_string4[80] ;
11215 size_t local_string_length4 ;
11216 charMatrix local_charMatrix4 ;
11217 octave_value_list retval4 ;
11218 octave_value_list _out;
11219 octave_value_list *_outp=&_out;
11220 octave_value _outv;
11228 arg4 = local_string4;
11240 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11262 local_string_length4 = strlen( local_string4 );
11263 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11264 local_charMatrix4.insert( local_string4, 0, 0 );
11265 retval4( 0 ) = octave_value( local_charMatrix4 );
11312 return octave_value_list();
11333 octave_value_list _out;
11334 octave_value_list *_outp=&_out;
11335 octave_value _outv;
11348 arg3 =
static_cast< PLFLT >(val3);
11353 arg4 =
static_cast< PLFLT >(val4);
11371 return octave_value_list();
11381 char *arg2 = (
char *) 0 ;
11382 char *arg3 = (
char *) 0 ;
11396 char *arg17 = (
char *) 0 ;
11397 char *arg18 = (
char *) 0 ;
11398 char *arg19 = (
char *) 0 ;
11399 char *arg20 = (
char *) 0 ;
11400 char *arg21 = (
char *) 0 ;
11401 char *arg22 = (
char *) 0 ;
11402 char *arg23 = (
char *) 0 ;
11456 octave_value_list _out;
11457 octave_value_list *_outp=&_out;
11458 octave_value _outv;
11469 arg2 =
reinterpret_cast< char *
>(buf2);
11474 arg3 =
reinterpret_cast< char *
>(buf3);
11479 arg4 =
static_cast< PLFLT >(val4);
11484 arg5 =
static_cast< PLFLT >(val5);
11489 arg6 =
static_cast< PLFLT >(val6);
11494 arg7 =
static_cast< PLFLT >(val7);
11499 arg8 =
static_cast< PLFLT >(val8);
11504 arg9 =
static_cast< PLFLT >(val9);
11509 arg10 =
static_cast< PLFLT >(val10);
11514 arg11 =
static_cast< PLBOOL >(val11);
11519 arg12 =
static_cast< PLBOOL >(val12);
11524 arg13 =
static_cast< PLINT >(val13);
11529 arg14 =
static_cast< PLINT >(val14);
11531 if (
_n_dims( args(13) ) > 1 )
11536 temp15 = args(13).matrix_value();
11541 if (
_n_dims( args(14) ) > 1 )
11545 if (
_dim( args(14), 0 ) !=
Alen )
11549 temp16 = args(14).matrix_value();
11557 arg17 =
reinterpret_cast< char *
>(buf17);
11562 arg18 =
reinterpret_cast< char *
>(buf18);
11567 arg19 =
reinterpret_cast< char *
>(buf19);
11572 arg20 =
reinterpret_cast< char *
>(buf20);
11577 arg21 =
reinterpret_cast< char *
>(buf21);
11582 arg22 =
reinterpret_cast< char *
>(buf22);
11587 arg23 =
reinterpret_cast< char *
>(buf23);
11588 my_plstripc(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(
int const *)arg15,(
int const *)arg16,(
char const *)arg17,(
char const *)arg18,(
char const *)arg19,(
char const *)arg20,(
char const *)arg21,(
char const *)arg22,(
char const *)arg23);
11589 _outv = octave_value();
11629 return octave_value_list();
11674 octave_value_list _out;
11675 octave_value_list *_outp=&_out;
11676 octave_value _outv;
11683 if (
_n_dims( args(0) ) > 2 )
11685 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11687 temp1 = args(0).matrix_value();
11688 arg1 = &temp1( 0, 0 );
11696 arg4 =
static_cast< PLINT >(val4);
11701 arg5 =
static_cast< PLINT >(val5);
11706 arg6 =
static_cast< PLINT >(val6);
11711 arg7 =
static_cast< PLINT >(val7);
11713 if (
_n_dims( args(5) ) > 1 )
11717 temp8 = args(5).matrix_value();
11718 arg8 = &temp8( 0, 0 );
11722 if (
_n_dims( args(6) ) > 1 )
11726 if (
_dim( args(6), 0 ) != 6 )
11730 temp10 = args(6).matrix_value();
11731 arg10 = &temp10( 0, 0 );
11733 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11734 _outv = octave_value();
11756 return octave_value_list();
11793 octave_value_list _out;
11794 octave_value_list *_outp=&_out;
11795 octave_value _outv;
11802 if (
_n_dims( args(0) ) > 2 )
11804 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11806 temp1 = args(0).matrix_value();
11807 arg1 = &temp1( 0, 0 );
11815 arg4 =
static_cast< PLINT >(val4);
11820 arg5 =
static_cast< PLINT >(val5);
11825 arg6 =
static_cast< PLINT >(val6);
11830 arg7 =
static_cast< PLINT >(val7);
11832 if (
_n_dims( args(5) ) > 1 )
11836 temp8 = args(5).matrix_value();
11837 arg8 = &temp8( 0, 0 );
11840 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11841 _outv = octave_value();
11857 return octave_value_list();
11895 octave_value_list _out;
11896 octave_value_list *_outp=&_out;
11897 octave_value _outv;
11904 if (
_n_dims( args(0) ) > 2 )
11906 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11908 temp1 = args(0).matrix_value();
11909 arg1 = &temp1( 0, 0 );
11917 arg4 =
static_cast< PLINT >(val4);
11922 arg5 =
static_cast< PLINT >(val5);
11927 arg6 =
static_cast< PLINT >(val6);
11932 arg7 =
static_cast< PLINT >(val7);
11934 if (
_n_dims( args(5) ) > 1 )
11938 temp8 = args(5).matrix_value();
11939 arg8 = &temp8( 0, 0 );
11943 if (
_n_dims( args(6) ) > 1 )
11951 temp10 = args(6).matrix_value();
11952 arg10 = &temp10( 0, 0 );
11955 if (
_n_dims( args(7) ) > 1 )
11963 temp11 = args(7).matrix_value();
11964 arg11 = &temp11( 0, 0 );
11966 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11967 _outv = octave_value();
11995 return octave_value_list();
12039 octave_value_list _out;
12040 octave_value_list *_outp=&_out;
12041 octave_value _outv;
12048 if (
_n_dims( args(0) ) > 2 )
12050 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12052 temp1 = args(0).matrix_value();
12053 arg1 = &temp1( 0, 0 );
12061 arg4 =
static_cast< PLINT >(val4);
12066 arg5 =
static_cast< PLINT >(val5);
12071 arg6 =
static_cast< PLINT >(val6);
12076 arg7 =
static_cast< PLINT >(val7);
12078 if (
_n_dims( args(5) ) > 1 )
12082 temp8 = args(5).matrix_value();
12083 arg8 = &temp8( 0, 0 );
12087 if (
_n_dims( args(6) ) > 2 )
12089 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12093 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12097 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12099 temp10 = args(6).matrix_value();
12100 arg10 = &temp10( 0, 0 );
12103 if (
_n_dims( args(7) ) > 2 )
12105 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12109 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12113 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12115 temp11 = args(7).matrix_value();
12116 arg11 = &temp11( 0, 0 );
12118 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12119 _outv = octave_value();
12147 return octave_value_list();
12191 octave_value_list _out;
12192 octave_value_list *_outp=&_out;
12193 octave_value _outv;
12200 if (
_n_dims( args(0) ) > 2 )
12202 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12204 temp1 = args(0).matrix_value();
12205 arg1 = &temp1( 0, 0 );
12213 arg4 =
static_cast< PLINT >(val4);
12218 arg5 =
static_cast< PLINT >(val5);
12223 arg6 =
static_cast< PLINT >(val6);
12228 arg7 =
static_cast< PLINT >(val7);
12230 if (
_n_dims( args(5) ) > 1 )
12234 temp8 = args(5).matrix_value();
12235 arg8 = &temp8( 0, 0 );
12239 if (
_n_dims( args(6) ) > 2 )
12241 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12245 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12249 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12251 temp10 = args(6).matrix_value();
12252 arg10 = &temp10( 0, 0 );
12255 if (
_n_dims( args(7) ) > 2 )
12257 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12261 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12265 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12267 temp11 = args(7).matrix_value();
12268 arg11 = &temp11( 0, 0 );
12270 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12271 _outv = octave_value();
12299 return octave_value_list();
12336 octave_value_list retval7 ;
12341 octave_value_list _out;
12342 octave_value_list *_outp=&_out;
12343 octave_value _outv;
12350 if (
_n_dims( args(0) ) > 1 )
12355 temp1 = args(0).matrix_value();
12356 arg1 = &temp1( 0, 0 );
12359 if (
_n_dims( args(1) ) > 1 )
12367 temp2 = args(1).matrix_value();
12368 arg2 = &temp2( 0, 0 );
12371 if (
_n_dims( args(2) ) > 1 )
12379 temp3 = args(2).matrix_value();
12380 arg3 = &temp3( 0, 0 );
12384 if (
_n_dims( args(3) ) > 1 )
12388 temp5 = args(3).matrix_value();
12389 arg5 = &temp5( 0, 0 );
12393 if (
_n_dims( args(4) ) > 1 )
12397 temp7 = args(4).matrix_value();
12398 arg7 = &temp7( 0, 0 );
12400 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12401 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12407 arg10 =
static_cast< PLINT >(val10);
12412 arg11 =
static_cast< PLFLT >(val11);
12413 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12414 _outv = octave_value();
12451 return octave_value_list();
12486 octave_value_list _out;
12487 octave_value_list *_outp=&_out;
12488 octave_value _outv;
12495 if (
_n_dims( args(0) ) > 1 )
12499 temp1 = args(0).matrix_value();
12500 arg1 = &temp1( 0, 0 );
12504 if (
_n_dims( args(1) ) > 1 )
12508 temp2 = args(1).matrix_value();
12509 arg2 = &temp2( 0, 0 );
12513 if (
_n_dims( args(2) ) > 2 )
12515 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12519 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12523 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12525 temp3 = args(2).matrix_value();
12526 arg3 = &temp3( 0, 0 );
12534 arg6 =
static_cast< PLINT >(val6);
12535 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12536 _outv = octave_value();
12558 return octave_value_list();
12590 octave_value_list _out;
12591 octave_value_list *_outp=&_out;
12592 octave_value _outv;
12599 if (
_n_dims( args(0) ) > 1 )
12603 temp1 = args(0).matrix_value();
12604 arg1 = &temp1( 0, 0 );
12608 if (
_n_dims( args(1) ) > 1 )
12612 temp2 = args(1).matrix_value();
12613 arg2 = &temp2( 0, 0 );
12617 if (
_n_dims( args(2) ) > 2 )
12619 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12623 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12627 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12629 temp3 = args(2).matrix_value();
12630 arg3 = &temp3( 0, 0 );
12638 arg6 =
static_cast< PLINT >(val6);
12640 if (
_n_dims( args(4) ) > 1 )
12644 temp7 = args(4).matrix_value();
12645 arg7 = &temp7( 0, 0 );
12648 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12649 _outv = octave_value();
12677 return octave_value_list();
12712 octave_value_list _out;
12713 octave_value_list *_outp=&_out;
12714 octave_value _outv;
12721 if (
_n_dims( args(0) ) > 1 )
12725 temp1 = args(0).matrix_value();
12726 arg1 = &temp1( 0, 0 );
12730 if (
_n_dims( args(1) ) > 1 )
12734 temp2 = args(1).matrix_value();
12735 arg2 = &temp2( 0, 0 );
12739 if (
_n_dims( args(2) ) > 2 )
12741 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12745 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12749 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12751 temp3 = args(2).matrix_value();
12752 arg3 = &temp3( 0, 0 );
12760 arg6 =
static_cast< PLINT >(val6);
12765 arg7 =
static_cast< PLBOOL >(val7);
12766 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12767 _outv = octave_value();
12789 return octave_value_list();
12821 octave_value_list _out;
12822 octave_value_list *_outp=&_out;
12823 octave_value _outv;
12830 if (
_n_dims( args(0) ) > 1 )
12834 temp1 = args(0).matrix_value();
12835 arg1 = &temp1( 0, 0 );
12839 if (
_n_dims( args(1) ) > 1 )
12843 temp2 = args(1).matrix_value();
12844 arg2 = &temp2( 0, 0 );
12848 if (
_n_dims( args(2) ) > 2 )
12850 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12854 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12858 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12860 temp3 = args(2).matrix_value();
12861 arg3 = &temp3( 0, 0 );
12869 arg6 =
static_cast< PLINT >(val6);
12871 if (
_n_dims( args(4) ) > 1 )
12875 temp7 = args(4).matrix_value();
12876 arg7 = &temp7( 0, 0 );
12879 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12880 _outv = octave_value();
12908 return octave_value_list();
12951 octave_value_list _out;
12952 octave_value_list *_outp=&_out;
12953 octave_value _outv;
12960 if (
_n_dims( args(0) ) > 1 )
12964 temp1 = args(0).matrix_value();
12965 arg1 = &temp1( 0, 0 );
12969 if (
_n_dims( args(1) ) > 1 )
12973 temp2 = args(1).matrix_value();
12974 arg2 = &temp2( 0, 0 );
12978 if (
_n_dims( args(2) ) > 2 )
12980 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12984 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12988 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12990 temp3 = args(2).matrix_value();
12991 arg3 = &temp3( 0, 0 );
12999 arg6 =
static_cast< PLINT >(val6);
13001 if (
_n_dims( args(4) ) > 1 )
13005 temp7 = args(4).matrix_value();
13006 arg7 = &temp7( 0, 0 );
13013 arg9 =
static_cast< PLINT >(val9);
13015 if (
_n_dims( args(6) ) > 1 )
13021 temp10 = args(6).matrix_value();
13025 if (
_n_dims( args(7) ) > 1 )
13033 temp12 = args(7).matrix_value();
13037 my_plot3dcl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
13038 _outv = octave_value();
13078 return octave_value_list();
13119 octave_value_list _out;
13120 octave_value_list *_outp=&_out;
13121 octave_value _outv;
13128 if (
_n_dims( args(0) ) > 1 )
13132 temp1 = args(0).matrix_value();
13133 arg1 = &temp1( 0, 0 );
13137 if (
_n_dims( args(1) ) > 1 )
13141 temp2 = args(1).matrix_value();
13142 arg2 = &temp2( 0, 0 );
13146 if (
_n_dims( args(2) ) > 2 )
13148 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13152 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13156 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13158 temp3 = args(2).matrix_value();
13159 arg3 = &temp3( 0, 0 );
13167 arg6 =
static_cast< PLINT >(val6);
13169 if (
_n_dims( args(4) ) > 1 )
13173 temp7 = args(4).matrix_value();
13174 arg7 = &temp7( 0, 0 );
13177 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13178 _outv = octave_value();
13206 return octave_value_list();
13249 octave_value_list _out;
13250 octave_value_list *_outp=&_out;
13251 octave_value _outv;
13258 if (
_n_dims( args(0) ) > 1 )
13262 temp1 = args(0).matrix_value();
13263 arg1 = &temp1( 0, 0 );
13267 if (
_n_dims( args(1) ) > 1 )
13271 temp2 = args(1).matrix_value();
13272 arg2 = &temp2( 0, 0 );
13276 if (
_n_dims( args(2) ) > 2 )
13278 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13282 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13286 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13288 temp3 = args(2).matrix_value();
13289 arg3 = &temp3( 0, 0 );
13297 arg6 =
static_cast< PLINT >(val6);
13299 if (
_n_dims( args(4) ) > 1 )
13303 temp7 = args(4).matrix_value();
13304 arg7 = &temp7( 0, 0 );
13311 arg9 =
static_cast< PLINT >(val9);
13313 if (
_n_dims( args(6) ) > 1 )
13319 temp10 = args(6).matrix_value();
13323 if (
_n_dims( args(7) ) > 1 )
13331 temp12 = args(7).matrix_value();
13335 my_plsurf3dl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
13336 _outv = octave_value();
13376 return octave_value_list();
13453 octave_value_list _out;
13454 octave_value_list *_outp=&_out;
13455 octave_value _outv;
13462 if (
_n_dims( args(0) ) > 2 )
13464 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13466 temp1 = args(0).matrix_value();
13467 arg1 = &temp1( 0, 0 );
13472 if (
_n_dims( args(1) ) > 1 )
13477 temp4 = args(1).matrix_value();
13478 arg4 = &temp4( 0, 0 );
13484 arg5 =
static_cast< PLFLT >(val5);
13489 arg6 =
static_cast< PLFLT >(val6);
13494 arg7 =
static_cast< PLFLT >(val7);
13499 arg8 =
static_cast< PLFLT >(val8);
13504 arg9 =
static_cast< PLFLT >(val9);
13509 arg10 =
static_cast< PLFLT >(val10);
13514 arg11 =
static_cast< PLINT >(val11);
13519 arg12 =
static_cast< PLFLT >(val12);
13524 arg13 =
static_cast< PLINT >(val13);
13529 arg14 =
static_cast< PLINT >(val14);
13534 arg15 =
static_cast< PLINT >(val15);
13539 arg16 =
static_cast< PLINT >(val16);
13544 arg17 =
static_cast< PLINT >(val17);
13549 arg18 =
static_cast< PLBOOL >(val18);
13551 if (
_n_dims( args(16) ) > 1 )
13555 if (
_dim( args(16), 0 ) != 6 )
13559 temp19 = args(16).matrix_value();
13560 arg19 = &temp19( 0, 0 );
13562 my_plshade((
double const *)arg1,arg2,arg3,(
double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
13563 _outv = octave_value();
13585 return octave_value_list();
13606 char *arg4 = (
char *) 0 ;
13657 octave_value_list _out;
13658 octave_value_list *_outp=&_out;
13659 octave_value _outv;
13666 if (
_n_dims( args(0) ) > 2 )
13668 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13670 temp1 = args(0).matrix_value();
13671 arg1 = &temp1( 0, 0 );
13679 arg4 =
reinterpret_cast< char *
>(buf4);
13684 arg5 =
static_cast< PLFLT >(val5);
13689 arg6 =
static_cast< PLFLT >(val6);
13694 arg7 =
static_cast< PLFLT >(val7);
13699 arg8 =
static_cast< PLFLT >(val8);
13704 arg9 =
static_cast< PLFLT >(val9);
13709 arg10 =
static_cast< PLFLT >(val10);
13714 arg11 =
static_cast< PLINT >(val11);
13719 arg12 =
static_cast< PLFLT >(val12);
13724 arg13 =
static_cast< PLINT >(val13);
13729 arg14 =
static_cast< PLINT >(val14);
13734 arg15 =
static_cast< PLINT >(val15);
13739 arg16 =
static_cast< PLINT >(val16);
13744 arg17 =
static_cast< PLINT >(val17);
13749 arg18 =
static_cast< PLBOOL >(val18);
13751 if (
_n_dims( args(16) ) > 1 )
13755 if (
_dim( args(16), 0 ) !=
Xlen )
13759 temp19 = args(16).matrix_value();
13760 arg19 = &temp19( 0, 0 );
13763 if (
_n_dims( args(17) ) > 1 )
13767 if (
_dim( args(17), 0 ) !=
Ylen )
13771 temp20 = args(17).matrix_value();
13772 arg20 = &temp20( 0, 0 );
13774 my_plshade1((
double const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(
double const *)arg19,(
double const *)arg20);
13775 _outv = octave_value();
13799 return octave_value_list();
13821 char *arg4 = (
char *) 0 ;
13872 octave_value_list _out;
13873 octave_value_list *_outp=&_out;
13874 octave_value _outv;
13881 if (
_n_dims( args(0) ) > 2 )
13883 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13885 temp1 = args(0).matrix_value();
13886 arg1 = &temp1( 0, 0 );
13894 arg4 =
reinterpret_cast< char *
>(buf4);
13899 arg5 =
static_cast< PLFLT >(val5);
13904 arg6 =
static_cast< PLFLT >(val6);
13909 arg7 =
static_cast< PLFLT >(val7);
13914 arg8 =
static_cast< PLFLT >(val8);
13919 arg9 =
static_cast< PLFLT >(val9);
13924 arg10 =
static_cast< PLFLT >(val10);
13929 arg11 =
static_cast< PLINT >(val11);
13934 arg12 =
static_cast< PLFLT >(val12);
13939 arg13 =
static_cast< PLINT >(val13);
13944 arg14 =
static_cast< PLINT >(val14);
13949 arg15 =
static_cast< PLINT >(val15);
13954 arg16 =
static_cast< PLINT >(val16);
13959 arg17 =
static_cast< PLINT >(val17);
13964 arg18 =
static_cast< PLBOOL >(val18);
13966 if (
_n_dims( args(16) ) > 2 )
13968 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13970 temp19 = args(16).matrix_value();
13971 arg19 = &temp19( 0, 0 );
13976 if (
_n_dims( args(17) ) > 2 )
13978 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13980 temp20 = args(17).matrix_value();
13981 arg20 = &temp20( 0, 0 );
13985 my_plshade2((
double const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(
double const *)arg19,(
double const *)arg20);
13986 _outv = octave_value();
14010 return octave_value_list();
14060 octave_value_list _out;
14061 octave_value_list *_outp=&_out;
14062 octave_value _outv;
14069 if (
_n_dims( args(0) ) > 2 )
14071 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14073 temp1 = args(0).matrix_value();
14074 arg1 = &temp1( 0, 0 );
14082 arg4 =
static_cast< PLFLT >(val4);
14087 arg5 =
static_cast< PLFLT >(val5);
14092 arg6 =
static_cast< PLFLT >(val6);
14097 arg7 =
static_cast< PLFLT >(val7);
14099 if (
_n_dims( args(5) ) > 1 )
14103 temp8 = args(5).matrix_value();
14104 arg8 = &temp8( 0, 0 );
14111 arg10 =
static_cast< PLINT >(val10);
14116 arg11 =
static_cast< PLINT >(val11);
14121 arg12 =
static_cast< PLINT >(val12);
14126 arg13 =
static_cast< PLBOOL >(val13);
14127 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14128 _outv = octave_value();
14144 return octave_value_list();
14192 octave_value_list _out;
14193 octave_value_list *_outp=&_out;
14194 octave_value _outv;
14201 if (
_n_dims( args(0) ) > 2 )
14203 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14205 temp1 = args(0).matrix_value();
14206 arg1 = &temp1( 0, 0 );
14214 arg4 =
static_cast< PLFLT >(val4);
14219 arg5 =
static_cast< PLFLT >(val5);
14224 arg6 =
static_cast< PLFLT >(val6);
14229 arg7 =
static_cast< PLFLT >(val7);
14231 if (
_n_dims( args(5) ) > 1 )
14235 temp8 = args(5).matrix_value();
14236 arg8 = &temp8( 0, 0 );
14243 arg10 =
static_cast< PLINT >(val10);
14248 arg11 =
static_cast< PLINT >(val11);
14253 arg12 =
static_cast< PLINT >(val12);
14258 arg13 =
static_cast< PLBOOL >(val13);
14260 if (
_n_dims( args(10) ) > 1 )
14264 if (
_dim( args(10), 0 ) != 6 )
14268 temp14 = args(10).matrix_value();
14269 arg14 = &temp14( 0, 0 );
14271 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14272 _outv = octave_value();
14294 return octave_value_list();
14347 octave_value_list _out;
14348 octave_value_list *_outp=&_out;
14349 octave_value _outv;
14356 if (
_n_dims( args(0) ) > 2 )
14358 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14360 temp1 = args(0).matrix_value();
14361 arg1 = &temp1( 0, 0 );
14369 arg4 =
static_cast< PLFLT >(val4);
14374 arg5 =
static_cast< PLFLT >(val5);
14379 arg6 =
static_cast< PLFLT >(val6);
14384 arg7 =
static_cast< PLFLT >(val7);
14386 if (
_n_dims( args(5) ) > 1 )
14390 temp8 = args(5).matrix_value();
14391 arg8 = &temp8( 0, 0 );
14398 arg10 =
static_cast< PLINT >(val10);
14403 arg11 =
static_cast< PLINT >(val11);
14408 arg12 =
static_cast< PLINT >(val12);
14413 arg13 =
static_cast< PLBOOL >(val13);
14415 if (
_n_dims( args(10) ) > 1 )
14419 if (
_dim( args(10), 0 ) !=
Xlen )
14423 temp14 = args(10).matrix_value();
14424 arg14 = &temp14( 0, 0 );
14427 if (
_n_dims( args(11) ) > 1 )
14431 if (
_dim( args(11), 0 ) !=
Ylen )
14435 temp15 = args(11).matrix_value();
14436 arg15 = &temp15( 0, 0 );
14438 my_plshades1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,(
double const *)arg14,(
double const *)arg15);
14439 _outv = octave_value();
14467 return octave_value_list();
14523 octave_value_list _out;
14524 octave_value_list *_outp=&_out;
14525 octave_value _outv;
14532 if (
_n_dims( args(0) ) > 2 )
14534 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14536 temp1 = args(0).matrix_value();
14537 arg1 = &temp1( 0, 0 );
14545 arg4 =
static_cast< PLFLT >(val4);
14550 arg5 =
static_cast< PLFLT >(val5);
14555 arg6 =
static_cast< PLFLT >(val6);
14560 arg7 =
static_cast< PLFLT >(val7);
14562 if (
_n_dims( args(5) ) > 1 )
14566 temp8 = args(5).matrix_value();
14567 arg8 = &temp8( 0, 0 );
14574 arg10 =
static_cast< PLINT >(val10);
14579 arg11 =
static_cast< PLINT >(val11);
14584 arg12 =
static_cast< PLINT >(val12);
14589 arg13 =
static_cast< PLBOOL >(val13);
14591 if (
_n_dims( args(10) ) > 2 )
14593 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14595 temp14 = args(10).matrix_value();
14596 arg14 = &temp14( 0, 0 );
14601 if (
_n_dims( args(11) ) > 2 )
14603 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14605 temp15 = args(11).matrix_value();
14606 arg15 = &temp15( 0, 0 );
14610 my_plshades2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,(
double const *)arg14,(
double const *)arg15);
14611 _outv = octave_value();
14639 return octave_value_list();
14671 octave_value_list _out;
14672 octave_value_list *_outp=&_out;
14673 octave_value _outv;
14680 if (
_n_dims( args(0) ) > 2 )
14682 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14684 temp1 = args(0).matrix_value();
14685 arg1 = &temp1( 0, 0 );
14690 if (
_n_dims( args(1) ) > 2 )
14692 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14696 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14700 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14702 temp2 = args(1).matrix_value();
14703 arg2 = &temp2( 0, 0 );
14711 arg5 =
static_cast< PLFLT >(val5);
14713 if (
_n_dims( args(3) ) > 1 )
14717 if (
_dim( args(3), 0 ) != 6 )
14721 temp6 = args(3).matrix_value();
14722 arg6 = &temp6( 0, 0 );
14724 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14725 _outv = octave_value();
14747 return octave_value_list();
14778 octave_value_list _out;
14779 octave_value_list *_outp=&_out;
14780 octave_value _outv;
14787 if (
_n_dims( args(0) ) > 2 )
14789 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14791 temp1 = args(0).matrix_value();
14792 arg1 = &temp1( 0, 0 );
14797 if (
_n_dims( args(1) ) > 2 )
14799 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14803 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14807 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14809 temp2 = args(1).matrix_value();
14810 arg2 = &temp2( 0, 0 );
14818 arg5 =
static_cast< PLFLT >(val5);
14820 if (
_n_dims( args(3) ) > 1 )
14828 temp6 = args(3).matrix_value();
14829 arg6 = &temp6( 0, 0 );
14832 if (
_n_dims( args(4) ) > 1 )
14840 temp7 = args(4).matrix_value();
14841 arg7 = &temp7( 0, 0 );
14843 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14844 _outv = octave_value();
14872 return octave_value_list();
14906 octave_value_list _out;
14907 octave_value_list *_outp=&_out;
14908 octave_value _outv;
14915 if (
_n_dims( args(0) ) > 2 )
14917 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14919 temp1 = args(0).matrix_value();
14920 arg1 = &temp1( 0, 0 );
14925 if (
_n_dims( args(1) ) > 2 )
14927 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14931 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14935 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14937 temp2 = args(1).matrix_value();
14938 arg2 = &temp2( 0, 0 );
14946 arg5 =
static_cast< PLFLT >(val5);
14948 if (
_n_dims( args(3) ) > 2 )
14950 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14952 temp6 = args(3).matrix_value();
14953 arg6 = &temp6( 0, 0 );
14958 if (
_n_dims( args(4) ) > 2 )
14960 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14962 temp7 = args(4).matrix_value();
14963 arg7 = &temp7( 0, 0 );
14967 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14968 _outv = octave_value();
14996 return octave_value_list();
15051 octave_value_list _out;
15052 octave_value_list *_outp=&_out;
15053 octave_value _outv;
15060 if (
_n_dims( args(0) ) > 2 )
15062 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15064 temp1 = args(0).matrix_value();
15065 arg1 = &temp1( 0, 0 );
15073 arg4 =
static_cast< PLFLT >(val4);
15078 arg5 =
static_cast< PLFLT >(val5);
15083 arg6 =
static_cast< PLFLT >(val6);
15088 arg7 =
static_cast< PLFLT >(val7);
15093 arg8 =
static_cast< PLFLT >(val8);
15098 arg9 =
static_cast< PLFLT >(val9);
15103 arg10 =
static_cast< PLFLT >(val10);
15108 arg11 =
static_cast< PLFLT >(val11);
15113 arg12 =
static_cast< PLFLT >(val12);
15118 arg13 =
static_cast< PLFLT >(val13);
15119 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15120 _outv = octave_value();
15130 return octave_value_list();
15170 octave_value_list _out;
15171 octave_value_list *_outp=&_out;
15172 octave_value _outv;
15179 if (
_n_dims( args(0) ) > 2 )
15181 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15183 temp1 = args(0).matrix_value();
15184 arg1 = &temp1( 0, 0 );
15192 arg4 =
static_cast< PLFLT >(val4);
15197 arg5 =
static_cast< PLFLT >(val5);
15202 arg6 =
static_cast< PLFLT >(val6);
15207 arg7 =
static_cast< PLFLT >(val7);
15212 arg8 =
static_cast< PLFLT >(val8);
15217 arg9 =
static_cast< PLFLT >(val9);
15222 arg10 =
static_cast< PLFLT >(val10);
15227 arg11 =
static_cast< PLFLT >(val11);
15228 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15229 _outv = octave_value();
15239 return octave_value_list();
15281 octave_value_list _out;
15282 octave_value_list *_outp=&_out;
15283 octave_value _outv;
15290 if (
_n_dims( args(0) ) > 2 )
15292 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15294 temp1 = args(0).matrix_value();
15295 arg1 = &temp1( 0, 0 );
15303 arg4 =
static_cast< PLFLT >(val4);
15308 arg5 =
static_cast< PLFLT >(val5);
15313 arg6 =
static_cast< PLFLT >(val6);
15318 arg7 =
static_cast< PLFLT >(val7);
15323 arg8 =
static_cast< PLFLT >(val8);
15328 arg9 =
static_cast< PLFLT >(val9);
15333 arg10 =
static_cast< PLFLT >(val10);
15338 arg11 =
static_cast< PLFLT >(val11);
15340 if (
_n_dims( args(9) ) > 1 )
15344 if (
_dim( args(9), 0 ) != 6 )
15348 temp12 = args(9).matrix_value();
15349 arg12 = &temp12( 0, 0 );
15351 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15352 _outv = octave_value();
15368 return octave_value_list();
15415 octave_value_list _out;
15416 octave_value_list *_outp=&_out;
15417 octave_value _outv;
15424 if (
_n_dims( args(0) ) > 2 )
15426 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15428 temp1 = args(0).matrix_value();
15429 arg1 = &temp1( 0, 0 );
15437 arg4 =
static_cast< PLFLT >(val4);
15442 arg5 =
static_cast< PLFLT >(val5);
15447 arg6 =
static_cast< PLFLT >(val6);
15452 arg7 =
static_cast< PLFLT >(val7);
15457 arg8 =
static_cast< PLFLT >(val8);
15462 arg9 =
static_cast< PLFLT >(val9);
15467 arg10 =
static_cast< PLFLT >(val10);
15472 arg11 =
static_cast< PLFLT >(val11);
15474 if (
_n_dims( args(9) ) > 1 )
15482 temp12 = args(9).matrix_value();
15483 arg12 = &temp12( 0, 0 );
15486 if (
_n_dims( args(10) ) > 1 )
15490 if (
_dim( args(10), 0 ) !=
Ylen )
15494 temp13 = args(10).matrix_value();
15495 arg13 = &temp13( 0, 0 );
15497 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15498 _outv = octave_value();
15520 return octave_value_list();
15570 octave_value_list _out;
15571 octave_value_list *_outp=&_out;
15572 octave_value _outv;
15579 if (
_n_dims( args(0) ) > 2 )
15581 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15583 temp1 = args(0).matrix_value();
15584 arg1 = &temp1( 0, 0 );
15592 arg4 =
static_cast< PLFLT >(val4);
15597 arg5 =
static_cast< PLFLT >(val5);
15602 arg6 =
static_cast< PLFLT >(val6);
15607 arg7 =
static_cast< PLFLT >(val7);
15612 arg8 =
static_cast< PLFLT >(val8);
15617 arg9 =
static_cast< PLFLT >(val9);
15622 arg10 =
static_cast< PLFLT >(val10);
15627 arg11 =
static_cast< PLFLT >(val11);
15629 if (
_n_dims( args(9) ) > 2 )
15631 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15633 temp12 = args(9).matrix_value();
15634 arg12 = &temp12( 0, 0 );
15639 if (
_n_dims( args(10) ) > 2 )
15641 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15643 temp13 = args(10).matrix_value();
15644 arg13 = &temp13( 0, 0 );
15648 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15649 _outv = octave_value();
15671 return octave_value_list();
15706 char **arg18 = (
char **) 0 ;
15708 char **arg20 = (
char **) 0 ;
15748 octave_value_list _out;
15749 octave_value_list *_outp=&_out;
15750 octave_value _outv;
15762 arg3 =
static_cast< PLINT >(val3);
15767 arg4 =
static_cast< PLINT >(val4);
15772 arg5 =
static_cast< PLFLT >(val5);
15777 arg6 =
static_cast< PLFLT >(val6);
15782 arg7 =
static_cast< PLFLT >(val7);
15787 arg8 =
static_cast< PLFLT >(val8);
15792 arg9 =
static_cast< PLINT >(val9);
15797 arg10 =
static_cast< PLINT >(val10);
15802 arg11 =
static_cast< PLINT >(val11);
15807 arg12 =
static_cast< PLFLT >(val12);
15812 arg13 =
static_cast< PLFLT >(val13);
15817 arg14 =
static_cast< PLINT >(val14);
15822 arg15 =
static_cast< PLFLT >(val15);
15824 if (
_n_dims( args(13) ) > 1 )
15830 temp16 = args(13).matrix_value();
15834 charMatrix temp_matrix;
15838 size_t max_length = 0, non_blank_length;
15840 if (
_n_dims( args(14) ) > 2 )
15842 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15844#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15845 if ( !args(14).isempty() )
15847 if ( !args(14).is_empty() )
15850 if (
_dim( args(14), 0 ) !=
Alen )
15852 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15854 arg18 =
new char*[
Alen];
15855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15856 ifcell = args(14).iscell();
15858 ifcell = args(14).is_cell();
15862 temp_cell = args(14).cell_value();
15866 temp_matrix = args(14).char_matrix_value();
15868 max_length =
_dim( args(14), 1 ) + 1;
15871 for ( i = 0; i <
Alen; i++ )
15878 if ( temp_cell.elem( i ).is_string() )
15880 str = temp_cell.elem( i ).string_value();
15882 max_length = str.size() + 1;
15883 tmp_cstring = (
char *) str.c_str();
15893 tmp_cstring = (
char *)
"";
15898 str = temp_matrix.row_as_string( i );
15899 tmp_cstring = (
char *) str.c_str();
15901 arg18[i] =
new char[max_length];
15902 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15903 arg18[i][max_length - 1] =
'\0';
15918 non_blank_length = max_length - 2;
15919 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15921 non_blank_length--;
15923 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15925 non_blank_length--;
15927 arg18[i][non_blank_length + 1] =
'\0';
15937 charMatrix temp_matrix;
15941 size_t max_length = 0, non_blank_length;
15943 if (
_n_dims( args(15) ) > 2 )
15945 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15947#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15948 if ( !args(15).isempty() )
15950 if ( !args(15).is_empty() )
15955 arg20 =
new char*[
Alen];
15956#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15957 ifcell = args(15).iscell();
15959 ifcell = args(15).is_cell();
15963 temp_cell = args(15).cell_value();
15967 temp_matrix = args(15).char_matrix_value();
15969 max_length =
_dim( args(15), 1 ) + 1;
15972 for ( i = 0; i <
Alen; i++ )
15979 if ( temp_cell.elem( i ).is_string() )
15981 str = temp_cell.elem( i ).string_value();
15983 max_length = str.size() + 1;
15984 tmp_cstring = (
char *) str.c_str();
15994 tmp_cstring = (
char *)
"";
15999 str = temp_matrix.row_as_string( i );
16000 tmp_cstring = (
char *) str.c_str();
16002 arg20[i] =
new char[max_length];
16003 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16004 arg20[i][max_length - 1] =
'\0';
16019 non_blank_length = max_length - 2;
16020 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16022 non_blank_length--;
16024 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16026 non_blank_length--;
16028 arg20[i][non_blank_length + 1] =
'\0';
16039 if (
_n_dims( args(16) ) > 1 )
16043 if (
_dim( args(16), 0 ) !=
Alen )
16047 temp21 = args(16).matrix_value();
16048 arg21 = &temp21( 0, 0 );
16051 if (
_n_dims( args(17) ) > 1 )
16055 if (
_dim( args(17), 0 ) !=
Alen )
16059 temp22 = args(17).matrix_value();
16065 if (
_n_dims( args(18) ) > 1 )
16069 if (
_dim( args(18), 0 ) !=
Alen )
16074 temp23 = args(18).matrix_value();
16078 for ( i = 0; i <
Xlen; i++ )
16079 if ( arg23[i] >
Ylen )
16083 if (
_n_dims( args(19) ) > 2 )
16085 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16087 if (
_dim( args(19), 0 ) !=
Xlen )
16089 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16091 if (
_dim( args(19), 1 ) !=
Ylen )
16093 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16095 temp24 = args(19).matrix_value();
16096 arg24 = &temp24( 0, 0 );
16098 my_plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(
int const *)arg17,(
char const **)arg18,arg19,(
char const **)arg20,(
double const *)arg21,(
int const *)arg22,(
int const *)arg23,(
double const *)arg24);
16099 _outv = octave_value();
16118 if ( arg18 != NULL )
16120 for ( i = 0; i <
Alen; i++ )
16129 if ( arg20 != NULL )
16131 for ( i = 0; i <
Alen; i++ )
16157 if ( arg18 != NULL )
16159 for ( i = 0; i <
Alen; i++ )
16168 if ( arg20 != NULL )
16170 for ( i = 0; i <
Alen; i++ )
16189 return octave_value_list();
16197 if ( arg18 != NULL )
16199 for ( i = 0; i <
Alen; i++ )
16208 if ( arg20 != NULL )
16210 for ( i = 0; i <
Alen; i++ )
16241 octave_value_list _out;
16242 octave_value_list *_outp=&_out;
16243 octave_value _outv;
16258 arg2 =
static_cast< int >(val2);
16259 if (arg1) (arg1)->type = arg2;
16260 _outv = octave_value();
16264 return octave_value_list();
16276 octave_value_list _out;
16277 octave_value_list *_outp=&_out;
16278 octave_value _outv;
16290 result = (int) ((arg1)->type);
16295 return octave_value_list();
16305 unsigned int arg2 ;
16308 unsigned int val2 ;
16310 octave_value_list _out;
16311 octave_value_list *_outp=&_out;
16312 octave_value _outv;
16327 arg2 =
static_cast< unsigned int >(val2);
16328 if (arg1) (arg1)->state = arg2;
16329 _outv = octave_value();
16333 return octave_value_list();
16345 octave_value_list _out;
16346 octave_value_list *_outp=&_out;
16347 octave_value _outv;
16348 unsigned int result;
16359 result = (
unsigned int) ((arg1)->state);
16364 return octave_value_list();
16374 unsigned int arg2 ;
16377 unsigned int val2 ;
16379 octave_value_list _out;
16380 octave_value_list *_outp=&_out;
16381 octave_value _outv;
16396 arg2 =
static_cast< unsigned int >(val2);
16397 if (arg1) (arg1)->keysym = arg2;
16398 _outv = octave_value();
16402 return octave_value_list();
16414 octave_value_list _out;
16415 octave_value_list *_outp=&_out;
16416 octave_value _outv;
16417 unsigned int result;
16428 result = (
unsigned int) ((arg1)->keysym);
16433 return octave_value_list();
16443 unsigned int arg2 ;
16446 unsigned int val2 ;
16448 octave_value_list _out;
16449 octave_value_list *_outp=&_out;
16450 octave_value _outv;
16465 arg2 =
static_cast< unsigned int >(val2);
16466 if (arg1) (arg1)->button = arg2;
16467 _outv = octave_value();
16471 return octave_value_list();
16483 octave_value_list _out;
16484 octave_value_list *_outp=&_out;
16485 octave_value _outv;
16486 unsigned int result;
16497 result = (
unsigned int) ((arg1)->button);
16502 return octave_value_list();
16517 octave_value_list _out;
16518 octave_value_list *_outp=&_out;
16519 octave_value _outv;
16534 arg2 =
static_cast< PLINT >(val2);
16535 if (arg1) (arg1)->subwindow = arg2;
16536 _outv = octave_value();
16540 return octave_value_list();
16552 octave_value_list _out;
16553 octave_value_list *_outp=&_out;
16554 octave_value _outv;
16566 result = (
PLINT) ((arg1)->subwindow);
16571 return octave_value_list();
16581 char *arg2 = (
char *) (
char *)0 ;
16586 octave_value_list _out;
16587 octave_value_list *_outp=&_out;
16588 octave_value _outv;
16603 arg2 =
reinterpret_cast< char *
>(temp2);
16604 if (arg2) memcpy(arg1->string,arg2,16*
sizeof(
char));
16605 else memset(arg1->string,0,16*
sizeof(
char));
16606 _outv = octave_value();
16610 return octave_value_list();
16622 octave_value_list _out;
16623 octave_value_list *_outp=&_out;
16624 octave_value _outv;
16636 result = (
char *)(
char *) ((arg1)->
string);
16647 return octave_value_list();
16662 octave_value_list _out;
16663 octave_value_list *_outp=&_out;
16664 octave_value _outv;
16679 arg2 =
static_cast< int >(val2);
16680 if (arg1) (arg1)->pX = arg2;
16681 _outv = octave_value();
16685 return octave_value_list();
16697 octave_value_list _out;
16698 octave_value_list *_outp=&_out;
16699 octave_value _outv;
16711 result = (int) ((arg1)->pX);
16716 return octave_value_list();
16731 octave_value_list _out;
16732 octave_value_list *_outp=&_out;
16733 octave_value _outv;
16748 arg2 =
static_cast< int >(val2);
16749 if (arg1) (arg1)->pY = arg2;
16750 _outv = octave_value();
16754 return octave_value_list();
16766 octave_value_list _out;
16767 octave_value_list *_outp=&_out;
16768 octave_value _outv;
16780 result = (int) ((arg1)->pY);
16785 return octave_value_list();
16800 octave_value_list _out;
16801 octave_value_list *_outp=&_out;
16802 octave_value _outv;
16817 arg2 =
static_cast< PLFLT >(val2);
16818 if (arg1) (arg1)->dX = arg2;
16819 _outv = octave_value();
16823 return octave_value_list();
16835 octave_value_list _out;
16836 octave_value_list *_outp=&_out;
16837 octave_value _outv;
16849 result = (
PLFLT) ((arg1)->dX);
16854 return octave_value_list();
16869 octave_value_list _out;
16870 octave_value_list *_outp=&_out;
16871 octave_value _outv;
16886 arg2 =
static_cast< PLFLT >(val2);
16887 if (arg1) (arg1)->dY = arg2;
16888 _outv = octave_value();
16892 return octave_value_list();
16904 octave_value_list _out;
16905 octave_value_list *_outp=&_out;
16906 octave_value _outv;
16918 result = (
PLFLT) ((arg1)->dY);
16923 return octave_value_list();
16938 octave_value_list _out;
16939 octave_value_list *_outp=&_out;
16940 octave_value _outv;
16955 arg2 =
static_cast< PLFLT >(val2);
16956 if (arg1) (arg1)->wX = arg2;
16957 _outv = octave_value();
16961 return octave_value_list();
16973 octave_value_list _out;
16974 octave_value_list *_outp=&_out;
16975 octave_value _outv;
16987 result = (
PLFLT) ((arg1)->wX);
16992 return octave_value_list();
17007 octave_value_list _out;
17008 octave_value_list *_outp=&_out;
17009 octave_value _outv;
17024 arg2 =
static_cast< PLFLT >(val2);
17025 if (arg1) (arg1)->wY = arg2;
17026 _outv = octave_value();
17030 return octave_value_list();
17042 octave_value_list _out;
17043 octave_value_list *_outp=&_out;
17044 octave_value _outv;
17056 result = (
PLFLT) ((arg1)->wY);
17061 return octave_value_list();
17070 octave_value_list _out;
17071 octave_value_list *_outp=&_out;
17072 octave_value _outv;
17084 return octave_value_list();
17096 octave_value_list _out;
17097 octave_value_list *_outp=&_out;
17098 octave_value _outv;
17110 _outv = octave_value();
17114 return octave_value_list();
17148 octave_value_list _out;
17149 octave_value_list *_outp=&_out;
17150 octave_value _outv;
17160 arg1 =
static_cast< PLINT >(val1);
17165 arg2 =
static_cast< PLINT >(val2);
17167 _outv = octave_value();
17171 return octave_value_list();
17192 octave_value_list _out;
17193 octave_value_list *_outp=&_out;
17194 octave_value _outv;
17204 arg1 =
static_cast< PLFLT >(val1);
17209 arg2 =
static_cast< PLFLT >(val2);
17214 arg3 =
static_cast< PLFLT >(val3);
17219 arg4 =
static_cast< PLINT >(val4);
17221 _outv = octave_value();
17225 return octave_value_list();
17237 octave_value_list _out;
17238 octave_value_list *_outp=&_out;
17239 octave_value _outv;
17249 arg1 =
static_cast< PLINT >(val1);
17251 _outv = octave_value();
17255 return octave_value_list();
17288 octave_value_list _out;
17289 octave_value_list *_outp=&_out;
17290 octave_value _outv;
17300 arg1 =
static_cast< PLFLT >(val1);
17305 arg2 =
static_cast< PLFLT >(val2);
17310 arg3 =
static_cast< PLFLT >(val3);
17315 arg4 =
static_cast< PLFLT >(val4);
17320 arg5 =
static_cast< PLFLT >(val5);
17325 arg6 =
static_cast< PLFLT >(val6);
17330 arg7 =
static_cast< PLFLT >(val7);
17335 arg8 =
static_cast< PLBOOL >(val8);
17336 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17337 _outv = octave_value();
17341 return octave_value_list();
17352 char *arg3 = (
char *) 0 ;
17355 char *arg6 = (
char *) 0 ;
17376 octave_value_list _out;
17377 octave_value_list *_outp=&_out;
17378 octave_value _outv;
17388 arg1 =
static_cast< PLFLT >(val1);
17393 arg2 =
static_cast< PLFLT >(val2);
17398 arg3 =
reinterpret_cast< char *
>(buf3);
17403 arg4 =
static_cast< PLFLT >(val4);
17408 arg5 =
static_cast< PLINT >(val5);
17413 arg6 =
reinterpret_cast< char *
>(buf6);
17418 arg7 =
static_cast< PLFLT >(val7);
17423 arg8 =
static_cast< PLINT >(val8);
17424 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17425 _outv = octave_value();
17433 return octave_value_list();
17452 octave_value_list _out;
17453 octave_value_list *_outp=&_out;
17454 octave_value _outv;
17461 if (
_n_dims( args(0) ) > 1 )
17466 temp1 = args(0).matrix_value();
17467 arg2 = &temp1( 0, 0 );
17470 if (
_n_dims( args(1) ) > 1 )
17478 temp3 = args(1).matrix_value();
17479 arg3 = &temp3( 0, 0 );
17485 arg4 =
static_cast< PLINT >(val4);
17486 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17487 _outv = octave_value();
17503 return octave_value_list();
17539 octave_value_list _out;
17540 octave_value_list *_outp=&_out;
17541 octave_value _outv;
17557 arg7 =
static_cast< PLFLT >(val7);
17558 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17559 _outv = octave_value();
17599 return octave_value_list();
17608 octave_value_list _out;
17609 octave_value_list *_outp=&_out;
17610 octave_value _outv;
17617 _outv = octave_value();
17621 return octave_value_list();
17630 char *arg1 = (
char *) 0 ;
17633 char *arg4 = (
char *) 0 ;
17650 octave_value_list _out;
17651 octave_value_list *_outp=&_out;
17652 octave_value _outv;
17662 arg1 =
reinterpret_cast< char *
>(buf1);
17667 arg2 =
static_cast< PLFLT >(val2);
17672 arg3 =
static_cast< PLINT >(val3);
17677 arg4 =
reinterpret_cast< char *
>(buf4);
17682 arg5 =
static_cast< PLFLT >(val5);
17687 arg6 =
static_cast< PLINT >(val6);
17688 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17689 _outv = octave_value();
17697 return octave_value_list();
17708 char *arg1 = (
char *) 0 ;
17709 char *arg2 = (
char *) 0 ;
17712 char *arg5 = (
char *) 0 ;
17713 char *arg6 = (
char *) 0 ;
17716 char *arg9 = (
char *) 0 ;
17717 char *arg10 = (
char *) 0 ;
17750 octave_value_list _out;
17751 octave_value_list *_outp=&_out;
17752 octave_value _outv;
17762 arg1 =
reinterpret_cast< char *
>(buf1);
17767 arg2 =
reinterpret_cast< char *
>(buf2);
17772 arg3 =
static_cast< PLFLT >(val3);
17777 arg4 =
static_cast< PLINT >(val4);
17782 arg5 =
reinterpret_cast< char *
>(buf5);
17787 arg6 =
reinterpret_cast< char *
>(buf6);
17792 arg7 =
static_cast< PLFLT >(val7);
17797 arg8 =
static_cast< PLINT >(val8);
17802 arg9 =
reinterpret_cast< char *
>(buf9);
17807 arg10 =
reinterpret_cast< char *
>(buf10);
17812 arg11 =
static_cast< PLFLT >(val11);
17817 arg12 =
static_cast< PLINT >(val12);
17818 plbox3((
char const *)arg1,(
char const *)arg2,arg3,arg4,(
char const *)arg5,(
char const *)arg6,arg7,arg8,(
char const *)arg9,(
char const *)arg10,arg11,arg12);
17819 _outv = octave_value();
17835 return octave_value_list();
17865 octave_value_list _out;
17866 octave_value_list *_outp=&_out;
17867 octave_value _outv;
17880 arg1 =
static_cast< PLFLT >(val1);
17885 arg2 =
static_cast< PLFLT >(val2);
17887 _outv = octave_value();
17909 return octave_value_list();
17918 octave_value_list _out;
17919 octave_value_list *_outp=&_out;
17920 octave_value _outv;
17927 _outv = octave_value();
17931 return octave_value_list();
17943 octave_value_list _out;
17944 octave_value_list *_outp=&_out;
17945 octave_value _outv;
17955 arg1 =
static_cast< PLINT >(val1);
17957 _outv = octave_value();
17961 return octave_value_list();
17973 octave_value_list _out;
17974 octave_value_list *_outp=&_out;
17975 octave_value _outv;
17985 arg1 =
static_cast< PLFLT >(val1);
17987 _outv = octave_value();
17991 return octave_value_list();
18033 octave_value_list _out;
18034 octave_value_list *_outp=&_out;
18035 octave_value _outv;
18045 arg1 =
static_cast< PLFLT >(val1);
18050 arg2 =
static_cast< PLFLT >(val2);
18055 arg3 =
static_cast< PLFLT >(val3);
18060 arg4 =
static_cast< PLINT >(val4);
18065 arg5 =
static_cast< PLBOOL >(val5);
18070 arg6 =
static_cast< PLINT >(val6);
18075 arg7 =
static_cast< PLINT >(val7);
18080 arg8 =
static_cast< PLINT >(val8);
18085 arg9 =
static_cast< PLINT >(val9);
18090 arg10 =
static_cast< PLINT >(val10);
18095 arg11 =
static_cast< PLFLT >(val11);
18096 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18097 _outv = octave_value();
18101 return octave_value_list();
18131 octave_value_list _out;
18132 octave_value_list *_outp=&_out;
18133 octave_value _outv;
18144 arg1 =
static_cast< PLINT >(val1);
18149 arg2 =
static_cast< PLINT >(val2);
18154 arg3 =
static_cast< PLINT >(val3);
18159 arg4 =
static_cast< PLINT >(val4);
18164 arg5 =
static_cast< PLINT >(val5);
18169 arg6 =
static_cast< PLFLT >(val6);
18170 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18171 _outv = octave_value();
18181 return octave_value_list();
18196 octave_value_list _out;
18197 octave_value_list *_outp=&_out;
18198 octave_value _outv;
18208 arg1 =
static_cast< PLINT >(val1);
18213 arg2 =
static_cast< PLBOOL >(val2);
18215 _outv = octave_value();
18219 return octave_value_list();
18228 octave_value_list _out;
18229 octave_value_list *_outp=&_out;
18230 octave_value _outv;
18237 _outv = octave_value();
18241 return octave_value_list();
18250 octave_value_list _out;
18251 octave_value_list *_outp=&_out;
18252 octave_value _outv;
18259 _outv = octave_value();
18263 return octave_value_list();
18290 octave_value_list _out;
18291 octave_value_list *_outp=&_out;
18292 octave_value _outv;
18302 arg1 =
static_cast< PLFLT >(val1);
18307 arg2 =
static_cast< PLFLT >(val2);
18312 arg3 =
static_cast< PLFLT >(val3);
18317 arg4 =
static_cast< PLFLT >(val4);
18322 arg5 =
static_cast< PLINT >(val5);
18327 arg6 =
static_cast< PLINT >(val6);
18328 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18329 _outv = octave_value();
18333 return octave_value_list();
18360 octave_value_list _out;
18361 octave_value_list *_outp=&_out;
18362 octave_value _outv;
18372 arg1 =
static_cast< PLFLT >(val1);
18377 arg2 =
static_cast< PLFLT >(val2);
18382 arg3 =
static_cast< PLFLT >(val3);
18387 arg4 =
static_cast< PLFLT >(val4);
18392 arg5 =
static_cast< PLINT >(val5);
18397 arg6 =
static_cast< PLINT >(val6);
18398 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18399 _outv = octave_value();
18403 return octave_value_list();
18412 octave_value_list _out;
18413 octave_value_list *_outp=&_out;
18414 octave_value _outv;
18421 _outv = octave_value();
18425 return octave_value_list();
18441 octave_value_list _out;
18442 octave_value_list *_outp=&_out;
18443 octave_value _outv;
18450 if (
_n_dims( args(0) ) > 1 )
18455 temp1 = args(0).matrix_value();
18456 arg2 = &temp1( 0, 0 );
18459 if (
_n_dims( args(1) ) > 1 )
18467 temp3 = args(1).matrix_value();
18468 arg3 = &temp3( 0, 0 );
18471 if (
_n_dims( args(2) ) > 1 )
18479 temp4 = args(2).matrix_value();
18480 arg4 = &temp4( 0, 0 );
18482 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18483 _outv = octave_value();
18505 return octave_value_list();
18530 octave_value_list _out;
18531 octave_value_list *_outp=&_out;
18532 octave_value _outv;
18539 if (
_n_dims( args(0) ) > 1 )
18544 temp1 = args(0).matrix_value();
18545 arg2 = &temp1( 0, 0 );
18548 if (
_n_dims( args(1) ) > 1 )
18556 temp3 = args(1).matrix_value();
18557 arg3 = &temp3( 0, 0 );
18560 if (
_n_dims( args(2) ) > 1 )
18568 temp4 = args(2).matrix_value();
18569 arg4 = &temp4( 0, 0 );
18571 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18572 _outv = octave_value();
18594 return octave_value_list();
18612 octave_value_list _out;
18613 octave_value_list *_outp=&_out;
18614 octave_value _outv;
18621 _outv = octave_value();
18625 return octave_value_list();
18639 octave_value_list _out;
18640 octave_value_list *_outp=&_out;
18641 octave_value _outv;
18648 if (
_n_dims( args(0) ) > 1 )
18653 temp1 = args(0).matrix_value();
18654 arg2 = &temp1( 0, 0 );
18657 if (
_n_dims( args(1) ) > 1 )
18665 temp3 = args(1).matrix_value();
18666 arg3 = &temp3( 0, 0 );
18668 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18669 _outv = octave_value();
18685 return octave_value_list();
18707 octave_value_list _out;
18708 octave_value_list *_outp=&_out;
18709 octave_value _outv;
18716 if (
_n_dims( args(0) ) > 1 )
18721 temp1 = args(0).matrix_value();
18722 arg2 = &temp1( 0, 0 );
18725 if (
_n_dims( args(1) ) > 1 )
18733 temp3 = args(1).matrix_value();
18734 arg3 = &temp3( 0, 0 );
18737 if (
_n_dims( args(2) ) > 1 )
18745 temp4 = args(2).matrix_value();
18746 arg4 = &temp4( 0, 0 );
18748 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18749 _outv = octave_value();
18771 return octave_value_list();
18797 octave_value_list _out;
18798 octave_value_list *_outp=&_out;
18799 octave_value _outv;
18806 if (
_n_dims( args(0) ) > 1 )
18811 temp1 = args(0).matrix_value();
18812 arg2 = &temp1( 0, 0 );
18815 if (
_n_dims( args(1) ) > 1 )
18823 temp3 = args(1).matrix_value();
18824 arg3 = &temp3( 0, 0 );
18830 arg4 =
static_cast< PLFLT >(val4);
18831 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18832 _outv = octave_value();
18848 return octave_value_list();
18863 octave_value_list _out;
18864 octave_value_list *_outp=&_out;
18865 octave_value _outv;
18872 _outv = octave_value();
18876 return octave_value_list();
18888 octave_value_list _out;
18889 octave_value_list *_outp=&_out;
18890 octave_value _outv;
18900 arg1 =
static_cast< PLINT >(val1);
18902 _outv = octave_value();
18906 return octave_value_list();
18918 octave_value_list _out;
18919 octave_value_list *_outp=&_out;
18920 octave_value _outv;
18930 arg1 =
static_cast< PLINT >(val1);
18932 _outv = octave_value();
18936 return octave_value_list();
18951 octave_value_list _out;
18952 octave_value_list *_outp=&_out;
18953 octave_value _outv;
18962 _outv = octave_value();
18978 return octave_value_list();
18999 octave_value_list _out;
19000 octave_value_list *_outp=&_out;
19001 octave_value _outv;
19014 arg1 =
static_cast< PLINT >(val1);
19015 plgcol0(arg1,arg2,arg3,arg4);
19016 _outv = octave_value();
19038 return octave_value_list();
19062 octave_value_list _out;
19063 octave_value_list *_outp=&_out;
19064 octave_value _outv;
19078 arg1 =
static_cast< PLINT >(val1);
19079 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19080 _outv = octave_value();
19108 return octave_value_list();
19126 octave_value_list _out;
19127 octave_value_list *_outp=&_out;
19128 octave_value _outv;
19138 _outv = octave_value();
19160 return octave_value_list();
19181 octave_value_list _out;
19182 octave_value_list *_outp=&_out;
19183 octave_value _outv;
19194 _outv = octave_value();
19222 return octave_value_list();
19234 octave_value_list _out;
19235 octave_value_list *_outp=&_out;
19236 octave_value _outv;
19244 _outv = octave_value();
19254 return octave_value_list();
19263 char *arg1 = (
char *) 0 ;
19264 char local_string1[80] ;
19265 size_t local_string_length1 ;
19266 charMatrix local_charMatrix1 ;
19267 octave_value_list retval1 ;
19268 octave_value_list _out;
19269 octave_value_list *_outp=&_out;
19270 octave_value _outv;
19274 arg1 = local_string1;
19280 _outv = octave_value();
19283 local_string_length1 = strlen( local_string1 );
19284 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19285 local_charMatrix1.insert( local_string1, 0, 0 );
19286 retval1( 0 ) = octave_value( local_charMatrix1 );
19291 return octave_value_list();
19312 octave_value_list _out;
19313 octave_value_list *_outp=&_out;
19314 octave_value _outv;
19325 _outv = octave_value();
19353 return octave_value_list();
19365 octave_value_list _out;
19366 octave_value_list *_outp=&_out;
19367 octave_value _outv;
19375 _outv = octave_value();
19385 return octave_value_list();
19406 octave_value_list _out;
19407 octave_value_list *_outp=&_out;
19408 octave_value _outv;
19419 _outv = octave_value();
19447 return octave_value_list();
19465 octave_value_list _out;
19466 octave_value_list *_outp=&_out;
19467 octave_value _outv;
19477 _outv = octave_value();
19499 return octave_value_list();
19511 octave_value_list _out;
19512 octave_value_list *_outp=&_out;
19513 octave_value _outv;
19521 _outv = octave_value();
19531 return octave_value_list();
19540 char *arg1 = (
char *) 0 ;
19541 char local_string1[80] ;
19542 size_t local_string_length1 ;
19543 charMatrix local_charMatrix1 ;
19544 octave_value_list retval1 ;
19545 octave_value_list _out;
19546 octave_value_list *_outp=&_out;
19547 octave_value _outv;
19551 arg1 = local_string1;
19557 _outv = octave_value();
19560 local_string_length1 = strlen( local_string1 );
19561 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19562 local_charMatrix1.insert( local_string1, 0, 0 );
19563 retval1( 0 ) = octave_value( local_charMatrix1 );
19568 return octave_value_list();
19586 octave_value_list _out;
19587 octave_value_list *_outp=&_out;
19588 octave_value _outv;
19598 _outv = octave_value();
19620 return octave_value_list();
19632 octave_value_list _out;
19633 octave_value_list *_outp=&_out;
19634 octave_value _outv;
19642 _outv = octave_value();
19652 return octave_value_list();
19679 octave_value_list _out;
19680 octave_value_list *_outp=&_out;
19681 octave_value _outv;
19693 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19694 _outv = octave_value();
19734 return octave_value_list();
19743 octave_value_list _out;
19744 octave_value_list *_outp=&_out;
19745 octave_value _outv;
19752 _outv = octave_value();
19756 return octave_value_list();
19777 octave_value_list _out;
19778 octave_value_list *_outp=&_out;
19779 octave_value _outv;
19789 plgspa(arg1,arg2,arg3,arg4);
19790 _outv = octave_value();
19818 return octave_value_list();
19830 octave_value_list _out;
19831 octave_value_list *_outp=&_out;
19832 octave_value _outv;
19840 _outv = octave_value();
19850 return octave_value_list();
19859 char *arg1 = (
char *) 0 ;
19860 char local_string1[80] ;
19861 size_t local_string_length1 ;
19862 charMatrix local_charMatrix1 ;
19863 octave_value_list retval1 ;
19864 octave_value_list _out;
19865 octave_value_list *_outp=&_out;
19866 octave_value _outv;
19870 arg1 = local_string1;
19876 _outv = octave_value();
19879 local_string_length1 = strlen( local_string1 );
19880 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19881 local_charMatrix1.insert( local_string1, 0, 0 );
19882 retval1( 0 ) = octave_value( local_charMatrix1 );
19887 return octave_value_list();
19908 octave_value_list _out;
19909 octave_value_list *_outp=&_out;
19910 octave_value _outv;
19920 plgvpd(arg1,arg2,arg3,arg4);
19921 _outv = octave_value();
19949 return octave_value_list();
19970 octave_value_list _out;
19971 octave_value_list *_outp=&_out;
19972 octave_value _outv;
19982 plgvpw(arg1,arg2,arg3,arg4);
19983 _outv = octave_value();
20011 return octave_value_list();
20026 octave_value_list _out;
20027 octave_value_list *_outp=&_out;
20028 octave_value _outv;
20037 _outv = octave_value();
20053 return octave_value_list();
20068 octave_value_list _out;
20069 octave_value_list *_outp=&_out;
20070 octave_value _outv;
20079 _outv = octave_value();
20095 return octave_value_list();
20110 octave_value_list _out;
20111 octave_value_list *_outp=&_out;
20112 octave_value _outv;
20121 _outv = octave_value();
20137 return octave_value_list();
20161 octave_value_list _out;
20162 octave_value_list *_outp=&_out;
20163 octave_value _outv;
20170 if (
_n_dims( args(0) ) > 1 )
20175 temp1 = args(0).matrix_value();
20176 arg2 = &temp1( 0, 0 );
20182 arg3 =
static_cast< PLFLT >(val3);
20187 arg4 =
static_cast< PLFLT >(val4);
20192 arg5 =
static_cast< PLINT >(val5);
20197 arg6 =
static_cast< PLINT >(val6);
20198 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20199 _outv = octave_value();
20209 return octave_value_list();
20239 octave_value_list _out;
20240 octave_value_list *_outp=&_out;
20241 octave_value _outv;
20254 arg1 =
static_cast< PLFLT >(val1);
20259 arg2 =
static_cast< PLFLT >(val2);
20264 arg3 =
static_cast< PLFLT >(val3);
20265 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20266 _outv = octave_value();
20288 return octave_value_list();
20297 octave_value_list _out;
20298 octave_value_list *_outp=&_out;
20299 octave_value _outv;
20306 _outv = octave_value();
20310 return octave_value_list();
20331 octave_value_list _out;
20332 octave_value_list *_outp=&_out;
20333 octave_value _outv;
20343 arg1 =
static_cast< PLFLT >(val1);
20348 arg2 =
static_cast< PLFLT >(val2);
20353 arg3 =
static_cast< PLFLT >(val3);
20358 arg4 =
static_cast< PLFLT >(val4);
20359 pljoin(arg1,arg2,arg3,arg4);
20360 _outv = octave_value();
20364 return octave_value_list();
20373 char *arg1 = (
char *) 0 ;
20374 char *arg2 = (
char *) 0 ;
20375 char *arg3 = (
char *) 0 ;
20385 octave_value_list _out;
20386 octave_value_list *_outp=&_out;
20387 octave_value _outv;
20397 arg1 =
reinterpret_cast< char *
>(buf1);
20402 arg2 =
reinterpret_cast< char *
>(buf2);
20407 arg3 =
reinterpret_cast< char *
>(buf3);
20408 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20409 _outv = octave_value();
20419 return octave_value_list();
20450 char **arg20 = (
char **) 0 ;
20461 char **arg31 = (
char **) 0 ;
20506 octave_value_list _out;
20507 octave_value_list *_outp=&_out;
20508 octave_value _outv;
20520 arg3 =
static_cast< PLINT >(val3);
20525 arg4 =
static_cast< PLINT >(val4);
20530 arg5 =
static_cast< PLFLT >(val5);
20535 arg6 =
static_cast< PLFLT >(val6);
20540 arg7 =
static_cast< PLFLT >(val7);
20545 arg8 =
static_cast< PLINT >(val8);
20550 arg9 =
static_cast< PLINT >(val9);
20555 arg10 =
static_cast< PLINT >(val10);
20560 arg11 =
static_cast< PLINT >(val11);
20565 arg12 =
static_cast< PLINT >(val12);
20567 if (
_n_dims( args(10) ) > 1 )
20573 temp13 = args(10).matrix_value();
20580 arg15 =
static_cast< PLFLT >(val15);
20585 arg16 =
static_cast< PLFLT >(val16);
20590 arg17 =
static_cast< PLFLT >(val17);
20595 arg18 =
static_cast< PLFLT >(val18);
20597 if (
_n_dims( args(15) ) > 1 )
20601 if (
_dim( args(15), 0 ) !=
Alen )
20605 temp19 = args(15).matrix_value();
20610 charMatrix temp_matrix;
20614 size_t max_length = 0, non_blank_length;
20616 if (
_n_dims( args(16) ) > 2 )
20618 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20620#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20621 if ( !args(16).isempty() )
20623 if ( !args(16).is_empty() )
20626 if (
_dim( args(16), 0 ) !=
Alen )
20628 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20630 arg20 =
new char*[
Alen];
20631#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20632 ifcell = args(16).iscell();
20634 ifcell = args(16).is_cell();
20638 temp_cell = args(16).cell_value();
20642 temp_matrix = args(16).char_matrix_value();
20644 max_length =
_dim( args(16), 1 ) + 1;
20647 for ( i = 0; i <
Alen; i++ )
20654 if ( temp_cell.elem( i ).is_string() )
20656 str = temp_cell.elem( i ).string_value();
20658 max_length = str.size() + 1;
20659 tmp_cstring = (
char *) str.c_str();
20669 tmp_cstring = (
char *)
"";
20674 str = temp_matrix.row_as_string( i );
20675 tmp_cstring = (
char *) str.c_str();
20677 arg20[i] =
new char[max_length];
20678 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20679 arg20[i][max_length - 1] =
'\0';
20694 non_blank_length = max_length - 2;
20695 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20697 non_blank_length--;
20699 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20701 non_blank_length--;
20703 arg20[i][non_blank_length + 1] =
'\0';
20713 if (
_n_dims( args(17) ) > 1 )
20717#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20718 if ( !args(17).isempty() )
20720 if ( !args(17).is_empty() )
20723 if (
_dim( args(17), 0 ) !=
Alen )
20727 temp21 = args(17).matrix_value();
20737 if (
_n_dims( args(18) ) > 1 )
20741#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20742 if ( !args(18).isempty() )
20744 if ( !args(18).is_empty() )
20747 if (
_dim( args(18), 0 ) !=
Alen )
20751 temp22 = args(18).matrix_value();
20761 if (
_n_dims( args(19) ) > 1 )
20765#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20766 if ( !args(19).isempty() )
20768 if ( !args(19).is_empty() )
20771 if (
_dim( args(19), 0 ) !=
Alen )
20775 temp23 = args(19).matrix_value();
20776 arg23 = &temp23( 0, 0 );
20784 if (
_n_dims( args(20) ) > 1 )
20788#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20789 if ( !args(20).isempty() )
20791 if ( !args(20).is_empty() )
20794 if (
_dim( args(20), 0 ) !=
Alen )
20798 temp24 = args(20).matrix_value();
20799 arg24 = &temp24( 0, 0 );
20807 if (
_n_dims( args(21) ) > 1 )
20811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20812 if ( !args(21).isempty() )
20814 if ( !args(21).is_empty() )
20817 if (
_dim( args(21), 0 ) !=
Alen )
20821 temp25 = args(21).matrix_value();
20831 if (
_n_dims( args(22) ) > 1 )
20835#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20836 if ( !args(22).isempty() )
20838 if ( !args(22).is_empty() )
20841 if (
_dim( args(22), 0 ) !=
Alen )
20845 temp26 = args(22).matrix_value();
20855 if (
_n_dims( args(23) ) > 1 )
20859#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20860 if ( !args(23).isempty() )
20862 if ( !args(23).is_empty() )
20865 if (
_dim( args(23), 0 ) !=
Alen )
20869 temp27 = args(23).matrix_value();
20870 arg27 = &temp27( 0, 0 );
20878 if (
_n_dims( args(24) ) > 1 )
20882#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20883 if ( !args(24).isempty() )
20885 if ( !args(24).is_empty() )
20888 if (
_dim( args(24), 0 ) !=
Alen )
20892 temp28 = args(24).matrix_value();
20902 if (
_n_dims( args(25) ) > 1 )
20906#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20907 if ( !args(25).isempty() )
20909 if ( !args(25).is_empty() )
20912 if (
_dim( args(25), 0 ) !=
Alen )
20916 temp29 = args(25).matrix_value();
20917 arg29 = &temp29( 0, 0 );
20925 if (
_n_dims( args(26) ) > 1 )
20929#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20930 if ( !args(26).isempty() )
20932 if ( !args(26).is_empty() )
20935 if (
_dim( args(26), 0 ) !=
Alen )
20939 temp30 = args(26).matrix_value();
20949 charMatrix temp_matrix;
20953 size_t max_length = 0, non_blank_length;
20955 if (
_n_dims( args(27) ) > 2 )
20957 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20959#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20960 if ( !args(27).isempty() )
20962 if ( !args(27).is_empty() )
20965 if (
_dim( args(27), 0 ) !=
Alen )
20967 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20969 arg31 =
new char*[
Alen];
20970#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20971 ifcell = args(27).iscell();
20973 ifcell = args(27).is_cell();
20977 temp_cell = args(27).cell_value();
20981 temp_matrix = args(27).char_matrix_value();
20983 max_length =
_dim( args(27), 1 ) + 1;
20986 for ( i = 0; i <
Alen; i++ )
20993 if ( temp_cell.elem( i ).is_string() )
20995 str = temp_cell.elem( i ).string_value();
20997 max_length = str.size() + 1;
20998 tmp_cstring = (
char *) str.c_str();
21008 tmp_cstring = (
char *)
"";
21013 str = temp_matrix.row_as_string( i );
21014 tmp_cstring = (
char *) str.c_str();
21016 arg31[i] =
new char[max_length];
21017 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21018 arg31[i][max_length - 1] =
'\0';
21033 non_blank_length = max_length - 2;
21034 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
21036 non_blank_length--;
21038 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
21040 non_blank_length--;
21042 arg31[i][non_blank_length + 1] =
'\0';
21051 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(
int const *)arg14,arg15,arg16,arg17,arg18,(
int const *)arg19,(
char const **)arg20,(
int const *)arg21,(
int const *)arg22,(
double const *)arg23,(
double const *)arg24,(
int const *)arg25,(
int const *)arg26,(
double const *)arg27,(
int const *)arg28,(
double const *)arg29,(
int const *)arg30,(
char const **)arg31);
21052 _outv = octave_value();
21074 if ( arg20 != NULL )
21076 for ( i = 0; i <
Alen; i++ )
21084 if ( arg21 != NULL )
21088 if ( arg22 != NULL )
21098 if ( arg25 != NULL )
21102 if ( arg26 != NULL )
21109 if ( arg28 != NULL )
21116 if ( arg30 != NULL )
21121 if ( arg31 != NULL )
21123 for ( i = 0; i <
Alen; i++ )
21140 if ( arg20 != NULL )
21142 for ( i = 0; i <
Alen; i++ )
21150 if ( arg21 != NULL )
21154 if ( arg22 != NULL )
21164 if ( arg25 != NULL )
21168 if ( arg26 != NULL )
21175 if ( arg28 != NULL )
21182 if ( arg30 != NULL )
21187 if ( arg31 != NULL )
21189 for ( i = 0; i <
Alen; i++ )
21196 return octave_value_list();
21207 if ( arg20 != NULL )
21209 for ( i = 0; i <
Alen; i++ )
21217 if ( arg21 != NULL )
21221 if ( arg22 != NULL )
21231 if ( arg25 != NULL )
21235 if ( arg26 != NULL )
21242 if ( arg28 != NULL )
21249 if ( arg30 != NULL )
21254 if ( arg31 != NULL )
21256 for ( i = 0; i <
Alen; i++ )
21278 octave_value_list _out;
21279 octave_value_list *_outp=&_out;
21280 octave_value _outv;
21290 arg1 =
static_cast< PLFLT >(val1);
21295 arg2 =
static_cast< PLFLT >(val2);
21300 arg3 =
static_cast< PLFLT >(val3);
21302 _outv = octave_value();
21306 return octave_value_list();
21320 octave_value_list _out;
21321 octave_value_list *_outp=&_out;
21322 octave_value _outv;
21329 if (
_n_dims( args(0) ) > 1 )
21334 temp1 = args(0).matrix_value();
21335 arg2 = &temp1( 0, 0 );
21338 if (
_n_dims( args(1) ) > 1 )
21346 temp3 = args(1).matrix_value();
21347 arg3 = &temp3( 0, 0 );
21349 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21350 _outv = octave_value();
21366 return octave_value_list();
21388 octave_value_list _out;
21389 octave_value_list *_outp=&_out;
21390 octave_value _outv;
21397 if (
_n_dims( args(0) ) > 1 )
21402 temp1 = args(0).matrix_value();
21403 arg2 = &temp1( 0, 0 );
21406 if (
_n_dims( args(1) ) > 1 )
21414 temp3 = args(1).matrix_value();
21415 arg3 = &temp3( 0, 0 );
21418 if (
_n_dims( args(2) ) > 1 )
21426 temp4 = args(2).matrix_value();
21427 arg4 = &temp4( 0, 0 );
21429 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21430 _outv = octave_value();
21452 return octave_value_list();
21473 octave_value_list _out;
21474 octave_value_list *_outp=&_out;
21475 octave_value _outv;
21485 arg1 =
static_cast< PLINT >(val1);
21487 _outv = octave_value();
21491 return octave_value_list();
21503 octave_value_list _out;
21504 octave_value_list *_outp=&_out;
21505 octave_value _outv;
21513 _outv = octave_value();
21523 return octave_value_list();
21532 char *arg1 = (
char *) 0 ;
21536 char *arg5 = (
char *) 0 ;
21549 octave_value_list _out;
21550 octave_value_list *_outp=&_out;
21551 octave_value _outv;
21561 arg1 =
reinterpret_cast< char *
>(buf1);
21566 arg2 =
static_cast< PLFLT >(val2);
21571 arg3 =
static_cast< PLFLT >(val3);
21576 arg4 =
static_cast< PLFLT >(val4);
21581 arg5 =
reinterpret_cast< char *
>(buf5);
21582 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21583 _outv = octave_value();
21591 return octave_value_list();
21602 char *arg1 = (
char *) 0 ;
21606 char *arg5 = (
char *) 0 ;
21619 octave_value_list _out;
21620 octave_value_list *_outp=&_out;
21621 octave_value _outv;
21631 arg1 =
reinterpret_cast< char *
>(buf1);
21636 arg2 =
static_cast< PLFLT >(val2);
21641 arg3 =
static_cast< PLFLT >(val3);
21646 arg4 =
static_cast< PLFLT >(val4);
21651 arg5 =
reinterpret_cast< char *
>(buf5);
21652 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21653 _outv = octave_value();
21661 return octave_value_list();
21672 int *arg1 = (
int *) 0 ;
21673 char **arg2 = (
char **) 0 ;
21681 octave_value_list _out;
21682 octave_value_list *_outp=&_out;
21683 octave_value _outv;
21694 arg1 =
reinterpret_cast< int *
>(argp1);
21699 arg2 =
reinterpret_cast< char **
>(argp2);
21704 arg3 =
static_cast< PLINT >(val3);
21710 return octave_value_list();
21724 octave_value_list _out;
21725 octave_value_list *_outp=&_out;
21726 octave_value _outv;
21733 if (
_n_dims( args(0) ) > 1 )
21739 temp1 = args(0).matrix_value();
21743 if (
_n_dims( args(1) ) > 1 )
21751 temp3 = args(1).matrix_value();
21755 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21756 _outv = octave_value();
21772 return octave_value_list();
21802 octave_value_list _out;
21803 octave_value_list *_outp=&_out;
21804 octave_value _outv;
21814 arg1 =
static_cast< PLINT >(val1);
21819 arg2 =
static_cast< PLFLT >(val2);
21824 arg3 =
static_cast< PLFLT >(val3);
21829 arg4 =
static_cast< PLFLT >(val4);
21834 arg5 =
static_cast< PLFLT >(val5);
21835 plpath(arg1,arg2,arg3,arg4,arg5);
21836 _outv = octave_value();
21840 return octave_value_list();
21857 octave_value_list _out;
21858 octave_value_list *_outp=&_out;
21859 octave_value _outv;
21866 if (
_n_dims( args(0) ) > 1 )
21871 temp1 = args(0).matrix_value();
21872 arg2 = &temp1( 0, 0 );
21875 if (
_n_dims( args(1) ) > 1 )
21883 temp3 = args(1).matrix_value();
21884 arg3 = &temp3( 0, 0 );
21890 arg4 =
static_cast< PLINT >(val4);
21891 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21892 _outv = octave_value();
21908 return octave_value_list();
21933 octave_value_list _out;
21934 octave_value_list *_outp=&_out;
21935 octave_value _outv;
21942 if (
_n_dims( args(0) ) > 1 )
21947 temp1 = args(0).matrix_value();
21948 arg2 = &temp1( 0, 0 );
21951 if (
_n_dims( args(1) ) > 1 )
21959 temp3 = args(1).matrix_value();
21960 arg3 = &temp3( 0, 0 );
21963 if (
_n_dims( args(2) ) > 1 )
21971 temp4 = args(2).matrix_value();
21972 arg4 = &temp4( 0, 0 );
21978 arg5 =
static_cast< PLINT >(val5);
21979 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21980 _outv = octave_value();
22002 return octave_value_list();
22032 octave_value_list _out;
22033 octave_value_list *_outp=&_out;
22034 octave_value _outv;
22041 if (
_n_dims( args(0) ) > 1 )
22046 temp1 = args(0).matrix_value();
22047 arg2 = &temp1( 0, 0 );
22050 if (
_n_dims( args(1) ) > 1 )
22058 temp3 = args(1).matrix_value();
22059 arg3 = &temp3( 0, 0 );
22062 if (
_n_dims( args(2) ) > 1 )
22070 temp4 = args(2).matrix_value();
22071 arg4 = &temp4( 0, 0 );
22074 if (
_n_dims( args(3) ) > 1 )
22080 error(
"argument vector must be same length or one less" );
SWIG_fail;
22082 temp5 = args(3).matrix_value();
22090 arg6 =
static_cast< PLBOOL >(val6);
22091 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22092 _outv = octave_value();
22120 return octave_value_list();
22147 octave_value_list _out;
22148 octave_value_list *_outp=&_out;
22149 octave_value _outv;
22159 arg1 =
static_cast< PLINT >(val1);
22164 arg2 =
static_cast< PLINT >(val2);
22166 _outv = octave_value();
22170 return octave_value_list();
22182 octave_value_list _out;
22183 octave_value_list *_outp=&_out;
22184 octave_value _outv;
22194 arg1 =
static_cast< PLINT >(val1);
22196 _outv = octave_value();
22200 return octave_value_list();
22214 char *arg6 = (
char *) 0 ;
22228 octave_value_list _out;
22229 octave_value_list *_outp=&_out;
22230 octave_value _outv;
22240 arg1 =
static_cast< PLFLT >(val1);
22245 arg2 =
static_cast< PLFLT >(val2);
22250 arg3 =
static_cast< PLFLT >(val3);
22255 arg4 =
static_cast< PLFLT >(val4);
22260 arg5 =
static_cast< PLFLT >(val5);
22265 arg6 =
reinterpret_cast< char *
>(buf6);
22266 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22267 _outv = octave_value();
22273 return octave_value_list();
22293 char *arg11 = (
char *) 0 ;
22317 octave_value_list _out;
22318 octave_value_list *_outp=&_out;
22319 octave_value _outv;
22329 arg1 =
static_cast< PLFLT >(val1);
22334 arg2 =
static_cast< PLFLT >(val2);
22339 arg3 =
static_cast< PLFLT >(val3);
22344 arg4 =
static_cast< PLFLT >(val4);
22349 arg5 =
static_cast< PLFLT >(val5);
22354 arg6 =
static_cast< PLFLT >(val6);
22359 arg7 =
static_cast< PLFLT >(val7);
22364 arg8 =
static_cast< PLFLT >(val8);
22369 arg9 =
static_cast< PLFLT >(val9);
22374 arg10 =
static_cast< PLFLT >(val10);
22379 arg11 =
reinterpret_cast< char *
>(buf11);
22380 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22381 _outv = octave_value();
22387 return octave_value_list();
22397 octave_value_list _out;
22398 octave_value_list *_outp=&_out;
22399 octave_value _outv;
22411 return octave_value_list();
22420 octave_value_list _out;
22421 octave_value_list *_outp=&_out;
22422 octave_value _outv;
22429 _outv = octave_value();
22433 return octave_value_list();
22460 octave_value_list _out;
22461 octave_value_list *_outp=&_out;
22462 octave_value _outv;
22475 arg1 =
static_cast< PLFLT >(val1);
22480 arg2 =
static_cast< PLFLT >(val2);
22485 arg3 =
static_cast< PLFLT >(val3);
22486 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22487 _outv = octave_value();
22509 return octave_value_list();
22524 octave_value_list _out;
22525 octave_value_list *_outp=&_out;
22526 octave_value _outv;
22536 arg1 =
static_cast< PLFLT >(val1);
22541 arg2 =
static_cast< PLFLT >(val2);
22543 _outv = octave_value();
22547 return octave_value_list();
22563 octave_value_list _out;
22564 octave_value_list *_outp=&_out;
22565 octave_value _outv;
22572 if (
_n_dims( args(0) ) > 1 )
22577 temp1 = args(0).matrix_value();
22582 if (
_n_dims( args(1) ) > 1 )
22590 temp2 = args(1).matrix_value();
22595 if (
_n_dims( args(2) ) > 1 )
22603 temp3 = args(2).matrix_value();
22608 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22609 _outv = octave_value();
22631 return octave_value_list();
22658 octave_value_list _out;
22659 octave_value_list *_outp=&_out;
22660 octave_value _outv;
22667 if (
_n_dims( args(0) ) > 1 )
22672 temp1 = args(0).matrix_value();
22677 if (
_n_dims( args(1) ) > 1 )
22685 temp2 = args(1).matrix_value();
22690 if (
_n_dims( args(2) ) > 1 )
22698 temp3 = args(2).matrix_value();
22703 if (
_n_dims( args(3) ) > 1 )
22711 temp4 = args(3).matrix_value();
22712 arg4 = &temp4( 0, 0 );
22715 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22716 _outv = octave_value();
22744 return octave_value_list();
22768 octave_value_list _out;
22769 octave_value_list *_outp=&_out;
22770 octave_value _outv;
22780 arg1 =
static_cast< PLINT >(val1);
22782 _outv = octave_value();
22786 return octave_value_list();
22802 octave_value_list _out;
22803 octave_value_list *_outp=&_out;
22804 octave_value _outv;
22811 if (
_n_dims( args(0) ) > 1 )
22816 temp1 = args(0).matrix_value();
22821 if (
_n_dims( args(1) ) > 1 )
22829 temp2 = args(1).matrix_value();
22834 if (
_n_dims( args(2) ) > 1 )
22842 temp3 = args(2).matrix_value();
22847 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22848 _outv = octave_value();
22870 return octave_value_list();
22897 octave_value_list _out;
22898 octave_value_list *_outp=&_out;
22899 octave_value _outv;
22906 if (
_n_dims( args(0) ) > 1 )
22911 temp1 = args(0).matrix_value();
22916 if (
_n_dims( args(1) ) > 1 )
22924 temp2 = args(1).matrix_value();
22929 if (
_n_dims( args(2) ) > 1 )
22937 temp3 = args(2).matrix_value();
22942 if (
_n_dims( args(3) ) > 1 )
22950 temp4 = args(3).matrix_value();
22951 arg4 = &temp4( 0, 0 );
22954 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22955 _outv = octave_value();
22983 return octave_value_list();
23018 octave_value_list _out;
23019 octave_value_list *_outp=&_out;
23020 octave_value _outv;
23030 arg1 =
static_cast< PLBOOL >(val1);
23032 if (
_n_dims( args(1) ) > 1 )
23037 temp2 = args(1).matrix_value();
23038 arg3 = &temp2( 0, 0 );
23041 if (
_n_dims( args(2) ) > 1 )
23049 temp4 = args(2).matrix_value();
23050 arg4 = &temp4( 0, 0 );
23053 if (
_n_dims( args(3) ) > 1 )
23061 temp5 = args(3).matrix_value();
23062 arg5 = &temp5( 0, 0 );
23065 if (
_n_dims( args(4) ) > 1 )
23073 temp6 = args(4).matrix_value();
23074 arg6 = &temp6( 0, 0 );
23077 if (
_n_dims( args(5) ) > 1 )
23083 error(
"argument vector must be same length or one less" );
SWIG_fail;
23085 temp7 = args(5).matrix_value();
23089 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23090 _outv = octave_value();
23124 return octave_value_list();
23164 octave_value_list _out;
23165 octave_value_list *_outp=&_out;
23166 octave_value _outv;
23176 arg1 =
static_cast< PLBOOL >(val1);
23178 if (
_n_dims( args(1) ) > 1 )
23183 temp2 = args(1).matrix_value();
23184 arg3 = &temp2( 0, 0 );
23187 if (
_n_dims( args(2) ) > 1 )
23195 temp4 = args(2).matrix_value();
23196 arg4 = &temp4( 0, 0 );
23199 if (
_n_dims( args(3) ) > 1 )
23207 temp5 = args(3).matrix_value();
23208 arg5 = &temp5( 0, 0 );
23211 if (
_n_dims( args(4) ) > 1 )
23219 temp6 = args(4).matrix_value();
23220 arg6 = &temp6( 0, 0 );
23223 if (
_n_dims( args(5) ) > 1 )
23231 temp7 = args(5).matrix_value();
23232 arg7 = &temp7( 0, 0 );
23235 if (
_n_dims( args(6) ) > 1 )
23241 error(
"argument vector must be same length or one less" );
SWIG_fail;
23243 temp8 = args(6).matrix_value();
23247 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23248 _outv = octave_value();
23288 return octave_value_list();
23318 octave_value_list _out;
23319 octave_value_list *_outp=&_out;
23320 octave_value _outv;
23330 arg1 =
static_cast< PLINT >(val1);
23332 _outv = octave_value();
23336 return octave_value_list();
23351 octave_value_list _out;
23352 octave_value_list *_outp=&_out;
23353 octave_value _outv;
23363 arg1 =
static_cast< PLFLT >(val1);
23368 arg2 =
static_cast< PLFLT >(val2);
23370 _outv = octave_value();
23374 return octave_value_list();
23389 octave_value_list _out;
23390 octave_value_list *_outp=&_out;
23391 octave_value _outv;
23400 _outv = octave_value();
23416 return octave_value_list();
23437 octave_value_list _out;
23438 octave_value_list *_outp=&_out;
23439 octave_value _outv;
23449 arg1 =
static_cast< PLINT >(val1);
23454 arg2 =
static_cast< PLINT >(val2);
23459 arg3 =
static_cast< PLINT >(val3);
23464 arg4 =
static_cast< PLINT >(val4);
23465 plscol0(arg1,arg2,arg3,arg4);
23466 _outv = octave_value();
23470 return octave_value_list();
23494 octave_value_list _out;
23495 octave_value_list *_outp=&_out;
23496 octave_value _outv;
23506 arg1 =
static_cast< PLINT >(val1);
23511 arg2 =
static_cast< PLINT >(val2);
23516 arg3 =
static_cast< PLINT >(val3);
23521 arg4 =
static_cast< PLINT >(val4);
23526 arg5 =
static_cast< PLFLT >(val5);
23527 plscol0a(arg1,arg2,arg3,arg4,arg5);
23528 _outv = octave_value();
23532 return octave_value_list();
23550 octave_value_list _out;
23551 octave_value_list *_outp=&_out;
23552 octave_value _outv;
23562 arg1 =
static_cast< PLINT >(val1);
23567 arg2 =
static_cast< PLINT >(val2);
23572 arg3 =
static_cast< PLINT >(val3);
23574 _outv = octave_value();
23578 return octave_value_list();
23599 octave_value_list _out;
23600 octave_value_list *_outp=&_out;
23601 octave_value _outv;
23611 arg1 =
static_cast< PLINT >(val1);
23616 arg2 =
static_cast< PLINT >(val2);
23621 arg3 =
static_cast< PLINT >(val3);
23626 arg4 =
static_cast< PLFLT >(val4);
23628 _outv = octave_value();
23632 return octave_value_list();
23644 octave_value_list _out;
23645 octave_value_list *_outp=&_out;
23646 octave_value _outv;
23656 arg1 =
static_cast< PLINT >(val1);
23658 _outv = octave_value();
23662 return octave_value_list();
23674 octave_value_list _out;
23675 octave_value_list *_outp=&_out;
23676 octave_value _outv;
23686 arg1 =
static_cast< PLINT >(val1);
23688 _outv = octave_value();
23692 return octave_value_list();
23701 char *arg1 = (
char *) 0 ;
23705 octave_value_list _out;
23706 octave_value_list *_outp=&_out;
23707 octave_value _outv;
23717 arg1 =
reinterpret_cast< char *
>(buf1);
23718 plsdev((
char const *)arg1);
23719 _outv = octave_value();
23725 return octave_value_list();
23747 octave_value_list _out;
23748 octave_value_list *_outp=&_out;
23749 octave_value _outv;
23759 arg1 =
static_cast< PLFLT >(val1);
23764 arg2 =
static_cast< PLFLT >(val2);
23769 arg3 =
static_cast< PLFLT >(val3);
23774 arg4 =
static_cast< PLFLT >(val4);
23776 _outv = octave_value();
23780 return octave_value_list();
23807 octave_value_list _out;
23808 octave_value_list *_outp=&_out;
23809 octave_value _outv;
23819 arg1 =
static_cast< PLINT >(val1);
23824 arg2 =
static_cast< PLINT >(val2);
23829 arg3 =
static_cast< PLINT >(val3);
23834 arg4 =
static_cast< PLINT >(val4);
23839 arg5 =
static_cast< PLFLT >(val5);
23844 arg6 =
static_cast< PLFLT >(val6);
23845 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23846 _outv = octave_value();
23850 return octave_value_list();
23862 octave_value_list _out;
23863 octave_value_list *_outp=&_out;
23864 octave_value _outv;
23874 arg1 =
static_cast< PLFLT >(val1);
23876 _outv = octave_value();
23880 return octave_value_list();
23901 octave_value_list _out;
23902 octave_value_list *_outp=&_out;
23903 octave_value _outv;
23913 arg1 =
static_cast< PLFLT >(val1);
23918 arg2 =
static_cast< PLFLT >(val2);
23923 arg3 =
static_cast< PLFLT >(val3);
23928 arg4 =
static_cast< PLFLT >(val4);
23930 _outv = octave_value();
23934 return octave_value_list();
23955 octave_value_list _out;
23956 octave_value_list *_outp=&_out;
23957 octave_value _outv;
23967 arg1 =
static_cast< PLFLT >(val1);
23972 arg2 =
static_cast< PLFLT >(val2);
23977 arg3 =
static_cast< PLFLT >(val3);
23982 arg4 =
static_cast< PLFLT >(val4);
23984 _outv = octave_value();
23988 return octave_value_list();
23997 unsigned int arg1 ;
23998 unsigned int val1 ;
24000 octave_value_list _out;
24001 octave_value_list *_outp=&_out;
24002 octave_value _outv;
24012 arg1 =
static_cast< unsigned int >(val1);
24014 _outv = octave_value();
24018 return octave_value_list();
24030 octave_value_list _out;
24031 octave_value_list *_outp=&_out;
24032 octave_value _outv;
24042 arg1 =
static_cast< char >(val1);
24044 _outv = octave_value();
24048 return octave_value_list();
24057 char *arg1 = (
char *) 0 ;
24058 char *arg2 = (
char *) 0 ;
24065 octave_value_list _out;
24066 octave_value_list *_outp=&_out;
24067 octave_value _outv;
24078 arg1 =
reinterpret_cast< char *
>(buf1);
24083 arg2 =
reinterpret_cast< char *
>(buf2);
24084 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24093 return octave_value_list();
24113 octave_value_list _out;
24114 octave_value_list *_outp=&_out;
24115 octave_value _outv;
24125 arg1 =
static_cast< PLINT >(val1);
24130 arg2 =
static_cast< PLINT >(val2);
24135 arg3 =
static_cast< PLINT >(val3);
24137 _outv = octave_value();
24141 return octave_value_list();
24151 unsigned int val1 ;
24153 octave_value_list _out;
24154 octave_value_list *_outp=&_out;
24155 octave_value _outv;
24167 _outv = octave_value();
24171 return octave_value_list();
24180 char *arg1 = (
char *) 0 ;
24184 octave_value_list _out;
24185 octave_value_list *_outp=&_out;
24186 octave_value _outv;
24196 arg1 =
reinterpret_cast< char *
>(buf1);
24198 _outv = octave_value();
24204 return octave_value_list();
24223 octave_value_list _out;
24224 octave_value_list *_outp=&_out;
24225 octave_value _outv;
24235 arg1 =
static_cast< PLINT >(val1);
24240 arg2 =
static_cast< PLINT >(val2);
24245 arg3 =
static_cast< PLINT >(val3);
24247 _outv = octave_value();
24251 return octave_value_list();
24263 octave_value_list _out;
24264 octave_value_list *_outp=&_out;
24265 octave_value _outv;
24272 octave_value obj = args(0);
24273#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24274 if ( !obj.isempty() )
24276 if ( !obj.is_empty() )
24279 if ( obj.is_function_handle() || obj.is_inline_function() )
24283 else if ( obj.is_string() )
24300 _outv = octave_value();
24304 return octave_value_list();
24319 octave_value_list _out;
24320 octave_value_list *_outp=&_out;
24321 octave_value _outv;
24331 arg1 =
static_cast< PLFLT >(val1);
24336 arg2 =
static_cast< PLFLT >(val2);
24338 _outv = octave_value();
24342 return octave_value_list();
24357 octave_value_list _out;
24358 octave_value_list *_outp=&_out;
24359 octave_value _outv;
24369 arg1 =
static_cast< PLFLT >(val1);
24374 arg2 =
static_cast< PLFLT >(val2);
24376 _outv = octave_value();
24380 return octave_value_list();
24392 octave_value_list _out;
24393 octave_value_list *_outp=&_out;
24394 octave_value _outv;
24404 arg1 =
static_cast< PLINT >(val1);
24406 _outv = octave_value();
24410 return octave_value_list();
24437 octave_value_list _out;
24438 octave_value_list *_outp=&_out;
24439 octave_value _outv;
24449 arg1 =
static_cast< PLFLT >(val1);
24454 arg2 =
static_cast< PLFLT >(val2);
24459 arg3 =
static_cast< PLINT >(val3);
24464 arg4 =
static_cast< PLINT >(val4);
24469 arg5 =
static_cast< PLINT >(val5);
24474 arg6 =
static_cast< PLINT >(val6);
24475 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24476 _outv = octave_value();
24480 return octave_value_list();
24489 char *arg1 = (
char *) 0 ;
24493 octave_value_list _out;
24494 octave_value_list *_outp=&_out;
24495 octave_value _outv;
24505 arg1 =
reinterpret_cast< char *
>(buf1);
24507 _outv = octave_value();
24513 return octave_value_list();
24523 char *arg1 = (
char *) 0 ;
24530 octave_value_list _out;
24531 octave_value_list *_outp=&_out;
24532 octave_value _outv;
24542 arg1 =
reinterpret_cast< char *
>(buf1);
24547 arg2 =
static_cast< PLBOOL >(val2);
24548 plspal1((
char const *)arg1,arg2);
24549 _outv = octave_value();
24555 return octave_value_list();
24568 octave_value_list _out;
24569 octave_value_list *_outp=&_out;
24570 octave_value _outv;
24580 arg1 =
static_cast< PLBOOL >(val1);
24582 _outv = octave_value();
24586 return octave_value_list();
24598 octave_value_list _out;
24599 octave_value_list *_outp=&_out;
24600 octave_value _outv;
24610 arg1 =
static_cast< PLINT >(val1);
24612 _outv = octave_value();
24616 return octave_value_list();
24631 octave_value_list _out;
24632 octave_value_list *_outp=&_out;
24633 octave_value _outv;
24643 arg1 =
static_cast< PLINT >(val1);
24648 arg2 =
static_cast< PLINT >(val2);
24650 _outv = octave_value();
24654 return octave_value_list();
24669 octave_value_list _out;
24670 octave_value_list *_outp=&_out;
24671 octave_value _outv;
24681 arg1 =
static_cast< PLFLT >(val1);
24686 arg2 =
static_cast< PLFLT >(val2);
24688 _outv = octave_value();
24692 return octave_value_list();
24707 octave_value_list _out;
24708 octave_value_list *_outp=&_out;
24709 octave_value _outv;
24719 arg1 =
static_cast< PLINT >(val1);
24724 arg2 =
static_cast< PLINT >(val2);
24726 _outv = octave_value();
24730 return octave_value_list();
24739 char *arg1 = (
char *) 0 ;
24749 octave_value_list _out;
24750 octave_value_list *_outp=&_out;
24751 octave_value _outv;
24761 arg1 =
reinterpret_cast< char *
>(buf1);
24766 arg2 =
static_cast< PLINT >(val2);
24771 arg3 =
static_cast< PLINT >(val3);
24772 plstart((
char const *)arg1,arg2,arg3);
24773 _outv = octave_value();
24779 return octave_value_list();
24792 octave_value_list _out;
24793 octave_value_list *_outp=&_out;
24794 octave_value _outv;
24801 octave_value obj = args(0);
24802#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24803 if ( !obj.isempty() )
24805 if ( !obj.is_empty() )
24808 if ( obj.is_function_handle() || obj.is_inline_function() )
24812 else if ( obj.is_string() )
24829 _outv = octave_value();
24833 return octave_value_list();
24845 char *arg4 = (
char *) 0 ;
24851 octave_value_list _out;
24852 octave_value_list *_outp=&_out;
24853 octave_value _outv;
24860 if (
_n_dims( args(0) ) > 1 )
24865 temp1 = args(0).matrix_value();
24866 arg2 = &temp1( 0, 0 );
24869 if (
_n_dims( args(1) ) > 1 )
24877 temp3 = args(1).matrix_value();
24878 arg3 = &temp3( 0, 0 );
24884 arg4 =
reinterpret_cast< char *
>(buf4);
24885 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24886 _outv = octave_value();
24904 return octave_value_list();
24924 char *arg5 = (
char *) 0 ;
24931 octave_value_list _out;
24932 octave_value_list *_outp=&_out;
24933 octave_value _outv;
24940 if (
_n_dims( args(0) ) > 1 )
24945 temp1 = args(0).matrix_value();
24946 arg2 = &temp1( 0, 0 );
24949 if (
_n_dims( args(1) ) > 1 )
24957 temp3 = args(1).matrix_value();
24958 arg3 = &temp3( 0, 0 );
24961 if (
_n_dims( args(2) ) > 1 )
24969 temp4 = args(2).matrix_value();
24970 arg4 = &temp4( 0, 0 );
24976 arg5 =
reinterpret_cast< char *
>(buf5);
24977 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24978 _outv = octave_value();
25002 return octave_value_list();
25033 octave_value_list _out;
25034 octave_value_list *_outp=&_out;
25035 octave_value _outv;
25045 arg1 =
static_cast< PLINT >(val1);
25050 arg2 =
static_cast< PLINT >(val2);
25055 arg3 =
static_cast< PLFLT >(val3);
25060 arg4 =
static_cast< PLFLT >(val4);
25062 _outv = octave_value();
25066 return octave_value_list();
25078 octave_value_list _out;
25079 octave_value_list *_outp=&_out;
25080 octave_value _outv;
25090 arg1 =
static_cast< PLINT >(val1);
25092 _outv = octave_value();
25096 return octave_value_list();
25110 octave_value_list _out;
25111 octave_value_list *_outp=&_out;
25112 octave_value _outv;
25119 if (
_n_dims( args(0) ) > 1 )
25125 temp1 = args(0).matrix_value();
25129 if (
_n_dims( args(1) ) > 1 )
25137 temp3 = args(1).matrix_value();
25141 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25142 _outv = octave_value();
25158 return octave_value_list();
25181 octave_value_list _out;
25182 octave_value_list *_outp=&_out;
25183 octave_value _outv;
25190 if (
_n_dims( args(0) ) > 1 )
25194#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25195 if ( !args(0).isempty() )
25197 if ( !args(0).is_empty() )
25201 temp1 = args(0).matrix_value();
25202 arg1 = &temp1( 0, 0 );
25211 if (
_n_dims( args(1) ) > 1 )
25215#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25216 if ( !args(1).isempty() )
25218 if ( !args(1).is_empty() )
25225 temp2 = args(1).matrix_value();
25226 arg2 = &temp2( 0, 0 );
25239 arg4 =
static_cast< PLBOOL >(val4);
25240 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25241 _outv = octave_value();
25257 return octave_value_list();
25284 octave_value_list _out;
25285 octave_value_list *_outp=&_out;
25286 octave_value _outv;
25296 arg1 =
static_cast< PLFLT >(val1);
25301 arg2 =
static_cast< PLFLT >(val2);
25306 arg3 =
static_cast< PLFLT >(val3);
25311 arg4 =
static_cast< PLFLT >(val4);
25312 plsvpa(arg1,arg2,arg3,arg4);
25313 _outv = octave_value();
25317 return octave_value_list();
25332 octave_value_list _out;
25333 octave_value_list *_outp=&_out;
25334 octave_value _outv;
25344 arg1 =
static_cast< PLINT >(val1);
25349 arg2 =
static_cast< PLINT >(val2);
25351 _outv = octave_value();
25355 return octave_value_list();
25370 octave_value_list _out;
25371 octave_value_list *_outp=&_out;
25372 octave_value _outv;
25382 arg1 =
static_cast< PLINT >(val1);
25387 arg2 =
static_cast< PLINT >(val2);
25389 _outv = octave_value();
25393 return octave_value_list();
25410 octave_value_list _out;
25411 octave_value_list *_outp=&_out;
25412 octave_value _outv;
25419 if (
_n_dims( args(0) ) > 1 )
25424 temp1 = args(0).matrix_value();
25425 arg2 = &temp1( 0, 0 );
25428 if (
_n_dims( args(1) ) > 1 )
25436 temp3 = args(1).matrix_value();
25437 arg3 = &temp3( 0, 0 );
25443 arg4 =
static_cast< PLINT >(val4);
25444 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25445 _outv = octave_value();
25461 return octave_value_list();
25482 octave_value_list _out;
25483 octave_value_list *_outp=&_out;
25484 octave_value _outv;
25494 arg1 =
static_cast< PLINT >(val1);
25499 arg2 =
static_cast< PLINT >(val2);
25501 _outv = octave_value();
25505 return octave_value_list();
25514 octave_value_list _out;
25515 octave_value_list *_outp=&_out;
25516 octave_value _outv;
25523 _outv = octave_value();
25527 return octave_value_list();
25536 char *arg1 = (
char *) 0 ;
25540 octave_value_list _out;
25541 octave_value_list *_outp=&_out;
25542 octave_value _outv;
25552 arg1 =
reinterpret_cast< char *
>(buf1);
25554 _outv = octave_value();
25560 return octave_value_list();
25573 octave_value_list _out;
25574 octave_value_list *_outp=&_out;
25575 octave_value _outv;
25585 arg1 =
static_cast< PLFLT >(val1);
25587 _outv = octave_value();
25591 return octave_value_list();
25615 octave_value_list _out;
25616 octave_value_list *_outp=&_out;
25617 octave_value _outv;
25627 arg1 =
static_cast< PLFLT >(val1);
25632 arg2 =
static_cast< PLFLT >(val2);
25637 arg3 =
static_cast< PLFLT >(val3);
25642 arg4 =
static_cast< PLFLT >(val4);
25647 arg5 =
static_cast< PLFLT >(val5);
25648 plvpas(arg1,arg2,arg3,arg4,arg5);
25649 _outv = octave_value();
25653 return octave_value_list();
25674 octave_value_list _out;
25675 octave_value_list *_outp=&_out;
25676 octave_value _outv;
25686 arg1 =
static_cast< PLFLT >(val1);
25691 arg2 =
static_cast< PLFLT >(val2);
25696 arg3 =
static_cast< PLFLT >(val3);
25701 arg4 =
static_cast< PLFLT >(val4);
25702 plvpor(arg1,arg2,arg3,arg4);
25703 _outv = octave_value();
25707 return octave_value_list();
25716 octave_value_list _out;
25717 octave_value_list *_outp=&_out;
25718 octave_value _outv;
25725 _outv = octave_value();
25729 return octave_value_list();
25771 octave_value_list _out;
25772 octave_value_list *_outp=&_out;
25773 octave_value _outv;
25783 arg1 =
static_cast< PLFLT >(val1);
25788 arg2 =
static_cast< PLFLT >(val2);
25793 arg3 =
static_cast< PLFLT >(val3);
25798 arg4 =
static_cast< PLFLT >(val4);
25803 arg5 =
static_cast< PLFLT >(val5);
25808 arg6 =
static_cast< PLFLT >(val6);
25813 arg7 =
static_cast< PLFLT >(val7);
25818 arg8 =
static_cast< PLFLT >(val8);
25823 arg9 =
static_cast< PLFLT >(val9);
25828 arg10 =
static_cast< PLFLT >(val10);
25833 arg11 =
static_cast< PLFLT >(val11);
25834 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25835 _outv = octave_value();
25839 return octave_value_list();
25851 octave_value_list _out;
25852 octave_value_list *_outp=&_out;
25853 octave_value _outv;
25863 arg1 =
static_cast< PLFLT >(val1);
25865 _outv = octave_value();
25869 return octave_value_list();
25890 octave_value_list _out;
25891 octave_value_list *_outp=&_out;
25892 octave_value _outv;
25902 arg1 =
static_cast< PLFLT >(val1);
25907 arg2 =
static_cast< PLFLT >(val2);
25912 arg3 =
static_cast< PLFLT >(val3);
25917 arg4 =
static_cast< PLFLT >(val4);
25918 plwind(arg1,arg2,arg3,arg4);
25919 _outv = octave_value();
25923 return octave_value_list();
25938 octave_value_list _out;
25939 octave_value_list *_outp=&_out;
25940 octave_value _outv;
25951 arg1 =
static_cast< PLBOOL >(val1);
25953 _outv = octave_value();
25963 return octave_value_list();
25973 char *arg2 = (
char *) 0 ;
25989 octave_value_list _out;
25990 octave_value_list *_outp=&_out;
25991 octave_value _outv;
25998 octave_value obj = args(0);
25999#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26000 if ( !obj.isempty() )
26002 if ( !obj.is_empty() )
26005 if ( obj.is_function_handle() || obj.is_inline_function() )
26009 else if ( obj.is_string() )
26025 arg2 =
reinterpret_cast< char *
>(buf2);
26030 arg3 =
static_cast< PLFLT >(val3);
26035 arg4 =
static_cast< PLFLT >(val4);
26040 arg5 =
static_cast< PLFLT >(val5);
26045 arg6 =
static_cast< PLFLT >(val6);
26046 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
26047 _outv = octave_value();
26053 return octave_value_list();
26064 char *arg2 = (
char *) 0 ;
26083 octave_value_list _out;
26084 octave_value_list *_outp=&_out;
26085 octave_value _outv;
26092 octave_value obj = args(0);
26093#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26094 if ( !obj.isempty() )
26096 if ( !obj.is_empty() )
26099 if ( obj.is_function_handle() || obj.is_inline_function() )
26103 else if ( obj.is_string() )
26119 arg2 =
reinterpret_cast< char *
>(buf2);
26124 arg3 =
static_cast< PLFLT >(val3);
26129 arg4 =
static_cast< PLFLT >(val4);
26134 arg5 =
static_cast< PLFLT >(val5);
26139 arg6 =
static_cast< PLFLT >(val6);
26141 if (
_n_dims( args(6) ) > 1 )
26145#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26146 if ( !args(6).isempty() )
26148 if ( !args(6).is_empty() )
26152 temp7 = args(6).matrix_value();
26153 arg7 =
new PLINT[arg8];
26162 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26163 _outv = octave_value();
26175 return octave_value_list();
26189 char *arg2 = (
char *) 0 ;
26190 char *arg3 = (
char *) 0 ;
26212 octave_value_list _out;
26213 octave_value_list *_outp=&_out;
26214 octave_value _outv;
26221 octave_value obj = args(0);
26222#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26223 if ( !obj.isempty() )
26225 if ( !obj.is_empty() )
26228 if ( obj.is_function_handle() || obj.is_inline_function() )
26232 else if ( obj.is_string() )
26248 arg2 =
reinterpret_cast< char *
>(buf2);
26253 arg3 =
reinterpret_cast< char *
>(buf3);
26258 arg4 =
static_cast< PLFLT >(val4);
26263 arg5 =
static_cast< PLFLT >(val5);
26268 arg6 =
static_cast< PLFLT >(val6);
26273 arg7 =
static_cast< PLFLT >(val7);
26275 if (
_n_dims( args(7) ) > 1 )
26279#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26280 if ( !args(7).isempty() )
26282 if ( !args(7).is_empty() )
26286 temp8 = args(7).matrix_value();
26287 arg8 =
new PLINT[arg9];
26296 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26297 _outv = octave_value();
26311 return octave_value_list();
26326 char *arg2 = (
char *) 0 ;
26330 char *arg6 = (
char *) 0 ;
26358 octave_value_list _out;
26359 octave_value_list *_outp=&_out;
26360 octave_value _outv;
26367 octave_value obj = args(0);
26368#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26369 if ( !obj.isempty() )
26371 if ( !obj.is_empty() )
26374 if ( obj.is_function_handle() || obj.is_inline_function() )
26378 else if ( obj.is_string() )
26394 arg2 =
reinterpret_cast< char *
>(buf2);
26399 arg3 =
static_cast< PLFLT >(val3);
26404 arg4 =
static_cast< PLFLT >(val4);
26409 arg5 =
static_cast< PLFLT >(val5);
26414 arg6 =
reinterpret_cast< char *
>(buf6);
26419 arg7 =
static_cast< PLFLT >(val7);
26424 arg8 =
static_cast< PLFLT >(val8);
26429 arg9 =
static_cast< PLFLT >(val9);
26434 arg10 =
static_cast< PLFLT >(val10);
26439 arg11 =
static_cast< PLINT >(val11);
26440 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26441 _outv = octave_value();
26449 return octave_value_list();
26461 char *arg2 = (
char *) 0 ;
26480 octave_value_list _out;
26481 octave_value_list *_outp=&_out;
26482 octave_value _outv;
26489 octave_value obj = args(0);
26490#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26491 if ( !obj.isempty() )
26493 if ( !obj.is_empty() )
26496 if ( obj.is_function_handle() || obj.is_inline_function() )
26500 else if ( obj.is_string() )
26516 arg2 =
reinterpret_cast< char *
>(buf2);
26521 arg3 =
static_cast< PLFLT >(val3);
26526 arg4 =
static_cast< PLFLT >(val4);
26531 arg5 =
static_cast< PLFLT >(val5);
26536 arg6 =
static_cast< PLFLT >(val6);
26538 if (
_n_dims( args(6) ) > 1 )
26542#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26543 if ( !args(6).isempty() )
26545 if ( !args(6).is_empty() )
26549 temp7 = args(6).matrix_value();
26550 arg7 =
new PLINT[arg8];
26559 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26560 _outv = octave_value();
26572 return octave_value_list();
26604 octave_value_list _out;
26605 octave_value_list *_outp=&_out;
26606 octave_value _outv;
26613 octave_value obj = args(0);
26614#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26615 if ( !obj.isempty() )
26617 if ( !obj.is_empty() )
26620 if ( obj.is_function_handle() || obj.is_inline_function() )
26624 else if ( obj.is_string() )
26640 arg2 =
static_cast< PLFLT >(val2);
26645 arg3 =
static_cast< PLFLT >(val3);
26650 arg4 =
static_cast< PLFLT >(val4);
26655 arg5 =
static_cast< PLFLT >(val5);
26660 arg6 =
static_cast< PLFLT >(val6);
26665 arg7 =
static_cast< PLFLT >(val7);
26667 _outv = octave_value();
26671 return octave_value_list();
26680 octave_value_list _out;
26681 octave_value_list *_outp=&_out;
26682 octave_value _outv;
26689 _outv = octave_value();
26693 return octave_value_list();
26702 octave_value_list _out;
26703 octave_value_list *_outp=&_out;
26704 octave_value _outv;
26711 _outv = octave_value();
26715 return octave_value_list();
26724 char *arg1 = (
char *) 0 ;
26725 char *arg2 = (
char *) 0 ;
26732 octave_value_list _out;
26733 octave_value_list *_outp=&_out;
26734 octave_value _outv;
26744 arg1 =
reinterpret_cast< char *
>(buf1);
26749 arg2 =
reinterpret_cast< char *
>(buf2);
26750 plSetUsage((
char const *)arg1,(
char const *)arg2);
26751 _outv = octave_value();
26759 return octave_value_list();
26770 octave_value_list _out;
26771 octave_value_list *_outp=&_out;
26772 octave_value _outv;
26779 _outv = octave_value();
26783 return octave_value_list();
26793{
"testppchar",_wrap_testppchar,0,0,2,0},
26795{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26798{
"plcont0",_wrap_plcont0,0,0,2,0},
26799{
"plcont1",_wrap_plcont1,0,0,2,0},
26800{
"plcont2",_wrap_plcont2,0,0,2,0},
26801{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26811{
"plshade1",_wrap_plshade1,0,0,2,0},
26812{
"plshade2",_wrap_plshade2,0,0,2,0},
26814{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26815{
"plshades1",_wrap_plshades1,0,0,2,0},
26816{
"plshades2",_wrap_plshades2,0,0,2,0},
26818{
"plvect1",_wrap_plvect1,0,0,2,0},
26819{
"plvect2",_wrap_plvect2,0,0,2,0},
26820{
"pplimage",_wrap_pplimage,0,0,2,0},
26822{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26823{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26824{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27110#define SWIGRUNTIME_DEBUG
27113#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27114#define SWIG_INIT_CLIENT_DATA_TYPE void *
27136 if (!module_head) {
27149 }
while (iter!= module_head);
27160 if (init == 0)
return;
27163#ifdef SWIGRUNTIME_DEBUG
27164 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.size);
27171#ifdef SWIGRUNTIME_DEBUG
27172 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27181#ifdef SWIGRUNTIME_DEBUG
27182 printf(
"SWIG_InitializeModule: found type %s\n", type->name);
27185 type->clientdata =
swig_module.type_initial[i]->clientdata;
27186#ifdef SWIGRUNTIME_DEBUG
27187 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27196 while (cast->
type) {
27200#ifdef SWIGRUNTIME_DEBUG
27201 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27205#ifdef SWIGRUNTIME_DEBUG
27206 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->name);
27211#ifdef SWIGRUNTIME_DEBUG
27212 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->name);
27219#ifdef SWIGRUNTIME_DEBUG
27220 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->name);
27222 if (!ocast) ret = 0;
27227#ifdef SWIGRUNTIME_DEBUG
27228 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27231 type->cast->prev = cast;
27232 cast->
next = type->cast;
27243#ifdef SWIGRUNTIME_DEBUG
27244 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27248 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27249 while (cast->
type) {
27250 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27254 printf(
"---- Total casts: %d\n",j);
27256 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27269 static int init_run = 0;
27271 if (init_run)
return;
27278 if (!equiv->converter) {
27279 if (equiv->type && !equiv->type->clientdata)
27282 equiv = equiv->next;
27302#if SWIG_OCTAVE_PREREQ(6,0,0)
27303#elif SWIG_OCTAVE_PREREQ(4,2,0)
27304 octave::unwind_protect frame;
27305 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27306 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27307#elif SWIG_OCTAVE_PREREQ(3,3,50)
27308 unwind_protect frame;
27309 frame.protect_var(error_state); error_state = 0;
27310 frame.protect_var(warning_state); warning_state = 0;
27311 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27312 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27314 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27315 unwind_protect_int(error_state); error_state = 0;
27316 unwind_protect_int(warning_state); warning_state = 0;
27317 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27318 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27320#if SWIG_OCTAVE_PREREQ(4,2,0)
27322#if SWIG_OCTAVE_PREREQ(4,4,0)
27323 octave::feval(
name, octave_value_list(), 0);
27325 feval(
name, octave_value_list(), 0);
27328 }
catch (octave::execution_exception&) { }
27330 feval(
name, octave_value_list(), 0);
27331 retn = (error_state == 0);
27333#if !SWIG_OCTAVE_PREREQ(3,3,50)
27334 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27346#if SWIG_OCTAVE_PREREQ(6,0,0)
27347#elif SWIG_OCTAVE_PREREQ(4,2,0)
27348 octave::unwind_protect frame;
27349 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27350 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27351#elif SWIG_OCTAVE_PREREQ(3,3,50)
27352 unwind_protect frame;
27353 frame.protect_var(error_state); error_state = 0;
27354 frame.protect_var(warning_state); warning_state = 0;
27355 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27356 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27358 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27359 unwind_protect_int(error_state); error_state = 0;
27360 unwind_protect_int(warning_state); warning_state = 0;
27361 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27362 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27364 octave_value_list args;
27366 args.append(octloadfcn->fcn_file_name());
27367#if SWIG_OCTAVE_PREREQ(4,2,0)
27369#if SWIG_OCTAVE_PREREQ(4,4,0)
27370 octave::feval(
"autoload", args, 0);
27372 feval(
"autoload", args, 0);
27375 }
catch (octave::execution_exception&) { }
27377 feval(
"autoload", args, 0);
27378 retn = (error_state == 0);
27380#if !SWIG_OCTAVE_PREREQ(3,3,50)
27381 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27391@deftypefn {Loadable Function} {} subclass()\n\
27392@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27393Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27395See the SWIG manual for usage examples.\n\
27400 for (
int j = 0; j < args.length(); ++j) {
27401 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27404 if (!ost->is_owned()) {
27405 error(
"subclass: cannot subclass object not constructed on octave side");
27406 return octave_value_list();
27409 }
else if (args(j).is_function_handle()) {
27410 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27411 }
else if (args(j).is_string()) {
27412 if (j + 1 >= args.length()) {
27413 error(
"subclass: member assignments must be of string,value form");
27414 return octave_value_list();
27416 top->assign(args(j).string_value(), args(j + 1));
27419 error(
"subclass: invalid arguments to subclass()");
27420 return octave_value_list();
27427@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27428Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27432 if (args.length() != 1) {
27433 error(
"swig_type: must be called with only a single object");
27434 return octave_value_list();
27438 error(
"swig_type: object is not a swig_ref");
27439 return octave_value_list();
27441 return octave_value(ost->swig_type_name());
27445@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27446Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27447otherwise return `<unknown>'.\n\
27451 if (args.length() != 1 || !args(0).is_string()) {
27452 error(
"swig_typequery: must be called with single string argument");
27453 return octave_value_list();
27458 return octave_value(
"<unknown>");
27459 return octave_value(type->name);
27463@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27464Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27468 if (args.length() != 1) {
27469 error(
"swig_this: must be called with only a single object");
27470 return octave_value_list();
27472 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27473 return octave_value(octave_uint64(0));
27476 error(
"swig_this: object is not a swig_ref");
27477 return octave_value_list();
27479 return octave_value(octave_uint64((
unsigned long long) ost->swig_this()));
27483@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27484Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27488 if (args.length() != 3) {
27489 error(
"swig_octave_prereq: must be called with 3 arguments");
27490 return octave_value_list();
27492 const int major = args(0).int_value();
27493 const int minor = args(1).int_value();
27494 const int patch = args(2).int_value();
27496 return octave_value(prereq);
27500@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27501Exit Octave without performing any memory cleanup.\n\
27505 if (args.length() > 1) {
27506 error(
"swig_exit: must be called with at most one arguments");
27507 return octave_value_list();
27509 int exit_status = 0;
27510 if (args.length() == 1) {
27511 exit_status = args(0).int_value();
27513 ::_Exit(exit_status);
27514 return octave_value();
27518@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27519Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27532#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27533#if !SWIG_OCTAVE_PREREQ(4,4,0)
27534#if SWIG_OCTAVE_PREREQ(3,2,0)
27535 octave_exit = ::_Exit;
27541 if (args.length() != 0 || nargout != 0) {
27543 return octave_value_list();
27551#if SWIG_OCTAVE_PREREQ(3,2,0)
27552 octave_value_list eval_args;
27553 eval_args.append(
"base");
27554 eval_args.append(
"function __swig_atexit__; "
27561 "__swig_atexit__; "
27562 "atexit(\"__swig_atexit__\", false); "
27563 "atexit(\"__swig_atexit__\")");
27564#if SWIG_OCTAVE_PREREQ(4,4,0)
27565 octave::feval(
"evalin", eval_args, 0);
27567 feval(
"evalin", eval_args, 0);
27571#if SWIG_OCTAVE_PREREQ(4,4,0)
27573 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27574 string_vector types = typeinfo.installed_type_names();
27575 bool register_octave_swig_ref =
true;
27576 bool register_octave_swig_packed =
true;
27577 for (
int i = 0; i < types.numel(); ++i) {
27578 if (types(i) == octave_swig_ref::static_type_name()) {
27579 register_octave_swig_ref =
false;
27580 octave_swig_ref::set_type_id(i);
27582 if (types(i) == octave_swig_packed::static_type_name()) {
27583 register_octave_swig_packed =
false;
27584 octave_swig_packed::set_type_id(i);
27587 if (register_octave_swig_ref) {
27588 octave_swig_ref::register_type();
27590 if (register_octave_swig_packed) {
27591 octave_swig_packed::register_type();
27595 octave_swig_ref::register_type();
27596 octave_swig_packed::register_type();
27601#if SWIG_OCTAVE_PREREQ(8,0,0)
27602 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27603 octave_function *me = tree_eval.current_function();
27604#elif SWIG_OCTAVE_PREREQ(6,0,0)
27605 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27606 octave::call_stack& stack = tree_eval.get_call_stack();
27607 octave_function *me = stack.current_function();
27608#elif SWIG_OCTAVE_PREREQ(4,4,0)
27609 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27610 octave_function *me = stack.current();
27612 octave_function *me = octave_call_stack::current();
27616 return octave_value_list();
27619 return octave_value_list();
27622 return octave_value_list();
27625 return octave_value_list();
27628 return octave_value_list();
27631 return octave_value_list();
27661 module_ns->assign(c->name,
27669 return octave_value_list();
27675 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27676 if (mb->second.first && mb->second.first->method) {
27678 return octave_value_list();
27683#if SWIG_OCTAVE_PREREQ(4,4,0)
27684 octave::interpreter::the_interpreter()->mlock();
27685#elif SWIG_OCTAVE_PREREQ(3,2,0)
27694 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27695 if (mb->second.second.is_defined()) {
27704 return octave_value_list();
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_base_value * empty_clone() const
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
octave_base_value * clone() const
virtual bool save_ascii(std::ostream &os)
virtual string_vector map_keys() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual double scalar_value(bool frc_str_conv=false) const
virtual bool is_object() const
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual bool save_ascii(std::ostream &os)
octave_swig_type * get_ptr() const
dim_vector dims(void) const
octave_base_value * clone() const
virtual Octave_map map_value() const
virtual bool is_map() const
virtual bool is_string() const
virtual std::string string_value(bool force=false) const
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
octave_base_value * empty_clone() const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
octave_swig_ref(octave_swig_type *_ptr=0)
virtual bool load_ascii(std::istream &is)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void load_members(member_map &out) const
virtual Octave_map map_value() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
octave_base_value * empty_clone() const
dim_vector dims(void) const
octave_base_value * clone() const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
virtual bool is_object() const
const char * help_text() const
void assign(const std::string &name, const swig_octave_member *m)
octave_swig_type & operator=(const octave_swig_type &rhs)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
void assign(const std::string &name, const octave_value &ov)
virtual bool is_string() const
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
std::vector< type_ptr_pair > types
virtual double scalar_value(bool frc_str_conv=false) const
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
int cast(void **vptr, swig_type_info *type, int *own, int flags)
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
void merge(octave_swig_type &rhs)
member_map::const_iterator swig_member_const_iterator
swig_module_info *const swig_type_info * construct_type
void print(std::ostream &os, bool pr_as_read_syntax=false) const
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
static PLFLT value(double n1, double n2, double hue)
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
PLINT plTranslateCursor(PLGraphicsIn *plg)
PLINT plGetCursor(PLGraphicsIn *plg)
#define pl_setcontlabelformat
#define pl_setcontlabelparam
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
static const char * _wrap_plszax_texinfo
static const char * _wrap_plstring3_texinfo
static const char * _wrap_plvsta_texinfo
static const char * _wrap_plscmap1_texinfo
static const char * _wrap_plbox3_texinfo
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plvpas_texinfo
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
static const char * _wrap_plmkstrm_texinfo
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plend_texinfo
static const swig_type_info * swig_PLGraphicsIn_base[]
static const char * _wrap_plsvpa_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
octave_function * fcnCoordTrans
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
static const char * _wrap_plflush_texinfo
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
static const char * _wrap_plsfnam_texinfo
#define SWIG_CheckState(r)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plot3dc_texinfo
static const char * _wrap_plptex_texinfo
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
static const char * _wrap_plbin_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
static const char * _wrap_plsmaj_texinfo
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plscolor_texinfo
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
struct swig_cast_info swig_cast_info
static const char * _wrap_plfill_texinfo
static const struct swig_octave_member swig_globals[]
static const char * _wrap_pllightsource_texinfo
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plscmap0_texinfo
static const char *const swig_typequery_usage
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
std::string nameCoordTrans
static const char * _wrap_plgcol0a_texinfo
static const char * _wrap_plSetOpt_texinfo
#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
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