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_"
21 template<
typename T>
class SwigValueWrapper {
22 struct SwigMovePointer {
24 SwigMovePointer(T *p) : ptr(p) { }
25 ~SwigMovePointer() {
delete ptr; }
26 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
28 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
29 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
31 SwigValueWrapper() : pointer(0) { }
32 SwigValueWrapper& operator=(
const T& t) { SwigMovePointer tmp(
new T(t)); pointer = tmp;
return *
this; }
33 operator T&()
const {
return *pointer.ptr; }
34 T *operator&() {
return pointer.ptr; }
37 template <
typename T> T SwigValueInit() {
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
56 # define SWIGTEMPLATEDISAMBIGUATOR
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
78 # define SWIGUNUSED __attribute__ ((__unused__))
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505)
90 #ifndef SWIGUNUSEDPARM
92 # define SWIGUNUSEDPARM(p)
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
100 # define SWIGINTERN static SWIGUNUSED
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 # ifndef GCC_HASCLASSVISIBILITY
111 # define GCC_HASCLASSVISIBILITY
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
120 # define SWIGEXPORT __declspec(dllexport)
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
153 #include <octave/oct.h>
154 #include <octave/Cell.h>
155 #include <octave/dynamic-ld.h>
156 #include <octave/oct-env.h>
157 #include <octave/oct-map.h>
158 #include <octave/ov-fcn-handle.h>
159 #include <octave/parse.h>
160 #include <octave/toplev.h>
161 #include <octave/unwind-prot.h>
172 #define SWIG_RUNTIME_VERSION "4"
175 #ifdef SWIG_TYPE_TABLE
176 # define SWIG_QUOTE_STRING(x) #x
177 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
178 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
180 # define SWIG_TYPE_TABLE_NAME
193 # define SWIGRUNTIME SWIGINTERN
196 #ifndef SWIGRUNTIMEINLINE
197 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
201 #ifndef SWIG_BUFFER_SIZE
202 # define SWIG_BUFFER_SIZE 1024
206 #define SWIG_POINTER_DISOWN 0x1
207 #define SWIG_CAST_NEW_MEMORY 0x2
210 #define SWIG_POINTER_OWN 0x1
293 #define SWIG_ERROR (-1)
294 #define SWIG_IsOK(r) (r >= 0)
295 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
298 #define SWIG_CASTRANKLIMIT (1 << 8)
300 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
302 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
304 #define SWIG_BADOBJ (SWIG_ERROR)
305 #define SWIG_OLDOBJ (SWIG_OK)
306 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
307 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
309 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
310 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
311 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
312 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
313 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
314 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
317 #if defined(SWIG_CASTRANK_MODE)
318 # ifndef SWIG_TypeRank
319 # define SWIG_TypeRank unsigned long
321 # ifndef SWIG_MAXCASTRANK
322 # define SWIG_MAXCASTRANK (2)
324 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
325 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
330 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
333 # define SWIG_AddCast
334 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
344 typedef void *(*swig_converter_func)(
void *,
int *);
386 const char *f2,
const char *l2) {
387 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
388 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
389 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
390 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
392 return (
int)((l1 - f1) - (l2 - f2));
402 const char* te = tb + strlen(tb);
404 while (!equiv && *ne) {
405 for (nb = ne; *ne; ++ne) {
406 if (*ne ==
'|')
break;
421 const char* te = tb + strlen(tb);
423 while (!equiv && *ne) {
424 for (nb = ne; *ne; ++ne) {
425 if (*ne ==
'|')
break;
442 if (strcmp(iter->
type->
name, c) == 0) {
443 if (iter == ty->
cast)
469 if (iter->
type == from) {
470 if (iter == ty->
cast)
502 if (!ty || !ty->
dcast)
return ty;
503 while (ty && (ty->
dcast)) {
504 ty = (*ty->
dcast)(ptr);
528 if (!type)
return NULL;
529 if (type->
str != NULL) {
530 const char *last_name = type->
str;
532 for (s = type->
str; *s; s++)
533 if (*s ==
'|') last_name = s+1;
580 register size_t l = 0;
581 register size_t r = iter->
size - 1;
584 register size_t i = (l + r) >> 1;
585 const char *iname = iter->
types[i]->
name;
587 register int compare = strcmp(name, iname);
589 return iter->
types[i];
590 }
else if (compare < 0) {
596 }
else if (compare > 0) {
605 }
while (iter != end);
631 register size_t i = 0;
632 for (; i < iter->
size; ++i) {
634 return iter->
types[i];
637 }
while (iter != end);
649 static const char hex[17] =
"0123456789abcdef";
650 register const unsigned char *u = (
unsigned char *) ptr;
651 register const unsigned char *eu = u + sz;
652 for (; u != eu; ++u) {
653 register unsigned char uu = *u;
654 *(c++) = hex[(uu & 0xf0) >> 4];
655 *(c++) = hex[uu & 0xf];
665 register unsigned char *u = (
unsigned char *) ptr;
666 register const unsigned char *eu = u + sz;
667 for (; u != eu; ++u) {
668 register char d = *(c++);
669 register unsigned char uu;
670 if ((d >=
'0') && (d <=
'9'))
671 uu = ((d -
'0') << 4);
672 else if ((d >=
'a') && (d <=
'f'))
673 uu = ((d - (
'a'-10)) << 4);
677 if ((d >=
'0') && (d <=
'9'))
679 else if ((d >=
'a') && (d <=
'f'))
680 uu |= (d - (
'a'-10));
694 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
697 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
705 if (strcmp(c,
"NULL") == 0) {
718 size_t lname = (name ? strlen(name) : 0);
719 if ((2*sz + 2 + lname) > bsz)
return 0;
723 strncpy(r,name,lname+1);
733 if (strcmp(c,
"NULL") == 0) {
748 #define SWIG_UnknownError -1
749 #define SWIG_IOError -2
750 #define SWIG_RuntimeError -3
751 #define SWIG_IndexError -4
752 #define SWIG_TypeError -5
753 #define SWIG_DivisionByZero -6
754 #define SWIG_OverflowError -7
755 #define SWIG_SyntaxError -8
756 #define SWIG_ValueError -9
757 #define SWIG_SystemError -10
758 #define SWIG_AttributeError -11
759 #define SWIG_MemoryError -12
760 #define SWIG_NullReferenceError -13
765 #include <octave/version.h>
766 #ifndef OCTAVE_API_VERSION_NUMBER
769 #define ComplexLU __ignore
770 #include <octave/CmplxLU.h>
772 #ifdef octave_Complex_LU_h
773 # define OCTAVE_API_VERSION_NUMBER 36
775 # define OCTAVE_API_VERSION_NUMBER 37
780 #if OCTAVE_API_VERSION_NUMBER < 37
781 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
783 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
787 if (num_args > max_args && !varargs)
788 error(
"function %s takes at most %i arguments", func_name, max_args);
789 else if (num_args < min_args)
790 error(
"function %s requires at least %i arguments", func_name, min_args);
804 return "SWIG_MemoryError";
806 return "SWIG_IOError";
808 return "SWIG_RuntimeError";
810 return "SWIG_IndexError";
812 return "SWIG_TypeError";
814 return "SWIG_DivisionByZero";
816 return "SWIG_OverflowError";
818 return "SWIG_SyntaxError";
820 return "SWIG_ValueError";
822 return "SWIG_SystemError";
824 return "SWIG_AttributeError";
826 return "SWIG unknown error";
832 r +=
" (" + type.string_value() +
")";
834 return octave_value(r);
837 #define SWIG_fail goto fail
839 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
840 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
841 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
842 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
843 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
844 #define swig_owntype int
846 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
847 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
849 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
850 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
852 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
853 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
855 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
856 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
857 #define SWIG_MODULE_CLIENTDATA_TYPE void*
859 #define Octave_Error_Occurred() 0
860 #define SWIG_Octave_AddErrorMsg(msg) {;}
866 #define SWIG_POINTER_EXCEPTION 0
867 #define SWIG_arg_fail(arg) 0
875 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
880 #ifdef SWIG_DIRECTORS
884 typedef std::map < void *, Director * > rtdir_map;
901 #ifdef SWIG_DIRECTORS
902 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
903 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
904 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
951 std::vector < type_ptr_pair >
types;
955 typedef std::map < std::string, member_value_pair >
member_map;
983 member_map::iterator it =
members.find(name);
987 for (
unsigned int j = 0; j <
types.size(); ++j)
989 return &
members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
990 if (!insert_if_not_found)
997 for (
unsigned int j = 0; j <
types.size(); ++j) {
998 assert(
types[j].first->clientdata);
1000 if (cj->
name == name)
1001 return types[j].first;
1018 if (cj->
name == name)
1026 if (out.find(m->name) == out.end())
1027 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1047 for (
unsigned int j = 0; j <
types.size(); ++j)
1048 if (
types[j].first->clientdata)
1053 if (m->second.is_defined())
1054 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1055 else if (m->first && m->first->method)
1056 return m->first->method(args, nargout);
1057 error(
"member not defined or not invocable");
1058 return octave_value_list();
1063 if (!m || m->first->is_static() || m->first->is_global())
1065 octave_value_list args;
1068 if (argout.length() < 1)
1076 if (!m || m->first->is_static() || m->first->is_global())
1078 octave_value_list args;
1082 if (argout.length() < 1)
1088 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret) {
1090 if (!m || m->first->is_static() || m->first->is_global())
1092 octave_value_list args;
1096 if (argout.length() >= 1)
1102 if (m->second.is_defined())
1104 else if (m->first) {
1105 if (m->first->get_method)
1106 return m->first->get_method(args, 1);
1107 else if (m->first->method)
1108 return octave_value(
new octave_builtin(m->first->method));
1110 error(
"undefined member");
1111 return octave_value_list();
1116 return octave_value((octave_base_value *) &x);
1124 bool _always_static =
false)
1128 types.push_back(std::make_pair(_type, _ptr));
1129 #ifdef SWIG_DIRECTORS
1131 Swig::Director *d = Swig::get_rtdir(_ptr);
1133 Swig::swig_director_set_self(d,
this);
1141 for (
unsigned int j = 0; j <
types.size(); ++j) {
1142 if (!
types[j].first || !
types[j].first->clientdata)
1150 #ifdef SWIG_DIRECTORS
1151 for (
unsigned int j = 0; j <
types.size(); ++j)
1152 Swig::erase_rtdir(
types[j].second.ptr);
1162 if (!m)
return dim_vector(1,1);
1165 octave_value_list inarg;
1167 octave_value_list outarg = nc_this->
member_invoke(m, inarg, 1);
1170 if (outarg.length() < 1)
return dim_vector(1,1);
1172 octave_value & out = outarg(0);
1175 if (out.is_cell()) {
1176 const Cell & c=out.cell_value();
1177 int ndim = c.rows();
1178 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1181 d.resize(ndim < 2 ? 2 : ndim);
1185 for (
int k=0;k<ndim;k++) {
1186 const octave_value& obj = c(k);
1187 d.elem(k) = obj.int_value();
1190 if (error_state)
return dim_vector(1,1);
1193 }
else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1194 if (out.rows()==1 || out.columns()==1) {
1195 Array<int> a = out.int_vector_value();
1196 if (error_state)
return dim_vector(1,1);
1198 d.resize(a.numel() < 2 ? 2 : a.numel());
1200 for (
int k=0;k<a.numel();k++) {
1205 return dim_vector(1,1);
1208 return dim_vector(1,1);
1229 return (
long)
types[0].second.ptr;
1234 if (!
types[0].first->clientdata)
1244 for (
unsigned int j = 0; j <
types.size(); ++j) {
1247 if (
types[j].first->clientdata) {
1251 ret +=
types[j].first->name;
1258 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1259 assert(!rhs.
types[j].second.destroyed);
1260 #ifdef SWIG_DIRECTORS
1261 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1263 Swig::swig_director_set_self(d,
this);
1281 if (!type &&
types.size())
1282 return types[0].second.ptr;
1283 for (
unsigned int j = 0; j <
types.size(); ++j)
1284 if (type ==
types[j].first)
1285 return types[j].second.ptr;
1286 for (
unsigned int j = 0; j <
types.size(); ++j) {
1302 #ifdef SWIG_DIRECTORS
1303 void director_destroyed(Swig::Director *d) {
1305 for (
unsigned int j = 0; j <
types.size(); ++j) {
1306 Swig::Director *dj = Swig::get_rtdir(
types[j].second.ptr);
1308 types[j].second.destroyed =
true;
1321 members[
name] = std::make_pair(m, octave_value());
1344 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1345 octave_value_list ovl =
subsref(ops, idx, 1);
1346 return ovl.length()? ovl(0) : octave_value();
1349 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1350 assert(ops.size() > 0);
1351 assert(ops.size() == idx.size());
1353 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1355 octave_value_list sub_ovl;
1362 error(
"cannot create instance");
1363 return octave_value_list();
1365 octave_value_list args;
1368 args.append(*idx_it++);
1373 else if (ops[skip] ==
'.') {
1374 std::string subname;
1377 octave_value_list subname_ovl(*idx_it++);
1379 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1380 subname = subname_ovl(0).string_value();
1383 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1389 if (!base || !(m->first =
find_member(base, subname)))
1392 error(
"member not found");
1393 return octave_value_list();
1396 octave_value_list args;
1398 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1400 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1401 ((m->first && m->first->method) || m->second.is_function() ||
1402 m->second.is_function_handle())) {
1403 args.append(*idx_it++);
1412 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1413 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1414 octave_value_list args;
1415 args.append(*idx_it++);
1418 error(
"error evaluating index operator");
1419 return octave_value_list();
1422 error(
"unsupported subsref");
1423 return octave_value_list();
1427 if (skip >= (
int) ops.size())
1429 if (sub_ovl.length() < 1) {
1430 error(
"bad subs ref");
1431 return octave_value_list();
1433 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1436 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1437 assert(ops.size() > 0);
1438 assert(ops.size() == idx.size());
1440 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1443 if (ops.size() > 1) {
1444 std::list < octave_value_list >::const_iterator last = idx.end();
1446 std::list < octave_value_list > next_idx(idx.begin(), last);
1447 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1448 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1451 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1452 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1455 octave_value_list args;
1457 args.append(*idx_it);
1461 error(
"%s member not found", op_name);
1464 else if (ops[skip] ==
'.') {
1465 octave_value_list subname_ovl(*idx_it++);
1467 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1468 std::string subname = subname_ovl(0).string_value();
1471 if (!m->first || !m->first->set_method) {
1474 }
else if (m->first->set_method) {
1475 octave_value_list args;
1476 if (!m->first->is_static() && !m->first->is_global())
1479 m->first->set_method(args, 1);
1481 error(
"member not assignable");
1483 error(
"unsupported subsasgn");
1501 error(
"__str__ method not defined");
1502 return std::string();
1505 if (outarg.length() < 1 || !outarg(0).is_string()) {
1506 error(
"__str__ method did not return a string");
1507 return std::string();
1509 return outarg(0).string_value();
1512 #if OCTAVE_API_VERSION_NUMBER >= 40
1514 return octave_map();
1518 return Octave_map();
1526 string_vector keys(tmp.size());
1528 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1529 keys(k++) = it->first;
1547 oct_mach_info::float_format fmt) {
1551 #if defined (HAVE_HDF5)
1553 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1558 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1563 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1571 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1575 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1578 ret = fcn->do_multi_index_op(1, args)(0);
1587 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1590 octave_value_list args;
1595 error(
"could not dispatch unary operator");
1596 return octave_value();
1599 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1604 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1607 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1608 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1610 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1613 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1618 octave_value_list args;
1649 error(
"could not dispatch binary operator");
1650 return octave_value();
1653 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1663 os <<
"{"; newline(os);
1664 increment_indent_level();
1665 for (
unsigned int j = 0; j <
types.size(); ++j) {
1667 if (
types[j].first->clientdata) {
1669 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1671 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1674 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1676 if (it->second.first) {
1677 const char *objtype = it->second.first->method ?
"method" :
"variable";
1678 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1679 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1680 assert(it->second.first->name == it->first);
1682 os << it->first; newline(os);
1685 decrement_indent_level();
1687 os <<
"}"; newline(os);
1730 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
1733 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1736 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1748 #if OCTAVE_API_VERSION_NUMBER >= 40
1769 oct_mach_info::float_format fmt)
1772 #if defined (HAVE_HDF5)
1774 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
1775 {
return ptr->save_hdf5(loc_id, name, save_as_floats); }
1778 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug)
1779 {
return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1782 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
1788 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const
1789 {
return ptr->
print(os, pr_as_read_syntax); }
1804 :
type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len) {
1808 if (outtype && outtype !=
type)
1810 assert(sz <=
buf.size());
1827 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1829 os <<
"swig packed type: name = " << (
type ?
type->
name : std::string()) <<
", len = " <<
buf.size(); newline(os);
1846 oct_mach_info::float_format fmt) {
1850 #if defined (HAVE_HDF5)
1852 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats) {
1857 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug) {
1870 error(
"attempt to set immutable member variable");
1871 return octave_value_list();
1879 :
ovl(_ovl),
j(_j) { }
1881 operator octave_value()
const {
1898 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1899 ov = ov.cell_value()(0);
1904 if (ov.type_id() != octave_swig_ref::static_type_id())
1913 #define swig_unary_op(name) \
1914 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1915 return octave_swig_type::dispatch_unary_op(x,#name); \
1917 #define swig_binary_op(name) \
1918 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1919 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1921 #define swigreg_unary_op(name) \
1922 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1923 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1924 #define swigreg_binary_op(name) \
1925 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1926 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1995 for (
int j = 0; j < tid; ++j) {
2004 #ifdef SWIG_DIRECTORS
2005 Swig::Director *d = Swig::get_rtdir(ptr);
2006 if (d && Swig::swig_director_get_self(d))
2007 return Swig::swig_director_get_self(d)->as_value();
2013 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2014 ov = ov.cell_value()(0);
2015 if (!ov.is_defined() ||
2016 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2021 if (ov.type_id() != octave_swig_ref::static_type_id())
2025 void *vptr = ost->
cast(type, own, flags);
2038 if (!ov.is_defined())
2040 if (ov.type_id() != octave_swig_packed::static_type_id())
2047 module_ns->
assign(name, ov);
2051 return get_global_value(name,
true);
2063 octave_value *pov =
new octave_value(value);
2064 set_global_value(name, *pov);
2068 #if OCTAVE_API_VERSION_NUMBER < 37
2069 link_to_global_variable(curr_sym_tab->lookup(name,
true));
2071 symbol_table::varref(name);
2072 symbol_table::mark_global(name);
2078 if (!ov.is_defined() ||
2079 ov.type_id() != octave_swig_packed::static_type_id())
2095 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2097 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2103 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2104 #define SWIGTYPE_p_char swig_types[1]
2105 #define SWIGTYPE_p_double swig_types[2]
2106 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2107 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2108 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2109 #define SWIGTYPE_p_int swig_types[6]
2110 #define SWIGTYPE_p_p_char swig_types[7]
2111 #define SWIGTYPE_p_unsigned_int swig_types[8]
2114 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2115 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2120 #define SWIGVERSION 0x020007
2121 #define SWIG_VERSION SWIGVERSION
2124 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2125 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2128 #include <stdexcept>
2138 #ifdef OCTAVE_EXPORT
2139 #if defined ( __GNUC__ ) && __GNUC__ > 3
2140 #undef OCTAVE_EXPORT
2141 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2159 inline int max(
int a,
int b )
2161 return a >= b ? a : b;
2163 inline int min(
int a,
int b )
2165 return a >= b ? a : b;
2179 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2191 if (
max( o_obj.columns(), 1 ) > 1 )
2196 else if (
max( o_obj.rows(), 1 ) > 1 )
2206 _dim(
const octave_value &o_obj,
int dim_idx )
2209 return max( o_obj.rows(), 0 );
2213 else if ( dim_idx == 1 )
2214 return max( o_obj.columns(), 0 );
2227 template <
class FLOAT>
2231 while ( n_el-- > 0 )
2232 *out_arr++ = (FLOAT) ( *in_arr++ );
2238 template void _cvt_double_to(
unsigned long *,
double *,
unsigned );
2240 template void _cvt_double_to(
unsigned short *,
double *,
unsigned );
2251 template <
class FLOAT>
2255 while ( n_el-- > 0 )
2256 *d_arr++ = double(*arr++);
2262 template void _cvt_to_double(
unsigned long *,
double *,
unsigned );
2264 template void _cvt_to_double(
unsigned short *,
double *,
unsigned );
2287 octave_value_list functionArguments;
2288 octave_value_list retval;
2295 for ( i = 0; i < n; i++ )
2301 functionArguments( 0 ) = xin;
2302 functionArguments( 1 ) = yin;
2304 if ( fcnMapForm != NULL )
2305 retval = feval( fcnMapForm, functionArguments, 1 );
2307 retval = feval( nameMapForm, functionArguments, 1 );
2310 if ( retval.length() >= 2 )
2312 xout = retval( 0 ).matrix_value();
2313 yout = retval( 1 ).matrix_value();
2315 for ( i = 0; i < n; i++ )
2317 x[i] = xout( i, 0 );
2318 y[i] = yout( i, 0 );
2330 octave_value_list functionArguments;
2331 octave_value_list retval;
2333 Matrix inAxis( 1, 1 );
2334 Matrix inValue( 1, 1 );
2335 inAxis( 0, 0 ) = axis;
2336 inValue( 0, 0 ) =
value;
2338 functionArguments( 0 ) = inAxis;
2339 functionArguments( 1 ) = inValue;
2341 if ( fcnLabelFunc != NULL )
2342 retval = feval( fcnLabelFunc, functionArguments, 1 );
2344 retval = feval( nameLabelFunc, functionArguments, 1 );
2346 strncpy( label, retval( 0 ).string_value().c_str(), length );
2356 octave_value_list functionArguments;
2357 octave_value_list retval;
2367 functionArguments( 0 ) = xin;
2368 functionArguments( 1 ) = yin;
2370 if ( fcnCoordTrans != NULL )
2371 retval = feval( fcnCoordTrans, functionArguments, 1 );
2373 retval = feval( nameCoordTrans, functionArguments, 1 );
2376 if ( retval.length() >= 2 )
2378 xout = retval( 0 ).matrix_value();
2379 yout = retval( 1 ).matrix_value();
2387 void testppchar( PLINT nlegend,
const PLINT *opt_array,
const char ** text )
2390 printf(
"nlegend =%d\n", nlegend );
2391 for ( i = 0; i < nlegend; i++ )
2393 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2394 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen( text[i] ) );
2395 printf(
"text[%d] =%s\n", i, text[i] );
2401 #if !defined(SWIG_NO_LLONG_MAX)
2402 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2403 # define LLONG_MAX __LONG_LONG_MAX__
2404 # define LLONG_MIN (-LLONG_MAX - 1LL)
2405 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2412 if (!ov.is_scalar_type())
2414 if (ov.is_complex_scalar())
2416 if (ov.is_double_type()||ov.is_single_type()) {
2417 double v=ov.double_value();
2422 *val = ov.long_value();
2433 if ((v < INT_MIN || v > INT_MAX)) {
2436 if (val) *val = (int)(v);
2443 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 )
2451 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2459 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2460 ov = ov.cell_value()(0);
2461 if (!ov.is_string())
2464 std::string str=ov.string_value();
2465 size_t len=str.size();
2466 char* cstr=(
char*)str.c_str();
2468 *cptr = (
char*)(memcpy((
new char[len + 1]), cstr,
sizeof(
char)*(len + 1)));
2483 return octave_value(value);
2496 return octave_value(value);
2505 gin.
dX = x_in; gin.
dY = y_in;
2507 *x = gin.
wX; *y = gin.
wY;
2514 if (!ov.is_scalar_type())
2516 if (ov.is_complex_scalar())
2519 *val = ov.double_value();
2528 PLFLT xlpos, PLFLT ylpos,
2530 PLINT colbox, PLINT collab,
2531 const PLINT *colline,
const PLINT *styline,
2532 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2533 const char *labx,
const char *laby,
const char *labtop )
2535 const char *legline[4];
2536 legline[0] = legline1; legline[1] = legline2;
2537 legline[2] = legline3; legline[3] = legline4;
2538 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2539 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2540 labx, laby, labtop );
2558 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2559 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2564 #define f2c( f, ff, nx, ny ) \
2566 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2567 for ( int i = 0; i < nx; i++ ) { \
2568 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2569 for ( int j = 0; j < ny; j++ ) \
2570 *( ff[i] + j ) = *( f + nx * j + i );}
2574 void my_plcont(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2575 PLINT ly,
const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2577 f2c( f, ff, nx, ny );
2578 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2583 void my_plcont0(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2584 PLINT ly,
const PLFLT *clevel, PLINT nlevel )
2586 f2c( f, ff, nx, ny );
2587 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2592 void my_plcont1(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2593 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2596 grid1.
nx = nx; grid1.
ny = ny;
2597 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2598 f2c( f, ff, nx, ny );
2599 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2603 void my_plcont2(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2604 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2607 f2c( xg, xgg, nx, ny );
2608 f2c( yg, ygg, nx, ny );
2609 grid2.
nx = nx; grid2.
ny = ny;
2610 grid2.
xg = xgg; grid2.
yg = ygg;
2611 f2c( f, ff, nx, ny );
2612 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2617 void my_plcont2p(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2618 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2621 f2c( xg, xgg, nx, ny );
2622 f2c( yg, ygg, nx, ny );
2623 grid2.
nx = nx; grid2.
ny = ny;
2624 grid2.
xg = xgg; grid2.
yg = ygg;
2625 f2c( f, ff, nx, ny );
2626 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2631 const PLFLT *
xg,
int nptsx,
const PLFLT *
yg,
int nptsy,
2632 PLFLT *zg,
int type, PLFLT data )
2634 f2c( zg, zgg, nptsx, nptsy );
2635 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2636 for (
int i = 0; i < nptsx; i++ )
2637 for (
int j = 0; j < nptsy; j++ )
2638 *( zg + nptsx * j + i ) = zgg[i][j];
2644 void my_plmesh(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2646 f2c( z, zz, nx, ny );
2647 c_plmesh( x, y, (
const PLFLT **) zz, nx, ny, opt );
2652 void my_plmeshc(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
2654 f2c( z, zz, nx, ny );
2655 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2660 void my_plot3d(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z,
2661 PLINT nx, PLINT ny, PLINT opt, PLINT side )
2663 f2c( z, zz, nx, ny );
2664 c_plot3d( x, y, (
const PLFLT **) zz, nx, ny, opt, side );
2669 PLINT nx, PLINT ny, PLINT opt,
2670 const PLFLT *clevel, PLINT nlevel )
2672 f2c( z, zz, nx, ny );
2673 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2678 PLINT nx, PLINT ny, PLINT opt,
2679 const PLFLT * clevel, PLINT nlevel,
2680 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
2682 f2c( z, zz, nx, ny );
2683 c_plot3dcl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2684 indexxmin, indexxmax, indexymin, indexymax );
2689 PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
2691 f2c( z, zz, nx, ny );
2692 c_plsurf3d( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2696 PLINT nx, PLINT ny, PLINT opt,
const PLFLT * clevel, PLINT nlevel,
2697 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
2699 f2c( z, zz, nx, ny );
2700 c_plsurf3dl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2701 indexxmin, indexxmax, indexymin, indexymax );
2711 void my_plshade(
const PLFLT *a, PLINT nx, PLINT ny,
const PLFLT *defined,
2712 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2713 PLFLT shade_min, PLFLT shade_max,
2714 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2715 PLINT min_color, PLINT min_width,
2716 PLINT max_color, PLINT max_width,
2717 PLINT rectangular, PLFLT *tr )
2719 f2c( a, aa, nx, ny );
2720 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2721 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2722 min_color, min_width, max_color, max_width,
2727 void my_plshade1(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
2728 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2729 PLFLT shade_min, PLFLT shade_max,
2730 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2731 PLINT min_color, PLINT min_width,
2732 PLINT max_color, PLINT max_width,
2733 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2736 grid1.
nx = nx; grid1.
ny = ny;
2737 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2738 f2c( a, aa, nx, ny );
2739 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2740 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2741 min_color, min_width, max_color, max_width,
2746 void my_plshade2(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
2747 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2748 PLFLT shade_min, PLFLT shade_max,
2749 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2750 PLINT min_color, PLINT min_width,
2751 PLINT max_color, PLINT max_width,
2752 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2755 f2c( xg, xgg, nx, ny );
2756 f2c( yg, ygg, nx, ny );
2757 grid2.
nx = nx; grid2.
ny = ny;
2758 grid2.
xg = xgg; grid2.
yg = ygg;
2759 f2c( a, aa, nx, ny );
2760 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2761 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2762 min_color, min_width, max_color, max_width,
2769 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2770 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2771 PLINT cont_color, PLINT cont_width,
2774 f2c( a, aa, nx, ny );
2775 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2776 clevel, nlevel, fill_width, cont_color, cont_width,
2777 plfill, rectangular, NULL, NULL );
2781 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2782 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2783 PLINT cont_color, PLINT cont_width,
2784 PLINT rectangular, PLFLT *tr )
2786 f2c( a, aa, nx, ny );
2787 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2788 clevel, nlevel, fill_width, cont_color, cont_width,
2793 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2794 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2795 PLINT cont_color, PLINT cont_width,
2796 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2799 grid1.
nx = nx; grid1.
ny = ny;
2800 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2802 f2c( a, aa, nx, ny );
2803 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2804 clevel, nlevel, fill_width, cont_color, cont_width,
2809 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2810 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2811 PLINT cont_color, PLINT cont_width,
2812 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2815 f2c( xg, xgg, nx, ny );
2816 f2c( yg, ygg, nx, ny );
2817 grid2.
nx = nx; grid2.
ny = ny;
2818 grid2.
xg = xgg; grid2.
yg = ygg;
2819 f2c( a, aa, nx, ny );
2820 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2821 clevel, nlevel, fill_width, cont_color, cont_width,
2829 void my_plvect(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2831 f2c( u, uu, nx, ny );
2832 f2c( v, vv, nx, ny );
2833 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
xform, tr );
2837 void my_plvect1(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2840 grid1.
nx = nx; grid1.
ny = ny;
2841 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2842 f2c( u, uu, nx, ny );
2843 f2c( v, vv, nx, ny );
2844 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr1, &grid1 );
2848 void my_plvect2(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2851 f2c( xg, xgg, nx, ny );
2852 f2c( yg, ygg, nx, ny );
2853 grid2.
nx = nx; grid2.
ny = ny;
2854 grid2.
xg = xgg; grid2.
yg = ygg;
2855 f2c( u, uu, nx, ny );
2856 f2c( v, vv, nx, ny );
2857 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr2, &grid2 );
2864 PLFLT zmin, PLFLT zmax,
2865 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2867 f2c( a, aa, nx, ny );
2868 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2875 PLFLT zmin, PLFLT zmax,
2876 PLFLT valuemin, PLFLT valuemax )
2878 f2c( a, aa, nx, ny );
2879 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2884 PLFLT zmin, PLFLT zmax,
2885 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2887 f2c( a, aa, nx, ny );
2888 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
2894 PLFLT zmin, PLFLT zmax,
2895 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2898 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
2899 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2900 f2c( a, aa, nx, ny );
2901 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
2907 PLFLT zmin, PLFLT zmax,
2908 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2911 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
2912 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2913 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
2914 grid2.
xg = xgg; grid2.
yg = ygg;
2915 f2c( a, aa, nx, ny );
2916 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
2922 PLINT opt, PLINT position, PLFLT x, PLFLT y,
2923 PLFLT x_length, PLFLT y_length,
2924 PLINT bg_color, PLINT bb_color, PLINT bb_style,
2925 PLFLT low_cap_color, PLFLT high_cap_color,
2926 PLINT cont_color, PLFLT cont_width,
2927 PLINT n_labels,
const PLINT *label_opts,
const char **label,
2928 PLINT n_axes,
const char ** axis_opts,
2929 const PLFLT *ticks,
const PLINT *sub_ticks,
2930 const PLINT *n_values,
const PLFLT *a )
2935 for ( i = 0; i < nx; i++ )
2936 if ( n_values[i] > ny )
2938 f2c( a, aa, nx, ny );
2940 opt, position, x, y,
2942 bg_color, bb_color, bb_style,
2943 low_cap_color, high_cap_color,
2944 cont_color, cont_width,
2945 n_labels, label_opts, label,
2955 if (!ov.is_scalar_type())
2957 if (ov.is_complex_scalar())
2959 if (ov.is_double_type()||ov.is_single_type()) {
2960 double v=ov.double_value();
2966 if (ov.is_int8_type()||ov.is_int16_type()||
2967 ov.is_int32_type()) {
2968 long v=ov.long_value();
2972 if (ov.is_int64_type()) {
2973 long long v=ov.int64_scalar_value().value();
2978 *val = ov.ulong_value();
2989 if ((v > UINT_MAX)) {
2992 if (val) *val = (
unsigned int)(v);
3001 return octave_value(value);
3015 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3018 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3019 if (csize <= size) {
3021 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3022 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3039 static int init = 0;
3052 return std::string(carray,carray+size);
3064 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3065 if (val) *val = (char)(v);
3075 Specify viewport in absolute coordinates \n\
3079 Alternate routine to plvpor for setting up the viewport. This routine\n\
3080 should be used only if the viewport is required to have a definite\n\
3081 size in millimeters. The routine plgspa is useful for finding out the\n\
3082 size of the current subpage. \n\
3084 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3086 This function is used in example 10. \n\
3092 plsvpa(xmin, xmax, ymin, ymax)\n\
3096 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3097 viewport from the left-hand edge of the subpage in millimeters. \n\
3099 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3100 viewport from the left-hand edge of the subpage in millimeters. \n\
3102 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3103 viewport from the bottom edge of the subpage in millimeters. \n\
3105 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3106 from the bottom edge of the subpage in millimeters. \n\
3109 Write text relative to viewport boundaries in 3D plots \n\
3113 Writes text at a specified position relative to the viewport\n\
3114 boundaries. Text may be written inside or outside the viewport, but\n\
3115 is clipped at the subpage boundaries. The reference point of a string\n\
3116 lies along a line passing through the string at half the height of a\n\
3117 capital letter. The position of the reference point along this line\n\
3118 is determined by just, and the position of the reference point\n\
3119 relative to the viewport is set by disp and pos. \n\
3121 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3123 This function is used in example 28. \n\
3129 plmtex3(side, disp, pos, just, text)\n\
3133 side (const char *, input) : Specifies the side of the viewport\n\
3134 along which the text is to be written. The string should contain\n\
3135 one or more of the following characters: [xyz][ps][v]. Only one\n\
3136 label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3137 both the X and Y axes. x: Label the X axis. \n\
3138 y: Label the Y axis. \n\
3139 z: Label the Z axis. \n\
3140 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3141 For X it is the axis that starts at y-min. For Y it is the\n\
3142 axis that starts at x-min. \n\
3143 s: Label the secondary axis. \n\
3144 v: Draw the text perpendicular to the axis. \n\
3147 disp (PLFLT, input) : Position of the reference point of string,\n\
3148 measured outwards from the specified viewport edge in units of the\n\
3149 current character height. Use negative disp to write within the\n\
3152 pos (PLFLT, input) : Position of the reference point of string\n\
3153 along the specified edge, expressed as a fraction of the length of\n\
3156 just (PLFLT, input) : Specifies the position of the string relative\n\
3157 to its reference point. If just=0. , the reference point is at\n\
3158 the left and if just=1. , it is at the right of the string. Other\n\
3159 values of just give intermediate justifications. \n\
3161 text (const char *, input) : The string to be written out. \n\
3164 Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n\
3168 Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n\
3169 and double alpha transparency values. This also sets the number of\n\
3172 Redacted form: plscmap1a(r, g, b, alpha)\n\
3174 This function is used in example 31. \n\
3180 plscmap1a(r, g, b, alpha, ncol1)\n\
3184 r (const PLINT *, input) : Pointer to array with set of unsigned\n\
3185 8-bit integers (0-255) representing the degree of red in the\n\
3188 g (const PLINT *, input) : Pointer to array with set of unsigned\n\
3189 8-bit integers (0-255) representing the degree of green in the\n\
3192 b (const PLINT *, input) : Pointer to array with set of unsigned\n\
3193 8-bit integers (0-255) representing the degree of blue in the\n\
3196 alpha (const PLFLT *, input) : Pointer to array with set of double\n\
3197 values (0.0-1.0) representing the alpha transparency value of the\n\
3200 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3204 Select standard viewport \n\
3208 Sets up a standard viewport, leaving a left-hand margin of seven\n\
3209 character heights, and four character heights around the other three\n\
3212 Redacted form: plvsta()\n\
3214 This function is used in examples 1,12,14,17,25,29. \n\
3223 Switch to graphics screen \n\
3227 Sets an interactive device to graphics mode, used in conjunction with\n\
3228 pltext to allow graphics and text to be interspersed. On a device\n\
3229 which supports separate text and graphics windows, this command causes\n\
3230 control to be switched to the graphics window. If already in graphics\n\
3231 mode, this command is ignored. It is also ignored on devices which\n\
3232 only support a single window or use a different method for shifting\n\
3233 focus. See also pltext. \n\
3235 Redacted form: plgra()\n\
3237 This function is used in example 1. \n\
3246 Set 8-bit RGB values and double alpha transparency value for given cmap0 color index \n\
3250 Set 8-bit RGB value and double alpha transparency value for given\n\
3251 cmap0 (see the PLplot documentation) index. Overwrites the previous\n\
3252 color value for the given index and, thus, does not result in any\n\
3253 additional allocation of space for colors. \n\
3255 This function is used in example 30. \n\
3261 plscol0a(icol0, r, g, b, alpha)\n\
3265 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3266 number of colors (which is set by default, by plscmap0n, or even\n\
3269 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3270 degree of red in the color. \n\
3272 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3273 degree of green in the color. \n\
3275 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3276 degree of blue in the color. \n\
3278 alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
3279 alpha transparency value of the color. \n\
3282 Set y axis parameters \n\
3286 Identical to plsxax, except that arguments are flags for y axis. See\n\
3287 the description of plsxax for more detail. \n\
3289 Redacted form: plsyax(digmax, digits)\n\
3291 This function is used in examples 1,14,31. \n\
3297 plsyax(digmax, digits)\n\
3301 digmax (PLINT, input) : Variable to set the maximum number of\n\
3302 digits for the y axis. If nonzero, the printed label will be\n\
3303 switched to a floating point representation when the number of\n\
3304 digits exceeds digmax. \n\
3306 digits (PLINT, input) : Field digits value. Currently, changing\n\
3307 its value here has no effect since it is set only by plbox or\n\
3308 plbox3. However, the user may obtain its value after a call to\n\
3309 either of these functions by calling plgyax. \n\
3312 Returns 8-bit RGB values for given color index from cmap0 \n\
3316 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3317 PLplot documentation). Values are negative if an invalid color id is\n\
3320 Redacted form: plgcol0(icol0, r, g, b)\n\
3322 This function is used in example 2. \n\
3328 plgcol0(icol0, r, g, b)\n\
3332 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3334 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3336 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3338 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3341 Set seed for internal random number generator. \n\
3345 Set the seed for the internal random number generator. See plrandd for\n\
3346 further details. \n\
3348 Redacted form: plseed(seed)\n\
3350 This function is used in example 21. \n\
3360 seed (unsigned int, input) : Seed for random number generator. \n\
3363 Magnitude colored plot surface with contour for z[x][y] with y index limits \n\
3367 When the implementation is completed this variant of plot3dc (see that\n\
3368 function\'s documentation for more details) should be suitable for the\n\
3369 case where the area of the x, y coordinate grid where z is defined can\n\
3370 be non-rectangular. The implementation is incomplete so the last 4\n\
3371 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3372 indexymax; are currently ignored and the functionality is otherwise\n\
3373 identical to that of plot3dc. \n\
3375 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3376 indexymin, indexymax) \n\
3377 \t Perl/PDL: Not available? \n\
3380 This function is not used in any example. \n\
3386 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3390 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
3391 which the function is evaluated. \n\
3393 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
3394 which the function is evaluated. \n\
3396 z (const PLFLT * const *, input) : Pointer to a vectored\n\
3397 two-dimensional array with set of function values. \n\
3399 nx (PLINT, input) : Number of x values at which the function is\n\
3402 ny (PLINT, input) : Number of y values at which the function is\n\
3405 opt (PLINT, input) : Determines the way in which the surface is\n\
3406 represented. To specify more than one option just add the options,\n\
3407 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3408 showing z as a function of x for each value of y[j] . \n\
3409 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3410 for each value of x[i] . \n\
3411 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3412 at which function is defined. \n\
3413 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3414 the z value being plotted. The color is used from the current\n\
3416 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3417 using parameters \n\
3420 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3421 the borders of the plotted function. \n\
3424 clevel (const PLFLT *, input) : Pointer to the array that defines\n\
3425 the contour level spacing. \n\
3427 nlevel (PLINT, input) : Number of elements in the clevel array. \n\
3429 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3430 corresponds to the first x index where z is defined. \n\
3432 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3433 which corresponds (by convention) to one more than the last x\n\
3434 index value where z is defined. \n\
3436 indexymin (const PLINT *, input) : Array of y index values which\n\
3437 all must be ≥ 0. These values are the first y index where z is\n\
3438 defined for a particular x index in the range from indexxmin to\n\
3439 indexxmax - 1. The dimension of indexymin is indexxmax. \n\
3441 indexymax (const PLINT *, input) : Array of y index values which\n\
3442 all must be ≤ ny. These values correspond (by convention) to one\n\
3443 more than the last y index where z is defined for a particular x\n\
3444 index in the range from indexxmin to indexxmax - 1. The dimension\n\
3445 of indexymax is indexxmax. \n\
3448 Get output file name \n\
3452 Gets the current output file name, if applicable. \n\
3454 Redacted form: plgfnam(fnam)\n\
3456 This function is used in example 31. \n\
3466 fnam (char *, output) : Pointer to file name string (a preallocated\n\
3467 string of 80 characters or more). \n\
3470 Specify world coordinates of viewport boundaries \n\
3474 Sets up the world coordinates of the edges of the viewport. \n\
3476 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3478 This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3484 plwind(xmin, xmax, ymin, ymax)\n\
3488 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3489 of the viewport. \n\
3491 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3492 of the viewport. \n\
3494 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3497 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3501 Set cmap1 colors using a piece-wise linear relationship \n\
3505 Set cmap1 colors using a piece-wise linear relationship between\n\
3506 intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n\
3507 color space (see the PLplot documentation). May be called at any\n\
3510 The idea here is to specify a number of control points that define the\n\
3511 mapping between input cmap1 intensity indices and HLS (or RGB). \n\
3512 Between these points, linear interpolation is used which gives a\n\
3513 smooth variation of color with intensity index. Any number of control\n\
3514 points may be specified, located at arbitrary positions, although\n\
3515 typically 2 - 4 are enough. Another way of stating this is that we are\n\
3516 traversing a given number of lines through HLS (or RGB) space as we\n\
3517 move through cmap1 intensity indices. The control points at the\n\
3518 minimum and maximum position (0 and 1) must always be specified. By\n\
3519 adding more control points you can get more variation. One good\n\
3520 technique for plotting functions that vary about some expected average\n\
3521 is to use an additional 2 control points in the center (position ~=\n\
3522 0.5) that are the same lightness as the background (typically white\n\
3523 for paper output, black for crt), and same hue as the boundary control\n\
3524 points. This allows the highs and lows to be very easily\n\
3527 Each control point must specify the cmap1 intensity index and the\n\
3528 associated three coordinates in HLS or RGB space. The first point\n\
3529 must correspond to position = 0, and the last to position = 1. \n\
3531 The default behaviour is for the hue to be linearly interpolated\n\
3532 between the control points. Since the hue lies in the range [0, 360]\n\
3533 this corresponds to interpolation around the \"front\" of the color\n\
3534 wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3535 alternative interpolation is used between control points i and i+1. If\n\
3536 hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n\
3537 - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n\
3538 this as interpolation around the \"back\" or \"reverse\" of the color\n\
3539 wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3540 alt_hue_path[] = false for every control point. \n\
3542 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3543 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3544 240]truegreen-yellow-red-magenta-blue[240\n\
3545 120]trueblue-magenta-red-yellow-green\n\
3547 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3548 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3549 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3551 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3554 This function is used in examples 8,11,12,15,20,21. \n\
3560 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3564 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3566 npts (PLINT, input) : number of control points \n\
3568 intensity (const PLFLT *, input) : intensity index for each control\n\
3569 point (between 0.0 and 1.0, in ascending order) \n\
3571 coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n\
3574 coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n\
3577 coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n\
3580 alt_hue_path (const PLBOOL *, input) : alternative interpolation\n\
3581 method flag for each control point. (alt_hue_path[i] refers to the\n\
3582 interpolation interval between the i and i + 1 control points). \n\
3585 Set the pause (on end-of-page) status \n\
3589 Set the pause (on end-of-page) status. \n\
3591 Redacted form: plspause(pause)\n\
3593 This function is in examples 14,20. \n\
3603 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3604 end-of-page for those drivers which support this. Otherwise there\n\
3608 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3612 Routine for creating a discrete plot legend with a plotted filled box,\n\
3613 line, and/or line of symbols for each annotated legend entry. (See\n\
3614 plcolorbar for similar functionality for creating continuous color\n\
3615 bars.) The arguments of pllegend provide control over the location\n\
3616 and size of the legend as well as the location and characteristics of\n\
3617 the elements (most of which are optional) within that legend. The\n\
3618 resulting legend is clipped at the boundaries of the current subpage. \n\
3619 (N.B. the adopted coordinate system used for some of the parameters is\n\
3620 defined in the documentation of the position parameter.) \n\
3622 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3623 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3624 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3625 test_justification, text_colors, text, box_colors, box_patterns,\n\
3626 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3627 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3629 This function is used in examples 4, 26, and 33. \n\
3635 pllegend(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\
3639 p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3640 contains (after the call) the legend width in adopted coordinates.\n\
3641 This quantity is calculated from plot_width, text_offset, ncolumn\n\
3642 (possibly modified inside the routine depending on nlegend and\n\
3643 nrow), and the length (calculated internally) of the longest text\n\
3646 p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3647 contains (after the call) the legend height in adopted\n\
3648 coordinates. This quantity is calculated from text_scale,\n\
3649 text_spacing, and nrow (possibly modified inside the routine\n\
3650 depending on nlegend and nrow). \n\
3652 opt (PLINT, input) : opt contains bits controlling the overall\n\
3653 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3654 on the left of the legend and the plotted area on the right.\n\
3655 Otherwise, put the text area on the right of the legend and the\n\
3656 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3657 plot a (semi-transparent) background for the legend. If the\n\
3658 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3659 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3660 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3661 plot the resulting array of legend entries in row-major order.\n\
3662 Otherwise, plot the legend entries in column-major order. \n\
3664 position (PLINT, input) : position contains bits which control the\n\
3665 overall position of the legend and the definition of the adopted\n\
3666 coordinates used for positions just like what is done for the\n\
3667 position argument for plcolorbar. However, note that the defaults\n\
3668 for the position bits (see below) are different than the\n\
3669 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3670 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3671 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3672 the 16 possible standard positions (the 4 corners and centers of\n\
3673 the 4 sides for both the inside and outside cases) of the legend\n\
3674 relative to the adopted coordinate system. The corner positions\n\
3675 are specified by the appropriate combination of two of the\n\
3676 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3677 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3678 value of one of those bits. The adopted coordinates are\n\
3679 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3680 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3681 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3682 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3683 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3684 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3685 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3686 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3688 x (PLFLT, input) : X offset of the legend position in adopted\n\
3689 coordinates from the specified standard position of the legend.\n\
3690 For positive x, the direction of motion away from the standard\n\
3691 position is inward/outward from the standard corner positions or\n\
3692 standard left or right positions if the\n\
3693 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3694 For the standard top or bottom positions, the direction of motion\n\
3695 is toward positive X. \n\
3697 y (PLFLT, input) : Y offset of the legend position in adopted\n\
3698 coordinates from the specified standard position of the legend.\n\
3699 For positive y, the direction of motion away from the standard\n\
3700 position is inward/outward from the standard corner positions or\n\
3701 standard top or bottom positions if the\n\
3702 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3703 For the standard left or right positions, the direction of motion\n\
3704 is toward positive Y. \n\
3706 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3707 of the plot area (where the colored boxes, lines, and/or lines of\n\
3708 symbols are drawn) of the legend. \n\
3710 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3711 legend (PL_LEGEND_BACKGROUND). \n\
3713 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3714 for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3716 bb_style (PLINT, input) : The pllsty style number for the\n\
3717 bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n\
3719 nrow (PLINT, input) : The cmap0 index of the background color for\n\
3720 the legend (PL_LEGEND_BACKGROUND). \n\
3722 ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3723 for the legend (PL_LEGEND_BACKGROUND). \n\
3725 nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3726 vertical height of the legend in adopted coordinates is calculated\n\
3727 internally from nlegend, text_scale (see below), and text_spacing\n\
3730 opt_array (const PLINT *, input) : Array of nlegend values of\n\
3731 options to control each individual plotted area corresponding to a\n\
3732 legend entry. If the \n\
3733 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3735 PL_LEGEND_COLOR_BOX, \n\
3736 PL_LEGEND_LINE, and/or \n\
3737 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3738 entry is plotted with a colored box; a line; and/or a line of\n\
3741 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3742 area in units of character width. N.B. The total horizontal\n\
3743 width of the legend in adopted coordinates is calculated\n\
3745 plot_width (see above), \n\
3746 text_offset, and length (calculated internally) of the longest text\n\
3749 text_scale (PLFLT, input) : Character height scale for text\n\
3750 annotations. N.B. The total vertical height of the legend in\n\
3751 adopted coordinates is calculated internally from \n\
3752 nlegend (see above), \n\
3754 text_spacing (see below). \n\
3756 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3757 character height from one legend entry to the next. N.B. The\n\
3758 total vertical height of the legend in adopted coordinates is\n\
3759 calculated internally from \n\
3760 nlegend (see above), \n\
3761 text_scale (see above), and \n\
3764 text_justification (PLFLT, input) : Justification parameter used\n\
3765 for text justification. The most common values of\n\
3766 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3767 is left justified, centred, or right justified within the text\n\
3768 area, but other values are allowed as well. \n\
3770 text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n\
3773 text (const char * const *, input) : Array of nlegend text string\n\
3776 box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n\
3777 for the discrete colored boxes (\n\
3778 PL_LEGEND_COLOR_BOX). \n\
3780 box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3781 (plpsty indices) for the discrete colored boxes (\n\
3782 PL_LEGEND_COLOR_BOX). \n\
3784 box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3785 of fraction of character height) for the height of the discrete\n\
3787 PL_LEGEND_COLOR_BOX). \n\
3789 box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3790 widths for the patterns specified by box_patterns (\n\
3791 PL_LEGEND_COLOR_BOX). \n\
3793 line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n\
3795 PL_LEGEND_LINE). \n\
3797 line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3798 (plsty indices) (\n\
3799 PL_LEGEND_LINE). \n\
3801 line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3802 PL_LEGEND_LINE). \n\
3804 symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n\
3806 PL_LEGEND_SYMBOL). \n\
3808 symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3809 values for the symbol height (\n\
3810 PL_LEGEND_SYMBOL). \n\
3812 symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3813 symbols to be drawn across the width of the plotted area (\n\
3814 PL_LEGEND_SYMBOL). \n\
3816 symbols (const char * const *, input) : Array of nlegend symbols\n\
3817 (plpoin indices) (\n\
3818 PL_LEGEND_SYMBOL). \n\
3821 Set number of colors in cmap1 \n\
3825 Set number of colors in cmap1, (re-)allocate color map1, and set\n\
3826 default values if this is the first allocation (see the PLplot\n\
3829 Redacted form: plscmap1n(ncol1)\n\
3831 This function is used in examples 8,11,20,21. \n\
3841 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3842 the map1 palette. If this number is zero or less, then the value\n\
3843 from the previous call to plscmap1n is used and if there is no\n\
3844 previous call, then a default value is used. \n\
3847 Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n\
3851 Returns 8-bit RGB values (0-255) and double alpha transparency value\n\
3852 (0.0 - 1.0) for given color from cmap0 (see the PLplot\n\
3853 documentation). Values are negative if an invalid color id is given. \n\
3855 This function is used in example 30. \n\
3861 plgcol0a(icol0, r, g, b, alpha)\n\
3865 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3867 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3869 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3871 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3873 alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
3877 Replays contents of plot buffer to current device/file \n\
3881 Replays contents of plot buffer to current device/file. \n\
3883 Redacted form: plreplot()\n\
3885 This function is used in example 1,20. \n\
3894 Simple routine to write labels \n\
3898 Routine for writing simple labels. Use plmtex for more complex labels. \n\
3900 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3902 This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3908 pllab(xlabel, ylabel, tlabel)\n\
3912 xlabel (const char *, input) : Label for horizontal axis. \n\
3914 ylabel (const char *, input) : Label for vertical axis. \n\
3916 tlabel (const char *, input) : Title of graph. \n\
3919 Set parameters that define current device-space window \n\
3923 Set relative margin width, aspect ratio, and relative justification\n\
3924 that define current device-space window. If you want to just use the\n\
3925 previous value for any of these, just pass in the magic value\n\
3926 PL_NOTSET. It is unlikely that one should ever need to change the\n\
3927 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3928 called the default values of mar, jx, and jy are all 0. aspect is set\n\
3929 to a device-specific value. \n\
3931 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3933 This function is used in example 31. \n\
3939 plsdidev(mar, aspect, jx, jy)\n\
3943 mar (PLFLT, input) : Relative margin width. \n\
3945 aspect (PLFLT, input) : Aspect ratio. \n\
3947 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3948 the range -0.5 to 0.5. \n\
3950 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3951 the range -0.5 to 0.5. \n\
3958 Begins a new page.\tFor a file driver, the output file is opened if\n\
3959 necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3960 page break is desired at a particular point when plotting to subpages.\n\
3961 Another use for pleop and plbop is when plotting pages to different\n\
3962 files, since you can manually set the file name by calling plsfnam\n\
3963 after the call to pleop. (In fact some drivers may only support a\n\
3964 single page per file, making this a necessity.) One way to handle\n\
3965 this case automatically is to page advance via pladv, but enable\n\
3966 familying (see plsfam) with a small limit on the file size so that a\n\
3967 new family member file will be created on each page break. \n\
3969 Redacted form: plbop()\n\
3971 This function is used in examples 2,20. \n\
3980 Set cmap0 colors by 8-bit RGB values \n\
3984 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
3985 documentation). This sets the entire color map -- only as many colors\n\
3986 as specified will be allocated. \n\
3988 Redacted form: plscmap0(r, g, b)\n\
3990 This function is used in examples 2,24. \n\
3996 plscmap0(r, g, b, ncol0)\n\
4000 r (const PLINT *, input) : Pointer to array with set of unsigned\n\
4001 8-bit integers (0-255) representing the degree of red in the\n\
4004 g (const PLINT *, input) : Pointer to array with set of unsigned\n\
4005 8-bit integers (0-255) representing the degree of green in the\n\
4008 b (const PLINT *, input) : Pointer to array with set of unsigned\n\
4009 8-bit integers (0-255) representing the degree of blue in the\n\
4012 ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
4015 Set the number of subpages in x and y \n\
4019 Set the number of subpages in x and y. \n\
4021 Redacted form: plssub(nx, ny)\n\
4023 This function is examples 1,2,14,21,25,27. \n\
4033 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4034 of window columns). \n\
4036 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4037 of window rows). \n\
4040 Set a global coordinate transform function \n\
4044 This function can be used to define a coordinate transformation which\n\
4045 affects all elements drawn within the current plot window. The\n\
4046 coordinate_transform function is similar to that provided for the\n\
4047 plmap and plmeridians functions. The coordinate_transform_data\n\
4048 parameter may be used to pass extra data to coordinate_transform. \n\
4050 Redacted form: General: plstransform(coordinate_transform,\n\
4051 coordinate_transform_data)\n\
4054 This function is used in examples 19 and 22. \n\
4060 plstransform(coordinate_transform, coordinate_transform_data)\n\
4064 coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n\
4065 PLPointer) , input) : Pointer to a function that defines a\n\
4066 transformation from the input (x, y) coordinate to a new plot\n\
4067 world coordinate. A NULL pointer means that no transform is\n\
4070 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4072 coordinate_transform. \n\
4075 Set cmap1 colors using 8-bit RGB values \n\
4079 Set cmap1 colors using 8-bit RGB values (see the PLplot\n\
4080 documentation). This also sets the number of colors. \n\
4082 Redacted form: plscmap1(r, g, b)\n\
4084 This function is used in example 31. \n\
4090 plscmap1(r, g, b, ncol1)\n\
4094 r (const PLINT *, input) : Pointer to array with set of unsigned\n\
4095 8-bit integers (0-255) representing the degree of red in the\n\
4098 g (const PLINT *, input) : Pointer to array with set of unsigned\n\
4099 8-bit integers (0-255) representing the degree of green in the\n\
4102 b (const PLINT *, input) : Pointer to array with set of unsigned\n\
4103 8-bit integers (0-255) representing the degree of blue in the\n\
4106 ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
4109 Configure the transformation between continuous and broken-down time for the current stream \n\
4113 Configure the transformation between continuous and broken-down time\n\
4114 for the current stream. This transformation is used by both plbtime\n\
4117 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4118 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4119 \t Perl/PDL: Not available? \n\
4122 This function is used in example 29. \n\
4128 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4132 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4133 As a special case, if \n\
4134 scale is 0., then all other arguments are ignored, and the result (the\n\
4135 default used by PLplot) is the equivalent of a call to\n\
4136 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4137 That is, for this special case broken-down time is calculated with\n\
4138 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4139 and the continuous time is defined as the number of seconds since\n\
4140 the Unix epoch of 1970-01-01T00:00:00Z. \n\
4142 offset1 (PLFLT, input) : If \n\
4143 ifbtime_offset is true, the parameters \n\
4145 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4146 (with units in days) specify the epoch of the continuous time\n\
4147 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4148 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4149 are used to specify the origin to allow users (by specifying \n\
4150 offset1 as an integer that can be exactly represented by a\n\
4151 floating-point variable and specifying \n\
4152 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4153 the numerical errors of the continuous time representation. \n\
4155 offset2 (PLFLT, input) : See documentation of \n\
4158 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4159 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4160 calendar is used for broken-down time rather than the proleptic\n\
4161 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4162 have been historically used to define UTC are inserted into the\n\
4163 broken-down time. Other possibilities for additional control bits\n\
4164 for ccontrol exist such as making the historical time corrections\n\
4165 in the broken-down time corresponding to ET (ephemeris time) or\n\
4166 making the (slightly non-constant) corrections from international\n\
4167 atomic time (TAI) to what astronomers define as terrestrial time\n\
4168 (TT). But those additional possibilities have not been\n\
4169 implemented yet in the qsastime library (one of the PLplot utility\n\
4172 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4173 epoch of the continuous time scale is specified by the user. If \n\
4174 ifbtime_offset is false, then \n\
4176 offset2 are used to specify the epoch, and the following broken-down\n\
4177 time parameters are completely ignored. If \n\
4178 ifbtime_offset is true, then \n\
4180 offset2 are completely ignored, and the following broken-down time\n\
4181 parameters are used to specify the epoch. \n\
4183 year (PLINT, input) : Year of epoch. \n\
4185 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4188 day (PLINT, input) : Day of epoch in range from 1 to 31. \n\
4190 hour (PLINT, input) : Hour of epoch in range from 0 to 23 \n\
4192 min (PLINT, input) : Minute of epoch in range from 0 to 59. \n\
4194 sec (PLFLT, input) : Second of epoch in floating range from 0. to\n\
4198 Set length of minor ticks \n\
4202 This sets up the length of the minor ticks and the length of the\n\
4203 terminals on error bars. The actual length is the product of the\n\
4204 default length and a scaling factor as for character height. \n\
4206 Redacted form: plsmin(def, scale)\n\
4208 This function is used in example 29. \n\
4214 plsmin(def, scale)\n\
4218 def (PLFLT, input) : The default length of a minor tick in\n\
4219 millimeters, should be set to zero if the default length is to\n\
4220 remain unchanged. \n\
4222 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4223 actual tick length. \n\
4226 Set character size \n\
4230 This sets up the size of all subsequent characters drawn. The actual\n\
4231 height of a character is the product of the default character size and\n\
4232 a scaling factor. \n\
4234 Redacted form: plschr(def, scale)\n\
4236 This function is used in example 2,13,23,24. \n\
4242 plschr(def, scale)\n\
4246 def (PLFLT, input) : The default height of a character in\n\
4247 millimeters, should be set to zero if the default height is to\n\
4248 remain unchanged. \n\
4250 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4251 actual character height. \n\
4254 Initialize PLplot \n\
4258 Initializing the plotting package.\tThe program prompts for the device\n\
4259 keyword or number of the desired output device. Hitting a RETURN in\n\
4260 response to the prompt is the same as selecting the first device. \n\
4261 plinit will issue no prompt if either the device was specified\n\
4262 previously (via command line flag, the plsetopt function, or the\n\
4263 plsdev function), or if only one device is enabled when PLplot is\n\
4264 installed.\tIf subpages have been specified, the output device is\n\
4265 divided into nx by ny subpages, each of which may be used\n\
4266 independently. If plinit is called again during a program, the\n\
4267 previously opened file will be closed. The subroutine pladv is used\n\
4268 to advance from one subpage to the next. \n\
4270 Redacted form: plinit()\n\
4272 This function is used in all of the examples. \n\
4281 Draw a box with axes, etc\n\
4285 Draws a box around the currently defined viewport, and labels it with\n\
4286 world coordinate values appropriate to the window.\tThus plbox should\n\
4287 only be called after defining both viewport and window. The character\n\
4288 strings xopt and yopt specify how the box should be drawn as described\n\
4289 below. If ticks and/or subticks are to be drawn for a particular\n\
4290 axis, the tick intervals and number of subintervals may be specified\n\
4291 explicitly, or they may be defaulted by setting the appropriate\n\
4292 arguments to zero. \n\
4294 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4295 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4298 This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4304 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4308 xopt (const char *, input) : Pointer to character string specifying\n\
4309 options for horizontal axis. The string can include any\n\
4310 combination of the following letters (upper or lower case) in any\n\
4311 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4312 is vertical line (x=0). \n\
4313 b: Draws bottom (X) or left (Y) edge of frame. \n\
4314 c: Draws top (X) or right (Y) edge of frame. \n\
4315 d: Plot labels as date / time. Values are assumed to be\n\
4316 seconds since the epoch (as used by gmtime). \n\
4317 f: Always use fixed point numeric labels. \n\
4318 g: Draws a grid at the major tick interval. \n\
4319 h: Draws a grid at the minor tick interval. \n\
4320 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4322 l: Labels axis logarithmically. This only affects the labels,\n\
4323 not the data, and so it is necessary to compute the logarithms\n\
4324 of data points before passing them to any of the drawing\n\
4326 m: Writes numeric labels at major tick intervals in the\n\
4327 unconventional location (above box for X, right of box for Y). \n\
4328 n: Writes numeric labels at major tick intervals in the\n\
4329 conventional location (below box for X, left of box for Y). \n\
4330 o: Use custom labelling function to generate axis label text. \n\
4331 The custom labelling function can be defined with the\n\
4332 plslabelfunc command. \n\
4333 s: Enables subticks between major ticks, only valid if t is\n\
4335 t: Draws major ticks. \n\
4336 u: Exactly like \"b\" except don\'t draw edge line. \n\
4337 w: Exactly like \"c\" except don\'t draw edge line. \n\
4338 x: Exactly like \"t\" (including the side effect of the\n\
4339 numerical labels for the major ticks) except exclude drawing\n\
4340 the major and minor tick marks. \n\
4343 xtick (PLFLT, input) : World coordinate interval between major\n\
4344 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4345 generates a suitable tick interval. \n\
4347 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4348 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4349 generates a suitable minor tick interval. \n\
4351 yopt (const char *, input) : Pointer to character string specifying\n\
4352 options for vertical axis. The string can include any combination\n\
4353 of the letters defined above for xopt, and in addition may\n\
4354 contain: v: Write numeric labels for vertical axis parallel to the\n\
4355 base of the graph, rather than parallel to the axis. \n\
4358 ytick (PLFLT, input) : World coordinate interval between major\n\
4359 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4360 generates a suitable tick interval. \n\
4362 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4363 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4364 generates a suitable minor tick interval. \n\
4367 Get parameters that define current device-space window \n\
4371 Get relative margin width, aspect ratio, and relative justification\n\
4372 that define current device-space window. If plsdidev has not been\n\
4373 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4374 p_jy will all be 0. \n\
4376 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4378 This function is used in example 31. \n\
4384 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4388 p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4390 p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4392 p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4394 p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4397 Plot a glyph at the specified points \n\
4401 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4402 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4403 is specified with a PLplot user string. Note that the user string is\n\
4404 not actually limited to one glyph so it is possible (but not normally\n\
4405 useful) to plot more than one glyph at the specified points with this\n\
4406 function. As with plmtex and plptex, the user string can contain FCI\n\
4407 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4408 else PLplot escapes for Hershey or unicode text to determine the\n\
4411 Redacted form: plstring(x, y, string)\n\
4413 This function is used in examples 4, 21 and 26. \n\
4419 plstring(n, x, y, string)\n\
4423 n (PLINT, input) : Number of points in the x and y arrays. \n\
4425 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
4428 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
4431 string (const char *, input) : PLplot user string corresponding to\n\
4432 the glyph to be plotted at each of the n points. \n\
4435 Plot all or a subset of Shapefile data using strings or points in world coordinates \n\
4439 As per plmapline, however the items are plotted as strings or points\n\
4440 in the same way as plstring. \n\
4442 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4443 maxy, plotentries)\n\
4445 This function is used in example 19. \n\
4451 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4455 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
4456 supplied function to transform the coordinates given in the\n\
4457 shapefile into a plot coordinate system. By using this transform,\n\
4458 we can change from a longitude, latitude coordinate to a polar\n\
4459 stereographic project, for example. Initially, x[0]..[n-1] are\n\
4460 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
4461 After the call to mapform(), x[] and y[] should be replaced by the\n\
4462 corresponding plot coordinates. If no transform is desired,\n\
4463 mapform can be replaced by NULL. \n\
4465 name (const char *, input) : The file name of a set of Shapefile\n\
4466 files without the file extension. \n\
4468 string (const char *, input) : A NULL terminated string of\n\
4469 characters to be drawn. \n\
4471 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4472 be in the same units as used by the Shapefile. You could use a\n\
4473 very large negative number to plot everything, but you can improve\n\
4474 performance by limiting the area drawn. The units must match those\n\
4475 of the Shapefile projection, which may be for example longitude or\n\
4476 distance. The value of minx must be less than the value of maxx. \n\
4478 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4479 use a very large number to plot everything, but you can improve\n\
4480 performance by limiting the area drawn. \n\
4482 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4483 be in the same units as used by the Shapefile. You could use a\n\
4484 very large negative number to plot everything, but you can improve\n\
4485 performance by limiting the area drawn. The units must match those\n\
4486 of the Shapefile projection, which may be for example latitude or\n\
4487 distance. The value of miny must be less than the value of maxy. \n\
4489 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4490 use a very large number to plot everything, but you can improve\n\
4491 performance by limiting the area drawn. \n\
4493 plotentries (const PLINT *, input) : An array of integers\n\
4494 indicating the elements of the Shapefile (zero indexed) which will\n\
4495 be drawn. Setting plotentries to NULL will plot all elements of\n\
4498 nplotentries (PLINT, input) : The number of items in plotentries.\n\
4499 Ignored if plotentries is NULL. \n\
4502 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n\
4506 Sets up plotter environment for simple graphs by calling pladv and\n\
4507 setting up viewport and window to sensible default values.\tplenv0\n\
4508 leaves enough room around most graphs for axis labels and a title.\n\
4509 When these defaults are not suitable, use the individual routines\n\
4510 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4511 defining the window, and plbox for drawing the box. \n\
4513 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4515 This function is used in example 21. \n\
4521 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4525 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4526 world coordinates). \n\
4528 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4529 world coordinates). \n\
4531 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4534 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4537 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4538 scales will not be set, the user must set up the scale before\n\
4539 calling plenv0 using plsvpa, plvasp or other. \n\
4540 0: the x and y axes are scaled independently to use as much of\n\
4541 the screen as possible. \n\
4542 1: the scales of the x and y axes are made equal. \n\
4543 2: the axis of the x and y axes are made equal, and the plot\n\
4544 box will be square. \n\
4547 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4548 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4549 -1: draw box only. \n\
4550 0: draw box, ticks, and numeric tick labels. \n\
4551 1: also draw coordinate axes at x=0 and y=0. \n\
4552 2: also draw a grid at major tick positions in both\n\
4554 3: also draw a grid at minor tick positions in both\n\
4556 10: same as 0 except logarithmic x tick marks. (The x data\n\
4557 have to be converted to logarithms separately.) \n\
4558 11: same as 1 except logarithmic x tick marks. (The x data\n\
4559 have to be converted to logarithms separately.) \n\
4560 12: same as 2 except logarithmic x tick marks. (The x data\n\
4561 have to be converted to logarithms separately.) \n\
4562 13: same as 3 except logarithmic x tick marks. (The x data\n\
4563 have to be converted to logarithms separately.) \n\
4564 20: same as 0 except logarithmic y tick marks. (The y data\n\
4565 have to be converted to logarithms separately.) \n\
4566 21: same as 1 except logarithmic y tick marks. (The y data\n\
4567 have to be converted to logarithms separately.) \n\
4568 22: same as 2 except logarithmic y tick marks. (The y data\n\
4569 have to be converted to logarithms separately.) \n\
4570 23: same as 3 except logarithmic y tick marks. (The y data\n\
4571 have to be converted to logarithms separately.) \n\
4572 30: same as 0 except logarithmic x and y tick marks. (The x\n\
4573 and y data have to be converted to logarithms separately.) \n\
4574 31: same as 1 except logarithmic x and y tick marks. (The x\n\
4575 and y data have to be converted to logarithms separately.) \n\
4576 32: same as 2 except logarithmic x and y tick marks. (The x\n\
4577 and y data have to be converted to logarithms separately.) \n\
4578 33: same as 3 except logarithmic x and y tick marks. (The x\n\
4579 and y data have to be converted to logarithms separately.) \n\
4580 40: same as 0 except date / time x labels. \n\
4581 41: same as 1 except date / time x labels. \n\
4582 42: same as 2 except date / time x labels. \n\
4583 43: same as 3 except date / time x labels. \n\
4584 50: same as 0 except date / time y labels. \n\
4585 51: same as 1 except date / time y labels. \n\
4586 52: same as 2 except date / time y labels. \n\
4587 53: same as 3 except date / time y labels. \n\
4588 60: same as 0 except date / time x and y labels. \n\
4589 61: same as 1 except date / time x and y labels. \n\
4590 62: same as 2 except date / time x and y labels. \n\
4591 63: same as 3 except date / time x and y labels. \n\
4592 70: same as 0 except custom x and y labels. \n\
4593 71: same as 1 except custom x and y labels. \n\
4594 72: same as 2 except custom x and y labels. \n\
4595 73: same as 3 except custom x and y labels. \n\
4598 Set up window for 3-d plotting \n\
4602 Sets up a window for a three-dimensional surface plot within the\n\
4603 currently defined two-dimensional window. The enclosing box for the\n\
4604 surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4605 user-coordinate space is mapped into a box of world coordinate size\n\
4606 basex by basey by height so that xmin maps to -\n\
4607 basex/2 , xmax maps to basex/2 , ymin maps to -\n\
4608 basey/2 , ymax maps to basey/2 , zmin maps to 0 and zmax maps to\n\
4609 height. The resulting world-coordinate box is then viewed by an\n\
4610 observer at altitude alt and azimuth az. This routine must be called\n\
4611 before plbox3 or plot3d. For a more complete description of\n\
4612 three-dimensional plotting see the PLplot documentation. \n\
4614 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4615 zmin, zmax, alt, az)\n\
4617 This function is examples 8,11,18,21. \n\
4623 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4627 basex (PLFLT, input) : The x coordinate size of the\n\
4628 world-coordinate box. \n\
4630 basey (PLFLT, input) : The y coordinate size of the\n\
4631 world-coordinate box. \n\
4633 height (PLFLT, input) : The z coordinate size of the\n\
4634 world-coordinate box. \n\
4636 xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4638 xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4640 ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4642 ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4644 zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4646 zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4648 alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4651 az (PLFLT, input) : The viewing azimuth in degrees. When az=0 ,\n\
4652 the observer is looking face onto the ZX plane, and as az is\n\
4653 increased, the observer moves clockwise around the box when viewed\n\
4654 from above the XY plane. \n\
4657 Draw filled polygon \n\
4661 Fills the polygon defined by the n points (\n\
4663 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4664 style is a solid fill. The routine will automatically close the\n\
4665 polygon between the last and first vertices. If multiple closed\n\
4666 polygons are passed in x and y then plfill will fill in between them. \n\
4668 Redacted form: plfill(x,y)\n\
4670 This function is used in examples 12,13,15,16,21,24,25. \n\
4680 n (PLINT, input) : Number of vertices in polygon. \n\
4682 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
4685 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
4689 Magnitude colored plot surface with contour \n\
4693 Aside from dropping the \n\
4694 side functionality this is a more powerful form of plot3d: the surface\n\
4695 mesh can be colored accordingly to the current z value being plotted,\n\
4696 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
4697 drawn between the plotted function border and the base XY plane. The\n\
4698 arguments are identical to those of plmeshc. The only difference\n\
4699 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
4700 the surface, while plot3dc only draws the surface as viewed from the\n\
4703 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
4704 \t Perl/PDL: Not available? \n\
4707 This function is used in example 21. \n\
4713 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4717 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
4718 which the function is evaluated. \n\
4720 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
4721 which the function is evaluated. \n\
4723 z (const PLFLT * const *, input) : Pointer to a vectored\n\
4724 two-dimensional array with set of function values. \n\
4726 nx (PLINT, input) : Number of x values at which function is\n\
4729 ny (PLINT, input) : Number of y values at which function is\n\
4732 opt (PLINT, input) : Determines the way in which the surface is\n\
4733 represented. To specify more than one option just add the options,\n\
4734 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
4735 showing z as a function of x for each value of y[j] . \n\
4736 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4737 for each value of x[i] . \n\
4738 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4739 at which function is defined. \n\
4740 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
4741 the z value being plotted. The color is used from the current\n\
4743 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4744 using parameters \n\
4747 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4748 the borders of the plotted function. \n\
4751 clevel (const PLFLT *, input) : Pointer to the array that defines\n\
4752 the contour level spacing. \n\
4754 nlevel (PLINT, input) : Number of elements in the clevel array. \n\
4757 Write text relative to viewport boundaries \n\
4761 Writes text at a specified position relative to the viewport\n\
4762 boundaries. Text may be written inside or outside the viewport, but\n\
4763 is clipped at the subpage boundaries. The reference point of a string\n\
4764 lies along a line passing through the string at half the height of a\n\
4765 capital letter. The position of the reference point along this line\n\
4766 is determined by just, and the position of the reference point\n\
4767 relative to the viewport is set by disp and pos. \n\
4769 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4770 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4773 This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4779 plmtex(side, disp, pos, just, text)\n\
4783 side (const char *, input) : Specifies the side of the viewport\n\
4784 along which the text is to be written. The string must be one of:\n\
4785 b: Bottom of viewport, text written parallel to edge. \n\
4786 bv: Bottom of viewport, text written at right angles to edge. \n\
4787 l: Left of viewport, text written parallel to edge. \n\
4788 lv: Left of viewport, text written at right angles to edge. \n\
4789 r: Right of viewport, text written parallel to edge. \n\
4790 rv: Right of viewport, text written at right angles to edge. \n\
4791 t: Top of viewport, text written parallel to edge. \n\
4792 tv: Top of viewport, text written at right angles to edge. \n\
4795 disp (PLFLT, input) : Position of the reference point of string,\n\
4796 measured outwards from the specified viewport edge in units of the\n\
4797 current character height. Use negative disp to write within the\n\
4800 pos (PLFLT, input) : Position of the reference point of string\n\
4801 along the specified edge, expressed as a fraction of the length of\n\
4804 just (PLFLT, input) : Specifies the position of the string relative\n\
4805 to its reference point. If just=0. , the reference point is at\n\
4806 the left and if just=1. , it is at the right of the string. Other\n\
4807 values of just give intermediate justifications. \n\
4809 text (const char *, input) : The string to be written out. \n\
4812 Set arrow style for vector plots \n\
4816 Set the style for the arrow used by plvect to plot vectors. \n\
4818 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4820 This function is used in example 22. \n\
4826 plsvect(arrowx, arrowy, npts, fill)\n\
4830 arrowx, arrowy (const PLFLT *,input) : Pointers to a pair of arrays\n\
4831 containing the x and y points which make up the arrow. The arrow\n\
4832 is plotted by joining these points to form a polygon. The scaling\n\
4833 assumes that the x and y points in the arrow lie in the range -0.5\n\
4834 <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n\
4835 style will be reset to its default. \n\
4837 npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4840 fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4841 fill is false then the arrow is open. \n\
4844 Get family file parameters \n\
4848 Gets information about current family file, if familying is enabled. \n\
4849 See the PLplot documentation for more information. \n\
4851 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
4853 This function is used in examples 14,31. \n\
4859 plgfam(p_fam, p_num, p_bmax)\n\
4863 p_fam (PLINT *, output) : Pointer to variable with the Boolean\n\
4864 family flag value. If nonzero, familying is enabled. \n\
4866 p_num (PLINT *, output) : Pointer to variable with the current\n\
4867 family file number. \n\
4869 p_bmax (PLINT *, output) : Pointer to variable with the maximum\n\
4870 file size (in bytes) for a family file. \n\
4873 Random number generator returning a real random number in the range [0,1] \n\
4877 Random number generator returning a real random number in the range\n\
4878 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4879 / compilers provide their own random number generator, and so this is\n\
4880 provided purely for convenience and to give a consistent random number\n\
4881 generator across all languages supported by PLplot. This is\n\
4882 particularly useful for comparing results from the test suite of\n\
4885 Redacted form: plrandd()\n\
4887 This function is used in examples 17,21. \n\
4900 Draws a contour plot of the data in f[\n\
4902 ny], using the nlevel contour levels specified by clevel. Only the\n\
4903 region of the array from kx to lx and from ky to ly is plotted out. A\n\
4904 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4905 additional data required by the transformation routine is used to map\n\
4906 indices within the array to the world coordinates.\tSee the following\n\
4907 discussion of the arguments and the PLplot documentation for more\n\
4910 Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n\
4911 plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n\
4912 clevel, xgrid, ygrid)\n\
4913 \t Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n\
4914 \t Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
4915 \t Python: plcont2(f, kx, lx, ky, ly, clevel)\n\
4918 This function is used in examples 9,14,16,22. \n\
4924 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
4928 f (const PLFLT * const *, input) : Pointer to a vectored\n\
4929 two-dimensional array containing data to be contoured. \n\
4931 nx, ny (PLINT, input) : Physical dimensions of array f. \n\
4933 kx, lx (PLINT, input) : Range of x indices to consider. \n\
4935 ky, ly (PLINT, input) : Range of y indices to consider. \n\
4937 clevel (const PLFLT *, input) : Pointer to array specifying levels\n\
4938 at which to draw contours. \n\
4940 nlevel (PLINT, input) : Number of contour levels to draw. \n\
4942 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
4943 Pointer to function that defines transformation between indices\n\
4944 in array f and the world coordinates (C only). Transformation\n\
4945 functions are provided in the PLplot library: pltr0 for identity\n\
4946 mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
4947 defined by one- and two-dimensional arrays. In addition,\n\
4948 user-supplied routines for the transformation can be used as well.\n\
4949 Examples of all of these approaches are given in the PLplot\n\
4950 documentation. The transformation function should have the form\n\
4951 given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n\
4952 and similar PLplot functions which have a pltr argument, plcont\n\
4953 requires that a transformation function be provided in the C\n\
4954 interface. Leaving pltr NULL will result in an error. \n\
4956 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4957 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
4958 externally supplied. \n\
4965 This sets up the line style for all lines subsequently drawn. A line\n\
4966 consists of segments in which the pen is alternately down and up. The\n\
4967 lengths of these segments are passed in the arrays mark and space\n\
4968 respectively. The number of mark-space pairs is specified by nms.\tIn\n\
4969 order to return the line style to the default continuous line, plstyl\n\
4970 should be called with nms=0 .(see also pllsty) \n\
4972 Redacted form: plstyl(mark, space)\n\
4974 This function is used in examples 1,9,14. \n\
4980 plstyl(nms, mark, space)\n\
4984 nms (PLINT, input) : The number of mark and space elements in a\n\
4985 line. Thus a simple broken line can be obtained by setting nms=1\n\
4986 . A continuous line is specified by setting nms=0 . \n\
4988 mark (const PLINT *, input) : Pointer to array with the lengths of\n\
4989 the segments during which the pen is down, measured in\n\
4992 space (const PLINT *, input) : Pointer to array with the lengths of\n\
4993 the segments during which the pen is up, measured in micrometers. \n\
4996 Set the colors for color table 0 from a cmap0 file \n\
5000 Set the colors for color table 0 from a cmap0 file \n\
5002 Redacted form: plspal0(filename)\n\
5004 This function is in example 16. \n\
5010 plspal0(filename)\n\
5014 filename (const char *, input) : The name of the cmap0 file, or a\n\
5015 empty to string to specify the default cmap0 file. \n\
5018 Set the palette for cmap1 using the specified cmap1*.pal format file \n\
5022 Set the palette for cmap1 using the specified cmap1*.pal format file. \n\
5024 Redacted form: plspal1(filename, interpolate)\n\
5026 This function is used in example 16. \n\
5032 plspal1(filename, interpolate)\n\
5036 filename (const char *, input) : The name of the cmap1*.pal file,\n\
5037 or an empty string to specify the default cmap1.pal file. \n\
5039 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5040 columns containing the intensity index, r, g, b, alpha and\n\
5041 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5042 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5043 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5044 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5045 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5046 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5047 are used instead to set the cmap1 palette directly with a call to\n\
5051 Set current output stream \n\
5055 Sets the number of the current output stream. The stream number\n\
5056 defaults to 0 unless changed by this routine. The first use of this\n\
5057 routine must be followed by a call initializing PLplot (e.g. plstar). \n\
5059 Redacted form: plsstrm(strm)\n\
5061 This function is examples 1,14,20. \n\
5071 strm (PLINT, input) : The current stream number. \n\
5074 Specify viewport using coordinates \n\
5078 Device-independent routine for setting up the viewport. This defines\n\
5079 the viewport in terms of normalized subpage coordinates which run from\n\
5080 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5081 current subpage. Use the alternate routine plsvpa in order to create\n\
5082 a viewport of a definite size. \n\
5084 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5086 This function is used in examples\n\
5087 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
5093 plvpor(xmin, xmax, ymin, ymax)\n\
5097 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5098 left-hand edge of the viewport. \n\
5100 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5101 right-hand edge of the viewport. \n\
5103 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5104 bottom edge of the viewport. \n\
5106 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5107 edge of the viewport. \n\
5110 Write text inside the viewport \n\
5114 Writes text at a specified position and inclination within the\n\
5115 viewport. Text is clipped at the viewport boundaries. The reference\n\
5116 point of a string lies along a line passing through the string at half\n\
5117 the height of a capital letter. The position of the reference point\n\
5118 along this line is determined by just, the reference point is placed\n\
5119 at world coordinates (\n\
5121 y)\twithin the viewport. The inclination of the string is specified\n\
5122 in terms of differences of world coordinates making it easy to write\n\
5123 text parallel to a line in a graph. \n\
5125 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5127 This function is used in example 2-4,10,12-14,20,23,24,26. \n\
5133 plptex(x, y, dx, dy, just, text)\n\
5137 x (PLFLT, input) : x coordinate of reference point of string. \n\
5139 y (PLFLT, input) : y coordinate of reference point of string. \n\
5141 dx (PLFLT, input) : Together with dy, this specifies the\n\
5142 inclination of the string. The baseline of the string is parallel\n\
5143 to a line joining (\n\
5151 dy (PLFLT, input) : Together with dx, this specifies the\n\
5152 inclination of the string. \n\
5154 just (PLFLT, input) : Specifies the position of the string relative\n\
5155 to its reference point. If just=0. , the reference point is at\n\
5156 the left and if just=1. , it is at the right of the string. Other\n\
5157 values of just give intermediate justifications. \n\
5159 text (const char *, input) : The string to be written out. \n\
5162 Set z axis parameters \n\
5166 Identical to plsxax, except that arguments are flags for z axis. See\n\
5167 the description of plsxax for more detail. \n\
5169 Redacted form: plszax(digmax, digits)\n\
5171 This function is used in example 31. \n\
5177 plszax(digmax, digits)\n\
5181 digmax (PLINT, input) : Variable to set the maximum number of\n\
5182 digits for the z axis. If nonzero, the printed label will be\n\
5183 switched to a floating point representation when the number of\n\
5184 digits exceeds digmax. \n\
5186 digits (PLINT, input) : Field digits value. Currently, changing\n\
5187 its value here has no effect since it is set only by plbox or\n\
5188 plbox3. However, the user may obtain its value after a call to\n\
5189 either of these functions by calling plgzax. \n\
5192 Plot shaded 3-d surface plot for z[x][y] with y index limits \n\
5196 This variant of plsurf3d (see that function\'s documentation for more\n\
5197 details) should be suitable for the case where the area of the x, y\n\
5198 coordinate grid where z is defined can be non-rectangular.\tThe limits\n\
5199 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5200 indexymin, and indexymax. \n\
5202 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5205 This function is used in example 8. \n\
5211 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5215 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
5216 which the function is evaluated. \n\
5218 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
5219 which the function is evaluated. \n\
5221 z (const PLFLT * const *, input) : Pointer to a vectored\n\
5222 two-dimensional array with set of function values. \n\
5224 nx (PLINT, input) : Number of x values at which function is\n\
5227 ny (PLINT, input) : Number of y values at which function is\n\
5230 opt (PLINT, input) : Determines the way in which the surface is\n\
5231 represented. To specify more than one option just add the options,\n\
5232 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5233 connecting points at which function is defined. \n\
5234 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5235 using parameters \n\
5238 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5239 using parameters \n\
5242 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5243 the borders of the plotted function. \n\
5244 opt=MAG_COLOR : the surface is colored according to the value\n\
5245 of Z; if MAG_COLOR is not used, then the default the surface\n\
5246 is colored according to the intensity of the reflected light\n\
5247 in the surface from a light source whose position is set using\n\
5251 clevel (const PLFLT *, input) : Pointer to the array that defines\n\
5252 the contour level spacing. \n\
5254 nlevel (PLINT, input) : Number of elements in the clevel array. \n\
5256 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5257 corresponds to the first x index where z is defined. \n\
5259 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5260 which corresponds (by convention) to one more than the last x\n\
5261 index value where z is defined. \n\
5263 indexymin (const PLINT *, input) : Array of y index values which\n\
5264 all must be ≥ 0. These values are the first y index where z is\n\
5265 defined for a particular x index in the range from indexxmin to\n\
5266 indexxmax - 1. The dimension of indexymin is indexxmax. \n\
5268 indexymax (const PLINT *, input) : Array of y index values which\n\
5269 all must be ≤ ny. These values correspond (by convention) to one\n\
5270 more than the last y index where z is defined for a particular x\n\
5271 index in the range from indexxmin to indexxmax - 1. The dimension\n\
5272 of indexymax is indexxmax. \n\
5275 Set character font \n\
5279 Sets the default character font for subsequent character drawing. Also\n\
5280 affects symbols produced by plpoin. This routine has no effect unless\n\
5281 the extended character set is loaded (see plfontld). \n\
5283 Redacted form: plfont(ifont)\n\
5285 This function is used in examples 1,2,4,7,13,24,26. \n\
5295 ifont (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
5302 Get the cmap1 argument range for continuous color plots \n\
5306 Get the cmap1 argument range for continuous color plots. (Use\n\
5307 plgsmap1_range to set the cmap1 argument range.) \n\
5309 Redacted form: plgcmap1_range(min_color, max_color)\n\
5311 This function is currently not used in any example. \n\
5317 plgcmap1_range(min_color, max_color)\n\
5321 min_color (PLFLT *, output) : Pointer to the current minimum cmap1\n\
5322 floating point argument. \n\
5324 max_color (PLFLT *, output) : Pointer to the current maximum cmap1\n\
5325 floating point argument. \n\
5328 Set the cmap1 argument range for continuous color plots \n\
5332 Set the cmap1 argument range for continuous color plots. If \n\
5333 min_color is greater than \n\
5335 max_color is greater than 1.0 or \n\
5336 min_color is less than 0.0 then no change is made.\t(Use\n\
5337 plgcmap1_range to get the cmap1 argument range.) \n\
5339 Redacted form: plscmap1_range(min_color, max_color)\n\
5341 This function is currently used in example 33. \n\
5347 plscmap1_range(min_color, max_color)\n\
5351 min_color (PLFLT, input) : The minimum cmap1 floating point\n\
5354 max_color (PLFLT, input) : The maximum cmap1 floating point\n\
5358 Draw a circular or elliptical arc \n\
5362 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5363 semiminor axis b, starting at angle1 and ending at angle2. \n\
5365 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5369 This function is used in examples 3 and 27. \n\
5375 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5379 x (PLFLT, input) : X coordinate of arc center. \n\
5381 y (PLFLT, input) : Y coordinate of arc center. \n\
5383 a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
5385 b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
5387 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5390 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5393 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5396 fill (PLBOOL, input) : Draw a filled arc. \n\
5399 Plot 3-d surface plot \n\
5403 Plots a three dimensional surface plot within the environment set up\n\
5404 by plw3d. The surface is defined by the two-dimensional array z[\n\
5406 ny] , the point z[i][j] being the value of the function at (\n\
5408 y[j]) . Note that the points in arrays x and y do not need to be\n\
5409 equally spaced, but must be stored in ascending order. The parameter\n\
5410 opt controls the way in which the surface is displayed. For further\n\
5411 details see the PLplot documentation. The only difference between\n\
5412 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5413 while plot3d only draws the surface as viewed from the top. \n\
5415 Redacted form: plot3d(x, y, z, opt, side)\n\
5417 This function is used in examples 11,21. \n\
5423 plot3d(x, y, z, nx, ny, opt, side)\n\
5427 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
5428 which the function is evaluated. \n\
5430 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
5431 which the function is evaluated. \n\
5433 z (const PLFLT * const *, input) : Pointer to a vectored\n\
5434 two-dimensional array with set of function values. \n\
5436 nx (PLINT, input) : Number of x values at which function is\n\
5439 ny (PLINT, input) : Number of y values at which function is\n\
5442 opt (PLINT, input) : Determines the way in which the surface is\n\
5443 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5444 function of x for each value of y[j] . \n\
5445 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5446 for each value of x[i] . \n\
5447 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5448 at which function is defined. \n\
5451 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5452 should be draw on the figure. If side is true sides are drawn,\n\
5453 otherwise no sides are drawn. \n\
5456 Set area fill pattern \n\
5460 Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
5461 parallel lines with specified inclinations and spacings. The\n\
5462 arguments to this routine are the number of sets to use (1 or 2)\n\
5463 followed by two pointers to integer arrays (of 1 or 2 elements)\n\
5464 specifying the inclinations in tenths of a degree and the spacing in\n\
5465 micrometers. (also see plpsty) \n\
5467 Redacted form: General: plpat(inc, del)\n\
5468 \t Perl/PDL: plpat(nlin, inc, del)\n\
5471 This function is used in example 15. \n\
5477 plpat(nlin, inc, del)\n\
5481 nlin (PLINT, input) : Number of sets of lines making up the\n\
5482 pattern, either 1 or 2. \n\
5484 inc (const PLINT *, input) : Pointer to array with nlin elements.\n\
5485 Specifies the line inclination in tenths of a degree. (Should be\n\
5486 between -900 and 900). \n\
5488 del (const PLINT *, input) : Pointer to array with nlin elements.\n\
5489 Specifies the spacing in micrometers between the lines making up\n\
5493 Shade individual region on the basis of value \n\
5497 Shade individual region on the basis of value. Use plshades if you\n\
5498 want to shade a number of contiguous regions using continuous colors. \n\
5499 In particular the edge contours are treated properly in plshades. If\n\
5500 you attempt to do contiguous regions with plshade1 (or plshade) the\n\
5501 contours at the edge of the shade are partially obliterated by\n\
5502 subsequent plots of contiguous shaded regions. plshade1 differs from\n\
5503 plshade by the type of the first argument.\tLook at the argument list\n\
5504 below, plcont and the PLplot documentation for more information about\n\
5505 the transformation from grid to world coordinates.\tShading NEEDS\n\
5506 DOCUMENTATION, but as a stopgap look at how plshade is used in\n\
5507 examples/c/x15c.c\n\
5509 Redacted form: General: plshade1(a, defined, xmin, xmax, ymin, ymax,\n\
5510 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
5511 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
5512 \t Perl/PDL: plshade1(a, xmin, xmax, ymin, ymax, shade_min,\n\
5513 shade_max, sh_cmap, sh_color, sh_width, min_color, min_width,\n\
5514 max_color, max_width, fill, rectangular, defined, pltr, pltr_data)\n\
5517 This function is used in example 15. \n\
5523 plshade1(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\
5527 a (const PLFLT *, input) : Contains array to be plotted. The array\n\
5528 must have been declared as PLFLT a[nx][ny]. \n\
5530 nx (PLINT, input) : First dimension of array \"a\". \n\
5532 ny (PLINT, input) : Second dimension of array \"a\". \n\
5534 defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n\
5535 specifying regions excluded from the shading plot. This function\n\
5536 accepts x and y coordinates as input arguments and must return 0\n\
5537 if the point is in the excluded region or 1 otherwise. This\n\
5538 argument can be NULL if all the values are valid. \n\
5540 xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5541 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5542 at (xmax,ymin) and so on. \n\
5544 xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5545 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5546 at (xmax,ymin) and so on. \n\
5548 ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5549 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5550 at (xmax,ymin) and so on. \n\
5552 ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5553 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5554 at (xmax,ymin) and so on. \n\
5556 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
5557 be shaded. If shade_max <= shade_min, plshade1 does nothing. \n\
5559 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
5560 be shaded. If shade_max <= shade_min, plshade1 does nothing. \n\
5562 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0 , then\n\
5563 sh_color is interpreted as a color map 0 (integer) index. If\n\
5564 sh_cmap=1 , then sh_color is interpreted as a color map 1\n\
5565 floating-point index which ranges from 0. to 1. \n\
5567 sh_color (PLFLT, input) : Defines color map index if cmap0 or color\n\
5568 map input value (ranging from 0. to 1.) if cmap1. \n\
5570 sh_width (PLFLT, input) : Defines width used by the fill pattern. \n\
5572 min_color (PLINT, input) : Defines pen color, width used by the\n\
5573 boundary of shaded region. The min values are used for the\n\
5574 shade_min boundary, and the max values are used on the shade_max\n\
5575 boundary. Set color and width to zero for no plotted boundaries. \n\
5577 min_width (PLFLT, input) : Defines pen color, width used by the\n\
5578 boundary of shaded region. The min values are used for the\n\
5579 shade_min boundary, and the max values are used on the shade_max\n\
5580 boundary. Set color and width to zero for no plotted boundaries. \n\
5582 max_color (PLINT, input) : Defines pen color, width used by the\n\
5583 boundary of shaded region. The min values are used for the\n\
5584 shade_min boundary, and the max values are used on the shade_max\n\
5585 boundary. Set color and width to zero for no plotted boundaries. \n\
5587 max_width (PLFLT, input) : Defines pen color, width used by the\n\
5588 boundary of shaded region. The min values are used for the\n\
5589 shade_min boundary, and the max values are used on the shade_max\n\
5590 boundary. Set color and width to zero for no plotted boundaries. \n\
5592 fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
5593 Routine used to fill the region. Use plfill. Future version of\n\
5594 plplot may have other fill routines. \n\
5596 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5597 map to rectangles after coordinate transformation with pltrl. \n\
5598 Otherwise, set rectangular to false. If rectangular is set to\n\
5599 true, plshade tries to save time by filling large rectangles. \n\
5600 This optimization fails if the coordinate transformation distorts\n\
5601 the shape of rectangles. For example a plot in polar coordinates\n\
5602 has to have rectangular set to false. \n\
5604 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
5605 Pointer to function that defines transformation between indices\n\
5606 in array z and the world coordinates (C only). Transformation\n\
5607 functions are provided in the PLplot library: pltr0 for identity\n\
5608 mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
5609 defined by one- and two-dimensional arrays. In addition,\n\
5610 user-supplied routines for the transformation can be used as well.\n\
5611 Examples of all of these approaches are given in the PLplot\n\
5612 documentation. The transformation function should have the form\n\
5613 given by any of pltr0, pltr1, or pltr2. \n\
5615 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5616 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5617 externally supplied. \n\
5620 Get x axis parameters \n\
5624 Returns current values of the p_digmax and p_digits flags for the x\n\
5625 axis. p_digits is updated after the plot is drawn, so this routine\n\
5626 should only be called after the call to plbox (or plbox3) is complete.\n\
5627 See the PLplot documentation for more information. \n\
5629 Redacted form: plgxax(p_digmax, p_digits)\n\
5631 This function is used in example 31. \n\
5637 plgxax(p_digmax, p_digits)\n\
5641 p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5642 number of digits for the x axis. If nonzero, the printed label\n\
5643 has been switched to a floating point representation when the\n\
5644 number of digits exceeds p_digmax. \n\
5646 p_digits (PLINT *, output) : Pointer to variable with the actual\n\
5647 number of digits for the numeric labels (x axis) from the last\n\
5651 Draw filled polygon in 3D \n\
5655 Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
5656 using the pattern defined by plpsty or plpat. The routine will\n\
5657 automatically close the polygon between the last and first vertices. \n\
5658 If multiple closed polygons are passed in x, y, and z then plfill3\n\
5659 will fill in between them. \n\
5661 Redacted form: General: plfill3(x, y, z)\n\
5662 \t Perl/PDL: plfill3(n, x, y, z)\n\
5665 This function is used in example 15. \n\
5671 plfill3(n, x, y, z)\n\
5675 n (PLINT, input) : Number of vertices in polygon. \n\
5677 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
5680 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
5683 z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
5687 Set color, cmap0 \n\
5691 Sets the color index for cmap0 (see the PLplot documentation). \n\
5693 Redacted form: plcol0(icol0)\n\
5695 This function is used in examples 1-9,11-16,18-27,29. \n\
5705 icol0 (PLINT, input) : Integer representing the color. The\n\
5706 defaults at present are (these may change): \n\
5707 0 black (default background) \n\
5708 1 red (default foreground) \n\
5724 Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
5725 change an individual color in the map0 color palette. \n\
5728 Draw text at points defined by Shapefile data in world coordinates \n\
5732 As per plmapline, however the items are plotted as text in the same\n\
5735 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
5736 miny, maxy, plotentry)\n\
5738 This function is used in example 19. \n\
5744 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
5748 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5749 supplied function to transform the coordinates given in the\n\
5750 shapefile into a plot coordinate system. By using this transform,\n\
5751 we can change from a longitude, latitude coordinate to a polar\n\
5752 stereographic project, for example. Initially, x[0]..[n-1] are\n\
5753 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5754 After the call to mapform(), x[] and y[] should be replaced by the\n\
5755 corresponding plot coordinates. If no transform is desired,\n\
5756 mapform can be replaced by NULL. \n\
5758 name (const char *, input) : The file name of a set of Shapefile\n\
5759 files without the file extension. \n\
5761 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
5764 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
5767 just (PLFLT, input) : Set the justification of the text. The value\n\
5768 given will be the fraction of the distance along the string that\n\
5769 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
5770 centralized text and 1.0 gives right aligned text. \n\
5772 text (const char *, input) : A NULL-terminated string of characters\n\
5775 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5776 be in the same units as used by the Shapefile. You could use a\n\
5777 very large negative number to plot everything, but you can improve\n\
5778 performance by limiting the area drawn. The units must match those\n\
5779 of the Shapefile projection, which may be for example longitude or\n\
5780 distance. The value of minx must be less than the value of maxx. \n\
5782 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5783 use a very large number to plot everything, but you can improve\n\
5784 performance by limiting the area drawn. \n\
5786 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5787 be in the same units as used by the Shapefile. You could use a\n\
5788 very large negative number to plot everything, but you can improve\n\
5789 performance by limiting the area drawn. The units must match those\n\
5790 of the Shapefile projection, which may be for example latitude or\n\
5791 distance. The value of miny must be less than the value of maxy. \n\
5793 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5794 use a very large number to plot everything, but you can improve\n\
5795 performance by limiting the area drawn. \n\
5797 plotentry (PLINT, input) : An integer indicating which text string\n\
5798 of the Shapefile (zero indexed) will be drawn. \n\
5801 Draw a line between two points \n\
5805 Joins the point (\n\
5811 Redacted form: pljoin(x1,y1,x2,y2)\n\
5813 This function is used in examples 3,14. \n\
5819 pljoin(x1, y1, x2, y2)\n\
5823 x1 (PLFLT, input) : x coordinate of first point. \n\
5825 y1 (PLFLT, input) : y coordinate of first point. \n\
5827 x2 (PLFLT, input) : x coordinate of second point. \n\
5829 y2 (PLFLT, input) : y coordinate of second point. \n\
5832 Set color, cmap1 \n\
5836 Sets the color for cmap1 (see the PLplot documentation). \n\
5838 Redacted form: plcol1(col1)\n\
5840 This function is used in examples 12 and 21. \n\
5850 col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
5851 and is mapped to color using the continuous map1 color palette\n\
5852 which by default ranges from blue to the background color to red. \n\
5853 The map1 palette can also be straightforwardly changed by the user\n\
5854 with plscmap1 or plscmap1l. \n\
5861 Set integer plot orientation parameter. This function is identical to\n\
5862 plsdiori except for the type of the argument, and should be used in\n\
5863 the same way. See the PLplot documentation for details. \n\
5865 Redacted form: plsori(ori)\n\
5867 This function is used in example 3. \n\
5877 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5878 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5882 Calculate continuous time from broken-down time for the current stream \n\
5886 Calculate continuous time, ctime, from broken-down time for the\n\
5887 current stream. The broken-down\n\
5888 time is specified by the following parameters: year, month, day, hour,\n\
5889 min, and sec. This function is the inverse of plbtime. \n\
5891 The PLplot definition of broken-down time is a calendar time that\n\
5892 completely ignores all time zone offsets, i.e., it is the user\'s\n\
5893 responsibility to apply those offsets (if so desired) before using the\n\
5894 PLplot time API. By default broken-down time is defined using the\n\
5895 proleptic Gregorian calendar without the insertion of leap seconds and\n\
5896 continuous time is defined as the number of seconds since the Unix\n\
5897 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
5898 broken-down and continuous time are possible, see plconfigtime which\n\
5899 specifies that transformation for the current stream. \n\
5901 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
5903 \t Perl/PDL: Not available? \n\
5906 This function is used in example 29. \n\
5912 plctime(year, month, day, hour, min, sec, ctime)\n\
5916 year (PLINT, input) : Input year. \n\
5918 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
5921 day (PLINT, input) : Input day in range from 1 to 31. \n\
5923 hour (PLINT, input) : Input hour in range from 0 to 23 \n\
5925 min (PLINT, input) : Input minute in range from 0 to 59. \n\
5927 sec (PLFLT, input) : Input second in floating range from 0. to 60. \n\
5929 ctime (PLFLT *, output) : Continous time calculated from the\n\
5930 broken-down time specified by the previous parameters. \n\
5933 Plot continental outline or shapefile data in world coordinates \n\
5937 Plots continental outlines or shapefile data in world coordinates. A\n\
5938 demonstration of how to use this function to create different \n\
5939 projections can be found in examples/c/x19c. Plplot is provided with\n\
5940 basic coastal outlines and USA state borders. These can be used\n\
5941 irrespective of whether Shapefile support is built into Plplot. With\n\
5942 Shapefile support this function can also be used with user Shapefiles,\n\
5943 in which case it will plot the entire contents of a Shapefile joining\n\
5944 each point of each Shapefile element with a line. Shapefiles have\n\
5945 become a popular standard for geographical data and data in this\n\
5946 format can be easily found from a number of online sources. Shapefile\n\
5947 data is actually provided as three or more files with the same\n\
5948 filename, but different extensions. The .shp and .shx files are\n\
5949 required for plotting Shapefile data with Plplot. \n\
5951 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5953 This function is used in example 19. \n\
5959 plmap(mapform, name, minx, maxx, miny, maxy)\n\
5963 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5964 supplied function to transform the original map data coordinates\n\
5965 to a new coordinate system. The Plplot supplied map data is\n\
5966 provided as latitudes and longitudes; other Shapefile data may be\n\
5967 provided in other coordinate systems as can be found in their .prj\n\
5968 plain text files. For example, by using this transform we can\n\
5969 change from a longitude, latitude coordinate to a polar\n\
5970 stereographic projection. Initially, x[0]..[n-1] are the original\n\
5971 x coordinates (longitudes for the Plplot suplied data) and\n\
5972 y[0]..y[n-1] are the corresponding y coordinates (latitudes for\n\
5973 the Plplot supplied data). After the call to mapform(), x[] and\n\
5974 y[] should be replaced by the corresponding plot coordinates. If\n\
5975 no transform is desired, mapform can be replaced by NULL. \n\
5977 name (const char *, input) : A character string which determines\n\
5978 the type of map plotted. This is either one of the Plplot built\n\
5979 in maps or the file name of a set of Shapefile files without the\n\
5980 file extensions. For the Plplot built in maps the possible values\n\
5981 are: \"globe\" -- continental outlines \n\
5982 \"usa\" -- USA and state boundaries \n\
5983 \"cglobe\" -- continental outlines and countries \n\
5984 \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5987 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5988 drawn. For the built in maps this is a measure of longitude. For\n\
5989 Shapefiles the units must match the projection. The value of minx\n\
5990 must be less than the value of maxx. Specifying a useful limit for\n\
5991 these limits provides a useful optimization for complex or\n\
5994 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5997 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5998 drawn. For the built in maps this is a measure of latitude. For\n\
5999 Shapefiles the units must match the projection. The value of miny\n\
6000 must be less than the value of maxy. \n\
6002 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6006 Calculate broken-down time from continuous time for the current stream \n\
6010 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6011 continuous time, ctime for the current stream. This function is the\n\
6012 inverse of plctime. \n\
6014 The PLplot definition of broken-down time is a calendar time that\n\
6015 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6016 responsibility to apply those offsets (if so desired) before using the\n\
6017 PLplot time API. By default broken-down time is defined using the\n\
6018 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6019 continuous time is defined as the number of seconds since the Unix\n\
6020 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6021 broken-down and continuous time are possible, see plconfigtime. \n\
6023 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6025 \t Perl/PDL: Not available? \n\
6028 This function is used in example 29. \n\
6034 plbtime(year, month, day, hour, min, sec, ctime)\n\
6038 year (PLINT *, output) : Output year. \n\
6040 month (PLINT *, output) : Output month in range from 0 (January) to\n\
6043 day (PLINT *, output) : Output day in range from 1 to 31. \n\
6045 hour (PLINT *, output) : Output hour in range from 0 to 23. \n\
6047 min (PLINT *, output) : Output minute in range from 0 to 59 \n\
6049 sec (PLFLT *, output) : Output second in floating range from 0. to\n\
6052 ctime (PLFLT, input) : Continous time from which the broken-down\n\
6053 time is calculated. \n\
6056 Get current stream number \n\
6060 Gets the number of the current output stream. See also plsstrm. \n\
6062 Redacted form: plgstrm(p_strm)\n\
6064 This function is used in example 1,20. \n\
6074 p_strm (PLINT *, output) : Pointer to current stream value. \n\
6077 Draw a line in 3 space \n\
6081 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6082 first set up the viewport, the 2d viewing window (in world\n\
6083 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6086 Redacted form: plline3(x, y, z)\n\
6088 This function is used in example 18. \n\
6094 plline3(n, x, y, z)\n\
6098 n (PLINT, input) : Number of points defining line. \n\
6100 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
6103 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
6106 z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
6110 Load character font \n\
6114 Sets the character set to use for subsequent character drawing. May\n\
6115 be called before initializing PLplot. \n\
6117 Redacted form: plfontld(fnt)\n\
6119 This function is used in examples 1,7. \n\
6129 fnt (PLINT, input) : Specifies the character set to load: 0:\n\
6130 Standard character set \n\
6131 1: Extended character set \n\
6134 Set any command-line option \n\
6138 Set any command-line option internally from a program before it\n\
6139 invokes plinit. opt is the name of the command-line option and optarg\n\
6140 is the corresponding command-line option argument. \n\
6142 This function returns 0 on success. \n\
6144 Redacted form: plsetopt(opt, optarg)\n\
6146 This function is used in example 14. \n\
6152 int plsetopt(opt, optarg)\n\
6156 opt (const char *, input) : Pointer to string containing the\n\
6157 command-line option. \n\
6159 optarg (const char *, input) : Pointer to string containing the\n\
6160 argument of the command-line option. \n\
6163 Plot all or a subset of Shapefile data using lines in world coordinates \n\
6167 Plot all or a subset of Shapefile data using lines in world\n\
6168 coordinates. examples/c/x19c demonstrates how to use this function.\n\
6169 This function plots data from a Shapefile using lines as in plmap,\n\
6170 however it also has the option of also only drawing specified elements\n\
6171 from the Shapefile. The indices of the required elements are passed\n\
6172 into the function as an array. The Shapefile data should include a\n\
6173 metadata file (extension.dbf) listing all items within the Shapefile.\n\
6174 This file can be opened by most popular spreadsheet programs and can\n\
6175 be used to decide which indices to pass to this function. \n\
6177 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6180 This function is used in example 19. \n\
6186 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6190 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
6191 supplied function to transform the coordinates given in the\n\
6192 shapefile into a plot coordinate system. By using this transform,\n\
6193 we can change from a longitude, latitude coordinate to a polar\n\
6194 stereographic project, for example. Initially, x[0]..[n-1] are\n\
6195 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
6196 After the call to mapform(), x[] and y[] should be replaced by the\n\
6197 corresponding plot coordinates. If no transform is desired,\n\
6198 mapform can be replaced by NULL. \n\
6200 name (const char *, input) : The file name of a set of Shapefile\n\
6201 files without the file extension. \n\
6203 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6204 be in the same units as used by the Shapefile. You could use a\n\
6205 very large negative number to plot everything, but you can improve\n\
6206 performance by limiting the area drawn. The units must match those\n\
6207 of the Shapefile projection, which may be for example longitude or\n\
6208 distance. The value of minx must be less than the value of maxx. \n\
6210 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6211 use a very large number to plot everything, but you can improve\n\
6212 performance by limiting the area drawn. \n\
6214 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6215 be in the same units as used by the Shapefile. You could use a\n\
6216 very large negative number to plot everything, but you can improve\n\
6217 performance by limiting the area drawn. The units must match those\n\
6218 of the Shapefile projection, which may be for example latitude or\n\
6219 distance. The value of miny must be less than the value of maxy. \n\
6221 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6222 use a very large number to plot everything, but you can improve\n\
6223 performance by limiting the area drawn. \n\
6225 plotentries (const PLINT *, input) : An array of integers\n\
6226 indicating the elements of the Shapefile (zero indexed) which will\n\
6227 be drawn. Setting plotentries to NULL will plot all elements of\n\
6230 nplotentries (PLINT, input) : The number of items in plotentries.\n\
6231 Ignored if plotentries is NULL. \n\
6234 Used to globally turn color output on/off \n\
6238 Used to globally turn color output on/off for those drivers/devices\n\
6239 that support it. \n\
6241 Redacted form: plscolor(color)\n\
6243 This function is used in example 31. \n\
6253 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6254 turned off. If non-zero, color is turned on. \n\
6257 Get the current device (keyword) name \n\
6261 Get the current device (keyword) name. Note: you must have allocated\n\
6262 space for this (80 characters is safe). \n\
6264 Redacted form: plgdev(p_dev)\n\
6266 This function is used in example 14. \n\
6276 p_dev (char *, output) : Pointer to device (keyword) name string. \n\
6279 Add a point to a strip chart \n\
6283 Add a point to a given pen of a given strip chart. There is no need\n\
6284 for all pens to have the same number of points or to be equally\n\
6285 sampled in the x coordinate. Allocates memory and rescales as\n\
6288 Redacted form: plstripa(id, pen, x, y)\n\
6290 This function is used in example 17. \n\
6296 plstripa(id, pen, x, y)\n\
6300 id (PLINT, input) : Identification number of the strip chart (set\n\
6301 up in plstripc). \n\
6303 pen (PLINT, input) : Pen number (ranges from 0 to 3). \n\
6305 x (PLFLT, input) : X coordinate of point to plot. \n\
6307 y (PLFLT, input) : Y coordinate of point to plot. \n\
6310 Create a 4-pen strip chart \n\
6314 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6316 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6317 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6318 styline, legline, labx, laby, labz)\n\
6319 \t Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n\
6320 ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n\
6321 ypsec, legline, labx, laby, labtop)\n\
6324 This function is used in example 17. \n\
6330 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6334 id (PLINT *, output) : Identification number of strip chart to use\n\
6335 on plstripa and plstripd. \n\
6337 xspec (const char *, input) : X-axis specification as in plbox. \n\
6339 yspec (const char *, input) : Y-axis specification as in plbox. \n\
6341 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6342 change as data are added. \n\
6344 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6345 change as data are added. \n\
6347 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6348 is multiplied by the factor (1 + \n\
6351 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6352 change as data are added. \n\
6354 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6355 change as data are added. \n\
6357 xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n\
6359 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n\
6361 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6362 true, otherwise not. \n\
6364 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6365 otherwise slide display. \n\
6367 colbox (PLINT, input) : Plot box color index (cmap0). \n\
6369 collab (PLINT, input) : Legend color index (cmap0). \n\
6371 colline (const PLINT *, input) : Pointer to array with color\n\
6372 indices (cmap0) for the 4 pens. \n\
6374 styline (const PLINT *, input) : Pointer to array with line styles\n\
6377 legline (const char **, input) : Pointer to character array\n\
6378 containing legends for the 4 pens. \n\
6380 labx (const char *, input) : X-axis label. \n\
6382 laby (const char *, input) : Y-axis label. \n\
6384 labtop (const char *, input) : Plot title. \n\
6387 Deletes and releases memory used by a strip chart \n\
6391 Deletes and releases memory used by a strip chart. \n\
6393 Redacted form: plstripd(id)\n\
6395 This function is used in example 17. \n\
6405 id (PLINT, input) : Identification number of strip chart to delete. \n\
6408 Specify viewport using coordinates and aspect ratio \n\
6412 Device-independent routine for setting up the viewport. The viewport\n\
6413 is chosen to be the largest with the given aspect ratio that fits\n\
6414 within the specified region (in terms of normalized subpage\n\
6415 coordinates). This routine is functionally equivalent to plvpor when\n\
6416 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6417 routine reserves no extra space at the edges for labels. \n\
6419 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6421 This function is used in example 9. \n\
6427 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6431 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6432 left-hand edge of the viewport. \n\
6434 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6435 right-hand edge of the viewport. \n\
6437 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6438 bottom edge of the viewport. \n\
6440 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6441 edge of the viewport. \n\
6443 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6447 Assign a function to use for generating custom axis labels \n\
6451 This function allows a user to provide their own function to provide\n\
6452 axis label text. The user function is given the numeric value for a\n\
6453 point on an axis and returns a string label to correspond with that\n\
6454 value. Custom axis labels can be enabled by passing appropriate\n\
6455 arguments to plenv, plbox, plbox3 and similar functions. \n\
6457 This function is used in example 19. \n\
6463 plslabelfunc(label_func, label_data)\n\
6467 label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n\
6468 : This is the custom label function. In order to reset to the\n\
6469 default labelling, set this to NULL. The labelling function\n\
6470 parameters are, in order: axis: This indicates which axis a\n\
6471 label is being requested for. The value will be one of PL_X_AXIS,\n\
6472 PL_Y_AXIS or PL_Z_AXIS. \n\
6474 value: This is the value along the axis which is being labelled. \n\
6476 label_text: The string representation of the label value. \n\
6478 length: The maximum length in characters allowed for label_text. \n\
6481 label_data (PLPointer, input) : This parameter may be used to pass\n\
6482 data to the label_func function. \n\
6485 Set length of major ticks \n\
6489 This sets up the length of the major ticks. The actual length is the\n\
6490 product of the default length and a scaling factor as for character\n\
6493 Redacted form: plsmaj(def, scale)\n\
6495 This function is used in example 29. \n\
6501 plsmaj(def, scale)\n\
6505 def (PLFLT, input) : The default length of a major tick in\n\
6506 millimeters, should be set to zero if the default length is to\n\
6507 remain unchanged. \n\
6509 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6510 actual tick length. \n\
6513 Get the current library version number \n\
6517 Get the current library version number. Note: you must have allocated\n\
6518 space for this (80 characters is safe). \n\
6520 Redacted form: plgver(p_ver)\n\
6522 This function is used in example 1. \n\
6532 p_ver (char *, output) : Pointer to the current library version\n\
6536 Set format of numerical label for contours\n\
6540 Set format of numerical label for contours. \n\
6542 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6544 This function is used example 9. \n\
6550 pl_setcontlabelformat(lexp, sigdig)\n\
6554 lexp (PLINT, input) : If the contour numerical label is greater\n\
6555 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6556 format is used. Default value of lexp is 4. \n\
6558 sigdig (PLINT, input) : Number of significant digits. Default\n\
6562 Parse command-line arguments \n\
6566 Parse command-line arguments. \n\
6568 plparseopts removes all recognized flags (decreasing argc\n\
6569 accordingly), so that invalid input may be readily detected. It can\n\
6570 also be used to process user command line flags. The user can merge\n\
6571 an option table of type PLOptionTable into the internal option table\n\
6572 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6573 the external table(s) be parsed by calling plClearOpts before\n\
6576 The default action taken by plparseopts is as follows: \n\
6577 Returns with an error if an unrecognized option or badly formed\n\
6578 option-value pair are encountered.\t\n\
6579 Returns immediately (return code 0) when the first non-option command\n\
6580 line argument is found. \n\
6581 Returns with the return code of the option handler, if one was called.\n\
6583 Deletes command line arguments from argv list as they are found, and\n\
6584 decrements argc accordingly. \n\
6585 Does not show \"invisible\" options in usage or help messages. \n\
6586 Assumes the program name is contained in argv[0]. \n\
6588 These behaviors may be controlled through the \n\
6591 Redacted form: General: plparseopts(argv, mode)\n\
6592 \t Perl/PDL: Not available? \n\
6595 This function is used in all of the examples. \n\
6601 int plparseopts(p_argc, argv, mode)\n\
6605 p_argc (int *, input) : pointer to number of arguments. \n\
6607 argv (const char **, input) : Pointer to character array containing\n\
6608 *p_argc command-line arguments. \n\
6610 mode (PLINT, input) : Parsing mode with the following\n\
6611 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6612 and all error messages enabled, including program exit when an\n\
6613 error occurs. Anything on the command line that isn\'t recognized\n\
6614 as a valid option or option argument is flagged as an error. \n\
6615 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6617 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6619 PL_PARSE_SHOWALL (8) -- Show invisible options \n\
6620 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6621 pointer to the program name. \n\
6622 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
6623 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6624 unrecognized arguments. \n\
6631 Initializing the plotting package.\tThe program prompts for the device\n\
6632 keyword or number of the desired output device. Hitting a RETURN in\n\
6633 response to the prompt is the same as selecting the first device. If\n\
6634 only one device is enabled when PLplot is installed, plstar will issue\n\
6635 no prompt.\tThe output device is divided into nx by ny subpages, each\n\
6636 of which may be used independently. The subroutine pladv is used to\n\
6637 advance from one subpage to the next. \n\
6639 Redacted form: plstar(nx, ny)\n\
6641 This function is used in example 1. \n\
6651 nx (PLINT, input) : Number of subpages to divide output page in the\n\
6652 horizontal direction. \n\
6654 ny (PLINT, input) : Number of subpages to divide output page in the\n\
6655 vertical direction. \n\
6658 Get FCI (font characterization integer) \n\
6662 Gets information about the current font using the FCI approach. See\n\
6663 the PLplot documentation for more information. \n\
6665 Redacted form: plgfci(p_fci)\n\
6667 This function is used in example 23. \n\
6677 p_fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
6678 integer) variable which is updated with current FCI value. \n\
6681 Set family file parameters \n\
6685 Sets variables dealing with output file familying.\tDoes nothing if\n\
6686 familying not supported by the driver. This routine, if used, must be\n\
6687 called before initializing PLplot.\tSee the PLplot documentation for\n\
6688 more information. \n\
6690 Redacted form: plsfam(fam, num, bmax)\n\
6692 This function is used in examples 14,31. \n\
6698 plsfam(fam, num, bmax)\n\
6702 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
6705 num (PLINT, input) : Current family file number. \n\
6707 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
6711 Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n\
6715 This is a variant of plscmap1l that supports alpha channel\n\
6716 transparency. It sets cmap1 colors using a piece-wise linear\n\
6717 relationship between cmap1 intensity index (from 0. to 1.) and\n\
6718 position in HLS or RGB color space (see the PLplot documentation) with\n\
6719 alpha transparency value (0.0 - 1.0). It may be called at any time. \n\
6721 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
6722 alpha, alt_hue_path) \n\
6724 This function is used in example 30. \n\
6730 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
6734 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
6736 npts (PLINT, input) : number of control points \n\
6738 intensity (const PLFLT *, input) : position for each control point\n\
6739 (between 0.0 and 1.0, in ascending order) \n\
6741 coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n\
6744 coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n\
6747 coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n\
6750 alpha (const PLFLT *, input) : the alpha transparency value for\n\
6751 each control point \n\
6753 alt_hue_path (const PLBOOL *, input) : alternative interpolation\n\
6754 method flag for each control point. (alt_hue_path[i] refers to the\n\
6755 interpolation interval between the i and i + 1 control points). \n\
6758 Set page parameters \n\
6762 Sets the page configuration (optional). If an individual parameter is\n\
6763 zero then that parameter value is not updated. Not all parameters are\n\
6764 recognized by all drivers and the interpretation is device-dependent.\n\
6765 The X-window driver uses the length and offset parameters to determine\n\
6766 the window size and location. The length and offset values are\n\
6767 expressed in units that are specific to the current driver. For\n\
6768 instance: screen drivers will usually interpret them as number of\n\
6769 pixels, whereas printer drivers will usually use mm. This routine, if\n\
6770 used, must be called before initializing PLplot. \n\
6772 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6774 This function is used in examples 14 and 31. \n\
6780 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6784 xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
6786 yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
6788 xleng (PLINT , input) : Page length, x. \n\
6790 yleng (PLINT, input) : Page length, y. \n\
6792 xoff (PLINT, input) : Page offset, x. \n\
6794 yoff (PLINT, input) : Page offset, y. \n\
6797 Set precision in numeric labels \n\
6801 Sets the number of places after the decimal point in numeric labels. \n\
6803 Redacted form: plprec(setp, prec)\n\
6805 This function is used in example 29. \n\
6811 plprec(setp, prec)\n\
6815 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
6816 automatically determines the number of places to use after the\n\
6817 decimal point in numeric labels (like those used to label axes). \n\
6818 If setp is 1 then prec sets the number of places. \n\
6820 prec (PLINT, input) : The number of characters to draw after the\n\
6821 decimal point in numeric labels. \n\
6824 Copy state parameters from the reference stream to the current stream \n\
6828 Copies state parameters from the reference stream to the current\n\
6829 stream. Tell driver interface to map device coordinates unless flags\n\
6832 This function is used for making save files of selected plots (e.g.\n\
6833 from the TK driver). After initializing, you can get a copy of the\n\
6834 current plot to the specified device by switching to this stream and\n\
6835 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
6836 appropriate. The plot buffer must have previously been enabled (done\n\
6837 automatically by some display drivers, such as X). \n\
6839 Redacted form: plcpstrm(iplsr, flags)\n\
6841 This function is used in example 1,20. \n\
6847 plcpstrm(iplsr, flags)\n\
6851 iplsr (PLINT, input) : Number of reference stream. \n\
6853 flags (PLBOOL, input) : If flags is set to true the device\n\
6854 coordinates are not copied from the reference to current stream. \n\
6857 Plot a glyph at the specified points \n\
6861 Plot a glyph at the specified points. (This function is largely\n\
6862 superseded by plstring which gives access to many[!] more glyphs.)\n\
6863 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6864 and a draw at the same place. Not ideal, since a sufficiently\n\
6865 intelligent output device may optimize it away, or there may be faster\n\
6866 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6867 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6868 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6869 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6870 code <= 127 the corresponding printable ASCII character is plotted. \n\
6872 Redacted form: plpoin(x, y, code)\n\
6874 This function is used in examples 1,6,14,29. \n\
6880 plpoin(n, x, y, code)\n\
6884 n (PLINT, input) : Number of points in the x and y arrays. \n\
6886 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
6889 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
6892 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6893 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6894 each of the n points. \n\
6897 Enter or leave xor mode \n\
6901 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
6902 those drivers (e.g., the xwin driver) that support it. Enables\n\
6903 erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
6904 is not capable of xor operation it returns a status of false. \n\
6906 Redacted form: plxormod(mode, status)\n\
6908 This function is used in examples 1,20. \n\
6914 plxormod(mode, status)\n\
6918 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
6919 is false means leave xor mode. \n\
6921 status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
6922 of true (false) means driver is capable (incapable) of xor mode. \n\
6925 Get viewport limits in normalized device coordinates \n\
6929 Get viewport limits in normalized device coordinates. \n\
6931 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6932 \t Perl/PDL: Not available? \n\
6935 This function is used in example 31. \n\
6941 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6945 p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
6946 device coordinate in x. \n\
6948 p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
6949 device coordinate in x. \n\
6951 p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
6952 device coordinate in y. \n\
6954 p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
6955 device coordinate in y. \n\
6958 Plot surface mesh \n\
6962 Plots a surface mesh within the environment set up by plw3d. The\n\
6963 surface is defined by the two-dimensional array z[\n\
6965 ny] , the point z[i][j] being the value of the function at (\n\
6967 y[j]) . Note that the points in arrays x and y do not need to be\n\
6968 equally spaced, but must be stored in ascending order. The parameter\n\
6969 opt controls the way in which the surface is displayed. For further\n\
6970 details see the PLplot documentation. \n\
6972 Redacted form: plmesh(x, y, z, opt)\n\
6974 This function is used in example 11. \n\
6980 plmesh(x, y, z, nx, ny, opt)\n\
6984 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
6985 which the function is evaluated. \n\
6987 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
6988 which the function is evaluated. \n\
6990 z (const PLFLT * const *, input) : Pointer to a vectored\n\
6991 two-dimensional array with set of function values. \n\
6993 nx (PLINT, input) : Number of x values at which function is\n\
6996 ny (PLINT, input) : Number of y values at which function is\n\
6999 opt (PLINT, input) : Determines the way in which the surface is\n\
7000 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7001 function of x for each value of y[j] . \n\
7002 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7003 for each value of x[i] . \n\
7004 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7005 at which function is defined. \n\
7008 Magnitude colored plot surface mesh with contour \n\
7012 A more powerful form of plmesh: the surface mesh can be colored\n\
7013 accordingly to the current z value being plotted, a contour plot can\n\
7014 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7015 plotted function border and the base XY plane. \n\
7017 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7019 This function is used in example 11. \n\
7025 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7029 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
7030 which the function is evaluated. \n\
7032 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
7033 which the function is evaluated. \n\
7035 z (const PLFLT * const *, input) : Pointer to a vectored\n\
7036 two-dimensional array with set of function values. \n\
7038 nx (PLINT, input) : Number of x values at which function is\n\
7041 ny (PLINT, input) : Number of y values at which function is\n\
7044 opt (PLINT, input) : Determines the way in which the surface is\n\
7045 represented. To specify more than one option just add the options,\n\
7046 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7047 showing z as a function of x for each value of y[j] . \n\
7048 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7049 for each value of x[i] . \n\
7050 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7051 at which function is defined. \n\
7052 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7053 the z value being plotted. The color is used from the current\n\
7055 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7056 using parameters \n\
7059 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7060 the borders of the plotted function. \n\
7063 clevel (const PLFLT *, input) : Pointer to the array that defines\n\
7064 the contour level spacing. \n\
7066 nlevel (PLINT, input) : Number of elements in the clevel array. \n\
7069 End plotting session for current stream \n\
7073 Ends a plotting session for the current output stream only. See\n\
7074 plsstrm for more info. \n\
7076 Redacted form: plend1()\n\
7078 This function is used in examples 1,20. \n\
7087 Get y axis parameters \n\
7091 Identical to plgxax, except that arguments are flags for y axis. See\n\
7092 the description of plgxax for more detail. \n\
7094 Redacted form: plgyax(p_digmax, p_digits)\n\
7096 This function is used in example 31. \n\
7102 plgyax(p_digmax, p_digits)\n\
7106 p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7107 number of digits for the y axis. If nonzero, the printed label\n\
7108 has been switched to a floating point representation when the\n\
7109 number of digits exceeds p_digmax. \n\
7111 p_digits (PLINT *, output) : Pointer to variable with the actual\n\
7112 number of digits for the numeric labels (y axis) from the last\n\
7116 Set plot orientation \n\
7120 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7121 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7122 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7123 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7124 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7125 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7126 not called the default value of rot is 0. \n\
7128 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7129 probably want to change the aspect ratio to a value suitable for the\n\
7130 plot orientation using a call to plsdidev or the command-line options\n\
7131 -a or -freeaspect.\tFor more documentation of those options see the\n\
7132 PLplot documentation. Such command-line options can be set internally\n\
7133 using plsetopt or set directly using the command line and parsed using\n\
7134 a call to plparseopts. \n\
7136 Redacted form: plsdiori(rot)\n\
7138 This function is not used in any examples. \n\
7148 rot (PLFLT, input) : Plot orientation parameter. \n\
7151 Plot a histogram from unbinned data \n\
7155 Plots a histogram from n data points stored in the array data. This\n\
7156 routine bins the data into nbin bins equally spaced between datmin and\n\
7157 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7158 opt allows, among other things, the histogram either to be plotted in\n\
7159 an existing window or causes plhist to call plenv with suitable limits\n\
7160 before plotting the histogram. \n\
7162 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7164 This function is used in example 5. \n\
7170 plhist(n, data, datmin, datmax, nbin, opt)\n\
7174 n (PLINT, input) : Number of data points. \n\
7176 data (const PLFLT *, input) : Pointer to array with values of the n\n\
7179 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
7181 datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
7183 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7184 divide the interval xmin to xmax. \n\
7186 opt (PLINT, input) : Is a combination of several flags:\n\
7187 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7188 the histogram data, the outer bins are expanded to fill up the\n\
7189 entire x-axis, data outside the given extremes are assigned to the\n\
7190 outer bins and bins of zero height are simply drawn. \n\
7191 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7192 to fit the histogram data, without this flag, plenv is called\n\
7193 to set the world coordinates. \n\
7194 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7195 extremes are not taken into account. This option should\n\
7196 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7197 properly present the data. \n\
7198 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7199 size as the ones inside. \n\
7200 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7201 (there is a gap for such bins). \n\
7204 End plotting session \n\
7208 Ends a plotting session, tidies up all the output files, switches\n\
7209 interactive devices back into text mode and frees up any memory that\n\
7210 was allocated. Must be called before end of program. \n\
7212 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7213 wait state after a call to plend or other functions which trigger the\n\
7214 end of a plot page. To avoid this, use the plspause function. \n\
7216 Redacted form: plend()\n\
7218 This function is used in all of the examples. \n\
7227 Plot shaded 3-d surface plot \n\
7231 Plots a three dimensional shaded surface plot within the environment\n\
7232 set up by plw3d. The surface is defined by the two-dimensional array\n\
7235 ny] , the point z[i][j] being the value of the function at (\n\
7237 y[j]) . Note that the points in arrays x and y do not need to be\n\
7238 equally spaced, but must be stored in ascending order. For further\n\
7239 details see the PLplot documentation. \n\
7241 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7243 This function is not used in any examples. \n\
7249 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7253 x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
7254 which the function is evaluated. \n\
7256 y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
7257 which the function is evaluated. \n\
7259 z (const PLFLT * const *, input) : Pointer to a vectored\n\
7260 two-dimensional array with set of function values. \n\
7262 nx (PLINT, input) : Number of x values at which function is\n\
7265 ny (PLINT, input) : Number of y values at which function is\n\
7268 opt (PLINT, input) : Determines the way in which the surface is\n\
7269 represented. To specify more than one option just add the options,\n\
7270 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7271 connecting points at which function is defined. \n\
7272 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7273 using parameters \n\
7276 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7277 using parameters \n\
7280 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7281 the borders of the plotted function. \n\
7282 opt=MAG_COLOR : the surface is colored according to the value\n\
7283 of Z; if MAG_COLOR is not used, then the default the surface\n\
7284 is colored according to the intensity of the reflected light\n\
7285 in the surface from a light source whose position is set using\n\
7289 clevel (const PLFLT *, input) : Pointer to the array that defines\n\
7290 the contour level spacing. \n\
7292 nlevel (PLINT, input) : Number of elements in the clevel array. \n\
7295 Set device-compression level \n\
7299 Set device-compression level. Only used for drivers that provide\n\
7300 compression. This function, if used, should be invoked before a call\n\
7303 Redacted form: plscompression(compression)\n\
7305 This function is used in example 31. \n\
7311 plscompression(compression)\n\
7315 compression (PLINT, input) : The desired compression level. This is\n\
7316 a device-dependent value. Currently only the jpeg and png devices\n\
7317 use these values. For jpeg value is the jpeg quality which should\n\
7318 normally be in the range 0-95. Higher values denote higher quality\n\
7319 and hence larger image sizes. For png values are in the range -1\n\
7320 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7321 A value of -1 denotes the default zlib compression level. Values\n\
7322 in the range 10-99 are divided by 10 and then used as the zlib\n\
7323 compression level. Higher compression levels correspond to greater\n\
7324 compression and small file sizes at the expense of more\n\
7328 Get the current device-compression setting \n\
7332 Get the current device-compression setting. This parameter is only\n\
7333 used for drivers that provide compression. \n\
7335 Redacted form: plgcompression(compression)\n\
7337 This function is used in example 31. \n\
7343 plgcompression(compression)\n\
7347 compression (PLINT *, output) : Pointer to a variable to be filled\n\
7348 with the current device-compression setting. \n\
7351 Advance the (sub-)page\n\
7355 Advances to the next subpage if sub=0, performing a page advance if\n\
7356 there are no remaining subpages on the current page. If subpages\n\
7357 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7358 PLplot switches to the specified subpage. Note that this allows you\n\
7359 to overwrite a plot on the specified subpage; if this is not what you\n\
7360 intended, use pleop followed by plbop to first advance the page. This\n\
7361 routine is called automatically (with page=0) by plenv, but if plenv\n\
7362 is not used, pladv must be called after initializing PLplot but before\n\
7363 defining the viewport. \n\
7365 Redacted form: pladv(page)\n\
7367 This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
7377 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7378 in the top left corner and increasing along the rows) to which to\n\
7379 advance. Set to zero to advance to the next subpage (or to the\n\
7380 next page if subpages are not being used). \n\
7383 Set parameters of contour labelling other than format of numerical label\n\
7387 Set parameters of contour labelling other than those handled by\n\
7388 pl_setcontlabelformat. \n\
7390 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7392 This function is used in example 9. \n\
7398 pl_setcontlabelparam(offset, size, spacing, active)\n\
7402 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7403 to 0.0, labels are printed on the lines). Default value is 0.006. \n\
7405 size (PLFLT, input) : Font height for contour labels (normalized). \n\
7406 Default value is 0.3. \n\
7408 spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
7409 Default value is 0.1. \n\
7411 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7412 contour labels on. Default is off (0). \n\
7415 Set family, style and weight of the current font \n\
7419 Sets the current font. See the PLplot documentation for more\n\
7420 information on font selection. \n\
7422 Redacted form: plsfont(family, style, weight)\n\
7424 This function is used in example 23. \n\
7430 plsfont(family, style, weight)\n\
7434 family (PLINT, input) : Font family to select for the current font.\n\
7435 The available values are given by the PL_FCI_* constants in\n\
7436 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7437 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7438 signifies that the font family should not be altered. \n\
7440 style (PLINT, input) : Font style to select for the current font.\n\
7441 The available values are given by the PL_FCI_* constants in\n\
7442 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7443 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7444 should not be altered. \n\
7446 weight (PLINT, input) : Font weight to select for the current font.\n\
7447 The available values are given by the PL_FCI_* constants in\n\
7448 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7449 negative value signifies that the font weight should not be\n\
7453 Sets the 3D position of the light source \n\
7457 Sets the 3D position of the light source for use with plsurf3d. \n\
7459 Redacted form: pllightsource(x, y, z)\n\
7461 This function is used in example 8. \n\
7467 pllightsource(x, y, z)\n\
7471 x (PLFLT, input) : X-coordinate of the light source. \n\
7473 y (PLFLT, input) : Y-coordinate of the light source. \n\
7475 z (PLFLT, input) : Z-coordinate of the light source. \n\
7482 Draws line defined by n points in x and y. \n\
7484 Redacted form: plline(x, y)\n\
7486 This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
7496 n (PLINT, input) : Number of points defining line. \n\
7498 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
7501 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
7509 Sets the pen width. \n\
7511 Redacted form: plwidth(width)\n\
7513 This function is used in examples 1,2. \n\
7523 width (PLFLT, input) : The desired pen width. If width is negative\n\
7524 or the same as the previous value no action is taken. width = 0. \n\
7525 should be interpreted as as the minimum valid pen width for the\n\
7526 device. The interpretation of positive width values is also\n\
7527 device dependent. \n\
7530 Draw linear gradient inside polygon \n\
7534 Draw a linear gradient using colour map 1 inside the polygon defined\n\
7535 by the n points (\n\
7537 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7538 polygon coordinates and the gradient angle are all expressed in world\n\
7539 coordinates. The angle from the x axis for both the rotated\n\
7540 coordinate system and the gradient vector is specified by angle. The\n\
7541 magnitude of the gradient vector is the difference between the maximum\n\
7542 and minimum values of x for the vertices in the rotated coordinate\n\
7543 system. The origin of the gradient vector can be interpreted as being\n\
7544 anywhere on the line corresponding to the minimum x value for the\n\
7545 vertices in the rotated coordinate system.\tThe distance along the\n\
7546 gradient vector is linearly transformed to the independent variable of\n\
7547 colour map 1 which ranges from 0. at the tail of the gradient vector\n\
7548 to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
7549 colour corresponding to the independent variable of colour map 1. For\n\
7550 more information about colour map 1 (see the PLplot documentation). \n\
7552 Redacted form: plgradient(x,y,angle)\n\
7554 This function is used in examples 25,30. \n\
7560 plgradient(n, x, y, angle)\n\
7564 n (PLINT, input) : Number of vertices in polygon. \n\
7566 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
7569 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
7572 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
7576 Flushes the output stream \n\
7580 Flushes the output stream. Use sparingly, if at all. \n\
7582 Redacted form: plflush()\n\
7584 This function is used in examples 1,14. \n\
7593 Get plot orientation \n\
7597 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7598 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7599 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7600 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7601 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7602 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7603 not been called the default value pointed to by p_rot will be 0. \n\
7605 Redacted form: plgdiori(p_rot)\n\
7607 This function is not used in any examples. \n\
7617 p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
7620 Set x axis parameters \n\
7624 Sets values of the digmax and digits flags for the x axis.\tSee the\n\
7625 PLplot documentation for more information. \n\
7627 Redacted form: plsxax(digmax, digits)\n\
7629 This function is used in example 31. \n\
7635 plsxax(digmax, digits)\n\
7639 digmax (PLINT, input) : Variable to set the maximum number of\n\
7640 digits for the x axis. If nonzero, the printed label will be\n\
7641 switched to a floating point representation when the number of\n\
7642 digits exceeds digmax. \n\
7644 digits (PLINT, input) : Field digits value. Currently, changing\n\
7645 its value here has no effect since it is set only by plbox or\n\
7646 plbox3. However, the user may obtain its value after a call to\n\
7647 either of these functions by calling plgxax. \n\
7650 Get viewport limits in world coordinates \n\
7654 Get viewport limits in world coordinates. \n\
7656 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7657 \t Perl/PDL: Not available? \n\
7660 This function is used in example 31. \n\
7666 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7670 p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
7671 coordinate in x. \n\
7673 p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
7674 coordinate in x. \n\
7676 p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
7677 coordinate in y. \n\
7679 p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
7680 coordinate in y. \n\
7683 Shade regions on the basis of value \n\
7687 Shade regions on the basis of value. This is the high-level routine\n\
7688 for making continuous color shaded plots with cmap1 while plshade (or\n\
7689 plshade1) are used for individual shaded regions using either cmap0 or\n\
7690 cmap1. examples/c/x16c.c shows a number of examples for using this\n\
7691 function. See the following discussion of the arguments and the PLplot\n\
7692 documentation for more information. \n\
7694 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
7695 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
7697 \t Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n\
7698 fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n\
7702 This function is used in examples 16,21. \n\
7708 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
7712 a (const PLFLT * const *, input) : Contains ** pointer to array to\n\
7713 be plotted. The array must have been declared as PLFLT a[nx][ny]. \n\
7715 nx (PLINT, input) : First dimension of array \"a\". \n\
7717 ny (PLINT, input) : Second dimension of array \"a\". \n\
7719 defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n\
7720 specifying regions excluded from the shading plot. This function\n\
7721 accepts x and y coordinates as input arguments and must return 0\n\
7722 if the point is in the excluded region or 1 otherwise. This\n\
7723 argument can be NULL if all the values are valid. \n\
7725 xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7726 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7727 at (xmax,ymin) and so on. \n\
7729 xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7730 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7731 at (xmax,ymin) and so on. \n\
7733 ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7734 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7735 at (xmax,ymin) and so on. \n\
7737 ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7738 a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7739 at (xmax,ymin) and so on. \n\
7741 clevel (const PLFLT *, input) : Pointer to array containing the\n\
7742 data levels corresponding to the edges of each shaded region that\n\
7743 will be plotted by this function. To work properly the levels\n\
7744 should be monotonic. \n\
7746 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
7747 of shade edge values in clevel). \n\
7749 fill_width (PLFLT, input) : Defines line width used by the fill\n\
7752 cont_color (PLINT, input) : Defines pen color used for contours\n\
7753 defining edges of shaded regions. The pen color is only temporary\n\
7754 set for the contour drawing. Set this value to zero or less if no\n\
7755 shade edge contours are wanted. \n\
7757 cont_width (PLFLT, input) : Defines line width used for contours\n\
7758 defining edges of shaded regions. This value may not be honored\n\
7759 by all drivers. The pen width is only temporary set for the\n\
7760 contour drawing. Set this value to zero or less if no shade edge\n\
7761 contours are wanted. \n\
7763 fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
7764 Routine used to fill the region. Use plfill. Future version of\n\
7765 PLplot may have other fill routines. \n\
7767 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
7768 map to rectangles after coordinate transformation with pltrl. \n\
7769 Otherwise, set rectangular to false. If rectangular is set to\n\
7770 true, plshade tries to save time by filling large rectangles. \n\
7771 This optimization fails if the coordinate transformation distorts\n\
7772 the shape of rectangles. For example a plot in polar coordinates\n\
7773 has to have rectangular set to false. \n\
7775 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
7776 Pointer to function that defines transformation between indices\n\
7777 in array z and the world coordinates (C only). Transformation\n\
7778 functions are provided in the PLplot library: pltr0 for identity\n\
7779 mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
7780 defined by one- and two-dimensional arrays. In addition,\n\
7781 user-supplied routines for the transformation can be used as well.\n\
7782 Examples of all of these approaches are given in the PLplot\n\
7783 documentation. The transformation function should have the form\n\
7784 given by any of pltr0, pltr1, or pltr2. \n\
7786 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
7787 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
7788 externally supplied. \n\
7791 Plot color bar for image, shade or gradient plots \n\
7795 Routine for creating a continuous color bar for image, shade, or\n\
7796 gradient plots. (See pllegend for similar functionality for creating\n\
7797 legends with discrete elements). The arguments of plcolorbar provide\n\
7798 control over the location and size of the color bar as well as the\n\
7799 location and characteristics of the elements (most of which are\n\
7800 optional) within that color bar. The resulting color bar is clipped\n\
7801 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
7802 system used for some of the parameters is defined in the documentation\n\
7803 of the position parameter.) \n\
7805 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
7806 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
7807 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
7808 labels, axis_opts, ticks, sub_ticks, values)\n\
7810 This function is used in examples 16 and 33. \n\
7816 plcolorbar(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\
7820 p_colorbar_width (PLFLT *, output) : Pointer to a location which\n\
7821 contains (after the call) the labelled and decorated color bar\n\
7822 width in adopted coordinates. \n\
7824 p_colorbar_height (PLFLT *, output) : Pointer to a location which\n\
7825 contains (after the call) the labelled and decorated color bar\n\
7826 height in adopted coordinates. \n\
7828 opt (PLINT, input) : opt contains bits controlling the overall\n\
7829 color bar. The orientation (direction of the maximum value) of\n\
7830 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
7831 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
7832 specified, the default orientation is toward the top if the\n\
7833 colorbar is placed on the left or right of the viewport or toward\n\
7834 the right if the colorbar is placed on the top or bottom of the\n\
7835 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
7836 (semi-transparent) background for the color bar. If the\n\
7837 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
7838 color bar. The type of color bar must be specified with one of\n\
7839 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
7840 more than one of those bits is set only the first one in the above\n\
7841 list is honored. The position of the (optional) label/title can be\n\
7842 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
7843 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
7844 will be drawn. If more than one of this list of bits is specified,\n\
7845 only the first one on the list is honored. End-caps for the color\n\
7846 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
7847 If a particular color bar cap option is not specified then no cap\n\
7848 will be drawn for that end. As a special case for\n\
7849 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
7850 specified. If this option is provided then any tick marks and tick\n\
7851 labels will be placed at the breaks between shaded segments. TODO:\n\
7852 This should be expanded to support custom placement of tick marks\n\
7853 and tick labels at custom value locations for any color bar type. \n\
7855 position (PLINT, input) : position contains bits which control the\n\
7856 overall position of the color bar and the definition of the\n\
7857 adopted coordinates used for positions just like what is done for\n\
7858 the position argument for pllegend. However, note that the\n\
7859 defaults for the position bits (see below) are different than the\n\
7860 pllegend case. The combination of the PL_POSITION_LEFT,\n\
7861 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
7862 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
7863 the 16 possible standard positions (the 4 corners and centers of\n\
7864 the 4 sides for both the inside and outside cases) of the color\n\
7865 bar relative to the adopted coordinate system. The corner\n\
7866 positions are specified by the appropriate combination of two of\n\
7867 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
7868 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
7869 value of one of those bits. The adopted coordinates are\n\
7870 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
7871 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
7872 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
7873 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
7874 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
7875 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
7876 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
7877 PL_POSITION_VIEWPORT. \n\
7879 x (PLFLT, input) : X offset of the color bar position in adopted\n\
7880 coordinates from the specified standard position of the color bar.\n\
7881 For positive x, the direction of motion away from the standard\n\
7882 position is inward/outward from the standard corner positions or\n\
7883 standard left or right positions if the\n\
7884 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
7885 For the standard top or bottom positions, the direction of motion\n\
7886 is toward positive X. \n\
7888 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
7889 coordinates from the specified standard position of the color bar.\n\
7890 For positive y, the direction of motion away from the standard\n\
7891 position is inward/outward from the standard corner positions or\n\
7892 standard top or bottom positions if the\n\
7893 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
7894 For the standard left or right positions, the direction of motion\n\
7895 is toward positive Y. \n\
7897 x_length (PLFLT, input) : Length of the body of the color bar in\n\
7898 the X direction in adopted coordinates. \n\
7900 y_length (PLFLT, input) : Length of the body of the color bar in\n\
7901 the Y direction in adopted coordinates. \n\
7903 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
7904 color bar (PL_COLORBAR_BACKGROUND). \n\
7906 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
7907 for the color bar (PL_COLORBAR_BOUNDING_BOX). \n\
7909 bb_style (PLINT, input) : The pllsty style number for the\n\
7910 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n\
7912 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
7913 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n\
7915 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
7916 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n\
7918 cont_color (PLINT, input) : The cmap0 contour color for\n\
7919 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
7920 it will be interpreted according to the design of plshades. \n\
7922 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
7923 plots. This is passed directly to plshades, so it will be\n\
7924 interpreted according to the design of plshades. \n\
7926 n_labels (PLINT, input) : Number of labels to place around the\n\
7929 label_opts (const PLINT *, input) : Options for each of \n\
7930 n_labels labels. \n\
7932 labels (const char * const *, input) : n_labels text labels for the\n\
7933 color bar. No label is drawn if no label position is specified\n\
7934 with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
7935 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
7936 corresponding label_opts field. \n\
7938 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
7939 value must be greater than 0. It is typically 1 (numerical axis\n\
7940 labels are provided for one of the long edges of the color bar),\n\
7941 but it can be larger if multiple numerical axis labels for the\n\
7942 long edges of the color bar are desired. \n\
7944 axis_opts (const char * const *, input) : An array of n_axes axis\n\
7945 options (interpreted as for plbox) for the color bar\'s axis\n\
7948 ticks (const PLFLT *, input) : An array of n_axes values of the\n\
7949 spacing of the major tick marks (interpreted as for plbox) for the\n\
7950 color bar\'s axis definitions. \n\
7952 sub_ticks (const PLINT *, input) : An array of n_axes values of the\n\
7953 number of subticks (interpreted as for plbox) for the color bar\'s\n\
7954 axis definitions. \n\
7956 n_values (const PLINT *, input) : An array containing the number of\n\
7957 elements in each of the n_axes rows of the two-dimensional values\n\
7960 values (const PLFLT * const *, input) : A two-dimensional array\n\
7961 containing the numeric values for the data range represented by\n\
7962 the color bar. For a row index of i_axis (where 0 < i_axis <\n\
7963 n_axes), the number of elements in the row is specified by\n\
7964 n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n\
7965 the number of elements is 2, and the corresponding row elements of\n\
7966 the values array are the minimum and maximum value represented by\n\
7967 the colorbar. For PL_COLORBAR_SHADE, the number and values of the\n\
7968 elements of a row of the values array is interpreted the same as\n\
7969 the nlevel and clevel arguments of plshades. \n\
7972 Get current subpage parameters \n\
7976 Gets the size of the current subpage in millimeters measured from the\n\
7977 bottom left hand corner of the output device page or screen. Can be\n\
7978 used in conjunction with plsvpa for setting the size of a viewport in\n\
7979 absolute coordinates (millimeters). \n\
7981 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
7983 This function is used in example 23. \n\
7989 plgspa(xmin, xmax, ymin, ymax)\n\
7993 xmin (PLFLT *, output) : Pointer to variable with position of left\n\
7994 hand edge of subpage in millimeters. \n\
7996 xmax (PLFLT *, output) : Pointer to variable with position of right\n\
7997 hand edge of subpage in millimeters. \n\
7999 ymin (PLFLT *, output) : Pointer to variable with position of\n\
8000 bottom edge of subpage in millimeters. \n\
8002 ymax (PLFLT *, output) : Pointer to variable with position of top\n\
8003 edge of subpage in millimeters. \n\
8006 Shade individual region on the basis of value \n\
8010 Shade individual region on the basis of value. Use plshades if you\n\
8011 want to shade a number of regions using continuous colors. plshade is\n\
8012 identical to plshade1 except for the type of the first parameter. See\n\
8013 plshade1 for further discussion. \n\
8015 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8016 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8017 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8018 \t Perl/PDL: Not available? \n\
8021 This function is used in example 15. \n\
8027 plshade(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\
8031 a (const PLFLT * const *, input) : \n\
8033 nx (PLINT, input) : \n\
8035 ny (PLINT, input) : \n\
8037 defined (PLINT (*) (PLFLT, PLFLT), input) : \n\
8039 xmin (PLFLT, input) : \n\
8041 xmax (PLFLT, input) : \n\
8043 ymin (PLFLT, input) : \n\
8045 ymax (PLFLT, input) : \n\
8047 shade_min (PLFLT, input) : \n\
8049 shade_max (PLFLT, input) : \n\
8051 sh_cmap (PLINT, input) : \n\
8053 sh_color (PLFLT, input) : \n\
8055 sh_width (PLFLT, input) : \n\
8057 min_color (PLINT, input) : \n\
8059 min_width (PLFLT, input) : \n\
8061 max_color (PLINT, input) : \n\
8063 max_width (PLFLT, input) : \n\
8065 fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
8067 rectangular (PLBOOL, input) : \n\
8069 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8071 pltr_data (PLPointer, input) : \n\
8074 Calculate world coordinates and corresponding window index from relative device coordinates \n\
8078 Calculate world coordinates, wx and wy, and corresponding window index\n\
8079 from relative device coordinates, rx and ry. \n\
8081 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8082 \t Perl/PDL: Not available? \n\
8085 This function is used in example 31. \n\
8091 plcalc_world(rx, ry, wx, wy, window)\n\
8095 rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
8096 0. to 1.) for the x coordinate. \n\
8098 ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
8099 0. to 1.) for the y coordinate. \n\
8101 wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
8102 x corresponding to the relative device coordinates rx and ry. \n\
8104 wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
8105 y corresponding to the relative device coordinates rx and ry. \n\
8107 window (PLINT *, output) : Pointer to the returned last defined\n\
8108 window index that corresponds to the input relative device\n\
8109 coordinates (and the returned world coordinates). To give some\n\
8110 background on the window index, for each page the initial window\n\
8111 index is set to zero, and each time plwind is called within the\n\
8112 page, world and device coordinates are stored for the window and\n\
8113 the window index is incremented. Thus, for a simple page layout\n\
8114 with non-overlapping viewports and one window per viewport, window\n\
8115 corresponds to the viewport index (in the order which the\n\
8116 viewport/windows were created) of the only viewport/window\n\
8117 corresponding to rx and ry. However, for more complicated layouts\n\
8118 with potentially overlapping viewports and possibly more than one\n\
8119 window (set of world coordinates) per viewport, window and the\n\
8120 corresponding output world coordinates corresponds to the last\n\
8121 window created that fulfills the criterion that the relative\n\
8122 device coordinates are inside it. Finally, in all cases where the\n\
8123 input relative device coordinates are not inside any\n\
8124 viewport/window, then window is set to -1. \n\
8127 Draw a box with axes, etc, in 3-d \n\
8131 Draws axes, numeric and text labels for a three-dimensional surface\n\
8132 plot. For a more complete description of three-dimensional plotting\n\
8133 see the PLplot documentation. \n\
8135 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8136 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8137 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
8138 xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
8141 This function is used in examples 8,11,18,21. \n\
8147 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8151 xopt (const char *, input) : Pointer to character string specifying\n\
8152 options for the x axis. The string can include any combination of\n\
8153 the following letters (upper or lower case) in any order: b: Draws\n\
8154 axis at base, at height z=\n\
8155 zmin where zmin is defined by call to plw3d. This character must be\n\
8156 specified in order to use any of the other options. \n\
8157 d: Plot labels as date / time. Values are assumed to be\n\
8158 seconds since the epoch (as used by gmtime). \n\
8159 f: Always use fixed point numeric labels. \n\
8160 i: Inverts tick marks, so they are drawn downwards, rather\n\
8162 l: Labels axis logarithmically. This only affects the labels,\n\
8163 not the data, and so it is necessary to compute the logarithms\n\
8164 of data points before passing them to any of the drawing\n\
8166 n: Writes numeric labels at major tick intervals. \n\
8167 o: Use custom labelling function to generate axis label text. \n\
8168 The custom labelling function can be defined with the\n\
8169 plslabelfunc command. \n\
8170 s: Enables subticks between major ticks, only valid if t is\n\
8172 t: Draws major ticks. \n\
8173 u: If this is specified, the text label for the axis is\n\
8174 written under the axis. \n\
8177 xlabel (const char *, input) : Pointer to character string\n\
8178 specifying text label for the x axis. It is only drawn if u is in\n\
8179 the xopt string. \n\
8181 xtick (PLFLT, input) : World coordinate interval between major\n\
8182 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8183 generates a suitable tick interval. \n\
8185 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8186 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8187 generates a suitable minor tick interval. \n\
8189 yopt (const char *, input) : Pointer to character string specifying\n\
8190 options for the y axis. The string is interpreted in the same way\n\
8193 ylabel (const char *, input) : Pointer to character string\n\
8194 specifying text label for the y axis. It is only drawn if u is in\n\
8195 the yopt string. \n\
8197 ytick (PLFLT, input) : World coordinate interval between major\n\
8198 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8199 generates a suitable tick interval. \n\
8201 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8202 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8203 generates a suitable minor tick interval. \n\
8205 zopt (const char *, input) : Pointer to character string specifying\n\
8206 options for the z axis. The string can include any combination of\n\
8207 the following letters (upper or lower case) in any order: b: Draws\n\
8208 z axis to the left of the surface plot. \n\
8209 c: Draws z axis to the right of the surface plot. \n\
8210 d: Draws grid lines parallel to the x-y plane behind the\n\
8211 figure. These lines are not drawn until after plot3d or\n\
8212 plmesh are called because of the need for hidden line removal. \n\
8213 e: Plot labels as date / time. Values are assumed to be\n\
8214 seconds since the epoch (as used by gmtime). Note this\n\
8215 suboption is interpreted the same as the d suboption for xopt\n\
8216 and yopt, but it has to be identified as e for zopt since d\n\
8217 has already been used for the different purpose above. \n\
8218 f: Always use fixed point numeric labels. \n\
8219 i: Inverts tick marks, so they are drawn away from the center. \n\
8220 l: Labels axis logarithmically. This only affects the labels,\n\
8221 not the data, and so it is necessary to compute the logarithms\n\
8222 of data points before passing them to any of the drawing\n\
8224 m: Writes numeric labels at major tick intervals on the\n\
8225 right-hand vertical axis. \n\
8226 n: Writes numeric labels at major tick intervals on the\n\
8227 left-hand vertical axis. \n\
8228 o: Use custom labelling function to generate axis label text. \n\
8229 The custom labelling function can be defined with the\n\
8230 plslabelfunc command. \n\
8231 s: Enables subticks between major ticks, only valid if t is\n\
8233 t: Draws major ticks. \n\
8234 u: If this is specified, the text label is written beside the\n\
8236 v: If this is specified, the text label is written beside the\n\
8237 right-hand axis. \n\
8240 zlabel (const char *, input) : Pointer to character string\n\
8241 specifying text label for the z axis. It is only drawn if u or v\n\
8242 are in the zopt string. \n\
8244 ztick (PLFLT, input) : World coordinate interval between major\n\
8245 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8246 generates a suitable tick interval. \n\
8248 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8249 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8250 generates a suitable minor tick interval. \n\
8253 Get character default height and current (scaled) height \n\
8257 Get character default height and current (scaled) height. \n\
8259 Redacted form: plgchr(p_def, p_ht)\n\
8261 This function is used in example 23. \n\
8267 plgchr(p_def, p_ht)\n\
8271 p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
8273 p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
8277 Set the escape character for text strings \n\
8281 Set the escape character for text strings.\tFrom C (in contrast to\n\
8282 Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8283 selected characters are allowed to prevent the user from shooting\n\
8284 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8285 with C\'s use of backslash as a character escape). Here are the\n\
8286 allowed escape characters and their corresponding decimal ASCII\n\
8287 values: !, ASCII 33 \n\
8298 Redacted form: General: plsesc(esc)\n\
8299 \t Perl/PDL: Not available? \n\
8302 This function is used in example 29. \n\
8312 esc (char, input) : Escape character. \n\
8315 Draw a line between two points, accounting for coordinate transforms \n\
8319 Joins the point (\n\
8323 y2) . If a global coordinate transform is defined then the line is\n\
8324 broken in to n segments to approximate the path. If no transform is\n\
8325 defined then this simply acts like a call to pljoin. \n\
8327 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8329 This function is used in example 22. \n\
8335 plpath(n, x1, y1, x2, y2)\n\
8339 n (PLINT, input) : number of points to use to approximate the path. \n\
8341 x1 (PLFLT, input) : x coordinate of first point. \n\
8343 y1 (PLFLT, input) : y coordinate of first point. \n\
8345 x2 (PLFLT, input) : x coordinate of second point. \n\
8347 y2 (PLFLT, input) : y coordinate of second point. \n\
8350 Set up standard window and draw box \n\
8354 Sets up plotter environment for simple graphs by calling pladv and\n\
8355 setting up viewport and window to sensible default values.\tplenv\n\
8356 leaves enough room around most graphs for axis labels and a title.\n\
8357 When these defaults are not suitable, use the individual routines\n\
8358 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
8359 defining the window, and plbox for drawing the box. \n\
8361 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8363 This function is used in example 1,3,9,13,14,19-22,29. \n\
8369 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8373 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8374 world coordinates). \n\
8376 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8377 world coordinates). \n\
8379 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8382 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8385 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8386 scales will not be set, the user must set up the scale before\n\
8387 calling plenv using plsvpa, plvasp or other. \n\
8388 0: the x and y axes are scaled independently to use as much of\n\
8389 the screen as possible. \n\
8390 1: the scales of the x and y axes are made equal. \n\
8391 2: the axis of the x and y axes are made equal, and the plot\n\
8392 box will be square. \n\
8395 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8396 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
8397 -1: draw box only. \n\
8398 0: draw box, ticks, and numeric tick labels. \n\
8399 1: also draw coordinate axes at x=0 and y=0. \n\
8400 2: also draw a grid at major tick positions in both\n\
8402 3: also draw a grid at minor tick positions in both\n\
8404 10: same as 0 except logarithmic x tick marks. (The x data\n\
8405 have to be converted to logarithms separately.) \n\
8406 11: same as 1 except logarithmic x tick marks. (The x data\n\
8407 have to be converted to logarithms separately.) \n\
8408 12: same as 2 except logarithmic x tick marks. (The x data\n\
8409 have to be converted to logarithms separately.) \n\
8410 13: same as 3 except logarithmic x tick marks. (The x data\n\
8411 have to be converted to logarithms separately.) \n\
8412 20: same as 0 except logarithmic y tick marks. (The y data\n\
8413 have to be converted to logarithms separately.) \n\
8414 21: same as 1 except logarithmic y tick marks. (The y data\n\
8415 have to be converted to logarithms separately.) \n\
8416 22: same as 2 except logarithmic y tick marks. (The y data\n\
8417 have to be converted to logarithms separately.) \n\
8418 23: same as 3 except logarithmic y tick marks. (The y data\n\
8419 have to be converted to logarithms separately.) \n\
8420 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8421 and y data have to be converted to logarithms separately.) \n\
8422 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8423 and y data have to be converted to logarithms separately.) \n\
8424 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8425 and y data have to be converted to logarithms separately.) \n\
8426 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8427 and y data have to be converted to logarithms separately.) \n\
8428 40: same as 0 except date / time x labels. \n\
8429 41: same as 1 except date / time x labels. \n\
8430 42: same as 2 except date / time x labels. \n\
8431 43: same as 3 except date / time x labels. \n\
8432 50: same as 0 except date / time y labels. \n\
8433 51: same as 1 except date / time y labels. \n\
8434 52: same as 2 except date / time y labels. \n\
8435 53: same as 3 except date / time y labels. \n\
8436 60: same as 0 except date / time x and y labels. \n\
8437 61: same as 1 except date / time x and y labels. \n\
8438 62: same as 2 except date / time x and y labels. \n\
8439 63: same as 3 except date / time x and y labels. \n\
8440 70: same as 0 except custom x and y labels. \n\
8441 71: same as 1 except custom x and y labels. \n\
8442 72: same as 2 except custom x and y labels. \n\
8443 73: same as 3 except custom x and y labels. \n\
8446 Grid data from irregularly sampled data \n\
8450 Real world data is frequently irregularly sampled, but all PLplot 3D\n\
8451 plots require data placed in a uniform grid. This function takes\n\
8452 irregularly sampled data from three input arrays x[npts], y[npts], and\n\
8453 z[npts], reads the desired grid location from input arrays xg[nptsx]\n\
8454 and yg[nptsy], and returns the gridded data into output array\n\
8455 zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n\
8456 with the argument type which can have one parameter specified in\n\
8459 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8460 \t Perl/PDL: Not available? \n\
8461 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8464 This function is used in example 21. \n\
8470 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8474 x (const PLFLT *, input) : The input x array. \n\
8476 y (const PLFLT *, input) : The input y array. \n\
8478 z (const PLFLT *, input) : The input z array. Each triple x[i],\n\
8479 y[i], z[i] represents one data sample coordinate. \n\
8481 npts (PLINT, input) : The number of data samples in the x, y and z\n\
8484 xg (const PLFLT *, input) : The input array that specifies the grid\n\
8485 spacing in the x direction. Usually xg has nptsx equally spaced\n\
8486 values from the minimum to the maximum values of the x input\n\
8489 nptsx (PLINT, input) : The number of points in the xg array. \n\
8491 yg (const PLFLT *, input) : The input array that specifies the grid\n\
8492 spacing in the y direction. Similar to the xg parameter. \n\
8494 nptsy (PLINT, input) : The number of points in the yg array. \n\
8496 zg (PLFLT **, output) : The output array, where data lies in the\n\
8497 regular grid specified by xg and yg. the zg array must exist or be\n\
8498 allocated by the user prior to the call, and must have dimension\n\
8499 zg[nptsx][nptsy]. \n\
8501 type (PLINT, input) : The type of gridding algorithm to use, which\n\
8502 can be: GRID_CSA: Bivariate Cubic Spline approximation \n\
8503 GRID_DTLI: Delaunay Triangulation Linear Interpolation \n\
8504 GRID_NNI: Natural Neighbors Interpolation \n\
8505 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n\
8506 GRID_NNLI: Nearest Neighbors Linear Interpolation \n\
8507 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8509 For details of the algorithms read the source file plgridd.c. \n\
8511 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8512 which can be specified through this argument. Currently, for\n\
8513 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8514 use, the lower the value, the noisier (more local) the\n\
8515 approximation is. \n\
8516 GRID_NNLI, data specifies what a thin triangle is, in the\n\
8517 range [1. .. 2.]. High values enable the usage of very thin\n\
8518 triangles for interpolation, possibly resulting in error in\n\
8519 the approximation. \n\
8520 GRID_NNI, only weights greater than data will be accepted. If\n\
8521 0, all weights will be accepted. \n\
8524 Clear current (sub)page \n\
8528 Clears the current page, effectively erasing everything that have been\n\
8529 drawn. This command only works with interactive drivers; if the\n\
8530 driver does not support this, the page is filled with the background\n\
8531 color in use. If the current page is divided into subpages, only the\n\
8532 current subpage is erased.\tThe nth subpage can be selected with\n\
8535 Redacted form: General: plclear()\n\
8536 \t Perl/PDL: Not available? \n\
8539 This function is not used in any examples. \n\
8548 Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n\
8552 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8553 and floating point alpha transparency value. This sets the entire\n\
8554 color map -- only as many colors as specified will be allocated. \n\
8556 Redacted form: plscmap0a(r, g, b, alpha)\n\
8558 This function is used in examples 30. \n\
8564 plscmap0a(r, g, b, alpha, ncol0)\n\
8568 r (const PLINT *, input) : Pointer to array with set of unsigned\n\
8569 8-bit integers (0-255) representing the degree of red in the\n\
8572 g (const PLINT *, input) : Pointer to array with set of unsigned\n\
8573 8-bit integers (0-255) representing the degree of green in the\n\
8576 b (const PLINT *, input) : Pointer to array with set of unsigned\n\
8577 8-bit integers (0-255) representing the degree of blue in the\n\
8580 alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n\
8581 values (0.0 - 1.0) representing the alpha transparency of the\n\
8584 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8588 Set 8-bit RGB values for given cmap0 color index \n\
8592 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8593 index. Overwrites the previous color value for the given index and,\n\
8594 thus, does not result in any additional allocation of space for\n\
8597 Redacted form: plscol0(icol0, r, g, b)\n\
8599 This function is used in any example 31. \n\
8605 plscol0(icol0, r, g, b)\n\
8609 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8610 number of colors (which is set by default, by plscmap0n, or even\n\
8613 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8614 degree of red in the color. \n\
8616 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8617 degree of green in the color. \n\
8619 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8620 degree of blue in the color. \n\
8623 Set up transformation from metafile coordinates \n\
8627 Set up transformation from metafile coordinates. The size of the plot\n\
8628 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8629 general-purpose facility just yet (not sure why the user would need\n\
8632 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8635 This function is not used in any examples. \n\
8641 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8645 dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
8647 dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
8649 dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
8651 dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
8653 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8655 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8658 Creates a new stream and makes it the default \n\
8662 Creates a new stream and makes it the default. Differs from using\n\
8663 plsstrm, in that a free stream number is found, and returned.\n\
8664 Unfortunately, I have to start at stream 1 and work upward, since\n\
8665 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8666 that no initial, library-opening call is required.\tSo stream 0 must\n\
8667 be preallocated, and there is no simple way of determining whether it\n\
8668 is already in use or not. \n\
8670 Redacted form: plmkstrm(p_strm)\n\
8672 This function is used in examples 1,20. \n\
8682 p_strm (PLINT *, output) : Pointer to stream number of the created\n\
8686 Get page parameters \n\
8690 Gets the current page configuration. The length and offset values are\n\
8691 expressed in units that are specific to the current driver. For\n\
8692 instance: screen drivers will usually interpret them as number of\n\
8693 pixels, whereas printer drivers will usually use mm. \n\
8695 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8697 This function is used in examples 14 and 31. \n\
8703 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8707 p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
8709 p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n\
8712 p_xleng (PLINT *, output) : Pointer to x page length value. \n\
8714 p_yleng (PLINT *, output) : Pointer to y page length value. \n\
8716 p_xoff (PLINT *, output) : Pointer to x page offset. \n\
8718 p_yoff (PLINT *, output) : Pointer to y page offset. \n\
8721 Set format for date / time labels \n\
8725 Sets the format for date / time labels. To enable date / time format\n\
8726 labels see the options to plbox, plbox3, and plenv. \n\
8728 Redacted form: pltimefmt(fmt)\n\
8730 This function is used in example 29. \n\
8740 fmt (const char *, fmt) : This string is interpreted similarly to\n\
8741 the format specifier of typical system strftime routines except\n\
8742 that PLplot ignores locale and also supplies some useful\n\
8743 extensions in the context of plotting. All text in the string is\n\
8744 printed as-is other than conversion specifications which take the\n\
8745 form of a \'%\' character followed by further conversion\n\
8746 specification character. The conversion specifications which are\n\
8747 similar to those provided by system strftime routines are the\n\
8748 following: %a: The abbreviated (English) weekday name. \n\
8749 %A: The full (English) weekday name. \n\
8750 %b: The abbreviated (English) month name. \n\
8751 %B: The full (English) month name. \n\
8752 %c: Equivalent to %a %b %d %T %Y (non-ISO). \n\
8753 %C: The century number (year/100) as a 2-digit integer. \n\
8754 %d: The day of the month as a decimal number (range 01 to 31). \n\
8755 %D: Equivalent to %m/%d/%y (non-ISO). \n\
8756 %e: Like %d, but a leading zero is replaced by a space. \n\
8757 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format). \n\
8758 %h: Equivalent to %b. \n\
8759 %H: The hour as a decimal number using a 24-hour clock (range\n\
8761 %I: The hour as a decimal number using a 12-hour clock (range\n\
8763 %j: The day of the year as a decimal number (range 001 to\n\
8765 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
8766 23); single digits are preceded by a blank. (See also %H.) \n\
8767 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
8768 12); single digits are preceded by a blank. (See also %I.) \n\
8769 %m: The month as a decimal number (range 01 to 12). \n\
8770 %M: The minute as a decimal number (range 00 to 59). \n\
8771 %n: A newline character. \n\
8772 %p: Either \"AM\" or \"PM\" according to the given time value. \n\
8773 Noon is treated as \"PM\" and midnight as \"AM\". \n\
8774 %r: Equivalent to %I:%M:%S %p. \n\
8775 %R: The time in 24-hour notation (%H:%M). For a version\n\
8776 including the seconds, see %T below. \n\
8777 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
8779 %S: The second as a decimal number (range 00 to 60). (The\n\
8780 range is up to 60 to allow for occasional leap seconds.) \n\
8781 %t: A tab character. \n\
8782 %T: The time in 24-hour notation (%H:%M:%S). \n\
8783 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
8784 being 1. See also %w. \n\
8785 %U: The week number of the current year as a decimal number,\n\
8786 range 00 to 53, starting with the first Sunday as the first\n\
8787 day of week 01. See also %V and %W. \n\
8788 %v: Equivalent to %e-%b-%Y. \n\
8789 %V: The ISO 8601 week number of the current year as a decimal\n\
8790 number, range 01 to 53, where week 1 is the first week that\n\
8791 has at least 4 days in the new year. See also %U and %W. \n\
8792 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
8793 being 0. See also %u. \n\
8794 %W: The week number of the current year as a decimal number,\n\
8795 range 00 to 53, starting with the first Monday as the first\n\
8797 %x: Equivalent to %a %b %d %Y. \n\
8798 %X: Equivalent to %T. \n\
8799 %y: The year as a decimal number without a century (range 00\n\
8801 %Y: The year as a decimal number including a century. \n\
8802 %z: The UTC time-zone string = \"+0000\". \n\
8803 %Z: The UTC time-zone abbreviation = \"UTC\". \n\
8804 %+: The UTC date and time in default format of the Unix date\n\
8805 command which is equivalent to %a %b %d %T %Z %Y. \n\
8806 %%: A literal \"%\" character. \n\
8807 The conversion specifications which are extensions to those normally\n\
8808 provided by system strftime routines are the following: %(0-9):\n\
8809 The fractional part of the seconds field (including leading\n\
8810 decimal point) to the specified accuracy. Thus %S%3 would give\n\
8811 seconds to millisecond accuracy (00.000). \n\
8812 %.: The fractional part of the seconds field (including\n\
8813 leading decimal point) to the maximum available accuracy. Thus\n\
8814 %S%. would give seconds with fractional part up to 9 decimal\n\
8815 places if available. \n\
8818 Specify viewport using aspect ratio only \n\
8822 Sets the viewport so that the ratio of the length of the y axis to\n\
8823 that of the x axis is equal to aspect. \n\
8825 Redacted form: plvasp(aspect)\n\
8827 This function is used in example 13. \n\
8837 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8841 Set output file name \n\
8845 Sets the current output file name, if applicable. If the file name\n\
8846 has not been specified and is required by the driver, the user will be\n\
8847 prompted for it. If using the X-windows output driver, this sets the\n\
8848 display name. This routine, if used, must be called before\n\
8849 initializing PLplot. \n\
8851 Redacted form: plsfnam(fnam)\n\
8853 This function is used in examples 1,20. \n\
8863 fnam (const char *, input) : Pointer to file name string. \n\
8870 Draws a vector plot of the vector (\n\
8876 ny]) . The scaling factor for the vectors is given by scale. A\n\
8877 transformation routine pointed to by pltr with a pointer pltr_data for\n\
8878 additional data required by the transformation routine is used to map\n\
8879 indices within the array to the world coordinates. The style of the\n\
8880 vector arrow may be set using plsvect. \n\
8882 Redacted form: plvect(u, v, scale, pltr, pltr_data)\n\
8884 This function is used in example 22. \n\
8890 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
8894 u, v (const PLFLT * const *, input) : Pointers to a pair of\n\
8895 vectored two-dimensional arrays containing the x and y components\n\
8896 of the vector data to be plotted. \n\
8898 nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n\
8900 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
8901 the vectors for plotting. If scale = 0 then the scaling factor is\n\
8902 automatically calculated for the data. If scale < 0 then the\n\
8903 scaling factor is automatically calculated for the data and then\n\
8905 scale. If scale > 0 then the scaling factor is set to scale. \n\
8907 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8908 Pointer to function that defines transformation between indices\n\
8909 in array z and the world coordinates (C only). Transformation\n\
8910 functions are provided in the PLplot library: pltr0 for identity\n\
8911 mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
8912 defined by one- and two-dimensional arrays. In addition,\n\
8913 user-supplied routines for the transformation can be used as well.\n\
8914 Examples of all of these approaches are given in the PLplot\n\
8915 documentation. The transformation function should have the form\n\
8916 given by any of pltr0, pltr1, or pltr2. \n\
8918 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8919 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8920 externally supplied. \n\
8923 Set parameters that define current plot-space window \n\
8927 Set relative minima and maxima that define the current plot-space\n\
8928 window. If plsdiplt is not called the default values of xmin, ymin,\n\
8929 xmax, and ymax are 0., 0., 1., and 1. \n\
8931 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
8933 This function is used in example 31. \n\
8939 plsdiplt(xmin, ymin, xmax, ymax)\n\
8943 xmin (PLFLT, input) : Relative minimum in x. \n\
8945 ymin (PLFLT, input) : Relative minimum in y. \n\
8947 xmax (PLFLT, input) : Relative maximum in x. \n\
8949 ymax (PLFLT, input) : Relative maximum in y. \n\
8952 Select line style \n\
8956 This sets the line style according to one of eight predefined patterns\n\
8957 (also see plstyl). \n\
8959 Redacted form: pllsty(lin)\n\
8961 This function is used in examples 9,12,22,25. \n\
8971 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
8972 a continuous line, line style 2 is a line with short dashes and\n\
8973 gaps, line style 3 is a line with long dashes and gaps, line style\n\
8974 4 has long dashes and short gaps and so on. \n\
8977 Plot a glyph at the specified points \n\
8981 Plot a glyph at the specified points. (This function is largely\n\
8982 superseded by plstring which gives access to many[!] more glyphs.) \n\
8984 Redacted form: plsym(x, y, code)\n\
8986 This function is used in example 7. \n\
8992 plsym(n, x, y, code)\n\
8996 n (PLINT, input) : Number of points in the x and y arrays. \n\
8998 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9001 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9004 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9005 to be plotted at each of the n points. \n\
9008 Set the device (keyword) name \n\
9012 Set the device (keyword) name. \n\
9014 Redacted form: plsdev(devname)\n\
9016 This function is used in examples 1,14,20. \n\
9026 devname (const char *, input) : Pointer to device (keyword) name\n\
9030 Set the background color by 8-bit RGB value \n\
9034 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9035 (see the PLplot documentation). \n\
9037 Redacted form: plscolbg(r, g, b)\n\
9039 This function is used in examples 15,31. \n\
9045 plscolbg(r, g, b)\n\
9049 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9050 degree of red in the color. \n\
9052 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9053 degree of green in the color. \n\
9055 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9056 degree of blue in the color. \n\
9059 Set parameters incrementally (zoom mode) that define current plot-space window \n\
9063 Set relative minima and maxima incrementally (zoom mode) that define\n\
9064 the current plot-space window. This function has the same effect as\n\
9065 plsdiplt if that function has not been previously called. Otherwise,\n\
9066 this function implements zoom mode using the transformation min_used =\n\
9067 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9068 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9069 repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
9071 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9073 This function is used in example 31. \n\
9079 plsdiplz(xmin, ymin, xmax, ymax)\n\
9083 xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
9085 ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
9087 xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
9089 ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
9092 Advance to the next family file on the next new page \n\
9096 Advance to the next family file on the next new page. \n\
9098 Redacted form: plfamadv()\n\
9100 This function is not used in any examples. \n\
9109 Set number of colors in cmap0 \n\
9113 Set number of colors in color map0 (see the PLplot documentation).\n\
9114 Allocate (or reallocate) color map0, and fill with default values for\n\
9115 those colors not previously allocated. The first 16 default colors are\n\
9116 given in the plcol0 documentation. For larger indices the default\n\
9119 The drivers are not guaranteed to support more than 16 colors. \n\
9121 Redacted form: plscmap0n(ncol0)\n\
9123 This function is used in examples 15,16,24. \n\
9133 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9134 the map0 palette. If this number is zero or less, then the value\n\
9135 from the previous call to plscmap0n is used and if there is no\n\
9136 previous call, then a default value is used. \n\
9139 Plot latitude and longitude lines \n\
9143 Displays latitude and longitude on the current plot. The lines are\n\
9144 plotted in the current color and line style. \n\
9146 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9149 This function is used in example 19. \n\
9155 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9159 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9160 supplied function to transform the coordinate longitudes and\n\
9161 latitudes to a plot coordinate system. By using this transform, we\n\
9162 can change from a longitude, latitude coordinate to a polar\n\
9163 stereographic project, for example. Initially, x[0]..[n-1] are\n\
9164 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9165 After the call to mapform(), x[] and y[] should be replaced by the\n\
9166 corresponding plot coordinates. If no transform is desired,\n\
9167 mapform can be replaced by NULL. \n\
9169 dlong (PLFLT, input) : The interval in degrees at which the\n\
9170 longitude lines are to be plotted. \n\
9172 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9173 lines are to be plotted. \n\
9175 minlong (PLFLT, input) : The value of the longitude on the left\n\
9176 side of the plot. The value of minlong must be less than the value\n\
9177 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9180 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9181 side of the plot. \n\
9183 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9184 background. One can always use -90.0 as the boundary outside the\n\
9185 plot window will be automatically eliminated. However, the\n\
9186 program will be faster if one can reduce the size of the\n\
9187 background plotted. \n\
9189 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9190 background. One can always use 90.0 as the boundary outside the\n\
9191 plot window will be automatically eliminated. \n\
9194 Convert RGB color to HLS \n\
9198 Convert RGB color coordinates to HLS \n\
9200 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9201 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
9204 This function is used in example 2. \n\
9210 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9214 r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
9216 g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
9218 b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
9220 p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
9221 cone (0.0-360.0) \n\
9223 p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
9224 fraction of the axis of the colour cone (0.0-1.0) \n\
9226 p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
9227 fraction of the radius of the colour cone (0.0-1.0) \n\
9230 Plot a glyph at the specified 3D points \n\
9234 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9235 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9236 this function similar to what is done for plline3. The glyph is\n\
9237 specified with a PLplot user string. Note that the user string is not\n\
9238 actually limited to one glyph so it is possible (but not normally\n\
9239 useful) to plot more than one glyph at the specified points with this\n\
9240 function. As with plmtex and plptex, the user string can contain FCI\n\
9241 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9242 else PLplot escapes for Hershey or unicode text to determine the\n\
9245 Redacted form: plstring3(x, y, z, string)\n\
9247 This function is used in example 18. \n\
9253 plstring3(n, x, y, z, string)\n\
9257 n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
9259 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9262 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9265 z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9268 string (const char *, input) : PLplot user string corresponding to\n\
9269 the glyph to be plotted at each of the n points. \n\
9272 Switch to text screen \n\
9276 Sets an interactive device to text mode, used in conjunction with\n\
9277 plgra to allow graphics and text to be interspersed. On a device\n\
9278 which supports separate text and graphics windows, this command causes\n\
9279 control to be switched to the text window.\tThis can be useful for\n\
9280 printing diagnostic messages or getting user input, which would\n\
9281 otherwise interfere with the plots. The program must switch back to\n\
9282 the graphics window before issuing plot commands, as the text (or\n\
9283 console) device will probably become quite confused otherwise. If\n\
9284 already in text mode, this command is ignored. It is also ignored on\n\
9285 devices which only support a single window or use a different method\n\
9286 for shifting focus (see also plgra). \n\
9288 Redacted form: pltext()\n\
9290 This function is used in example 1. \n\
9299 Get parameters that define current plot-space window \n\
9303 Get relative minima and maxima that define current plot-space window.\n\
9304 If plsdiplt has not been called the default values pointed to by\n\
9305 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
9307 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9309 This function is used in example 31. \n\
9315 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9319 p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
9321 p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
9323 p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
9325 p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
9328 Get the (current) run level \n\
9332 Get the (current) run level. Valid settings are: 0, uninitialized \n\
9333 \t 1,\tinitialized \n\
9334 \t 2,\tviewport defined \n\
9335 \t 3,\tworld coordinates defined \n\
9338 Redacted form: plglevel(p_level)\n\
9340 This function is used in example 31. \n\
9346 plglevel(p_level)\n\
9350 p_level (PLINT *, output) : Pointer to the run level. \n\
9353 Plot a histogram from binned data \n\
9357 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9358 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9359 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9360 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9361 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9362 placed midway between the values in the x array. Also see plhist for\n\
9363 drawing histograms from unbinned data. \n\
9365 Redacted form: General: plbin(x, y, opt)\n\
9366 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9367 \t Python: plbin(nbin, x, y, opt)\n\
9370 This function is not used in any examples. \n\
9376 plbin(nbin, x, y, opt)\n\
9380 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9383 x (const PLFLT *, input) : Pointer to array containing values\n\
9384 associated with bins. These must form a strictly increasing\n\
9387 y (const PLFLT *, input) : Pointer to array containing number of\n\
9388 points in bin. This is a PLFLT (instead of PLINT) array so as to\n\
9389 allow histograms of probabilities, etc. \n\
9391 opt (PLINT, input) : Is a combination of several flags:\n\
9392 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9393 outer bins are expanded to fill up the entire x-axis and bins of\n\
9394 zero height are simply drawn. \n\
9395 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9396 between the x values. If the values in x are equally spaced,\n\
9397 the values are the center values of the bins. \n\
9398 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9399 size as the ones inside. \n\
9400 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9401 (there is a gap for such bins). \n\
9404 Plot a 2D matrix using cmap1 \n\
9408 Plot a 2D matrix using cmap1. \n\
9410 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n\
9411 zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n\
9414 This function is used in example 20. \n\
9420 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9424 idata (const PLFLT * const *, input) : A 2D array of values\n\
9425 (intensities) to plot. Should have dimensions idata[nx][ny]. \n\
9427 nx, ny (PLINT, input) : Dimensions of idata \n\
9429 xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n\
9430 Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n\
9431 idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n\
9433 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9434 (inclusive) will be plotted. \n\
9436 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9437 values to use for value to color mappings. A datum equal to or\n\
9438 less than valuemin will be plotted with color 0.0, while a datum\n\
9439 equal to or greater than valuemax will be plotted with color 1.0. \n\
9440 Data between valuemin and valuemax map linearly to colors between\n\
9443 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
9444 Pointer to function that defines a transformation between the\n\
9445 data in the array idata and world coordinates. An input\n\
9446 coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n\
9447 while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n\
9448 Some transformation functions are provided in the PLplot library:\n\
9449 pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n\
9450 mappings respectively defined by one- and two-dimensional arrays. \n\
9451 In addition, user-supplied routines for the transformation can be\n\
9452 used as well. Examples of all of these approaches are given in\n\
9453 the PLplot documentation. The transformation function should have\n\
9454 the form given by any of pltr0, pltr1, or pltr2. \n\
9456 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9457 information to pltr0, pltr1, pltr2, or whatever routine is\n\
9458 externally supplied. \n\
9461 Get family, style and weight of the current font \n\
9465 Gets information about current font. See the PLplot documentation for\n\
9466 more information on font selection. \n\
9468 Redacted form: plgfont(p_family, p_style, p_weight)\n\
9470 This function is used in example 23. \n\
9476 plgfont(p_family, p_style, p_weight)\n\
9480 p_family (PLINT *, output) : Pointer to variable with the current\n\
9481 font family. The available values are given by the PL_FCI_*\n\
9482 constants in plplot.h. Current options are PL_FCI_SANS,\n\
9483 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9484 p_family is NULL then the font family is not returned. \n\
9486 p_style (PLINT *, output) : Pointer to variable with the current\n\
9487 font style. The available values are given by the PL_FCI_*\n\
9488 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9489 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
9490 font style is not returned. \n\
9492 p_weight (PLINT *, output) : Pointer to variable with the current\n\
9493 font weight. The available values are given by the PL_FCI_*\n\
9494 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9495 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9499 Get z axis parameters \n\
9503 Identical to plgxax, except that arguments are flags for z axis. See\n\
9504 the description of plgxax for more detail. \n\
9506 Redacted form: plgzax(p_digmax, p_digits)\n\
9508 This function is used in example 31. \n\
9514 plgzax(p_digmax, p_digits)\n\
9518 p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
9519 number of digits for the z axis. If nonzero, the printed label\n\
9520 has been switched to a floating point representation when the\n\
9521 number of digits exceeds p_digmax. \n\
9523 p_digits (PLINT *, output) : Pointer to variable with the actual\n\
9524 number of digits for the numeric labels (z axis) from the last\n\
9528 Write text inside the viewport of a 3D plot \n\
9532 Writes text at a specified position and inclination and with a\n\
9533 specified shear within the viewport. Text is clipped at the viewport\n\
9534 boundaries. The reference point of a string lies along a line passing\n\
9535 through the string at half the height of a capital letter.\tThe\n\
9536 position of the reference point along this line is determined by just,\n\
9537 and the reference point is placed at world coordinates (\n\
9540 wz) within the viewport. The inclination and shear of the string is\n\
9541 specified in terms of differences of world coordinates making it easy\n\
9542 to write text parallel to a line in a graph. \n\
9544 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n\
9546 This function is used in example 28. \n\
9552 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9556 wx (PLFLT, input) : x world coordinate of reference point of\n\
9559 wy (PLFLT, input) : y world coordinate of reference point of\n\
9562 wz (PLFLT, input) : z world coordinate of reference point of\n\
9565 dx (PLFLT, input) : Together with dy and \n\
9566 dz , this specifies the inclination of the string. The baseline of\n\
9567 the string is parallel to a line joining (\n\
9578 dy (PLFLT, input) : Together with dx and \n\
9579 dz, this specifies the inclination of the string. \n\
9581 dz (PLFLT, input) : Together with dx and \n\
9582 dy, this specifies the inclination of the string. \n\
9584 sx (PLFLT, input) : Together with sy and \n\
9585 sz , this specifies the shear of the string. The string is sheared so\n\
9586 that the characters are vertically parallel to a line joining (\n\
9597 sz = 0.) then the text is not sheared. \n\
9599 sy (PLFLT, input) : Together with sx and \n\
9600 sz, this specifies shear of the string. \n\
9602 sz (PLFLT, input) : Together with sx and \n\
9603 sy, this specifies shear of the string. \n\
9605 just (PLFLT, input) : Specifies the position of the string relative\n\
9606 to its reference point. If just=0. , the reference point is at\n\
9607 the left and if just=1. , it is at the right of the string. Other\n\
9608 values of just give intermediate justifications. \n\
9610 text (const char *, input) : The string to be written out. \n\
9613 Draw a box with axes, etc. with arbitrary origin \n\
9617 Draws a box around the currently defined viewport with arbitrary\n\
9618 world-coordinate origin specified by x0 and y0 and labels it with\n\
9619 world coordinate values appropriate to the window.\tThus plaxes should\n\
9620 only be called after defining both viewport and window. The character\n\
9621 strings xopt and yopt specify how the box should be drawn as described\n\
9622 below. If ticks and/or subticks are to be drawn for a particular\n\
9623 axis, the tick intervals and number of subintervals may be specified\n\
9624 explicitly, or they may be defaulted by setting the appropriate\n\
9625 arguments to zero. \n\
9627 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9629 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9633 This function is not used in any examples. \n\
9639 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9643 x0 (PLFLT, input) : World X coordinate of origin. \n\
9645 y0 (PLFLT, input) : World Y coordinate of origin. \n\
9647 xopt (const char *, input) : Pointer to character string specifying\n\
9648 options for horizontal axis. The string can include any\n\
9649 combination of the following letters (upper or lower case) in any\n\
9650 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
9651 is vertical line (x=0). \n\
9652 b: Draws bottom (X) or left (Y) edge of frame. \n\
9653 c: Draws top (X) or right (Y) edge of frame. \n\
9654 d: Plot labels as date / time. Values are assumed to be\n\
9655 seconds since the epoch (as used by gmtime). \n\
9656 f: Always use fixed point numeric labels. \n\
9657 g: Draws a grid at the major tick interval. \n\
9658 h: Draws a grid at the minor tick interval. \n\
9659 i: Inverts tick marks, so they are drawn outwards, rather than\n\
9661 l: Labels axis logarithmically. This only affects the labels,\n\
9662 not the data, and so it is necessary to compute the logarithms\n\
9663 of data points before passing them to any of the drawing\n\
9665 m: Writes numeric labels at major tick intervals in the\n\
9666 unconventional location (above box for X, right of box for Y). \n\
9667 n: Writes numeric labels at major tick intervals in the\n\
9668 conventional location (below box for X, left of box for Y). \n\
9669 o: Use custom labelling function to generate axis label text. \n\
9670 The custom labelling function can be defined with the\n\
9671 plslabelfunc command. \n\
9672 s: Enables subticks between major ticks, only valid if t is\n\
9674 t: Draws major ticks. \n\
9675 u: Exactly like \"b\" except don\'t draw edge line. \n\
9676 w: Exactly like \"c\" except don\'t draw edge line. \n\
9677 x: Exactly like \"t\" (including the side effect of the\n\
9678 numerical labels for the major ticks) except exclude drawing\n\
9679 the major and minor tick marks. \n\
9682 xtick (PLFLT, input) : World coordinate interval between major\n\
9683 ticks on the x axis. If it is set to zero, PLplot automatically\n\
9684 generates a suitable tick interval. \n\
9686 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9687 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9688 generates a suitable minor tick interval. \n\
9690 yopt (const char *, input) : Pointer to character string specifying\n\
9691 options for vertical axis. The string can include any combination\n\
9692 of the letters defined above for xopt, and in addition may\n\
9693 contain: v: Write numeric labels for vertical axis parallel to the\n\
9694 base of the graph, rather than parallel to the axis. \n\
9697 ytick (PLFLT, input) : World coordinate interval between major\n\
9698 ticks on the y axis. If it is set to zero, PLplot automatically\n\
9699 generates a suitable tick interval. \n\
9701 nysub (PLINT, input) : Number of subintervals between major y axis\n\
9702 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9703 generates a suitable minor tick interval. \n\
9706 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
9710 Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
9712 Redacted form: plgcolbg(r, g, b)\n\
9714 This function is used in example 31. \n\
9720 plgcolbg(r, g, b)\n\
9724 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9725 representing the degree of red in the color. \n\
9727 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9728 representing the degree of green in the color. \n\
9730 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9731 representing the degree of blue in the color. \n\
9734 Plot a glyph at the specified 3D points \n\
9738 Plot a glyph at the specified 3D points. (This function is largely\n\
9739 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9740 Set up the call to this function similar to what is done for plline3.\n\
9741 code=-1 means try to just draw a point. Right now it\'s just a move\n\
9742 and a draw at the same place. Not ideal, since a sufficiently\n\
9743 intelligent output device may optimize it away, or there may be faster\n\
9744 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9745 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9746 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9747 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9748 code <= 127 the corresponding printable ASCII character is plotted. \n\
9750 Redacted form: plpoin3(x, y, z, code)\n\
9752 This function is not used in any example. \n\
9758 plpoin3(n, x, y, z, code)\n\
9762 n (PLINT, input) : Number of points in the x and y arrays. \n\
9764 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9767 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9770 z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9773 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
9774 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
9775 each of the n points. \n\
9778 Draw a polygon in 3 space \n\
9782 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
9783 like plline3, but differs from that function in that plpoly3 attempts\n\
9784 to determine if the polygon is viewable depending on the order of the\n\
9785 points within the arrays and the value of ifcc. If the back of\n\
9786 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
9787 you want, then use plline3 instead. \n\
9789 The points are assumed to be in a plane, and the directionality of the\n\
9790 plane is determined from the first three points. Additional points do\n\
9791 not have to lie on the plane defined by the first three, but if they\n\
9792 do not, then the determination of visibility obviously can\'t be 100%\n\
9793 accurate... So if you\'re 3 space polygons are too far from planar,\n\
9794 consider breaking them into smaller polygons. 3 points define a plane\n\
9797 Bugs: If one of the first two segments is of zero length, or if they\n\
9798 are co-linear, the calculation of visibility has a 50/50 chance of\n\
9799 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
9800 of this problem. (Search for 20.1). \n\
9802 Redacted form: plpoly3(x, y, z, code)\n\
9804 This function is used in example 18. \n\
9810 plpoly3(n, x, y, z, draw, ifcc)\n\
9814 n (PLINT, input) : Number of points defining line. \n\
9816 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
9819 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9822 z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
9825 draw (const PLBOOL *, input) : Pointer to array which controls\n\
9826 drawing the segments of the polygon. If draw[i] is true, then the\n\
9827 polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n\
9829 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
9830 polygon is determined by assuming the points are laid out in a\n\
9831 counter-clockwise order. Otherwise, the directionality of the\n\
9832 polygon is determined by assuming the points are laid out in a\n\
9833 clockwise order. \n\
9836 Set the background color by 8-bit RGB value and double alpha transparency value. \n\
9840 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9841 (see the PLplot documentation) and double alpha transparency value. \n\
9843 This function is used in example 31. \n\
9849 plscolbga(r, g, b, alpha)\n\
9853 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9854 degree of red in the color. \n\
9856 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9857 degree of green in the color. \n\
9859 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9860 degree of blue in the color. \n\
9862 alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
9863 alpha transparency value of the color. \n\
9866 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n\
9870 Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
9871 alpha transparency value. \n\
9873 This function is used in example 31. \n\
9879 plgcolbga(r, g, b, alpha)\n\
9883 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9884 representing the degree of red in the color. \n\
9886 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9887 representing the degree of green in the color. \n\
9889 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9890 representing the degree of blue in the color. \n\
9892 alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
9896 Draw x error bar \n\
9900 Draws a set of n horizontal error bars, the i\'th error bar extending\n\
9901 from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
9902 error bar are of length equal to the minor tick length (settable using\n\
9905 Redacted form: General: plerrx(xmin, ymax, y)\n\
9906 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
9909 This function is used in example 29. \n\
9915 plerrx(n, xmin, xmax, y)\n\
9919 n (PLINT, input) : Number of error bars to draw. \n\
9921 xmin (const PLFLT *, input) : Pointer to array with x coordinates\n\
9922 of left-hand endpoint of error bars. \n\
9924 xmax (const PLFLT *, input) : Pointer to array with x coordinates\n\
9925 of right-hand endpoint of error bars. \n\
9927 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9931 Eject current page \n\
9935 Clears the graphics screen of an interactive device, or ejects a page\n\
9936 on a plotter. See plbop for more information. \n\
9938 Redacted form: pleop()\n\
9940 This function is used in example 2,14. \n\
9949 Convert HLS color to RGB \n\
9953 Convert HLS color coordinates to RGB. \n\
9955 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9956 \t Perl/PDL: Not available? Implemented as plhls? \n\
9959 This function is used in example 2. \n\
9965 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9969 h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
9971 l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
9972 of the colour cone (0.0-1.0) \n\
9974 s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
9975 radius of the colour cone (0.0-1.0) \n\
9977 p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
9980 p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
9983 p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
9987 Plot all or a subset of Shapefile data, filling the polygons \n\
9991 As per plmapline, however the items are filled in the same way as\n\
9994 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
9997 This function is used in example 19. \n\
10003 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10007 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
10008 supplied function to transform the coordinates given in the\n\
10009 shapefile into a plot coordinate system. By using this transform,\n\
10010 we can change from a longitude, latitude coordinate to a polar\n\
10011 stereographic project, for example. Initially, x[0]..[n-1] are\n\
10012 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
10013 After the call to mapform(), x[] and y[] should be replaced by the\n\
10014 corresponding plot coordinates. If no transform is desired,\n\
10015 mapform can be replaced by NULL. \n\
10017 name (const char *, input) : The file name of a set of Shapefile\n\
10018 files without the file extension. \n\
10020 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10021 be in the same units as used by the Shapefile. You could use a\n\
10022 very large negative number to plot everything, but you can improve\n\
10023 performance by limiting the area drawn. The units must match those\n\
10024 of the Shapefile projection, which may be for example longitude or\n\
10025 distance. The value of minx must be less than the value of maxx. \n\
10027 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10028 use a very large number to plot everything, but you can improve\n\
10029 performance by limiting the area drawn. \n\
10031 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10032 be in the same units as used by the Shapefile. You could use a\n\
10033 very large negative number to plot everything, but you can improve\n\
10034 performance by limiting the area drawn. The units must match those\n\
10035 of the Shapefile projection, which may be for example latitude or\n\
10036 distance. The value of miny must be less than the value of maxy. \n\
10038 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10039 use a very large number to plot everything, but you can improve\n\
10040 performance by limiting the area drawn. \n\
10042 plotentries (const PLINT *, input) : An array of integers\n\
10043 indicating the elements of the Shapefile (zero indexed) which will\n\
10044 be drawn. Setting plotentries to NULL will plot all elements of\n\
10047 nplotentries (PLINT, input) : The number of items in plotentries.\n\
10048 Ignored if plotentries is NULL. \n\
10051 Draw y error bar \n\
10055 Draws a set of n vertical error bars, the i\'th error bar extending\n\
10056 from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
10057 error bar are of length equal to the minor tick length (settable using\n\
10060 Redacted form: General: plerry(x, ymin, ymax)\n\
10061 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
10064 This function is used in example 29. \n\
10070 plerry(n, x, ymin, ymax)\n\
10074 n (PLINT, input) : Number of error bars to draw. \n\
10076 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
10079 ymin (const PLFLT *, input) : Pointer to array with y coordinates\n\
10080 of lower endpoint of error bars. \n\
10082 ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n\
10083 upper endpoint of error bar. \n\
10086 Set FCI (font characterization integer) \n\
10090 Sets font characteristics to be used at the start of the next string\n\
10091 using the FCI approach. See the PLplot documentation for more\n\
10094 Redacted form: General: plsfci(fci)\n\
10095 \t Perl/PDL: Not available? \n\
10098 This function is used in example 23. \n\
10108 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10112 Select area fill pattern \n\
10116 Select one of eight predefined area fill patterns to use (also see\n\
10117 plpat). Setting the fill style to 0 gives a solid fill. \n\
10119 Redacted form: plpsty(patt)\n\
10121 This function is used in examples 12,13,15,16,25. \n\
10131 patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
10132 horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
10133 consists of lines at 45 degrees angle (upward), and so on. \n\
10136 Set symbol size \n\
10140 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10141 plsym. The actual height of a symbol is the product of the default\n\
10142 symbol size and a scaling factor as for the character height. \n\
10144 Redacted form: plssym(def, scale)\n\
10146 This function is used in example 29. \n\
10152 plssym(def, scale)\n\
10156 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10157 should be set to zero if the default height is to remain\n\
10160 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10161 actual symbol height. \n\
10168 Alternative to plstar for initializing the plotting package. The\n\
10169 device name keyword for the desired output device must be supplied as\n\
10170 an argument. These keywords are the same as those printed out by\n\
10171 plstar. If the requested device is not available, or if the input\n\
10172 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10173 is used. This routine also divides the output device page into nx by\n\
10174 ny subpages, each of which may be used independently. The subroutine\n\
10175 pladv is used to advance from one subpage to the next. \n\
10177 Redacted form: General: plstart(devname, nx, ny)\n\
10178 \t Perl/PDL: plstart(nx, ny, devname)\n\
10181 This function is not used in any examples. \n\
10187 plstart(devname, nx, ny)\n\
10191 devname (const char *, input) : Device name keyword of the required\n\
10192 output device. If NULL or if the first character is a ``?\'\', the\n\
10193 normal (prompted) start up is used. \n\
10195 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10196 horizontal direction. \n\
10198 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10199 vertical direction. \n\
10204 PLINT *arg2 = (PLINT *) 0 ;
10205 char **arg3 = (
char **) 0 ;
10207 octave_value_list _out;
10208 octave_value_list *_outp=&_out;
10209 octave_value _outv;
10215 if (
_n_dims( args(0) ) > 1 )
10219 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
10220 arg2 =
new PLINT[
Alen];
10221 temp1 = args(0).matrix_value();
10225 charMatrix temp_matrix;
10229 size_t max_length = 0, non_blank_length;
10231 if (
_n_dims( args(1) ) > 2 )
10233 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10235 if ( !args(1).is_empty() )
10237 if (
_dim( args(1), 0 ) != Alen )
10239 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10241 arg3 =
new char*[
Alen];
10242 ifcell = args(1).is_cell();
10245 temp_cell = args(1).cell_value();
10249 temp_matrix = args(1).char_matrix_value();
10251 max_length =
_dim( args(1), 1 ) + 1;
10254 for ( i = 0; i <
Alen; i++ )
10261 if ( temp_cell.elem( i ).is_string() )
10263 str = temp_cell.elem( i ).string_value();
10265 max_length = str.size() + 1;
10266 tmp_cstring = (
char *) str.c_str();
10276 tmp_cstring = (
char *)
"";
10281 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
10283 arg3[i] =
new char[max_length];
10284 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10285 arg3[i][max_length - 1] =
'\0';
10300 non_blank_length = max_length - 2;
10301 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10303 non_blank_length--;
10305 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10307 non_blank_length--;
10309 arg3[i][non_blank_length + 1] =
'\0';
10318 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10319 _outv = octave_value();
10326 if ( arg3 != NULL )
10328 for ( i = 0; i <
Alen; i++ )
10341 int *arg1 = (
int *) 0 ;
10342 int *arg2 = (
int *) 0 ;
10343 int *arg3 = (
int *) 0 ;
10344 char *arg4 = (
char *) 0 ;
10345 int *arg5 = (
int *) 0 ;
10346 int *arg6 = (
int *) 0 ;
10347 PLFLT *arg7 = (PLFLT *) 0 ;
10348 PLFLT *arg8 = (PLFLT *) 0 ;
10349 PLFLT *arg9 = (PLFLT *) 0 ;
10350 PLFLT *arg10 = (PLFLT *) 0 ;
10351 int *arg11 = (
int *) 0 ;
10358 octave_value_list retval4 ;
10373 octave_value_list _out;
10374 octave_value_list *_outp=&_out;
10375 octave_value _outv;
10383 # if OCTAVE_API_VERSION_NUMBER < 45
10384 retval4( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
10386 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10388 arg4 = (
char *) retval4( 0 ).char_matrix_value().data();
10400 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10472 PLFLT *arg1 = (PLFLT *) 0 ;
10473 PLFLT *arg2 = (PLFLT *) 0 ;
10484 octave_value_list _out;
10485 octave_value_list *_outp=&_out;
10486 octave_value _outv;
10498 arg3 = (
PLFLT)(val3);
10503 arg4 = (
PLFLT)(val4);
10525 PLINT *arg1 = (PLINT *) 0 ;
10526 char *arg2 = (
char *) 0 ;
10527 char *arg3 = (
char *) 0 ;
10539 PLINT *arg15 = (PLINT *) 0 ;
10540 PLINT *arg16 = (PLINT *) 0 ;
10541 char *arg17 = (
char *) 0 ;
10542 char *arg18 = (
char *) 0 ;
10543 char *arg19 = (
char *) 0 ;
10544 char *arg20 = (
char *) 0 ;
10545 char *arg21 = (
char *) 0 ;
10546 char *arg22 = (
char *) 0 ;
10547 char *arg23 = (
char *) 0 ;
10601 octave_value_list _out;
10602 octave_value_list *_outp=&_out;
10603 octave_value _outv;
10613 arg2 = (
char *)(buf2);
10618 arg3 = (
char *)(buf3);
10623 arg4 = (
PLFLT)(val4);
10628 arg5 = (
PLFLT)(val5);
10633 arg6 = (
PLFLT)(val6);
10638 arg7 = (
PLFLT)(val7);
10643 arg8 = (
PLFLT)(val8);
10648 arg9 = (
PLFLT)(val9);
10653 arg10 = (
PLFLT)(val10);
10658 arg11 = (
PLBOOL)(val11);
10663 arg12 = (
PLBOOL)(val12);
10668 arg13 = (
PLINT)(val13);
10673 arg14 = (
PLINT)(val14);
10675 if (
_n_dims( args(13) ) > 1 )
10679 Alen = (
PLINT) (
_dim( args(13), 0 ) );
10680 temp15 = args(13).matrix_value();
10681 arg15 =
new PLINT[
Alen];
10685 if (
_n_dims( args(14) ) > 1 )
10689 if (
_dim( args(14), 0 ) != Alen )
10693 temp16 = args(14).matrix_value();
10694 arg16 =
new PLINT[
Alen];
10701 arg17 = (
char *)(buf17);
10706 arg18 = (
char *)(buf18);
10711 arg19 = (
char *)(buf19);
10716 arg20 = (
char *)(buf20);
10721 arg21 = (
char *)(buf21);
10726 arg22 = (
char *)(buf22);
10731 arg23 = (
char *)(buf23);
10732 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);
10733 _outv = octave_value();
10762 PLFLT *arg1 = (PLFLT *) 0 ;
10769 PLFLT *arg8 = (PLFLT *) 0 ;
10771 PLFLT *arg10 = (PLFLT *) 0 ;
10783 octave_value_list _out;
10784 octave_value_list *_outp=&_out;
10785 octave_value _outv;
10791 if (
_n_dims( args(0) ) > 2 )
10793 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10795 temp1 = args(0).matrix_value();
10796 arg1 = &temp1( 0, 0 );
10797 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10804 arg4 = (
PLINT)(val4);
10809 arg5 = (
PLINT)(val5);
10814 arg6 = (
PLINT)(val6);
10819 arg7 = (
PLINT)(val7);
10821 if (
_n_dims( args(5) ) > 1 )
10825 temp8 = args(5).matrix_value();
10826 arg8 = &temp8( 0, 0 );
10827 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10830 if (
_n_dims( args(6) ) > 1 )
10834 if (
_dim( args(6), 0 ) != 6 )
10838 temp10 = args(6).matrix_value();
10839 arg10 = &temp10( 0, 0 );
10841 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
10842 _outv = octave_value();
10859 PLFLT *arg1 = (PLFLT *) 0 ;
10866 PLFLT *arg8 = (PLFLT *) 0 ;
10878 octave_value_list _out;
10879 octave_value_list *_outp=&_out;
10880 octave_value _outv;
10886 if (
_n_dims( args(0) ) > 2 )
10888 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10890 temp1 = args(0).matrix_value();
10891 arg1 = &temp1( 0, 0 );
10892 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10899 arg4 = (
PLINT)(val4);
10904 arg5 = (
PLINT)(val5);
10909 arg6 = (
PLINT)(val6);
10914 arg7 = (
PLINT)(val7);
10916 if (
_n_dims( args(5) ) > 1 )
10920 temp8 = args(5).matrix_value();
10921 arg8 = &temp8( 0, 0 );
10922 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10924 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
10925 _outv = octave_value();
10939 PLFLT *arg1 = (PLFLT *) 0 ;
10946 PLFLT *arg8 = (PLFLT *) 0 ;
10948 PLFLT *arg10 = (PLFLT *) 0 ;
10949 PLFLT *arg11 = (PLFLT *) 0 ;
10962 octave_value_list _out;
10963 octave_value_list *_outp=&_out;
10964 octave_value _outv;
10970 if (
_n_dims( args(0) ) > 2 )
10972 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10974 temp1 = args(0).matrix_value();
10975 arg1 = &temp1( 0, 0 );
10976 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10983 arg4 = (
PLINT)(val4);
10988 arg5 = (
PLINT)(val5);
10993 arg6 = (
PLINT)(val6);
10998 arg7 = (
PLINT)(val7);
11000 if (
_n_dims( args(5) ) > 1 )
11004 temp8 = args(5).matrix_value();
11005 arg8 = &temp8( 0, 0 );
11006 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11009 if (
_n_dims( args(6) ) > 1 )
11013 if (
_dim( args(6), 0 ) != Xlen )
11017 temp10 = args(6).matrix_value();
11018 arg10 = &temp10( 0, 0 );
11021 if (
_n_dims( args(7) ) > 1 )
11029 temp11 = args(7).matrix_value();
11030 arg11 = &temp11( 0, 0 );
11032 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11033 _outv = octave_value();
11053 PLFLT *arg1 = (PLFLT *) 0 ;
11060 PLFLT *arg8 = (PLFLT *) 0 ;
11062 PLFLT *arg10 = (PLFLT *) 0 ;
11063 PLFLT *arg11 = (PLFLT *) 0 ;
11076 octave_value_list _out;
11077 octave_value_list *_outp=&_out;
11078 octave_value _outv;
11084 if (
_n_dims( args(0) ) > 2 )
11086 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11088 temp1 = args(0).matrix_value();
11089 arg1 = &temp1( 0, 0 );
11090 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11097 arg4 = (
PLINT)(val4);
11102 arg5 = (
PLINT)(val5);
11107 arg6 = (
PLINT)(val6);
11112 arg7 = (
PLINT)(val7);
11114 if (
_n_dims( args(5) ) > 1 )
11118 temp8 = args(5).matrix_value();
11119 arg8 = &temp8( 0, 0 );
11120 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11123 if (
_n_dims( args(6) ) > 2 )
11125 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11127 if (
_dim( args(6), 0 ) != Xlen )
11129 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11133 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11135 temp10 = args(6).matrix_value();
11136 arg10 = &temp10( 0, 0 );
11139 if (
_n_dims( args(7) ) > 2 )
11141 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11143 if (
_dim( args(7), 0 ) != Xlen )
11145 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11149 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11151 temp11 = args(7).matrix_value();
11152 arg11 = &temp11( 0, 0 );
11154 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11155 _outv = octave_value();
11175 PLFLT *arg1 = (PLFLT *) 0 ;
11182 PLFLT *arg8 = (PLFLT *) 0 ;
11184 PLFLT *arg10 = (PLFLT *) 0 ;
11185 PLFLT *arg11 = (PLFLT *) 0 ;
11198 octave_value_list _out;
11199 octave_value_list *_outp=&_out;
11200 octave_value _outv;
11206 if (
_n_dims( args(0) ) > 2 )
11208 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11210 temp1 = args(0).matrix_value();
11211 arg1 = &temp1( 0, 0 );
11212 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11219 arg4 = (
PLINT)(val4);
11224 arg5 = (
PLINT)(val5);
11229 arg6 = (
PLINT)(val6);
11234 arg7 = (
PLINT)(val7);
11236 if (
_n_dims( args(5) ) > 1 )
11240 temp8 = args(5).matrix_value();
11241 arg8 = &temp8( 0, 0 );
11242 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11245 if (
_n_dims( args(6) ) > 2 )
11247 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11249 if (
_dim( args(6), 0 ) != Xlen )
11251 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11255 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11257 temp10 = args(6).matrix_value();
11258 arg10 = &temp10( 0, 0 );
11261 if (
_n_dims( args(7) ) > 2 )
11263 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11265 if (
_dim( args(7), 0 ) != Xlen )
11267 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11271 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11273 temp11 = args(7).matrix_value();
11274 arg11 = &temp11( 0, 0 );
11276 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11277 _outv = octave_value();
11297 PLFLT *arg1 = (PLFLT *) 0 ;
11298 PLFLT *arg2 = (PLFLT *) 0 ;
11299 PLFLT *arg3 = (PLFLT *) 0 ;
11301 PLFLT *arg5 = (PLFLT *) 0 ;
11303 PLFLT *arg7 = (PLFLT *) 0 ;
11305 PLFLT *arg9 = (PLFLT *) 0 ;
11313 octave_value_list retval7 ;
11318 octave_value_list _out;
11319 octave_value_list *_outp=&_out;
11320 octave_value _outv;
11326 if (
_n_dims( args(0) ) > 1 )
11331 temp1 = args(0).matrix_value();
11332 arg1 = &temp1( 0, 0 );
11335 if (
_n_dims( args(1) ) > 1 )
11339 if (
_dim( args(1), 0 ) != Alen )
11343 temp2 = args(1).matrix_value();
11344 arg2 = &temp2( 0, 0 );
11347 if (
_n_dims( args(2) ) > 1 )
11351 if (
_dim( args(2), 0 ) != Alen )
11355 temp3 = args(2).matrix_value();
11356 arg3 = &temp3( 0, 0 );
11360 if (
_n_dims( args(3) ) > 1 )
11364 temp5 = args(3).matrix_value();
11365 arg5 = &temp5( 0, 0 );
11366 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
11369 if (
_n_dims( args(4) ) > 1 )
11373 temp7 = args(4).matrix_value();
11374 arg7 = &temp7( 0, 0 );
11376 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
11377 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11383 arg10 = (
PLINT)(val10);
11388 arg11 = (
PLFLT)(val11);
11389 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
11390 _outv = octave_value();
11416 PLFLT *arg1 = (PLFLT *) 0 ;
11417 PLFLT *arg2 = (PLFLT *) 0 ;
11418 PLFLT *arg3 = (PLFLT *) 0 ;
11427 octave_value_list _out;
11428 octave_value_list *_outp=&_out;
11429 octave_value _outv;
11435 if (
_n_dims( args(0) ) > 1 )
11439 temp1 = args(0).matrix_value();
11440 arg1 = &temp1( 0, 0 );
11444 if (
_n_dims( args(1) ) > 1 )
11448 temp2 = args(1).matrix_value();
11449 arg2 = &temp2( 0, 0 );
11453 if (
_n_dims( args(2) ) > 2 )
11455 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11457 if (
_dim( args(2), 0 ) != Xlen )
11459 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11463 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11465 temp3 = args(2).matrix_value();
11466 arg3 = &temp3( 0, 0 );
11474 arg6 = (
PLINT)(val6);
11475 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
11476 _outv = octave_value();
11493 PLFLT *arg1 = (PLFLT *) 0 ;
11494 PLFLT *arg2 = (PLFLT *) 0 ;
11495 PLFLT *arg3 = (PLFLT *) 0 ;
11499 PLFLT *arg7 = (PLFLT *) 0 ;
11507 octave_value_list _out;
11508 octave_value_list *_outp=&_out;
11509 octave_value _outv;
11515 if (
_n_dims( args(0) ) > 1 )
11519 temp1 = args(0).matrix_value();
11520 arg1 = &temp1( 0, 0 );
11524 if (
_n_dims( args(1) ) > 1 )
11528 temp2 = args(1).matrix_value();
11529 arg2 = &temp2( 0, 0 );
11533 if (
_n_dims( args(2) ) > 2 )
11535 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11537 if (
_dim( args(2), 0 ) != Xlen )
11539 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11543 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11545 temp3 = args(2).matrix_value();
11546 arg3 = &temp3( 0, 0 );
11554 arg6 = (
PLINT)(val6);
11556 if (
_n_dims( args(4) ) > 1 )
11560 temp7 = args(4).matrix_value();
11561 arg7 = &temp7( 0, 0 );
11562 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11564 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11565 _outv = octave_value();
11585 PLFLT *arg1 = (PLFLT *) 0 ;
11586 PLFLT *arg2 = (PLFLT *) 0 ;
11587 PLFLT *arg3 = (PLFLT *) 0 ;
11599 octave_value_list _out;
11600 octave_value_list *_outp=&_out;
11601 octave_value _outv;
11607 if (
_n_dims( args(0) ) > 1 )
11611 temp1 = args(0).matrix_value();
11612 arg1 = &temp1( 0, 0 );
11616 if (
_n_dims( args(1) ) > 1 )
11620 temp2 = args(1).matrix_value();
11621 arg2 = &temp2( 0, 0 );
11625 if (
_n_dims( args(2) ) > 2 )
11627 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11629 if (
_dim( args(2), 0 ) != Xlen )
11631 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11635 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11637 temp3 = args(2).matrix_value();
11638 arg3 = &temp3( 0, 0 );
11646 arg6 = (
PLINT)(val6);
11652 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
11653 _outv = octave_value();
11670 PLFLT *arg1 = (PLFLT *) 0 ;
11671 PLFLT *arg2 = (PLFLT *) 0 ;
11672 PLFLT *arg3 = (PLFLT *) 0 ;
11676 PLFLT *arg7 = (PLFLT *) 0 ;
11684 octave_value_list _out;
11685 octave_value_list *_outp=&_out;
11686 octave_value _outv;
11692 if (
_n_dims( args(0) ) > 1 )
11696 temp1 = args(0).matrix_value();
11697 arg1 = &temp1( 0, 0 );
11701 if (
_n_dims( args(1) ) > 1 )
11705 temp2 = args(1).matrix_value();
11706 arg2 = &temp2( 0, 0 );
11710 if (
_n_dims( args(2) ) > 2 )
11712 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11714 if (
_dim( args(2), 0 ) != Xlen )
11716 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11720 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11722 temp3 = args(2).matrix_value();
11723 arg3 = &temp3( 0, 0 );
11731 arg6 = (
PLINT)(val6);
11733 if (
_n_dims( args(4) ) > 1 )
11737 temp7 = args(4).matrix_value();
11738 arg7 = &temp7( 0, 0 );
11739 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11741 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11742 _outv = octave_value();
11762 PLFLT *arg1 = (PLFLT *) 0 ;
11763 PLFLT *arg2 = (PLFLT *) 0 ;
11764 PLFLT *arg3 = (PLFLT *) 0 ;
11768 PLFLT *arg7 = (PLFLT *) 0 ;
11772 PLINT *arg11 = (PLINT *) 0 ;
11773 PLINT *arg12 = (PLINT *) 0 ;
11784 octave_value_list _out;
11785 octave_value_list *_outp=&_out;
11786 octave_value _outv;
11792 if (
_n_dims( args(0) ) > 1 )
11796 temp1 = args(0).matrix_value();
11797 arg1 = &temp1( 0, 0 );
11801 if (
_n_dims( args(1) ) > 1 )
11805 temp2 = args(1).matrix_value();
11806 arg2 = &temp2( 0, 0 );
11810 if (
_n_dims( args(2) ) > 2 )
11812 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11814 if (
_dim( args(2), 0 ) != Xlen )
11816 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11820 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11822 temp3 = args(2).matrix_value();
11823 arg3 = &temp3( 0, 0 );
11831 arg6 = (
PLINT)(val6);
11833 if (
_n_dims( args(4) ) > 1 )
11837 temp7 = args(4).matrix_value();
11838 arg7 = &temp7( 0, 0 );
11839 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11845 arg9 = (
PLINT)(val9);
11847 if (
_n_dims( args(6) ) > 1 )
11851 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
11852 arg11 =
new PLINT[
Alen];
11853 temp10 = args(6).matrix_value();
11857 if (
_n_dims( args(7) ) > 1 )
11861 if (
_dim( args(7), 0 ) != Alen )
11865 temp12 = args(7).matrix_value();
11866 arg12 =
new PLINT[
Alen];
11869 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);
11870 _outv = octave_value();
11896 PLFLT *arg1 = (PLFLT *) 0 ;
11897 PLFLT *arg2 = (PLFLT *) 0 ;
11898 PLFLT *arg3 = (PLFLT *) 0 ;
11902 PLFLT *arg7 = (PLFLT *) 0 ;
11910 octave_value_list _out;
11911 octave_value_list *_outp=&_out;
11912 octave_value _outv;
11918 if (
_n_dims( args(0) ) > 1 )
11922 temp1 = args(0).matrix_value();
11923 arg1 = &temp1( 0, 0 );
11927 if (
_n_dims( args(1) ) > 1 )
11931 temp2 = args(1).matrix_value();
11932 arg2 = &temp2( 0, 0 );
11936 if (
_n_dims( args(2) ) > 2 )
11938 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11940 if (
_dim( args(2), 0 ) != Xlen )
11942 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11946 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11948 temp3 = args(2).matrix_value();
11949 arg3 = &temp3( 0, 0 );
11957 arg6 = (
PLINT)(val6);
11959 if (
_n_dims( args(4) ) > 1 )
11963 temp7 = args(4).matrix_value();
11964 arg7 = &temp7( 0, 0 );
11965 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11967 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11968 _outv = octave_value();
11988 PLFLT *arg1 = (PLFLT *) 0 ;
11989 PLFLT *arg2 = (PLFLT *) 0 ;
11990 PLFLT *arg3 = (PLFLT *) 0 ;
11994 PLFLT *arg7 = (PLFLT *) 0 ;
11998 PLINT *arg11 = (PLINT *) 0 ;
11999 PLINT *arg12 = (PLINT *) 0 ;
12010 octave_value_list _out;
12011 octave_value_list *_outp=&_out;
12012 octave_value _outv;
12018 if (
_n_dims( args(0) ) > 1 )
12022 temp1 = args(0).matrix_value();
12023 arg1 = &temp1( 0, 0 );
12027 if (
_n_dims( args(1) ) > 1 )
12031 temp2 = args(1).matrix_value();
12032 arg2 = &temp2( 0, 0 );
12036 if (
_n_dims( args(2) ) > 2 )
12038 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12040 if (
_dim( args(2), 0 ) != Xlen )
12042 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12046 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12048 temp3 = args(2).matrix_value();
12049 arg3 = &temp3( 0, 0 );
12057 arg6 = (
PLINT)(val6);
12059 if (
_n_dims( args(4) ) > 1 )
12063 temp7 = args(4).matrix_value();
12064 arg7 = &temp7( 0, 0 );
12065 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12071 arg9 = (
PLINT)(val9);
12073 if (
_n_dims( args(6) ) > 1 )
12077 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12078 arg11 =
new PLINT[
Alen];
12079 temp10 = args(6).matrix_value();
12083 if (
_n_dims( args(7) ) > 1 )
12087 if (
_dim( args(7), 0 ) != Alen )
12091 temp12 = args(7).matrix_value();
12092 arg12 =
new PLINT[
Alen];
12095 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);
12096 _outv = octave_value();
12122 PLFLT *arg1 = (PLFLT *) 0 ;
12125 PLFLT *arg4 = (PLFLT *) 0 ;
12140 PLFLT *arg19 = (PLFLT *) 0 ;
12172 octave_value_list _out;
12173 octave_value_list *_outp=&_out;
12174 octave_value _outv;
12180 if (
_n_dims( args(0) ) > 2 )
12182 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12184 temp1 = args(0).matrix_value();
12185 arg1 = &temp1( 0, 0 );
12186 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12190 if (
_n_dims( args(1) ) > 1 )
12195 temp4 = args(1).matrix_value();
12196 arg4 = &temp4( 0, 0 );
12202 arg5 = (
PLFLT)(val5);
12207 arg6 = (
PLFLT)(val6);
12212 arg7 = (
PLFLT)(val7);
12217 arg8 = (
PLFLT)(val8);
12222 arg9 = (
PLFLT)(val9);
12227 arg10 = (
PLFLT)(val10);
12232 arg11 = (
PLINT)(val11);
12237 arg12 = (
PLFLT)(val12);
12242 arg13 = (
PLINT)(val13);
12247 arg14 = (
PLINT)(val14);
12252 arg15 = (
PLINT)(val15);
12257 arg16 = (
PLINT)(val16);
12262 arg17 = (
PLINT)(val17);
12267 arg18 = (
PLBOOL)(val18);
12269 if (
_n_dims( args(16) ) > 1 )
12273 if (
_dim( args(16), 0 ) != 6 )
12277 temp19 = args(16).matrix_value();
12278 arg19 = &temp19( 0, 0 );
12280 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);
12281 _outv = octave_value();
12298 PLFLT *arg1 = (PLFLT *) 0 ;
12301 char *arg4 = (
char *) 0 ;
12316 PLFLT *arg19 = (PLFLT *) 0 ;
12317 PLFLT *arg20 = (PLFLT *) 0 ;
12352 octave_value_list _out;
12353 octave_value_list *_outp=&_out;
12354 octave_value _outv;
12360 if (
_n_dims( args(0) ) > 2 )
12362 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12364 temp1 = args(0).matrix_value();
12365 arg1 = &temp1( 0, 0 );
12366 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12373 arg4 = (
char *)(buf4);
12378 arg5 = (
PLFLT)(val5);
12383 arg6 = (
PLFLT)(val6);
12388 arg7 = (
PLFLT)(val7);
12393 arg8 = (
PLFLT)(val8);
12398 arg9 = (
PLFLT)(val9);
12403 arg10 = (
PLFLT)(val10);
12408 arg11 = (
PLINT)(val11);
12413 arg12 = (
PLFLT)(val12);
12418 arg13 = (
PLINT)(val13);
12423 arg14 = (
PLINT)(val14);
12428 arg15 = (
PLINT)(val15);
12433 arg16 = (
PLINT)(val16);
12438 arg17 = (
PLINT)(val17);
12443 arg18 = (
PLBOOL)(val18);
12445 if (
_n_dims( args(16) ) > 1 )
12449 if (
_dim( args(16), 0 ) != Xlen )
12453 temp19 = args(16).matrix_value();
12454 arg19 = &temp19( 0, 0 );
12457 if (
_n_dims( args(17) ) > 1 )
12461 if (
_dim( args(17), 0 ) !=
Ylen )
12465 temp20 = args(17).matrix_value();
12466 arg20 = &temp20( 0, 0 );
12468 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);
12469 _outv = octave_value();
12487 PLFLT *arg1 = (PLFLT *) 0 ;
12490 char *arg4 = (
char *) 0 ;
12505 PLFLT *arg19 = (PLFLT *) 0 ;
12506 PLFLT *arg20 = (PLFLT *) 0 ;
12541 octave_value_list _out;
12542 octave_value_list *_outp=&_out;
12543 octave_value _outv;
12549 if (
_n_dims( args(0) ) > 2 )
12551 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12553 temp1 = args(0).matrix_value();
12554 arg1 = &temp1( 0, 0 );
12555 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12562 arg4 = (
char *)(buf4);
12567 arg5 = (
PLFLT)(val5);
12572 arg6 = (
PLFLT)(val6);
12577 arg7 = (
PLFLT)(val7);
12582 arg8 = (
PLFLT)(val8);
12587 arg9 = (
PLFLT)(val9);
12592 arg10 = (
PLFLT)(val10);
12597 arg11 = (
PLINT)(val11);
12602 arg12 = (
PLFLT)(val12);
12607 arg13 = (
PLINT)(val13);
12612 arg14 = (
PLINT)(val14);
12617 arg15 = (
PLINT)(val15);
12622 arg16 = (
PLINT)(val16);
12627 arg17 = (
PLINT)(val17);
12632 arg18 = (
PLBOOL)(val18);
12634 if (
_n_dims( args(16) ) > 2 )
12636 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12638 temp19 = args(16).matrix_value();
12639 arg19 = &temp19( 0, 0 );
12640 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
12644 if (
_n_dims( args(17) ) > 2 )
12646 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12648 temp20 = args(17).matrix_value();
12649 arg20 = &temp20( 0, 0 );
12650 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
12653 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);
12654 _outv = octave_value();
12672 PLFLT *arg1 = (PLFLT *) 0 ;
12679 PLFLT *arg8 = (PLFLT *) 0 ;
12703 octave_value_list _out;
12704 octave_value_list *_outp=&_out;
12705 octave_value _outv;
12711 if (
_n_dims( args(0) ) > 2 )
12713 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12715 temp1 = args(0).matrix_value();
12716 arg1 = &temp1( 0, 0 );
12717 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12724 arg4 = (
PLFLT)(val4);
12729 arg5 = (
PLFLT)(val5);
12734 arg6 = (
PLFLT)(val6);
12739 arg7 = (
PLFLT)(val7);
12741 if (
_n_dims( args(5) ) > 1 )
12745 temp8 = args(5).matrix_value();
12746 arg8 = &temp8( 0, 0 );
12747 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12753 arg10 = (
PLINT)(val10);
12758 arg11 = (
PLINT)(val11);
12763 arg12 = (
PLINT)(val12);
12768 arg13 = (
PLBOOL)(val13);
12769 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
12770 _outv = octave_value();
12784 PLFLT *arg1 = (PLFLT *) 0 ;
12791 PLFLT *arg8 = (PLFLT *) 0 ;
12797 PLFLT *arg14 = (PLFLT *) 0 ;
12817 octave_value_list _out;
12818 octave_value_list *_outp=&_out;
12819 octave_value _outv;
12825 if (
_n_dims( args(0) ) > 2 )
12827 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12829 temp1 = args(0).matrix_value();
12830 arg1 = &temp1( 0, 0 );
12831 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12838 arg4 = (
PLFLT)(val4);
12843 arg5 = (
PLFLT)(val5);
12848 arg6 = (
PLFLT)(val6);
12853 arg7 = (
PLFLT)(val7);
12855 if (
_n_dims( args(5) ) > 1 )
12859 temp8 = args(5).matrix_value();
12860 arg8 = &temp8( 0, 0 );
12861 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12867 arg10 = (
PLINT)(val10);
12872 arg11 = (
PLINT)(val11);
12877 arg12 = (
PLINT)(val12);
12882 arg13 = (
PLBOOL)(val13);
12884 if (
_n_dims( args(10) ) > 1 )
12888 if (
_dim( args(10), 0 ) != 6 )
12892 temp14 = args(10).matrix_value();
12893 arg14 = &temp14( 0, 0 );
12895 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12896 _outv = octave_value();
12913 PLFLT *arg1 = (PLFLT *) 0 ;
12920 PLFLT *arg8 = (PLFLT *) 0 ;
12926 PLFLT *arg14 = (PLFLT *) 0 ;
12927 PLFLT *arg15 = (PLFLT *) 0 ;
12948 octave_value_list _out;
12949 octave_value_list *_outp=&_out;
12950 octave_value _outv;
12956 if (
_n_dims( args(0) ) > 2 )
12958 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12960 temp1 = args(0).matrix_value();
12961 arg1 = &temp1( 0, 0 );
12962 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12969 arg4 = (
PLFLT)(val4);
12974 arg5 = (
PLFLT)(val5);
12979 arg6 = (
PLFLT)(val6);
12984 arg7 = (
PLFLT)(val7);
12986 if (
_n_dims( args(5) ) > 1 )
12990 temp8 = args(5).matrix_value();
12991 arg8 = &temp8( 0, 0 );
12992 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12998 arg10 = (
PLINT)(val10);
13003 arg11 = (
PLINT)(val11);
13008 arg12 = (
PLINT)(val12);
13013 arg13 = (
PLBOOL)(val13);
13015 if (
_n_dims( args(10) ) > 1 )
13019 if (
_dim( args(10), 0 ) != Xlen )
13023 temp14 = args(10).matrix_value();
13024 arg14 = &temp14( 0, 0 );
13027 if (
_n_dims( args(11) ) > 1 )
13031 if (
_dim( args(11), 0 ) !=
Ylen )
13035 temp15 = args(11).matrix_value();
13036 arg15 = &temp15( 0, 0 );
13038 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);
13039 _outv = octave_value();
13059 PLFLT *arg1 = (PLFLT *) 0 ;
13066 PLFLT *arg8 = (PLFLT *) 0 ;
13072 PLFLT *arg14 = (PLFLT *) 0 ;
13073 PLFLT *arg15 = (PLFLT *) 0 ;
13094 octave_value_list _out;
13095 octave_value_list *_outp=&_out;
13096 octave_value _outv;
13102 if (
_n_dims( args(0) ) > 2 )
13104 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13106 temp1 = args(0).matrix_value();
13107 arg1 = &temp1( 0, 0 );
13108 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13115 arg4 = (
PLFLT)(val4);
13120 arg5 = (
PLFLT)(val5);
13125 arg6 = (
PLFLT)(val6);
13130 arg7 = (
PLFLT)(val7);
13132 if (
_n_dims( args(5) ) > 1 )
13136 temp8 = args(5).matrix_value();
13137 arg8 = &temp8( 0, 0 );
13138 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13144 arg10 = (
PLINT)(val10);
13149 arg11 = (
PLINT)(val11);
13154 arg12 = (
PLINT)(val12);
13159 arg13 = (
PLBOOL)(val13);
13161 if (
_n_dims( args(10) ) > 2 )
13163 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13165 temp14 = args(10).matrix_value();
13166 arg14 = &temp14( 0, 0 );
13167 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
13171 if (
_n_dims( args(11) ) > 2 )
13173 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13175 temp15 = args(11).matrix_value();
13176 arg15 = &temp15( 0, 0 );
13177 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
13180 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);
13181 _outv = octave_value();
13201 PLFLT *arg1 = (PLFLT *) 0 ;
13202 PLFLT *arg2 = (PLFLT *) 0 ;
13206 PLFLT *arg6 = (PLFLT *) 0 ;
13212 octave_value_list _out;
13213 octave_value_list *_outp=&_out;
13214 octave_value _outv;
13220 if (
_n_dims( args(0) ) > 2 )
13222 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13224 temp1 = args(0).matrix_value();
13225 arg1 = &temp1( 0, 0 );
13230 if (
_n_dims( args(1) ) > 2 )
13232 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13234 if (
_dim( args(1), 0 ) != Xlen )
13236 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13240 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13242 temp2 = args(1).matrix_value();
13243 arg2 = &temp2( 0, 0 );
13251 arg5 = (
PLFLT)(val5);
13253 if (
_n_dims( args(3) ) > 1 )
13257 if (
_dim( args(3), 0 ) != 6 )
13261 temp6 = args(3).matrix_value();
13262 arg6 = &temp6( 0, 0 );
13264 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
13265 _outv = octave_value();
13282 PLFLT *arg1 = (PLFLT *) 0 ;
13283 PLFLT *arg2 = (PLFLT *) 0 ;
13287 PLFLT *arg6 = (PLFLT *) 0 ;
13288 PLFLT *arg7 = (PLFLT *) 0 ;
13295 octave_value_list _out;
13296 octave_value_list *_outp=&_out;
13297 octave_value _outv;
13303 if (
_n_dims( args(0) ) > 2 )
13305 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13307 temp1 = args(0).matrix_value();
13308 arg1 = &temp1( 0, 0 );
13313 if (
_n_dims( args(1) ) > 2 )
13315 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13317 if (
_dim( args(1), 0 ) != Xlen )
13319 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13323 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13325 temp2 = args(1).matrix_value();
13326 arg2 = &temp2( 0, 0 );
13334 arg5 = (
PLFLT)(val5);
13336 if (
_n_dims( args(3) ) > 1 )
13340 if (
_dim( args(3), 0 ) != Xlen )
13344 temp6 = args(3).matrix_value();
13345 arg6 = &temp6( 0, 0 );
13348 if (
_n_dims( args(4) ) > 1 )
13356 temp7 = args(4).matrix_value();
13357 arg7 = &temp7( 0, 0 );
13359 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
13360 _outv = octave_value();
13380 PLFLT *arg1 = (PLFLT *) 0 ;
13381 PLFLT *arg2 = (PLFLT *) 0 ;
13385 PLFLT *arg6 = (PLFLT *) 0 ;
13386 PLFLT *arg7 = (PLFLT *) 0 ;
13393 octave_value_list _out;
13394 octave_value_list *_outp=&_out;
13395 octave_value _outv;
13401 if (
_n_dims( args(0) ) > 2 )
13403 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13405 temp1 = args(0).matrix_value();
13406 arg1 = &temp1( 0, 0 );
13411 if (
_n_dims( args(1) ) > 2 )
13413 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13415 if (
_dim( args(1), 0 ) != Xlen )
13417 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13421 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13423 temp2 = args(1).matrix_value();
13424 arg2 = &temp2( 0, 0 );
13432 arg5 = (
PLFLT)(val5);
13434 if (
_n_dims( args(3) ) > 2 )
13436 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13438 temp6 = args(3).matrix_value();
13439 arg6 = &temp6( 0, 0 );
13444 if (
_n_dims( args(4) ) > 2 )
13446 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13448 temp7 = args(4).matrix_value();
13449 arg7 = &temp7( 0, 0 );
13453 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
13454 _outv = octave_value();
13474 PLFLT *arg1 = (PLFLT *) 0 ;
13508 octave_value_list _out;
13509 octave_value_list *_outp=&_out;
13510 octave_value _outv;
13516 if (
_n_dims( args(0) ) > 2 )
13518 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13520 temp1 = args(0).matrix_value();
13521 arg1 = &temp1( 0, 0 );
13522 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13529 arg4 = (
PLFLT)(val4);
13534 arg5 = (
PLFLT)(val5);
13539 arg6 = (
PLFLT)(val6);
13544 arg7 = (
PLFLT)(val7);
13549 arg8 = (
PLFLT)(val8);
13554 arg9 = (
PLFLT)(val9);
13559 arg10 = (
PLFLT)(val10);
13564 arg11 = (
PLFLT)(val11);
13569 arg12 = (
PLFLT)(val12);
13574 arg13 = (
PLFLT)(val13);
13575 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13576 _outv = octave_value();
13587 PLFLT *arg1 = (PLFLT *) 0 ;
13615 octave_value_list _out;
13616 octave_value_list *_outp=&_out;
13617 octave_value _outv;
13623 if (
_n_dims( args(0) ) > 2 )
13625 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13627 temp1 = args(0).matrix_value();
13628 arg1 = &temp1( 0, 0 );
13629 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13636 arg4 = (
PLFLT)(val4);
13641 arg5 = (
PLFLT)(val5);
13646 arg6 = (
PLFLT)(val6);
13651 arg7 = (
PLFLT)(val7);
13656 arg8 = (
PLFLT)(val8);
13661 arg9 = (
PLFLT)(val9);
13666 arg10 = (
PLFLT)(val10);
13671 arg11 = (
PLFLT)(val11);
13672 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13673 _outv = octave_value();
13684 PLFLT *arg1 = (PLFLT *) 0 ;
13695 PLFLT *arg12 = (PLFLT *) 0 ;
13714 octave_value_list _out;
13715 octave_value_list *_outp=&_out;
13716 octave_value _outv;
13722 if (
_n_dims( args(0) ) > 2 )
13724 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13726 temp1 = args(0).matrix_value();
13727 arg1 = &temp1( 0, 0 );
13728 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13735 arg4 = (
PLFLT)(val4);
13740 arg5 = (
PLFLT)(val5);
13745 arg6 = (
PLFLT)(val6);
13750 arg7 = (
PLFLT)(val7);
13755 arg8 = (
PLFLT)(val8);
13760 arg9 = (
PLFLT)(val9);
13765 arg10 = (
PLFLT)(val10);
13770 arg11 = (
PLFLT)(val11);
13772 if (
_n_dims( args(9) ) > 1 )
13776 if (
_dim( args(9), 0 ) != 6 )
13780 temp12 = args(9).matrix_value();
13781 arg12 = &temp12( 0, 0 );
13783 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13784 _outv = octave_value();
13798 PLFLT *arg1 = (PLFLT *) 0 ;
13809 PLFLT *arg12 = (PLFLT *) 0 ;
13810 PLFLT *arg13 = (PLFLT *) 0 ;
13830 octave_value_list _out;
13831 octave_value_list *_outp=&_out;
13832 octave_value _outv;
13838 if (
_n_dims( args(0) ) > 2 )
13840 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13842 temp1 = args(0).matrix_value();
13843 arg1 = &temp1( 0, 0 );
13844 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13851 arg4 = (
PLFLT)(val4);
13856 arg5 = (
PLFLT)(val5);
13861 arg6 = (
PLFLT)(val6);
13866 arg7 = (
PLFLT)(val7);
13871 arg8 = (
PLFLT)(val8);
13876 arg9 = (
PLFLT)(val9);
13881 arg10 = (
PLFLT)(val10);
13886 arg11 = (
PLFLT)(val11);
13888 if (
_n_dims( args(9) ) > 1 )
13892 if (
_dim( args(9), 0 ) != Xlen )
13896 temp12 = args(9).matrix_value();
13897 arg12 = &temp12( 0, 0 );
13900 if (
_n_dims( args(10) ) > 1 )
13904 if (
_dim( args(10), 0 ) !=
Ylen )
13908 temp13 = args(10).matrix_value();
13909 arg13 = &temp13( 0, 0 );
13911 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
13912 _outv = octave_value();
13929 PLFLT *arg1 = (PLFLT *) 0 ;
13940 PLFLT *arg12 = (PLFLT *) 0 ;
13941 PLFLT *arg13 = (PLFLT *) 0 ;
13961 octave_value_list _out;
13962 octave_value_list *_outp=&_out;
13963 octave_value _outv;
13969 if (
_n_dims( args(0) ) > 2 )
13971 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13973 temp1 = args(0).matrix_value();
13974 arg1 = &temp1( 0, 0 );
13975 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13982 arg4 = (
PLFLT)(val4);
13987 arg5 = (
PLFLT)(val5);
13992 arg6 = (
PLFLT)(val6);
13997 arg7 = (
PLFLT)(val7);
14002 arg8 = (
PLFLT)(val8);
14007 arg9 = (
PLFLT)(val9);
14012 arg10 = (
PLFLT)(val10);
14017 arg11 = (
PLFLT)(val11);
14019 if (
_n_dims( args(9) ) > 2 )
14021 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14023 temp12 = args(9).matrix_value();
14024 arg12 = &temp12( 0, 0 );
14029 if (
_n_dims( args(10) ) > 2 )
14031 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14033 temp13 = args(10).matrix_value();
14034 arg13 = &temp13( 0, 0 );
14035 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
14038 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14039 _outv = octave_value();
14056 PLFLT *arg1 = (PLFLT *) 0 ;
14057 PLFLT *arg2 = (PLFLT *) 0 ;
14072 PLINT *arg17 = (PLINT *) 0 ;
14073 char **arg18 = (
char **) 0 ;
14075 char **arg20 = (
char **) 0 ;
14076 PLFLT *arg21 = (PLFLT *) 0 ;
14077 PLINT *arg22 = (PLINT *) 0 ;
14078 PLINT *arg23 = (PLINT *) 0 ;
14079 PLFLT *arg24 = (PLFLT *) 0 ;
14115 octave_value_list _out;
14116 octave_value_list *_outp=&_out;
14117 octave_value _outv;
14128 arg3 = (
PLINT)(val3);
14133 arg4 = (
PLINT)(val4);
14138 arg5 = (
PLFLT)(val5);
14143 arg6 = (
PLFLT)(val6);
14148 arg7 = (
PLFLT)(val7);
14153 arg8 = (
PLFLT)(val8);
14158 arg9 = (
PLINT)(val9);
14163 arg10 = (
PLINT)(val10);
14168 arg11 = (
PLINT)(val11);
14173 arg12 = (
PLFLT)(val12);
14178 arg13 = (
PLFLT)(val13);
14183 arg14 = (
PLINT)(val14);
14188 arg15 = (
PLFLT)(val15);
14190 if (
_n_dims( args(13) ) > 1 )
14194 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
14195 arg17 =
new PLINT[
Alen];
14196 temp16 = args(13).matrix_value();
14200 charMatrix temp_matrix;
14204 size_t max_length = 0, non_blank_length;
14206 if (
_n_dims( args(14) ) > 2 )
14208 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14210 if ( !args(14).is_empty() )
14212 if (
_dim( args(14), 0 ) != Alen )
14214 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
14216 arg18 =
new char*[
Alen];
14217 ifcell = args(14).is_cell();
14220 temp_cell = args(14).cell_value();
14224 temp_matrix = args(14).char_matrix_value();
14226 max_length =
_dim( args(14), 1 ) + 1;
14229 for ( i = 0; i <
Alen; i++ )
14236 if ( temp_cell.elem( i ).is_string() )
14238 str = temp_cell.elem( i ).string_value();
14240 max_length = str.size() + 1;
14241 tmp_cstring = (
char *) str.c_str();
14251 tmp_cstring = (
char *)
"";
14256 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14258 arg18[i] =
new char[max_length];
14259 strncpy( arg18[i], tmp_cstring, max_length - 1 );
14260 arg18[i][max_length - 1] =
'\0';
14275 non_blank_length = max_length - 2;
14276 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
14278 non_blank_length--;
14280 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
14282 non_blank_length--;
14284 arg18[i][non_blank_length + 1] =
'\0';
14294 charMatrix temp_matrix;
14298 size_t max_length = 0, non_blank_length;
14300 if (
_n_dims( args(15) ) > 2 )
14302 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14304 if ( !args(15).is_empty() )
14306 Alen =
_dim( args(15), 0 );
14308 arg20 =
new char*[
Alen];
14309 ifcell = args(15).is_cell();
14312 temp_cell = args(15).cell_value();
14316 temp_matrix = args(15).char_matrix_value();
14318 max_length =
_dim( args(15), 1 ) + 1;
14321 for ( i = 0; i <
Alen; i++ )
14328 if ( temp_cell.elem( i ).is_string() )
14330 str = temp_cell.elem( i ).string_value();
14332 max_length = str.size() + 1;
14333 tmp_cstring = (
char *) str.c_str();
14343 tmp_cstring = (
char *)
"";
14348 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14350 arg20[i] =
new char[max_length];
14351 strncpy( arg20[i], tmp_cstring, max_length - 1 );
14352 arg20[i][max_length - 1] =
'\0';
14367 non_blank_length = max_length - 2;
14368 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
14370 non_blank_length--;
14372 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
14374 non_blank_length--;
14376 arg20[i][non_blank_length + 1] =
'\0';
14387 if (
_n_dims( args(16) ) > 1 )
14391 if (
_dim( args(16), 0 ) != Alen )
14395 temp21 = args(16).matrix_value();
14396 arg21 = &temp21( 0, 0 );
14399 if (
_n_dims( args(17) ) > 1 )
14403 if (
_dim( args(17), 0 ) != Alen )
14407 temp22 = args(17).matrix_value();
14408 arg22 =
new PLINT[
Alen];
14413 if (
_n_dims( args(18) ) > 1 )
14417 if (
_dim( args(18), 0 ) != Alen )
14422 temp23 = args(18).matrix_value();
14423 arg23 =
new PLINT[
Alen];
14426 for ( i = 0; i <
Xlen; i++ )
14427 if ( arg23[i] >
Ylen )
14431 if (
_n_dims( args(19) ) > 2 )
14433 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14435 if (
_dim( args(19), 0 ) != Xlen )
14437 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14439 if (
_dim( args(19), 1 ) !=
Ylen )
14441 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14443 temp24 = args(19).matrix_value();
14444 arg24 = &temp24( 0, 0 );
14446 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);
14447 _outv = octave_value();
14466 if ( arg18 != NULL )
14468 for ( i = 0; i <
Alen; i++ )
14477 if ( arg20 != NULL )
14479 for ( i = 0; i <
Alen; i++ )
14510 octave_value_list _out;
14511 octave_value_list *_outp=&_out;
14512 octave_value _outv;
14526 arg2 = (int)(val2);
14527 if (arg1) (arg1)->type = arg2;
14528 _outv = octave_value();
14539 octave_value_list _out;
14540 octave_value_list *_outp=&_out;
14541 octave_value _outv;
14552 result = (int) ((arg1)->type);
14562 unsigned int arg2 ;
14565 unsigned int val2 ;
14567 octave_value_list _out;
14568 octave_value_list *_outp=&_out;
14569 octave_value _outv;
14583 arg2 = (
unsigned int)(val2);
14584 if (arg1) (arg1)->state = arg2;
14585 _outv = octave_value();
14596 octave_value_list _out;
14597 octave_value_list *_outp=&_out;
14598 octave_value _outv;
14599 unsigned int result;
14609 result = (
unsigned int) ((arg1)->state);
14619 unsigned int arg2 ;
14622 unsigned int val2 ;
14624 octave_value_list _out;
14625 octave_value_list *_outp=&_out;
14626 octave_value _outv;
14640 arg2 = (
unsigned int)(val2);
14641 if (arg1) (arg1)->keysym = arg2;
14642 _outv = octave_value();
14653 octave_value_list _out;
14654 octave_value_list *_outp=&_out;
14655 octave_value _outv;
14656 unsigned int result;
14666 result = (
unsigned int) ((arg1)->keysym);
14676 unsigned int arg2 ;
14679 unsigned int val2 ;
14681 octave_value_list _out;
14682 octave_value_list *_outp=&_out;
14683 octave_value _outv;
14697 arg2 = (
unsigned int)(val2);
14698 if (arg1) (arg1)->button = arg2;
14699 _outv = octave_value();
14710 octave_value_list _out;
14711 octave_value_list *_outp=&_out;
14712 octave_value _outv;
14713 unsigned int result;
14723 result = (
unsigned int) ((arg1)->button);
14738 octave_value_list _out;
14739 octave_value_list *_outp=&_out;
14740 octave_value _outv;
14754 arg2 = (
PLINT)(val2);
14755 if (arg1) (arg1)->subwindow = arg2;
14756 _outv = octave_value();
14767 octave_value_list _out;
14768 octave_value_list *_outp=&_out;
14769 octave_value _outv;
14780 result = (
PLINT) ((arg1)->subwindow);
14795 octave_value_list _out;
14796 octave_value_list *_outp=&_out;
14797 octave_value _outv;
14811 arg2 = (
char *)(temp2);
14812 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
14813 else memset(arg1->
string,0,16*
sizeof(
char));
14814 _outv = octave_value();
14825 octave_value_list _out;
14826 octave_value_list *_outp=&_out;
14827 octave_value _outv;
14838 result = (
char *)(
char *) ((arg1)->
string);
14842 while (size && (result[size - 1] ==
'\0')) --size;
14859 octave_value_list _out;
14860 octave_value_list *_outp=&_out;
14861 octave_value _outv;
14875 arg2 = (int)(val2);
14876 if (arg1) (arg1)->pX = arg2;
14877 _outv = octave_value();
14888 octave_value_list _out;
14889 octave_value_list *_outp=&_out;
14890 octave_value _outv;
14901 result = (int) ((arg1)->pX);
14916 octave_value_list _out;
14917 octave_value_list *_outp=&_out;
14918 octave_value _outv;
14932 arg2 = (int)(val2);
14933 if (arg1) (arg1)->pY = arg2;
14934 _outv = octave_value();
14945 octave_value_list _out;
14946 octave_value_list *_outp=&_out;
14947 octave_value _outv;
14958 result = (int) ((arg1)->pY);
14973 octave_value_list _out;
14974 octave_value_list *_outp=&_out;
14975 octave_value _outv;
14989 arg2 = (
PLFLT)(val2);
14990 if (arg1) (arg1)->dX = arg2;
14991 _outv = octave_value();
15002 octave_value_list _out;
15003 octave_value_list *_outp=&_out;
15004 octave_value _outv;
15015 result = (
PLFLT) ((arg1)->dX);
15030 octave_value_list _out;
15031 octave_value_list *_outp=&_out;
15032 octave_value _outv;
15046 arg2 = (
PLFLT)(val2);
15047 if (arg1) (arg1)->dY = arg2;
15048 _outv = octave_value();
15059 octave_value_list _out;
15060 octave_value_list *_outp=&_out;
15061 octave_value _outv;
15072 result = (
PLFLT) ((arg1)->dY);
15087 octave_value_list _out;
15088 octave_value_list *_outp=&_out;
15089 octave_value _outv;
15103 arg2 = (
PLFLT)(val2);
15104 if (arg1) (arg1)->wX = arg2;
15105 _outv = octave_value();
15116 octave_value_list _out;
15117 octave_value_list *_outp=&_out;
15118 octave_value _outv;
15129 result = (
PLFLT) ((arg1)->wX);
15144 octave_value_list _out;
15145 octave_value_list *_outp=&_out;
15146 octave_value _outv;
15160 arg2 = (
PLFLT)(val2);
15161 if (arg1) (arg1)->wY = arg2;
15162 _outv = octave_value();
15173 octave_value_list _out;
15174 octave_value_list *_outp=&_out;
15175 octave_value _outv;
15186 result = (
PLFLT) ((arg1)->wY);
15195 octave_value_list _out;
15196 octave_value_list *_outp=&_out;
15197 octave_value _outv;
15215 octave_value_list _out;
15216 octave_value_list *_outp=&_out;
15217 octave_value _outv;
15228 _outv = octave_value();
15261 octave_value_list _out;
15262 octave_value_list *_outp=&_out;
15263 octave_value _outv;
15272 arg1 = (
PLINT)(val1);
15277 arg2 = (
PLINT)(val2);
15279 _outv = octave_value();
15299 octave_value_list _out;
15300 octave_value_list *_outp=&_out;
15301 octave_value _outv;
15310 arg1 = (
PLFLT)(val1);
15315 arg2 = (
PLFLT)(val2);
15320 arg3 = (
PLFLT)(val3);
15325 arg4 = (
PLINT)(val4);
15327 _outv = octave_value();
15338 octave_value_list _out;
15339 octave_value_list *_outp=&_out;
15340 octave_value _outv;
15349 arg1 = (
PLINT)(val1);
15351 _outv = octave_value();
15383 octave_value_list _out;
15384 octave_value_list *_outp=&_out;
15385 octave_value _outv;
15394 arg1 = (
PLFLT)(val1);
15399 arg2 = (
PLFLT)(val2);
15404 arg3 = (
PLFLT)(val3);
15409 arg4 = (
PLFLT)(val4);
15414 arg5 = (
PLFLT)(val5);
15419 arg6 = (
PLFLT)(val6);
15424 arg7 = (
PLFLT)(val7);
15430 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15431 _outv = octave_value();
15441 char *arg3 = (
char *) 0 ;
15444 char *arg6 = (
char *) 0 ;
15465 octave_value_list _out;
15466 octave_value_list *_outp=&_out;
15467 octave_value _outv;
15476 arg1 = (
PLFLT)(val1);
15481 arg2 = (
PLFLT)(val2);
15486 arg3 = (
char *)(buf3);
15491 arg4 = (
PLFLT)(val4);
15496 arg5 = (
PLINT)(val5);
15501 arg6 = (
char *)(buf6);
15506 arg7 = (
PLFLT)(val7);
15511 arg8 = (
PLINT)(val8);
15512 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
15513 _outv = octave_value();
15524 PLFLT *arg2 = (PLFLT *) 0 ;
15525 PLFLT *arg3 = (PLFLT *) 0 ;
15531 octave_value_list _out;
15532 octave_value_list *_outp=&_out;
15533 octave_value _outv;
15539 if (
_n_dims( args(0) ) > 1 )
15543 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
15544 temp1 = args(0).matrix_value();
15545 arg2 = &temp1( 0, 0 );
15548 if (
_n_dims( args(1) ) > 1 )
15552 if (
_dim( args(1), 0 ) != Alen )
15556 temp3 = args(1).matrix_value();
15557 arg3 = &temp3( 0, 0 );
15563 arg4 = (
PLINT)(val4);
15564 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
15565 _outv = octave_value();
15579 PLINT *arg1 = (PLINT *) 0 ;
15580 PLINT *arg2 = (PLINT *) 0 ;
15581 PLINT *arg3 = (PLINT *) 0 ;
15582 PLINT *arg4 = (PLINT *) 0 ;
15583 PLINT *arg5 = (PLINT *) 0 ;
15584 PLFLT *arg6 = (PLFLT *) 0 ;
15600 octave_value_list _out;
15601 octave_value_list *_outp=&_out;
15602 octave_value _outv;
15617 arg7 = (
PLFLT)(val7);
15618 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
15619 _outv = octave_value();
15663 octave_value_list _out;
15664 octave_value_list *_outp=&_out;
15665 octave_value _outv;
15671 _outv = octave_value();
15679 char *arg1 = (
char *) 0 ;
15682 char *arg4 = (
char *) 0 ;
15699 octave_value_list _out;
15700 octave_value_list *_outp=&_out;
15701 octave_value _outv;
15710 arg1 = (
char *)(buf1);
15715 arg2 = (
PLFLT)(val2);
15720 arg3 = (
PLINT)(val3);
15725 arg4 = (
char *)(buf4);
15730 arg5 = (
PLFLT)(val5);
15735 arg6 = (
PLINT)(val6);
15736 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
15737 _outv = octave_value();
15747 char *arg1 = (
char *) 0 ;
15748 char *arg2 = (
char *) 0 ;
15751 char *arg5 = (
char *) 0 ;
15752 char *arg6 = (
char *) 0 ;
15755 char *arg9 = (
char *) 0 ;
15756 char *arg10 = (
char *) 0 ;
15789 octave_value_list _out;
15790 octave_value_list *_outp=&_out;
15791 octave_value _outv;
15800 arg1 = (
char *)(buf1);
15805 arg2 = (
char *)(buf2);
15810 arg3 = (
PLFLT)(val3);
15815 arg4 = (
PLINT)(val4);
15820 arg5 = (
char *)(buf5);
15825 arg6 = (
char *)(buf6);
15830 arg7 = (
PLFLT)(val7);
15835 arg8 = (
PLINT)(val8);
15840 arg9 = (
char *)(buf9);
15845 arg10 = (
char *)(buf10);
15850 arg11 = (
PLFLT)(val11);
15855 arg12 = (
PLINT)(val12);
15856 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);
15857 _outv = octave_value();
15873 PLFLT *arg3 = (PLFLT *) 0 ;
15874 PLFLT *arg4 = (PLFLT *) 0 ;
15875 PLINT *arg5 = (PLINT *) 0 ;
15886 octave_value_list _out;
15887 octave_value_list *_outp=&_out;
15888 octave_value _outv;
15900 arg1 = (
PLFLT)(val1);
15905 arg2 = (
PLFLT)(val2);
15907 _outv = octave_value();
15933 octave_value_list _out;
15934 octave_value_list *_outp=&_out;
15935 octave_value _outv;
15941 _outv = octave_value();
15952 octave_value_list _out;
15953 octave_value_list *_outp=&_out;
15954 octave_value _outv;
15963 arg1 = (
PLINT)(val1);
15965 _outv = octave_value();
15976 octave_value_list _out;
15977 octave_value_list *_outp=&_out;
15978 octave_value _outv;
15987 arg1 = (
PLFLT)(val1);
15989 _outv = octave_value();
16030 octave_value_list _out;
16031 octave_value_list *_outp=&_out;
16032 octave_value _outv;
16041 arg1 = (
PLFLT)(val1);
16046 arg2 = (
PLFLT)(val2);
16051 arg3 = (
PLFLT)(val3);
16056 arg4 = (
PLINT)(val4);
16066 arg6 = (
PLINT)(val6);
16071 arg7 = (
PLINT)(val7);
16076 arg8 = (
PLINT)(val8);
16081 arg9 = (
PLINT)(val9);
16086 arg10 = (
PLINT)(val10);
16091 arg11 = (
PLFLT)(val11);
16092 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16093 _outv = octave_value();
16107 PLFLT *arg7 = (PLFLT *) 0 ;
16122 octave_value_list _out;
16123 octave_value_list *_outp=&_out;
16124 octave_value _outv;
16134 arg1 = (
PLINT)(val1);
16139 arg2 = (
PLINT)(val2);
16144 arg3 = (
PLINT)(val3);
16149 arg4 = (
PLINT)(val4);
16154 arg5 = (
PLINT)(val5);
16159 arg6 = (
PLFLT)(val6);
16160 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16161 _outv = octave_value();
16181 octave_value_list _out;
16182 octave_value_list *_outp=&_out;
16183 octave_value _outv;
16192 arg1 = (
PLINT)(val1);
16199 _outv = octave_value();
16207 octave_value_list _out;
16208 octave_value_list *_outp=&_out;
16209 octave_value _outv;
16215 _outv = octave_value();
16223 octave_value_list _out;
16224 octave_value_list *_outp=&_out;
16225 octave_value _outv;
16231 _outv = octave_value();
16257 octave_value_list _out;
16258 octave_value_list *_outp=&_out;
16259 octave_value _outv;
16268 arg1 = (
PLFLT)(val1);
16273 arg2 = (
PLFLT)(val2);
16278 arg3 = (
PLFLT)(val3);
16283 arg4 = (
PLFLT)(val4);
16288 arg5 = (
PLINT)(val5);
16293 arg6 = (
PLINT)(val6);
16294 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16295 _outv = octave_value();
16321 octave_value_list _out;
16322 octave_value_list *_outp=&_out;
16323 octave_value _outv;
16332 arg1 = (
PLFLT)(val1);
16337 arg2 = (
PLFLT)(val2);
16342 arg3 = (
PLFLT)(val3);
16347 arg4 = (
PLFLT)(val4);
16352 arg5 = (
PLINT)(val5);
16357 arg6 = (
PLINT)(val6);
16358 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
16359 _outv = octave_value();
16367 octave_value_list _out;
16368 octave_value_list *_outp=&_out;
16369 octave_value _outv;
16375 _outv = octave_value();
16384 PLFLT *arg2 = (PLFLT *) 0 ;
16385 PLFLT *arg3 = (PLFLT *) 0 ;
16386 PLFLT *arg4 = (PLFLT *) 0 ;
16390 octave_value_list _out;
16391 octave_value_list *_outp=&_out;
16392 octave_value _outv;
16398 if (
_n_dims( args(0) ) > 1 )
16402 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16403 temp1 = args(0).matrix_value();
16404 arg2 = &temp1( 0, 0 );
16407 if (
_n_dims( args(1) ) > 1 )
16411 if (
_dim( args(1), 0 ) != Alen )
16415 temp3 = args(1).matrix_value();
16416 arg3 = &temp3( 0, 0 );
16419 if (
_n_dims( args(2) ) > 1 )
16423 if (
_dim( args(2), 0 ) != Alen )
16427 temp4 = args(2).matrix_value();
16428 arg4 = &temp4( 0, 0 );
16430 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16431 _outv = octave_value();
16449 PLFLT *arg2 = (PLFLT *) 0 ;
16450 PLFLT *arg3 = (PLFLT *) 0 ;
16451 PLFLT *arg4 = (PLFLT *) 0 ;
16455 octave_value_list _out;
16456 octave_value_list *_outp=&_out;
16457 octave_value _outv;
16463 if (
_n_dims( args(0) ) > 1 )
16467 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16468 temp1 = args(0).matrix_value();
16469 arg2 = &temp1( 0, 0 );
16472 if (
_n_dims( args(1) ) > 1 )
16476 if (
_dim( args(1), 0 ) != Alen )
16480 temp3 = args(1).matrix_value();
16481 arg3 = &temp3( 0, 0 );
16484 if (
_n_dims( args(2) ) > 1 )
16488 if (
_dim( args(2), 0 ) != Alen )
16492 temp4 = args(2).matrix_value();
16493 arg4 = &temp4( 0, 0 );
16495 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16496 _outv = octave_value();
16513 octave_value_list _out;
16514 octave_value_list *_outp=&_out;
16515 octave_value _outv;
16521 _outv = octave_value();
16530 PLFLT *arg2 = (PLFLT *) 0 ;
16531 PLFLT *arg3 = (PLFLT *) 0 ;
16534 octave_value_list _out;
16535 octave_value_list *_outp=&_out;
16536 octave_value _outv;
16542 if (
_n_dims( args(0) ) > 1 )
16546 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16547 temp1 = args(0).matrix_value();
16548 arg2 = &temp1( 0, 0 );
16551 if (
_n_dims( args(1) ) > 1 )
16555 if (
_dim( args(1), 0 ) != Alen )
16559 temp3 = args(1).matrix_value();
16560 arg3 = &temp3( 0, 0 );
16562 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
16563 _outv = octave_value();
16578 PLFLT *arg2 = (PLFLT *) 0 ;
16579 PLFLT *arg3 = (PLFLT *) 0 ;
16580 PLFLT *arg4 = (PLFLT *) 0 ;
16584 octave_value_list _out;
16585 octave_value_list *_outp=&_out;
16586 octave_value _outv;
16592 if (
_n_dims( args(0) ) > 1 )
16596 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16597 temp1 = args(0).matrix_value();
16598 arg2 = &temp1( 0, 0 );
16601 if (
_n_dims( args(1) ) > 1 )
16605 if (
_dim( args(1), 0 ) != Alen )
16609 temp3 = args(1).matrix_value();
16610 arg3 = &temp3( 0, 0 );
16613 if (
_n_dims( args(2) ) > 1 )
16617 if (
_dim( args(2), 0 ) != Alen )
16621 temp4 = args(2).matrix_value();
16622 arg4 = &temp4( 0, 0 );
16624 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16625 _outv = octave_value();
16643 PLFLT *arg2 = (PLFLT *) 0 ;
16644 PLFLT *arg3 = (PLFLT *) 0 ;
16650 octave_value_list _out;
16651 octave_value_list *_outp=&_out;
16652 octave_value _outv;
16658 if (
_n_dims( args(0) ) > 1 )
16662 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16663 temp1 = args(0).matrix_value();
16664 arg2 = &temp1( 0, 0 );
16667 if (
_n_dims( args(1) ) > 1 )
16671 if (
_dim( args(1), 0 ) != Alen )
16675 temp3 = args(1).matrix_value();
16676 arg3 = &temp3( 0, 0 );
16682 arg4 = (
PLFLT)(val4);
16683 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16684 _outv = octave_value();
16698 octave_value_list _out;
16699 octave_value_list *_outp=&_out;
16700 octave_value _outv;
16706 _outv = octave_value();
16717 octave_value_list _out;
16718 octave_value_list *_outp=&_out;
16719 octave_value _outv;
16728 arg1 = (
PLINT)(val1);
16730 _outv = octave_value();
16741 octave_value_list _out;
16742 octave_value_list *_outp=&_out;
16743 octave_value _outv;
16752 arg1 = (
PLINT)(val1);
16754 _outv = octave_value();
16762 PLFLT *arg1 = (PLFLT *) 0 ;
16763 PLFLT *arg2 = (PLFLT *) 0 ;
16768 octave_value_list _out;
16769 octave_value_list *_outp=&_out;
16770 octave_value _outv;
16778 _outv = octave_value();
16799 PLINT *arg2 = (PLINT *) 0 ;
16800 PLINT *arg3 = (PLINT *) 0 ;
16801 PLINT *arg4 = (PLINT *) 0 ;
16810 octave_value_list _out;
16811 octave_value_list *_outp=&_out;
16812 octave_value _outv;
16824 arg1 = (
PLINT)(val1);
16825 plgcol0(arg1,arg2,arg3,arg4);
16826 _outv = octave_value();
16853 PLINT *arg2 = (PLINT *) 0 ;
16854 PLINT *arg3 = (PLINT *) 0 ;
16855 PLINT *arg4 = (PLINT *) 0 ;
16856 PLFLT *arg5 = (PLFLT *) 0 ;
16867 octave_value_list _out;
16868 octave_value_list *_outp=&_out;
16869 octave_value _outv;
16882 arg1 = (
PLINT)(val1);
16883 plgcol0a(arg1,arg2,arg3,arg4,arg5);
16884 _outv = octave_value();
16916 PLINT *arg1 = (PLINT *) 0 ;
16917 PLINT *arg2 = (PLINT *) 0 ;
16918 PLINT *arg3 = (PLINT *) 0 ;
16925 octave_value_list _out;
16926 octave_value_list *_outp=&_out;
16927 octave_value _outv;
16936 _outv = octave_value();
16962 PLINT *arg1 = (PLINT *) 0 ;
16963 PLINT *arg2 = (PLINT *) 0 ;
16964 PLINT *arg3 = (PLINT *) 0 ;
16965 PLFLT *arg4 = (PLFLT *) 0 ;
16974 octave_value_list _out;
16975 octave_value_list *_outp=&_out;
16976 octave_value _outv;
16986 _outv = octave_value();
17018 PLINT *arg1 = (PLINT *) 0 ;
17021 octave_value_list _out;
17022 octave_value_list *_outp=&_out;
17023 octave_value _outv;
17030 _outv = octave_value();
17044 char *arg1 = (
char *) 0 ;
17045 octave_value_list retval1 ;
17046 octave_value_list _out;
17047 octave_value_list *_outp=&_out;
17048 octave_value _outv;
17052 # if OCTAVE_API_VERSION_NUMBER < 45
17053 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17055 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17057 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17063 _outv = octave_value();
17074 PLFLT *arg1 = (PLFLT *) 0 ;
17075 PLFLT *arg2 = (PLFLT *) 0 ;
17076 PLFLT *arg3 = (PLFLT *) 0 ;
17077 PLFLT *arg4 = (PLFLT *) 0 ;
17086 octave_value_list _out;
17087 octave_value_list *_outp=&_out;
17088 octave_value _outv;
17098 _outv = octave_value();
17130 PLFLT *arg1 = (PLFLT *) 0 ;
17133 octave_value_list _out;
17134 octave_value_list *_outp=&_out;
17135 octave_value _outv;
17142 _outv = octave_value();
17156 PLFLT *arg1 = (PLFLT *) 0 ;
17157 PLFLT *arg2 = (PLFLT *) 0 ;
17158 PLFLT *arg3 = (PLFLT *) 0 ;
17159 PLFLT *arg4 = (PLFLT *) 0 ;
17168 octave_value_list _out;
17169 octave_value_list *_outp=&_out;
17170 octave_value _outv;
17180 _outv = octave_value();
17212 PLINT *arg1 = (PLINT *) 0 ;
17213 PLINT *arg2 = (PLINT *) 0 ;
17214 PLINT *arg3 = (PLINT *) 0 ;
17221 octave_value_list _out;
17222 octave_value_list *_outp=&_out;
17223 octave_value _outv;
17232 _outv = octave_value();
17261 octave_value_list _out;
17262 octave_value_list *_outp=&_out;
17263 octave_value _outv;
17270 _outv = octave_value();
17284 char *arg1 = (
char *) 0 ;
17285 octave_value_list retval1 ;
17286 octave_value_list _out;
17287 octave_value_list *_outp=&_out;
17288 octave_value _outv;
17292 # if OCTAVE_API_VERSION_NUMBER < 45
17293 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17295 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17297 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17303 _outv = octave_value();
17314 PLINT *arg1 = (PLINT *) 0 ;
17315 PLINT *arg2 = (PLINT *) 0 ;
17316 PLINT *arg3 = (PLINT *) 0 ;
17323 octave_value_list _out;
17324 octave_value_list *_outp=&_out;
17325 octave_value _outv;
17334 _outv = octave_value();
17360 PLINT *arg1 = (PLINT *) 0 ;
17363 octave_value_list _out;
17364 octave_value_list *_outp=&_out;
17365 octave_value _outv;
17372 _outv = octave_value();
17386 PLFLT *arg1 = (PLFLT *) 0 ;
17387 PLFLT *arg2 = (PLFLT *) 0 ;
17388 PLINT *arg3 = (PLINT *) 0 ;
17389 PLINT *arg4 = (PLINT *) 0 ;
17390 PLINT *arg5 = (PLINT *) 0 ;
17391 PLINT *arg6 = (PLINT *) 0 ;
17404 octave_value_list _out;
17405 octave_value_list *_outp=&_out;
17406 octave_value _outv;
17417 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
17418 _outv = octave_value();
17462 octave_value_list _out;
17463 octave_value_list *_outp=&_out;
17464 octave_value _outv;
17470 _outv = octave_value();
17478 PLFLT *arg1 = (PLFLT *) 0 ;
17479 PLFLT *arg2 = (PLFLT *) 0 ;
17480 PLFLT *arg3 = (PLFLT *) 0 ;
17481 PLFLT *arg4 = (PLFLT *) 0 ;
17490 octave_value_list _out;
17491 octave_value_list *_outp=&_out;
17492 octave_value _outv;
17501 plgspa(arg1,arg2,arg3,arg4);
17502 _outv = octave_value();
17534 PLINT *arg1 = (PLINT *) 0 ;
17537 octave_value_list _out;
17538 octave_value_list *_outp=&_out;
17539 octave_value _outv;
17546 _outv = octave_value();
17560 char *arg1 = (
char *) 0 ;
17561 octave_value_list retval1 ;
17562 octave_value_list _out;
17563 octave_value_list *_outp=&_out;
17564 octave_value _outv;
17568 # if OCTAVE_API_VERSION_NUMBER < 45
17569 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17571 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17573 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17579 _outv = octave_value();
17590 PLFLT *arg1 = (PLFLT *) 0 ;
17591 PLFLT *arg2 = (PLFLT *) 0 ;
17592 PLFLT *arg3 = (PLFLT *) 0 ;
17593 PLFLT *arg4 = (PLFLT *) 0 ;
17602 octave_value_list _out;
17603 octave_value_list *_outp=&_out;
17604 octave_value _outv;
17613 plgvpd(arg1,arg2,arg3,arg4);
17614 _outv = octave_value();
17646 PLFLT *arg1 = (PLFLT *) 0 ;
17647 PLFLT *arg2 = (PLFLT *) 0 ;
17648 PLFLT *arg3 = (PLFLT *) 0 ;
17649 PLFLT *arg4 = (PLFLT *) 0 ;
17658 octave_value_list _out;
17659 octave_value_list *_outp=&_out;
17660 octave_value _outv;
17669 plgvpw(arg1,arg2,arg3,arg4);
17670 _outv = octave_value();
17702 PLINT *arg1 = (PLINT *) 0 ;
17703 PLINT *arg2 = (PLINT *) 0 ;
17708 octave_value_list _out;
17709 octave_value_list *_outp=&_out;
17710 octave_value _outv;
17718 _outv = octave_value();
17738 PLINT *arg1 = (PLINT *) 0 ;
17739 PLINT *arg2 = (PLINT *) 0 ;
17744 octave_value_list _out;
17745 octave_value_list *_outp=&_out;
17746 octave_value _outv;
17754 _outv = octave_value();
17774 PLINT *arg1 = (PLINT *) 0 ;
17775 PLINT *arg2 = (PLINT *) 0 ;
17780 octave_value_list _out;
17781 octave_value_list *_outp=&_out;
17782 octave_value _outv;
17790 _outv = octave_value();
17811 PLFLT *arg2 = (PLFLT *) 0 ;
17825 octave_value_list _out;
17826 octave_value_list *_outp=&_out;
17827 octave_value _outv;
17833 if (
_n_dims( args(0) ) > 1 )
17837 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17838 temp1 = args(0).matrix_value();
17839 arg2 = &temp1( 0, 0 );
17845 arg3 = (
PLFLT)(val3);
17850 arg4 = (
PLFLT)(val4);
17855 arg5 = (
PLINT)(val5);
17860 arg6 = (
PLINT)(val6);
17861 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
17862 _outv = octave_value();
17876 PLFLT *arg4 = (PLFLT *) 0 ;
17877 PLFLT *arg5 = (PLFLT *) 0 ;
17878 PLFLT *arg6 = (PLFLT *) 0 ;
17891 octave_value_list _out;
17892 octave_value_list *_outp=&_out;
17893 octave_value _outv;
17905 arg1 = (
PLFLT)(val1);
17910 arg2 = (
PLFLT)(val2);
17915 arg3 = (
PLFLT)(val3);
17916 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
17917 _outv = octave_value();
17943 octave_value_list _out;
17944 octave_value_list *_outp=&_out;
17945 octave_value _outv;
17951 _outv = octave_value();
17971 octave_value_list _out;
17972 octave_value_list *_outp=&_out;
17973 octave_value _outv;
17982 arg1 = (
PLFLT)(val1);
17987 arg2 = (
PLFLT)(val2);
17992 arg3 = (
PLFLT)(val3);
17997 arg4 = (
PLFLT)(val4);
17998 pljoin(arg1,arg2,arg3,arg4);
17999 _outv = octave_value();
18007 char *arg1 = (
char *) 0 ;
18008 char *arg2 = (
char *) 0 ;
18009 char *arg3 = (
char *) 0 ;
18019 octave_value_list _out;
18020 octave_value_list *_outp=&_out;
18021 octave_value _outv;
18030 arg1 = (
char *)(buf1);
18035 arg2 = (
char *)(buf2);
18040 arg3 = (
char *)(buf3);
18041 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
18042 _outv = octave_value();
18053 PLFLT *arg1 = (PLFLT *) 0 ;
18054 PLFLT *arg2 = (PLFLT *) 0 ;
18066 PLINT *arg14 = (PLINT *) 0 ;
18071 PLINT *arg19 = (PLINT *) 0 ;
18072 char **arg20 = (
char **) 0 ;
18073 PLINT *arg21 = (PLINT *) 0 ;
18074 PLINT *arg22 = (PLINT *) 0 ;
18075 PLFLT *arg23 = (PLFLT *) 0 ;
18076 PLFLT *arg24 = (PLFLT *) 0 ;
18077 PLINT *arg25 = (PLINT *) 0 ;
18078 PLINT *arg26 = (PLINT *) 0 ;
18079 PLFLT *arg27 = (PLFLT *) 0 ;
18080 PLINT *arg28 = (PLINT *) 0 ;
18081 PLFLT *arg29 = (PLFLT *) 0 ;
18082 PLINT *arg30 = (PLINT *) 0 ;
18083 char **arg31 = (
char **) 0 ;
18128 octave_value_list _out;
18129 octave_value_list *_outp=&_out;
18130 octave_value _outv;
18141 arg3 = (
PLINT)(val3);
18146 arg4 = (
PLINT)(val4);
18151 arg5 = (
PLFLT)(val5);
18156 arg6 = (
PLFLT)(val6);
18161 arg7 = (
PLFLT)(val7);
18166 arg8 = (
PLINT)(val8);
18171 arg9 = (
PLINT)(val9);
18176 arg10 = (
PLINT)(val10);
18181 arg11 = (
PLINT)(val11);
18186 arg12 = (
PLINT)(val12);
18188 if (
_n_dims( args(10) ) > 1 )
18192 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
18193 arg14 =
new PLINT[
Alen];
18194 temp13 = args(10).matrix_value();
18201 arg15 = (
PLFLT)(val15);
18206 arg16 = (
PLFLT)(val16);
18211 arg17 = (
PLFLT)(val17);
18216 arg18 = (
PLFLT)(val18);
18218 if (
_n_dims( args(15) ) > 1 )
18222 if (
_dim( args(15), 0 ) != Alen )
18226 temp19 = args(15).matrix_value();
18227 arg19 =
new PLINT[
Alen];
18231 charMatrix temp_matrix;
18235 size_t max_length = 0, non_blank_length;
18237 if (
_n_dims( args(16) ) > 2 )
18239 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
18241 if ( !args(16).is_empty() )
18243 if (
_dim( args(16), 0 ) != Alen )
18245 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
18247 arg20 =
new char*[
Alen];
18248 ifcell = args(16).is_cell();
18251 temp_cell = args(16).cell_value();
18255 temp_matrix = args(16).char_matrix_value();
18257 max_length =
_dim( args(16), 1 ) + 1;
18260 for ( i = 0; i <
Alen; i++ )
18267 if ( temp_cell.elem( i ).is_string() )
18269 str = temp_cell.elem( i ).string_value();
18271 max_length = str.size() + 1;
18272 tmp_cstring = (
char *) str.c_str();
18282 tmp_cstring = (
char *)
"";
18287 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
18289 arg20[i] =
new char[max_length];
18290 strncpy( arg20[i], tmp_cstring, max_length - 1 );
18291 arg20[i][max_length - 1] =
'\0';
18306 non_blank_length = max_length - 2;
18307 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
18309 non_blank_length--;
18311 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
18313 non_blank_length--;
18315 arg20[i][non_blank_length + 1] =
'\0';
18325 if (
_n_dims( args(17) ) > 1 )
18329 if ( !args(17).is_empty() )
18331 if (
_dim( args(17), 0 ) != Alen )
18335 temp21 = args(17).matrix_value();
18336 arg21 =
new PLINT[
Alen];
18345 if (
_n_dims( args(18) ) > 1 )
18349 if ( !args(18).is_empty() )
18351 if (
_dim( args(18), 0 ) != Alen )
18355 temp22 = args(18).matrix_value();
18356 arg22 =
new PLINT[
Alen];
18365 if (
_n_dims( args(19) ) > 1 )
18369 if ( !args(19).is_empty() )
18371 if (
_dim( args(19), 0 ) != Alen )
18375 temp23 = args(19).matrix_value();
18376 arg23 = &temp23( 0, 0 );
18384 if (
_n_dims( args(20) ) > 1 )
18388 if ( !args(20).is_empty() )
18390 if (
_dim( args(20), 0 ) != Alen )
18394 temp24 = args(20).matrix_value();
18395 arg24 = &temp24( 0, 0 );
18403 if (
_n_dims( args(21) ) > 1 )
18407 if ( !args(21).is_empty() )
18409 if (
_dim( args(21), 0 ) != Alen )
18413 temp25 = args(21).matrix_value();
18414 arg25 =
new PLINT[
Alen];
18423 if (
_n_dims( args(22) ) > 1 )
18427 if ( !args(22).is_empty() )
18429 if (
_dim( args(22), 0 ) != Alen )
18433 temp26 = args(22).matrix_value();
18434 arg26 =
new PLINT[
Alen];
18443 if (
_n_dims( args(23) ) > 1 )
18447 if ( !args(23).is_empty() )
18449 if (
_dim( args(23), 0 ) != Alen )
18453 temp27 = args(23).matrix_value();
18454 arg27 = &temp27( 0, 0 );
18462 if (
_n_dims( args(24) ) > 1 )
18466 if ( !args(24).is_empty() )
18468 if (
_dim( args(24), 0 ) != Alen )
18472 temp28 = args(24).matrix_value();
18473 arg28 =
new PLINT[
Alen];
18482 if (
_n_dims( args(25) ) > 1 )
18486 if ( !args(25).is_empty() )
18488 if (
_dim( args(25), 0 ) != Alen )
18492 temp29 = args(25).matrix_value();
18493 arg29 = &temp29( 0, 0 );
18501 if (
_n_dims( args(26) ) > 1 )
18505 if ( !args(26).is_empty() )
18507 if (
_dim( args(26), 0 ) != Alen )
18511 temp30 = args(26).matrix_value();
18512 arg30 =
new PLINT[
Alen];
18521 charMatrix temp_matrix;
18525 size_t max_length = 0, non_blank_length;
18527 if (
_n_dims( args(27) ) > 2 )
18529 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
18531 if ( !args(27).is_empty() )
18533 if (
_dim( args(27), 0 ) != Alen )
18535 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
18537 arg31 =
new char*[
Alen];
18538 ifcell = args(27).is_cell();
18541 temp_cell = args(27).cell_value();
18545 temp_matrix = args(27).char_matrix_value();
18547 max_length =
_dim( args(27), 1 ) + 1;
18550 for ( i = 0; i <
Alen; i++ )
18557 if ( temp_cell.elem( i ).is_string() )
18559 str = temp_cell.elem( i ).string_value();
18561 max_length = str.size() + 1;
18562 tmp_cstring = (
char *) str.c_str();
18572 tmp_cstring = (
char *)
"";
18577 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
18579 arg31[i] =
new char[max_length];
18580 strncpy( arg31[i], tmp_cstring, max_length - 1 );
18581 arg31[i][max_length - 1] =
'\0';
18596 non_blank_length = max_length - 2;
18597 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
18599 non_blank_length--;
18601 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
18603 non_blank_length--;
18605 arg31[i][non_blank_length + 1] =
'\0';
18614 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);
18615 _outv = octave_value();
18637 if ( arg20 != NULL )
18639 for ( i = 0; i <
Alen; i++ )
18647 if ( arg21 != NULL )
18651 if ( arg22 != NULL )
18661 if ( arg25 != NULL )
18665 if ( arg26 != NULL )
18672 if ( arg28 != NULL )
18679 if ( arg30 != NULL )
18684 if ( arg31 != NULL )
18686 for ( i = 0; i <
Alen; i++ )
18708 octave_value_list _out;
18709 octave_value_list *_outp=&_out;
18710 octave_value _outv;
18719 arg1 = (
PLFLT)(val1);
18724 arg2 = (
PLFLT)(val2);
18729 arg3 = (
PLFLT)(val3);
18731 _outv = octave_value();
18740 PLFLT *arg2 = (PLFLT *) 0 ;
18741 PLFLT *arg3 = (PLFLT *) 0 ;
18744 octave_value_list _out;
18745 octave_value_list *_outp=&_out;
18746 octave_value _outv;
18752 if (
_n_dims( args(0) ) > 1 )
18756 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18757 temp1 = args(0).matrix_value();
18758 arg2 = &temp1( 0, 0 );
18761 if (
_n_dims( args(1) ) > 1 )
18765 if (
_dim( args(1), 0 ) != Alen )
18769 temp3 = args(1).matrix_value();
18770 arg3 = &temp3( 0, 0 );
18772 plline(arg1,(
double const *)arg2,(
double const *)arg3);
18773 _outv = octave_value();
18788 PLFLT *arg2 = (PLFLT *) 0 ;
18789 PLFLT *arg3 = (PLFLT *) 0 ;
18790 PLFLT *arg4 = (PLFLT *) 0 ;
18794 octave_value_list _out;
18795 octave_value_list *_outp=&_out;
18796 octave_value _outv;
18802 if (
_n_dims( args(0) ) > 1 )
18806 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18807 temp1 = args(0).matrix_value();
18808 arg2 = &temp1( 0, 0 );
18811 if (
_n_dims( args(1) ) > 1 )
18815 if (
_dim( args(1), 0 ) != Alen )
18819 temp3 = args(1).matrix_value();
18820 arg3 = &temp3( 0, 0 );
18823 if (
_n_dims( args(2) ) > 1 )
18827 if (
_dim( args(2), 0 ) != Alen )
18831 temp4 = args(2).matrix_value();
18832 arg4 = &temp4( 0, 0 );
18834 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18835 _outv = octave_value();
18855 octave_value_list _out;
18856 octave_value_list *_outp=&_out;
18857 octave_value _outv;
18866 arg1 = (
PLINT)(val1);
18868 _outv = octave_value();
18876 PLINT *arg1 = (PLINT *) 0 ;
18879 octave_value_list _out;
18880 octave_value_list *_outp=&_out;
18881 octave_value _outv;
18888 _outv = octave_value();
18902 char *arg1 = (
char *) 0 ;
18906 char *arg5 = (
char *) 0 ;
18919 octave_value_list _out;
18920 octave_value_list *_outp=&_out;
18921 octave_value _outv;
18930 arg1 = (
char *)(buf1);
18935 arg2 = (
PLFLT)(val2);
18940 arg3 = (
PLFLT)(val3);
18945 arg4 = (
PLFLT)(val4);
18950 arg5 = (
char *)(buf5);
18951 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
18952 _outv = octave_value();
18962 char *arg1 = (
char *) 0 ;
18966 char *arg5 = (
char *) 0 ;
18979 octave_value_list _out;
18980 octave_value_list *_outp=&_out;
18981 octave_value _outv;
18990 arg1 = (
char *)(buf1);
18995 arg2 = (
PLFLT)(val2);
19000 arg3 = (
PLFLT)(val3);
19005 arg4 = (
PLFLT)(val4);
19010 arg5 = (
char *)(buf5);
19011 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
19012 _outv = octave_value();
19022 int *arg1 = (
int *) 0 ;
19023 char **arg2 = (
char **) 0 ;
19031 octave_value_list _out;
19032 octave_value_list *_outp=&_out;
19033 octave_value _outv;
19043 arg1 = (
int *)(argp1);
19048 arg2 = (
char **)(argp2);
19053 arg3 = (
PLINT)(val3);
19064 PLINT *arg2 = (PLINT *) 0 ;
19065 PLINT *arg3 = (PLINT *) 0 ;
19068 octave_value_list _out;
19069 octave_value_list *_outp=&_out;
19070 octave_value _outv;
19076 if (
_n_dims( args(0) ) > 1 )
19080 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19081 arg2 =
new PLINT[
Alen];
19082 temp1 = args(0).matrix_value();
19086 if (
_n_dims( args(1) ) > 1 )
19090 if (
_dim( args(1), 0 ) != Alen )
19094 temp3 = args(1).matrix_value();
19095 arg3 =
new PLINT[
Alen];
19098 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
19099 _outv = octave_value();
19128 octave_value_list _out;
19129 octave_value_list *_outp=&_out;
19130 octave_value _outv;
19139 arg1 = (
PLINT)(val1);
19144 arg2 = (
PLFLT)(val2);
19149 arg3 = (
PLFLT)(val3);
19154 arg4 = (
PLFLT)(val4);
19159 arg5 = (
PLFLT)(val5);
19160 plpath(arg1,arg2,arg3,arg4,arg5);
19161 _outv = octave_value();
19170 PLFLT *arg2 = (PLFLT *) 0 ;
19171 PLFLT *arg3 = (PLFLT *) 0 ;
19177 octave_value_list _out;
19178 octave_value_list *_outp=&_out;
19179 octave_value _outv;
19185 if (
_n_dims( args(0) ) > 1 )
19189 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19190 temp1 = args(0).matrix_value();
19191 arg2 = &temp1( 0, 0 );
19194 if (
_n_dims( args(1) ) > 1 )
19198 if (
_dim( args(1), 0 ) != Alen )
19202 temp3 = args(1).matrix_value();
19203 arg3 = &temp3( 0, 0 );
19209 arg4 = (
PLINT)(val4);
19210 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
19211 _outv = octave_value();
19226 PLFLT *arg2 = (PLFLT *) 0 ;
19227 PLFLT *arg3 = (PLFLT *) 0 ;
19228 PLFLT *arg4 = (PLFLT *) 0 ;
19235 octave_value_list _out;
19236 octave_value_list *_outp=&_out;
19237 octave_value _outv;
19243 if (
_n_dims( args(0) ) > 1 )
19247 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19248 temp1 = args(0).matrix_value();
19249 arg2 = &temp1( 0, 0 );
19252 if (
_n_dims( args(1) ) > 1 )
19256 if (
_dim( args(1), 0 ) != Alen )
19260 temp3 = args(1).matrix_value();
19261 arg3 = &temp3( 0, 0 );
19264 if (
_n_dims( args(2) ) > 1 )
19268 if (
_dim( args(2), 0 ) != Alen )
19272 temp4 = args(2).matrix_value();
19273 arg4 = &temp4( 0, 0 );
19279 arg5 = (
PLINT)(val5);
19280 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
19281 _outv = octave_value();
19299 PLFLT *arg2 = (PLFLT *) 0 ;
19300 PLFLT *arg3 = (PLFLT *) 0 ;
19301 PLFLT *arg4 = (PLFLT *) 0 ;
19310 octave_value_list _out;
19311 octave_value_list *_outp=&_out;
19312 octave_value _outv;
19318 if (
_n_dims( args(0) ) > 1 )
19322 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19323 temp1 = args(0).matrix_value();
19324 arg2 = &temp1( 0, 0 );
19327 if (
_n_dims( args(1) ) > 1 )
19331 if (
_dim( args(1), 0 ) != Alen )
19335 temp3 = args(1).matrix_value();
19336 arg3 = &temp3( 0, 0 );
19339 if (
_n_dims( args(2) ) > 1 )
19343 if (
_dim( args(2), 0 ) != Alen )
19347 temp4 = args(2).matrix_value();
19348 arg4 = &temp4( 0, 0 );
19351 if (
_n_dims( args(3) ) > 1 )
19355 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
19357 error(
"argument vector must be same length or one less" );
SWIG_fail;
19359 temp5 = args(3).matrix_value();
19360 arg5 =
new PLINT[
Alen];
19368 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
19369 _outv = octave_value();
19395 octave_value_list _out;
19396 octave_value_list *_outp=&_out;
19397 octave_value _outv;
19406 arg1 = (
PLINT)(val1);
19411 arg2 = (
PLINT)(val2);
19413 _outv = octave_value();
19424 octave_value_list _out;
19425 octave_value_list *_outp=&_out;
19426 octave_value _outv;
19435 arg1 = (
PLINT)(val1);
19437 _outv = octave_value();
19450 char *arg6 = (
char *) 0 ;
19464 octave_value_list _out;
19465 octave_value_list *_outp=&_out;
19466 octave_value _outv;
19475 arg1 = (
PLFLT)(val1);
19480 arg2 = (
PLFLT)(val2);
19485 arg3 = (
PLFLT)(val3);
19490 arg4 = (
PLFLT)(val4);
19495 arg5 = (
PLFLT)(val5);
19500 arg6 = (
char *)(buf6);
19501 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
19502 _outv = octave_value();
19521 char *arg11 = (
char *) 0 ;
19545 octave_value_list _out;
19546 octave_value_list *_outp=&_out;
19547 octave_value _outv;
19556 arg1 = (
PLFLT)(val1);
19561 arg2 = (
PLFLT)(val2);
19566 arg3 = (
PLFLT)(val3);
19571 arg4 = (
PLFLT)(val4);
19576 arg5 = (
PLFLT)(val5);
19581 arg6 = (
PLFLT)(val6);
19586 arg7 = (
PLFLT)(val7);
19591 arg8 = (
PLFLT)(val8);
19596 arg9 = (
PLFLT)(val9);
19601 arg10 = (
PLFLT)(val10);
19606 arg11 = (
char *)(buf11);
19607 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
19608 _outv = octave_value();
19617 octave_value_list _out;
19618 octave_value_list *_outp=&_out;
19619 octave_value _outv;
19634 octave_value_list _out;
19635 octave_value_list *_outp=&_out;
19636 octave_value _outv;
19642 _outv = octave_value();
19653 PLFLT *arg4 = (PLFLT *) 0 ;
19654 PLFLT *arg5 = (PLFLT *) 0 ;
19655 PLFLT *arg6 = (PLFLT *) 0 ;
19668 octave_value_list _out;
19669 octave_value_list *_outp=&_out;
19670 octave_value _outv;
19682 arg1 = (
PLFLT)(val1);
19687 arg2 = (
PLFLT)(val2);
19692 arg3 = (
PLFLT)(val3);
19693 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
19694 _outv = octave_value();
19726 octave_value_list _out;
19727 octave_value_list *_outp=&_out;
19728 octave_value _outv;
19737 arg1 = (
PLFLT)(val1);
19742 arg2 = (
PLFLT)(val2);
19744 _outv = octave_value();
19752 PLINT *arg1 = (PLINT *) 0 ;
19753 PLINT *arg2 = (PLINT *) 0 ;
19754 PLINT *arg3 = (PLINT *) 0 ;
19759 octave_value_list _out;
19760 octave_value_list *_outp=&_out;
19761 octave_value _outv;
19767 if (
_n_dims( args(0) ) > 1 )
19772 temp1 = args(0).matrix_value();
19773 arg1 =
new PLINT[
Alen];
19777 if (
_n_dims( args(1) ) > 1 )
19781 if (
_dim( args(1), 0 ) != Alen )
19785 temp2 = args(1).matrix_value();
19786 arg2 =
new PLINT[
Alen];
19790 if (
_n_dims( args(2) ) > 1 )
19794 if (
_dim( args(2), 0 ) != Alen )
19798 temp3 = args(2).matrix_value();
19799 arg3 =
new PLINT[
Alen];
19803 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
19804 _outv = octave_value();
19821 PLINT *arg1 = (PLINT *) 0 ;
19822 PLINT *arg2 = (PLINT *) 0 ;
19823 PLINT *arg3 = (PLINT *) 0 ;
19824 PLFLT *arg4 = (PLFLT *) 0 ;
19830 octave_value_list _out;
19831 octave_value_list *_outp=&_out;
19832 octave_value _outv;
19838 if (
_n_dims( args(0) ) > 1 )
19843 temp1 = args(0).matrix_value();
19844 arg1 =
new PLINT[
Alen];
19848 if (
_n_dims( args(1) ) > 1 )
19852 if (
_dim( args(1), 0 ) != Alen )
19856 temp2 = args(1).matrix_value();
19857 arg2 =
new PLINT[
Alen];
19861 if (
_n_dims( args(2) ) > 1 )
19865 if (
_dim( args(2), 0 ) != Alen )
19869 temp3 = args(2).matrix_value();
19870 arg3 =
new PLINT[
Alen];
19874 if (
_n_dims( args(3) ) > 1 )
19878 if (
_dim( args(3), 0 ) != Alen )
19882 temp4 = args(3).matrix_value();
19883 arg4 = &temp4( 0, 0 );
19886 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
19887 _outv = octave_value();
19910 octave_value_list _out;
19911 octave_value_list *_outp=&_out;
19912 octave_value _outv;
19921 arg1 = (
PLINT)(val1);
19923 _outv = octave_value();
19931 PLINT *arg1 = (PLINT *) 0 ;
19932 PLINT *arg2 = (PLINT *) 0 ;
19933 PLINT *arg3 = (PLINT *) 0 ;
19938 octave_value_list _out;
19939 octave_value_list *_outp=&_out;
19940 octave_value _outv;
19946 if (
_n_dims( args(0) ) > 1 )
19951 temp1 = args(0).matrix_value();
19952 arg1 =
new PLINT[
Alen];
19956 if (
_n_dims( args(1) ) > 1 )
19960 if (
_dim( args(1), 0 ) != Alen )
19964 temp2 = args(1).matrix_value();
19965 arg2 =
new PLINT[
Alen];
19969 if (
_n_dims( args(2) ) > 1 )
19973 if (
_dim( args(2), 0 ) != Alen )
19977 temp3 = args(2).matrix_value();
19978 arg3 =
new PLINT[
Alen];
19982 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
19983 _outv = octave_value();
20000 PLINT *arg1 = (PLINT *) 0 ;
20001 PLINT *arg2 = (PLINT *) 0 ;
20002 PLINT *arg3 = (PLINT *) 0 ;
20003 PLFLT *arg4 = (PLFLT *) 0 ;
20009 octave_value_list _out;
20010 octave_value_list *_outp=&_out;
20011 octave_value _outv;
20017 if (
_n_dims( args(0) ) > 1 )
20022 temp1 = args(0).matrix_value();
20023 arg1 =
new PLINT[
Alen];
20027 if (
_n_dims( args(1) ) > 1 )
20031 if (
_dim( args(1), 0 ) != Alen )
20035 temp2 = args(1).matrix_value();
20036 arg2 =
new PLINT[
Alen];
20040 if (
_n_dims( args(2) ) > 1 )
20044 if (
_dim( args(2), 0 ) != Alen )
20048 temp3 = args(2).matrix_value();
20049 arg3 =
new PLINT[
Alen];
20053 if (
_n_dims( args(3) ) > 1 )
20057 if (
_dim( args(3), 0 ) != Alen )
20061 temp4 = args(3).matrix_value();
20062 arg4 = &temp4( 0, 0 );
20065 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
20066 _outv = octave_value();
20088 PLFLT *arg3 = (PLFLT *) 0 ;
20089 PLFLT *arg4 = (PLFLT *) 0 ;
20090 PLFLT *arg5 = (PLFLT *) 0 ;
20091 PLFLT *arg6 = (PLFLT *) 0 ;
20100 octave_value_list _out;
20101 octave_value_list *_outp=&_out;
20102 octave_value _outv;
20113 if (
_n_dims( args(1) ) > 1 )
20117 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
20118 temp2 = args(1).matrix_value();
20119 arg3 = &temp2( 0, 0 );
20122 if (
_n_dims( args(2) ) > 1 )
20126 if (
_dim( args(2), 0 ) != Alen )
20130 temp4 = args(2).matrix_value();
20131 arg4 = &temp4( 0, 0 );
20134 if (
_n_dims( args(3) ) > 1 )
20138 if (
_dim( args(3), 0 ) != Alen )
20142 temp5 = args(3).matrix_value();
20143 arg5 = &temp5( 0, 0 );
20146 if (
_n_dims( args(4) ) > 1 )
20150 if (
_dim( args(4), 0 ) != Alen )
20154 temp6 = args(4).matrix_value();
20155 arg6 = &temp6( 0, 0 );
20158 if (
_n_dims( args(5) ) > 1 )
20162 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
20164 error(
"argument vector must be same length or one less" );
SWIG_fail;
20166 temp7 = args(5).matrix_value();
20167 arg7 =
new PLINT[
Alen];
20170 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
20171 _outv = octave_value();
20196 PLFLT *arg3 = (PLFLT *) 0 ;
20197 PLFLT *arg4 = (PLFLT *) 0 ;
20198 PLFLT *arg5 = (PLFLT *) 0 ;
20199 PLFLT *arg6 = (PLFLT *) 0 ;
20200 PLFLT *arg7 = (PLFLT *) 0 ;
20210 octave_value_list _out;
20211 octave_value_list *_outp=&_out;
20212 octave_value _outv;
20223 if (
_n_dims( args(1) ) > 1 )
20227 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
20228 temp2 = args(1).matrix_value();
20229 arg3 = &temp2( 0, 0 );
20232 if (
_n_dims( args(2) ) > 1 )
20236 if (
_dim( args(2), 0 ) != Alen )
20240 temp4 = args(2).matrix_value();
20241 arg4 = &temp4( 0, 0 );
20244 if (
_n_dims( args(3) ) > 1 )
20248 if (
_dim( args(3), 0 ) != Alen )
20252 temp5 = args(3).matrix_value();
20253 arg5 = &temp5( 0, 0 );
20256 if (
_n_dims( args(4) ) > 1 )
20260 if (
_dim( args(4), 0 ) != Alen )
20264 temp6 = args(4).matrix_value();
20265 arg6 = &temp6( 0, 0 );
20268 if (
_n_dims( args(5) ) > 1 )
20272 if (
_dim( args(5), 0 ) != Alen )
20276 temp7 = args(5).matrix_value();
20277 arg7 = &temp7( 0, 0 );
20280 if (
_n_dims( args(6) ) > 1 )
20284 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
20286 error(
"argument vector must be same length or one less" );
SWIG_fail;
20288 temp8 = args(6).matrix_value();
20289 arg8 =
new PLINT[
Alen];
20292 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
20293 _outv = octave_value();
20322 octave_value_list _out;
20323 octave_value_list *_outp=&_out;
20324 octave_value _outv;
20333 arg1 = (
PLINT)(val1);
20335 _outv = octave_value();
20349 octave_value_list _out;
20350 octave_value_list *_outp=&_out;
20351 octave_value _outv;
20360 arg1 = (
PLFLT)(val1);
20365 arg2 = (
PLFLT)(val2);
20367 _outv = octave_value();
20375 PLFLT *arg1 = (PLFLT *) 0 ;
20376 PLFLT *arg2 = (PLFLT *) 0 ;
20381 octave_value_list _out;
20382 octave_value_list *_outp=&_out;
20383 octave_value _outv;
20391 _outv = octave_value();
20423 octave_value_list _out;
20424 octave_value_list *_outp=&_out;
20425 octave_value _outv;
20434 arg1 = (
PLINT)(val1);
20439 arg2 = (
PLINT)(val2);
20444 arg3 = (
PLINT)(val3);
20449 arg4 = (
PLINT)(val4);
20450 plscol0(arg1,arg2,arg3,arg4);
20451 _outv = octave_value();
20474 octave_value_list _out;
20475 octave_value_list *_outp=&_out;
20476 octave_value _outv;
20485 arg1 = (
PLINT)(val1);
20490 arg2 = (
PLINT)(val2);
20495 arg3 = (
PLINT)(val3);
20500 arg4 = (
PLINT)(val4);
20505 arg5 = (
PLFLT)(val5);
20506 plscol0a(arg1,arg2,arg3,arg4,arg5);
20507 _outv = octave_value();
20524 octave_value_list _out;
20525 octave_value_list *_outp=&_out;
20526 octave_value _outv;
20535 arg1 = (
PLINT)(val1);
20540 arg2 = (
PLINT)(val2);
20545 arg3 = (
PLINT)(val3);
20547 _outv = octave_value();
20567 octave_value_list _out;
20568 octave_value_list *_outp=&_out;
20569 octave_value _outv;
20578 arg1 = (
PLINT)(val1);
20583 arg2 = (
PLINT)(val2);
20588 arg3 = (
PLINT)(val3);
20593 arg4 = (
PLFLT)(val4);
20595 _outv = octave_value();
20606 octave_value_list _out;
20607 octave_value_list *_outp=&_out;
20608 octave_value _outv;
20617 arg1 = (
PLINT)(val1);
20619 _outv = octave_value();
20630 octave_value_list _out;
20631 octave_value_list *_outp=&_out;
20632 octave_value _outv;
20641 arg1 = (
PLINT)(val1);
20643 _outv = octave_value();
20651 char *arg1 = (
char *) 0 ;
20655 octave_value_list _out;
20656 octave_value_list *_outp=&_out;
20657 octave_value _outv;
20666 arg1 = (
char *)(buf1);
20667 plsdev((
char const *)arg1);
20668 _outv = octave_value();
20689 octave_value_list _out;
20690 octave_value_list *_outp=&_out;
20691 octave_value _outv;
20700 arg1 = (
PLFLT)(val1);
20705 arg2 = (
PLFLT)(val2);
20710 arg3 = (
PLFLT)(val3);
20715 arg4 = (
PLFLT)(val4);
20717 _outv = octave_value();
20743 octave_value_list _out;
20744 octave_value_list *_outp=&_out;
20745 octave_value _outv;
20754 arg1 = (
PLINT)(val1);
20759 arg2 = (
PLINT)(val2);
20764 arg3 = (
PLINT)(val3);
20769 arg4 = (
PLINT)(val4);
20774 arg5 = (
PLFLT)(val5);
20779 arg6 = (
PLFLT)(val6);
20780 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
20781 _outv = octave_value();
20792 octave_value_list _out;
20793 octave_value_list *_outp=&_out;
20794 octave_value _outv;
20803 arg1 = (
PLFLT)(val1);
20805 _outv = octave_value();
20825 octave_value_list _out;
20826 octave_value_list *_outp=&_out;
20827 octave_value _outv;
20836 arg1 = (
PLFLT)(val1);
20841 arg2 = (
PLFLT)(val2);
20846 arg3 = (
PLFLT)(val3);
20851 arg4 = (
PLFLT)(val4);
20853 _outv = octave_value();
20873 octave_value_list _out;
20874 octave_value_list *_outp=&_out;
20875 octave_value _outv;
20884 arg1 = (
PLFLT)(val1);
20889 arg2 = (
PLFLT)(val2);
20894 arg3 = (
PLFLT)(val3);
20899 arg4 = (
PLFLT)(val4);
20901 _outv = octave_value();
20909 unsigned int arg1 ;
20910 unsigned int val1 ;
20912 octave_value_list _out;
20913 octave_value_list *_outp=&_out;
20914 octave_value _outv;
20923 arg1 = (
unsigned int)(val1);
20925 _outv = octave_value();
20936 octave_value_list _out;
20937 octave_value_list *_outp=&_out;
20938 octave_value _outv;
20947 arg1 = (char)(val1);
20949 _outv = octave_value();
20957 char *arg1 = (
char *) 0 ;
20958 char *arg2 = (
char *) 0 ;
20965 octave_value_list _out;
20966 octave_value_list *_outp=&_out;
20967 octave_value _outv;
20977 arg1 = (
char *)(buf1);
20982 arg2 = (
char *)(buf2);
20983 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
21003 octave_value_list _out;
21004 octave_value_list *_outp=&_out;
21005 octave_value _outv;
21014 arg1 = (
PLINT)(val1);
21019 arg2 = (
PLINT)(val2);
21024 arg3 = (
PLINT)(val3);
21026 _outv = octave_value();
21035 unsigned int val1 ;
21037 octave_value_list _out;
21038 octave_value_list *_outp=&_out;
21039 octave_value _outv;
21050 _outv = octave_value();
21058 char *arg1 = (
char *) 0 ;
21062 octave_value_list _out;
21063 octave_value_list *_outp=&_out;
21064 octave_value _outv;
21073 arg1 = (
char *)(buf1);
21075 _outv = octave_value();
21093 octave_value_list _out;
21094 octave_value_list *_outp=&_out;
21095 octave_value _outv;
21104 arg1 = (
PLINT)(val1);
21109 arg2 = (
PLINT)(val2);
21114 arg3 = (
PLINT)(val3);
21116 _outv = octave_value();
21127 octave_value_list _out;
21128 octave_value_list *_outp=&_out;
21129 octave_value _outv;
21135 octave_value obj = args(0);
21136 if ( !obj.is_empty() )
21138 if ( obj.is_function_handle() || obj.is_inline_function() )
21140 fcnLabelFunc = obj.function_value();
21142 else if ( obj.is_string() )
21144 nameLabelFunc = obj.string_value();
21145 fcnLabelFunc = NULL;
21159 _outv = octave_value();
21173 octave_value_list _out;
21174 octave_value_list *_outp=&_out;
21175 octave_value _outv;
21184 arg1 = (
PLFLT)(val1);
21189 arg2 = (
PLFLT)(val2);
21191 _outv = octave_value();
21205 octave_value_list _out;
21206 octave_value_list *_outp=&_out;
21207 octave_value _outv;
21216 arg1 = (
PLFLT)(val1);
21221 arg2 = (
PLFLT)(val2);
21223 _outv = octave_value();
21234 octave_value_list _out;
21235 octave_value_list *_outp=&_out;
21236 octave_value _outv;
21245 arg1 = (
PLINT)(val1);
21247 _outv = octave_value();
21273 octave_value_list _out;
21274 octave_value_list *_outp=&_out;
21275 octave_value _outv;
21284 arg1 = (
PLFLT)(val1);
21289 arg2 = (
PLFLT)(val2);
21294 arg3 = (
PLINT)(val3);
21299 arg4 = (
PLINT)(val4);
21304 arg5 = (
PLINT)(val5);
21309 arg6 = (
PLINT)(val6);
21310 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
21311 _outv = octave_value();
21319 char *arg1 = (
char *) 0 ;
21323 octave_value_list _out;
21324 octave_value_list *_outp=&_out;
21325 octave_value _outv;
21334 arg1 = (
char *)(buf1);
21336 _outv = octave_value();
21345 char *arg1 = (
char *) 0 ;
21352 octave_value_list _out;
21353 octave_value_list *_outp=&_out;
21354 octave_value _outv;
21363 arg1 = (
char *)(buf1);
21369 plspal1((
char const *)arg1,arg2);
21370 _outv = octave_value();
21382 octave_value_list _out;
21383 octave_value_list *_outp=&_out;
21384 octave_value _outv;
21395 _outv = octave_value();
21406 octave_value_list _out;
21407 octave_value_list *_outp=&_out;
21408 octave_value _outv;
21417 arg1 = (
PLINT)(val1);
21419 _outv = octave_value();
21433 octave_value_list _out;
21434 octave_value_list *_outp=&_out;
21435 octave_value _outv;
21444 arg1 = (
PLINT)(val1);
21449 arg2 = (
PLINT)(val2);
21451 _outv = octave_value();
21465 octave_value_list _out;
21466 octave_value_list *_outp=&_out;
21467 octave_value _outv;
21476 arg1 = (
PLFLT)(val1);
21481 arg2 = (
PLFLT)(val2);
21483 _outv = octave_value();
21497 octave_value_list _out;
21498 octave_value_list *_outp=&_out;
21499 octave_value _outv;
21508 arg1 = (
PLINT)(val1);
21513 arg2 = (
PLINT)(val2);
21515 _outv = octave_value();
21523 char *arg1 = (
char *) 0 ;
21533 octave_value_list _out;
21534 octave_value_list *_outp=&_out;
21535 octave_value _outv;
21544 arg1 = (
char *)(buf1);
21549 arg2 = (
PLINT)(val2);
21554 arg3 = (
PLINT)(val3);
21555 plstart((
char const *)arg1,arg2,arg3);
21556 _outv = octave_value();
21568 octave_value_list _out;
21569 octave_value_list *_outp=&_out;
21570 octave_value _outv;
21576 octave_value obj = args(0);
21577 if ( !obj.is_empty() )
21579 if ( obj.is_function_handle() || obj.is_inline_function() )
21581 fcnCoordTrans = obj.function_value();
21583 else if ( obj.is_string() )
21585 nameCoordTrans = obj.string_value();
21586 fcnCoordTrans = NULL;
21600 _outv = octave_value();
21609 PLFLT *arg2 = (PLFLT *) 0 ;
21610 PLFLT *arg3 = (PLFLT *) 0 ;
21611 char *arg4 = (
char *) 0 ;
21617 octave_value_list _out;
21618 octave_value_list *_outp=&_out;
21619 octave_value _outv;
21625 if (
_n_dims( args(0) ) > 1 )
21629 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21630 temp1 = args(0).matrix_value();
21631 arg2 = &temp1( 0, 0 );
21634 if (
_n_dims( args(1) ) > 1 )
21638 if (
_dim( args(1), 0 ) != Alen )
21642 temp3 = args(1).matrix_value();
21643 arg3 = &temp3( 0, 0 );
21649 arg4 = (
char *)(buf4);
21650 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
21651 _outv = octave_value();
21667 PLFLT *arg2 = (PLFLT *) 0 ;
21668 PLFLT *arg3 = (PLFLT *) 0 ;
21669 PLFLT *arg4 = (PLFLT *) 0 ;
21670 char *arg5 = (
char *) 0 ;
21677 octave_value_list _out;
21678 octave_value_list *_outp=&_out;
21679 octave_value _outv;
21685 if (
_n_dims( args(0) ) > 1 )
21689 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21690 temp1 = args(0).matrix_value();
21691 arg2 = &temp1( 0, 0 );
21694 if (
_n_dims( args(1) ) > 1 )
21698 if (
_dim( args(1), 0 ) != Alen )
21702 temp3 = args(1).matrix_value();
21703 arg3 = &temp3( 0, 0 );
21706 if (
_n_dims( args(2) ) > 1 )
21710 if (
_dim( args(2), 0 ) != Alen )
21714 temp4 = args(2).matrix_value();
21715 arg4 = &temp4( 0, 0 );
21721 arg5 = (
char *)(buf5);
21722 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
21723 _outv = octave_value();
21753 octave_value_list _out;
21754 octave_value_list *_outp=&_out;
21755 octave_value _outv;
21764 arg1 = (
PLINT)(val1);
21769 arg2 = (
PLINT)(val2);
21774 arg3 = (
PLFLT)(val3);
21779 arg4 = (
PLFLT)(val4);
21781 _outv = octave_value();
21792 octave_value_list _out;
21793 octave_value_list *_outp=&_out;
21794 octave_value _outv;
21803 arg1 = (
PLINT)(val1);
21805 _outv = octave_value();
21814 PLINT *arg2 = (PLINT *) 0 ;
21815 PLINT *arg3 = (PLINT *) 0 ;
21818 octave_value_list _out;
21819 octave_value_list *_outp=&_out;
21820 octave_value _outv;
21826 if (
_n_dims( args(0) ) > 1 )
21830 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21831 arg2 =
new PLINT[
Alen];
21832 temp1 = args(0).matrix_value();
21836 if (
_n_dims( args(1) ) > 1 )
21840 if (
_dim( args(1), 0 ) != Alen )
21844 temp3 = args(1).matrix_value();
21845 arg3 =
new PLINT[
Alen];
21848 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
21849 _outv = octave_value();
21863 PLFLT *arg1 = (PLFLT *) 0 ;
21864 PLFLT *arg2 = (PLFLT *) 0 ;
21871 octave_value_list _out;
21872 octave_value_list *_outp=&_out;
21873 octave_value _outv;
21879 if (
_n_dims( args(0) ) > 1 )
21883 if ( !args(0).is_empty() )
21886 temp1 = args(0).matrix_value();
21887 arg1 = &temp1( 0, 0 );
21896 if (
_n_dims( args(1) ) > 1 )
21900 if ( !args(1).is_empty() )
21902 if (
_dim( args(1), 0 ) != Alen )
21906 temp2 = args(1).matrix_value();
21907 arg2 = &temp2( 0, 0 );
21921 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
21922 _outv = octave_value();
21948 octave_value_list _out;
21949 octave_value_list *_outp=&_out;
21950 octave_value _outv;
21959 arg1 = (
PLFLT)(val1);
21964 arg2 = (
PLFLT)(val2);
21969 arg3 = (
PLFLT)(val3);
21974 arg4 = (
PLFLT)(val4);
21975 plsvpa(arg1,arg2,arg3,arg4);
21976 _outv = octave_value();
21990 octave_value_list _out;
21991 octave_value_list *_outp=&_out;
21992 octave_value _outv;
22001 arg1 = (
PLINT)(val1);
22006 arg2 = (
PLINT)(val2);
22008 _outv = octave_value();
22022 octave_value_list _out;
22023 octave_value_list *_outp=&_out;
22024 octave_value _outv;
22033 arg1 = (
PLINT)(val1);
22038 arg2 = (
PLINT)(val2);
22040 _outv = octave_value();
22049 PLFLT *arg2 = (PLFLT *) 0 ;
22050 PLFLT *arg3 = (PLFLT *) 0 ;
22056 octave_value_list _out;
22057 octave_value_list *_outp=&_out;
22058 octave_value _outv;
22064 if (
_n_dims( args(0) ) > 1 )
22068 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
22069 temp1 = args(0).matrix_value();
22070 arg2 = &temp1( 0, 0 );
22073 if (
_n_dims( args(1) ) > 1 )
22077 if (
_dim( args(1), 0 ) != Alen )
22081 temp3 = args(1).matrix_value();
22082 arg3 = &temp3( 0, 0 );
22088 arg4 = (
PLINT)(val4);
22089 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
22090 _outv = octave_value();
22110 octave_value_list _out;
22111 octave_value_list *_outp=&_out;
22112 octave_value _outv;
22121 arg1 = (
PLINT)(val1);
22126 arg2 = (
PLINT)(val2);
22128 _outv = octave_value();
22136 octave_value_list _out;
22137 octave_value_list *_outp=&_out;
22138 octave_value _outv;
22144 _outv = octave_value();
22152 char *arg1 = (
char *) 0 ;
22156 octave_value_list _out;
22157 octave_value_list *_outp=&_out;
22158 octave_value _outv;
22167 arg1 = (
char *)(buf1);
22169 _outv = octave_value();
22181 octave_value_list _out;
22182 octave_value_list *_outp=&_out;
22183 octave_value _outv;
22192 arg1 = (
PLFLT)(val1);
22194 _outv = octave_value();
22217 octave_value_list _out;
22218 octave_value_list *_outp=&_out;
22219 octave_value _outv;
22228 arg1 = (
PLFLT)(val1);
22233 arg2 = (
PLFLT)(val2);
22238 arg3 = (
PLFLT)(val3);
22243 arg4 = (
PLFLT)(val4);
22248 arg5 = (
PLFLT)(val5);
22249 plvpas(arg1,arg2,arg3,arg4,arg5);
22250 _outv = octave_value();
22270 octave_value_list _out;
22271 octave_value_list *_outp=&_out;
22272 octave_value _outv;
22281 arg1 = (
PLFLT)(val1);
22286 arg2 = (
PLFLT)(val2);
22291 arg3 = (
PLFLT)(val3);
22296 arg4 = (
PLFLT)(val4);
22297 plvpor(arg1,arg2,arg3,arg4);
22298 _outv = octave_value();
22306 octave_value_list _out;
22307 octave_value_list *_outp=&_out;
22308 octave_value _outv;
22314 _outv = octave_value();
22355 octave_value_list _out;
22356 octave_value_list *_outp=&_out;
22357 octave_value _outv;
22366 arg1 = (
PLFLT)(val1);
22371 arg2 = (
PLFLT)(val2);
22376 arg3 = (
PLFLT)(val3);
22381 arg4 = (
PLFLT)(val4);
22386 arg5 = (
PLFLT)(val5);
22391 arg6 = (
PLFLT)(val6);
22396 arg7 = (
PLFLT)(val7);
22401 arg8 = (
PLFLT)(val8);
22406 arg9 = (
PLFLT)(val9);
22411 arg10 = (
PLFLT)(val10);
22416 arg11 = (
PLFLT)(val11);
22417 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22418 _outv = octave_value();
22429 octave_value_list _out;
22430 octave_value_list *_outp=&_out;
22431 octave_value _outv;
22440 arg1 = (
PLFLT)(val1);
22442 _outv = octave_value();
22462 octave_value_list _out;
22463 octave_value_list *_outp=&_out;
22464 octave_value _outv;
22473 arg1 = (
PLFLT)(val1);
22478 arg2 = (
PLFLT)(val2);
22483 arg3 = (
PLFLT)(val3);
22488 arg4 = (
PLFLT)(val4);
22489 plwind(arg1,arg2,arg3,arg4);
22490 _outv = octave_value();
22504 octave_value_list _out;
22505 octave_value_list *_outp=&_out;
22506 octave_value _outv;
22518 _outv = octave_value();
22533 char *arg2 = (
char *) 0 ;
22549 octave_value_list _out;
22550 octave_value_list *_outp=&_out;
22551 octave_value _outv;
22557 octave_value obj = args(0);
22558 if ( !obj.is_empty() )
22560 if ( obj.is_function_handle() || obj.is_inline_function() )
22562 fcnMapForm = obj.function_value();
22564 else if ( obj.is_string() )
22566 nameMapForm = obj.string_value();
22580 arg2 = (
char *)(buf2);
22585 arg3 = (
PLFLT)(val3);
22590 arg4 = (
PLFLT)(val4);
22595 arg5 = (
PLFLT)(val5);
22600 arg6 = (
PLFLT)(val6);
22601 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
22602 _outv = octave_value();
22612 char *arg2 = (
char *) 0 ;
22617 PLINT *arg7 = (PLINT *) 0 ;
22631 octave_value_list _out;
22632 octave_value_list *_outp=&_out;
22633 octave_value _outv;
22639 octave_value obj = args(0);
22640 if ( !obj.is_empty() )
22642 if ( obj.is_function_handle() || obj.is_inline_function() )
22644 fcnMapForm = obj.function_value();
22646 else if ( obj.is_string() )
22648 nameMapForm = obj.string_value();
22662 arg2 = (
char *)(buf2);
22667 arg3 = (
PLFLT)(val3);
22672 arg4 = (
PLFLT)(val4);
22677 arg5 = (
PLFLT)(val5);
22682 arg6 = (
PLFLT)(val6);
22684 if (
_n_dims( args(6) ) > 1 )
22688 if ( !args(6).is_empty() )
22691 temp7 = args(6).matrix_value();
22692 arg7 =
new PLINT[arg8];
22701 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
22702 _outv = octave_value();
22715 char *arg2 = (
char *) 0 ;
22716 char *arg3 = (
char *) 0 ;
22721 PLINT *arg8 = (PLINT *) 0 ;
22738 octave_value_list _out;
22739 octave_value_list *_outp=&_out;
22740 octave_value _outv;
22746 octave_value obj = args(0);
22747 if ( !obj.is_empty() )
22749 if ( obj.is_function_handle() || obj.is_inline_function() )
22751 fcnMapForm = obj.function_value();
22753 else if ( obj.is_string() )
22755 nameMapForm = obj.string_value();
22769 arg2 = (
char *)(buf2);
22774 arg3 = (
char *)(buf3);
22779 arg4 = (
PLFLT)(val4);
22784 arg5 = (
PLFLT)(val5);
22789 arg6 = (
PLFLT)(val6);
22794 arg7 = (
PLFLT)(val7);
22796 if (
_n_dims( args(7) ) > 1 )
22800 if ( !args(7).is_empty() )
22803 temp8 = args(7).matrix_value();
22804 arg8 =
new PLINT[arg9];
22813 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
22814 _outv = octave_value();
22828 char *arg2 = (
char *) 0 ;
22832 char *arg6 = (
char *) 0 ;
22860 octave_value_list _out;
22861 octave_value_list *_outp=&_out;
22862 octave_value _outv;
22868 octave_value obj = args(0);
22869 if ( !obj.is_empty() )
22871 if ( obj.is_function_handle() || obj.is_inline_function() )
22873 fcnMapForm = obj.function_value();
22875 else if ( obj.is_string() )
22877 nameMapForm = obj.string_value();
22891 arg2 = (
char *)(buf2);
22896 arg3 = (
PLFLT)(val3);
22901 arg4 = (
PLFLT)(val4);
22906 arg5 = (
PLFLT)(val5);
22911 arg6 = (
char *)(buf6);
22916 arg7 = (
PLFLT)(val7);
22921 arg8 = (
PLFLT)(val8);
22926 arg9 = (
PLFLT)(val9);
22931 arg10 = (
PLFLT)(val10);
22936 arg11 = (
PLINT)(val11);
22937 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
22938 _outv = octave_value();
22949 char *arg2 = (
char *) 0 ;
22954 PLINT *arg7 = (PLINT *) 0 ;
22968 octave_value_list _out;
22969 octave_value_list *_outp=&_out;
22970 octave_value _outv;
22976 octave_value obj = args(0);
22977 if ( !obj.is_empty() )
22979 if ( obj.is_function_handle() || obj.is_inline_function() )
22981 fcnMapForm = obj.function_value();
22983 else if ( obj.is_string() )
22985 nameMapForm = obj.string_value();
22999 arg2 = (
char *)(buf2);
23004 arg3 = (
PLFLT)(val3);
23009 arg4 = (
PLFLT)(val4);
23014 arg5 = (
PLFLT)(val5);
23019 arg6 = (
PLFLT)(val6);
23021 if (
_n_dims( args(6) ) > 1 )
23025 if ( !args(6).is_empty() )
23028 temp7 = args(6).matrix_value();
23029 arg7 =
new PLINT[arg8];
23038 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
23039 _outv = octave_value();
23070 octave_value_list _out;
23071 octave_value_list *_outp=&_out;
23072 octave_value _outv;
23078 octave_value obj = args(0);
23079 if ( !obj.is_empty() )
23081 if ( obj.is_function_handle() || obj.is_inline_function() )
23083 fcnMapForm = obj.function_value();
23085 else if ( obj.is_string() )
23087 nameMapForm = obj.string_value();
23101 arg2 = (
PLFLT)(val2);
23106 arg3 = (
PLFLT)(val3);
23111 arg4 = (
PLFLT)(val4);
23116 arg5 = (
PLFLT)(val5);
23121 arg6 = (
PLFLT)(val6);
23126 arg7 = (
PLFLT)(val7);
23128 _outv = octave_value();
23136 octave_value_list _out;
23137 octave_value_list *_outp=&_out;
23138 octave_value _outv;
23144 _outv = octave_value();
23152 octave_value_list _out;
23153 octave_value_list *_outp=&_out;
23154 octave_value _outv;
23160 _outv = octave_value();
23168 char *arg1 = (
char *) 0 ;
23169 char *arg2 = (
char *) 0 ;
23176 octave_value_list _out;
23177 octave_value_list *_outp=&_out;
23178 octave_value _outv;
23187 arg1 = (
char *)(buf1);
23192 arg2 = (
char *)(buf2);
23193 plSetUsage((
char const *)arg1,(
char const *)arg2);
23194 _outv = octave_value();
23204 octave_value_list _out;
23205 octave_value_list *_outp=&_out;
23206 octave_value _outv;
23212 _outv = octave_value();
23221 {
"testppchar",_wrap_testppchar,0,0,2,0},
23223 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
23226 {
"plcont0",_wrap_plcont0,0,0,2,0},
23227 {
"plcont1",_wrap_plcont1,0,0,2,0},
23228 {
"plcont2",_wrap_plcont2,0,0,2,0},
23229 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
23239 {
"plshade1",_wrap_plshade1,0,0,2,_wrap_plshade1_texinfo},
23240 {
"plshade2",_wrap_plshade2,0,0,2,0},
23242 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
23243 {
"plshades1",_wrap_plshades1,0,0,2,0},
23244 {
"plshades2",_wrap_plshades2,0,0,2,0},
23246 {
"plvect1",_wrap_plvect1,0,0,2,0},
23247 {
"plvect2",_wrap_plvect2,0,0,2,0},
23248 {
"pplimage",_wrap_pplimage,0,0,2,0},
23250 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
23251 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
23252 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
23387 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
23538 #define SWIGRUNTIME_DEBUG
23548 clientdata = clientdata;
23551 if (swig_module.
next==0) {
23563 if (!module_head) {
23573 if (iter==&swig_module) {
23578 }
while (iter!= module_head);
23583 swig_module.
next = module_head->
next;
23591 if (init == 0)
return;
23594 #ifdef SWIGRUNTIME_DEBUG
23595 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
23597 for (i = 0; i < swig_module.
size; ++i) {
23602 #ifdef SWIGRUNTIME_DEBUG
23603 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
23607 if (swig_module.
next != &swig_module) {
23612 #ifdef SWIGRUNTIME_DEBUG
23613 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
23617 #ifdef SWIGRUNTIME_DEBUG
23618 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
23627 while (cast->
type) {
23631 #ifdef SWIGRUNTIME_DEBUG
23632 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
23634 if (swig_module.
next != &swig_module) {
23636 #ifdef SWIGRUNTIME_DEBUG
23637 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
23642 #ifdef SWIGRUNTIME_DEBUG
23643 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
23650 #ifdef SWIGRUNTIME_DEBUG
23651 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
23653 if (!ocast) ret = 0;
23658 #ifdef SWIGRUNTIME_DEBUG
23659 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
23670 swig_module.
types[i] = type;
23672 swig_module.
types[i] = 0;
23674 #ifdef SWIGRUNTIME_DEBUG
23675 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23676 for (i = 0; i < swig_module.
size; ++i) {
23679 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
23680 while (cast->
type) {
23681 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
23685 printf(
"---- Total casts: %d\n",j);
23687 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23700 static int init_run = 0;
23702 if (init_run)
return;
23705 for (i = 0; i < swig_module.
size; i++) {
23713 equiv = equiv->
next;
23731 octave_value_list args;
23733 args.append(octloadfcn->fcn_file_name());
23734 feval(
"autoload", args, 0);
23738 @deftypefn {Loadable Function} {} subclass()\n\
23739 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
23740 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
23742 See the SWIG manual for usage examples.\n\
23747 for (
int j = 0; j < args.length(); ++j) {
23748 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
23751 if (!ost->is_owned()) {
23752 error(
"cannot subclass object not constructed on octave side");
23753 return octave_value_list();
23756 }
else if (args(j).is_function_handle()) {
23757 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
23758 }
else if (args(j).is_string()) {
23759 if (j + 1 >= args.length()) {
23760 error(
"member assignments must be of string,value form");
23761 return octave_value_list();
23763 top->
assign(args(j).string_value(), args(j + 1));
23766 error(
"invalid arguments to subclass()");
23767 return octave_value_list();
23774 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
23775 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
23779 if (args.length() != 1) {
23780 error(
"swig_type() must be called with only a single object");
23781 return octave_value_list();
23785 error(
"object is not a swig_ref");
23786 return octave_value_list();
23792 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
23793 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
23794 otherwise return `<unknown>'.\n\
23797 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
23798 if (args.length() != 1 || !args(0).is_string()) {
23799 error(
"swig_typequery() must be called with single string argument");
23800 return octave_value_list();
23805 return octave_value(
"<unknown>");
23806 return octave_value(type->
name);
23810 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
23811 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
23815 if (args.length() != 1) {
23816 error(
"swig_this() must be called with only a single object");
23817 return octave_value_list();
23819 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
23820 return octave_value(octave_uint64(0));
23823 error(
"object is not a swig_ref");
23824 return octave_value_list();
23826 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
23833 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
23834 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
23835 #define SWIG_OCTAVE_SEGFAULT_HACK
23838 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23839 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
23840 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
23842 _exit(exit_status);
23847 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
23848 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
23850 To load the module into the global namespace:\n\
23854 To access the module through a local variable, without loading it globally:\n\
23858 To access the module locally through a variable named, e.g. @var{modl}:\n\
23867 octave_value_list retval;
23872 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23878 #if OCTAVE_API_VERSION_NUMBER >= 37
23879 octave_value_list eval_args;
23880 eval_args.append(
"base");
23881 eval_args.append(
"function __swig_atexit__; "
23888 "__swig_atexit__; "
23889 "atexit(\"__swig_atexit__\", false); "
23890 "atexit(\"__swig_atexit__\")");
23891 feval(
"evalin", eval_args, 0);
23894 octave_swig_ref::register_type();
23895 octave_swig_packed::register_type();
23899 octave_function *me = octave_call_stack::current();
23909 for (
int j=0;swig_globals[j].
name;++j)
23911 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23919 for (
int j=0;swig_globals[j].
name;++j)
23921 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23923 for (
int j=0;swig_globals[j].
name;++j)
23924 if (swig_globals[j].
method)
23925 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23930 for (
int j=0;swig_types[j];++j)
23931 if (swig_types[j]->clientdata) {
23942 #if OCTAVE_API_VERSION_NUMBER < 37
23951 if (args.length() == 0 && nargout == 1) {
23952 retval = octave_value(module_ns->
as_value());
23956 else if (args.length() == 0 && nargout == 0) {
23958 octave_function *me = octave_call_stack::current();
23962 if (mb->second.first && mb->second.first->method) {
23965 else if (mb->second.second.is_defined()) {