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();
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 f: Always use fixed point numeric labels. \n\
8158 i: Inverts tick marks, so they are drawn downwards, rather\n\
8160 l: Labels axis logarithmically. This only affects the labels,\n\
8161 not the data, and so it is necessary to compute the logarithms\n\
8162 of data points before passing them to any of the drawing\n\
8164 n: Writes numeric labels at major tick intervals. \n\
8165 o: Use custom labelling function to generate axis label text. \n\
8166 The custom labelling function can be defined with the\n\
8167 plslabelfunc command. \n\
8168 s: Enables subticks between major ticks, only valid if t is\n\
8170 t: Draws major ticks. \n\
8171 u: If this is specified, the text label for the axis is\n\
8172 written under the axis. \n\
8175 xlabel (const char *, input) : Pointer to character string\n\
8176 specifying text label for the x axis. It is only drawn if u is in\n\
8177 the xopt string. \n\
8179 xtick (PLFLT, input) : World coordinate interval between major\n\
8180 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8181 generates a suitable tick interval. \n\
8183 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8184 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8185 generates a suitable minor tick interval. \n\
8187 yopt (const char *, input) : Pointer to character string specifying\n\
8188 options for the y axis. The string is interpreted in the same way\n\
8191 ylabel (const char *, input) : Pointer to character string\n\
8192 specifying text label for the y axis. It is only drawn if u is in\n\
8193 the yopt string. \n\
8195 ytick (PLFLT, input) : World coordinate interval between major\n\
8196 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8197 generates a suitable tick interval. \n\
8199 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8200 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8201 generates a suitable minor tick interval. \n\
8203 zopt (const char *, input) : Pointer to character string specifying\n\
8204 options for the z axis. The string can include any combination of\n\
8205 the following letters (upper or lower case) in any order: b: Draws\n\
8206 z axis to the left of the surface plot. \n\
8207 c: Draws z axis to the right of the surface plot. \n\
8208 d: Draws grid lines parallel to the x-y plane behind the\n\
8209 figure. These lines are not drawn until after plot3d or\n\
8210 plmesh are called because of the need for hidden line removal. \n\
8211 f: Always use fixed point numeric labels. \n\
8212 i: Inverts tick marks, so they are drawn away from the center. \n\
8213 l: Labels axis logarithmically. This only affects the labels,\n\
8214 not the data, and so it is necessary to compute the logarithms\n\
8215 of data points before passing them to any of the drawing\n\
8217 m: Writes numeric labels at major tick intervals on the\n\
8218 right-hand vertical axis. \n\
8219 n: Writes numeric labels at major tick intervals on the\n\
8220 left-hand vertical axis. \n\
8221 o: Use custom labelling function to generate axis label text. \n\
8222 The custom labelling function can be defined with the\n\
8223 plslabelfunc command. \n\
8224 s: Enables subticks between major ticks, only valid if t is\n\
8226 t: Draws major ticks. \n\
8227 u: If this is specified, the text label is written beside the\n\
8229 v: If this is specified, the text label is written beside the\n\
8230 right-hand axis. \n\
8233 zlabel (const char *, input) : Pointer to character string\n\
8234 specifying text label for the z axis. It is only drawn if u or v\n\
8235 are in the zopt string. \n\
8237 ztick (PLFLT, input) : World coordinate interval between major\n\
8238 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8239 generates a suitable tick interval. \n\
8241 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8242 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8243 generates a suitable minor tick interval. \n\
8246 Get character default height and current (scaled) height \n\
8250 Get character default height and current (scaled) height. \n\
8252 Redacted form: plgchr(p_def, p_ht)\n\
8254 This function is used in example 23. \n\
8260 plgchr(p_def, p_ht)\n\
8264 p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
8266 p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
8270 Set the escape character for text strings \n\
8274 Set the escape character for text strings.\tFrom C (in contrast to\n\
8275 Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8276 selected characters are allowed to prevent the user from shooting\n\
8277 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8278 with C\'s use of backslash as a character escape). Here are the\n\
8279 allowed escape characters and their corresponding decimal ASCII\n\
8280 values: !, ASCII 33 \n\
8291 Redacted form: General: plsesc(esc)\n\
8292 \t Perl/PDL: Not available? \n\
8295 This function is used in example 29. \n\
8305 esc (char, input) : Escape character. \n\
8308 Draw a line between two points, accounting for coordinate transforms \n\
8312 Joins the point (\n\
8316 y2) . If a global coordinate transform is defined then the line is\n\
8317 broken in to n segments to approximate the path. If no transform is\n\
8318 defined then this simply acts like a call to pljoin. \n\
8320 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8322 This function is used in example 22. \n\
8328 plpath(n, x1, y1, x2, y2)\n\
8332 n (PLINT, input) : number of points to use to approximate the path. \n\
8334 x1 (PLFLT, input) : x coordinate of first point. \n\
8336 y1 (PLFLT, input) : y coordinate of first point. \n\
8338 x2 (PLFLT, input) : x coordinate of second point. \n\
8340 y2 (PLFLT, input) : y coordinate of second point. \n\
8343 Set up standard window and draw box \n\
8347 Sets up plotter environment for simple graphs by calling pladv and\n\
8348 setting up viewport and window to sensible default values.\tplenv\n\
8349 leaves enough room around most graphs for axis labels and a title.\n\
8350 When these defaults are not suitable, use the individual routines\n\
8351 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
8352 defining the window, and plbox for drawing the box. \n\
8354 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8356 This function is used in example 1,3,9,13,14,19-22,29. \n\
8362 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8366 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8367 world coordinates). \n\
8369 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8370 world coordinates). \n\
8372 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8375 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8378 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8379 scales will not be set, the user must set up the scale before\n\
8380 calling plenv using plsvpa, plvasp or other. \n\
8381 0: the x and y axes are scaled independently to use as much of\n\
8382 the screen as possible. \n\
8383 1: the scales of the x and y axes are made equal. \n\
8384 2: the axis of the x and y axes are made equal, and the plot\n\
8385 box will be square. \n\
8388 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8389 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
8390 -1: draw box only. \n\
8391 0: draw box, ticks, and numeric tick labels. \n\
8392 1: also draw coordinate axes at x=0 and y=0. \n\
8393 2: also draw a grid at major tick positions in both\n\
8395 3: also draw a grid at minor tick positions in both\n\
8397 10: same as 0 except logarithmic x tick marks. (The x data\n\
8398 have to be converted to logarithms separately.) \n\
8399 11: same as 1 except logarithmic x tick marks. (The x data\n\
8400 have to be converted to logarithms separately.) \n\
8401 12: same as 2 except logarithmic x tick marks. (The x data\n\
8402 have to be converted to logarithms separately.) \n\
8403 13: same as 3 except logarithmic x tick marks. (The x data\n\
8404 have to be converted to logarithms separately.) \n\
8405 20: same as 0 except logarithmic y tick marks. (The y data\n\
8406 have to be converted to logarithms separately.) \n\
8407 21: same as 1 except logarithmic y tick marks. (The y data\n\
8408 have to be converted to logarithms separately.) \n\
8409 22: same as 2 except logarithmic y tick marks. (The y data\n\
8410 have to be converted to logarithms separately.) \n\
8411 23: same as 3 except logarithmic y tick marks. (The y data\n\
8412 have to be converted to logarithms separately.) \n\
8413 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8414 and y data have to be converted to logarithms separately.) \n\
8415 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8416 and y data have to be converted to logarithms separately.) \n\
8417 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8418 and y data have to be converted to logarithms separately.) \n\
8419 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8420 and y data have to be converted to logarithms separately.) \n\
8421 40: same as 0 except date / time x labels. \n\
8422 41: same as 1 except date / time x labels. \n\
8423 42: same as 2 except date / time x labels. \n\
8424 43: same as 3 except date / time x labels. \n\
8425 50: same as 0 except date / time y labels. \n\
8426 51: same as 1 except date / time y labels. \n\
8427 52: same as 2 except date / time y labels. \n\
8428 53: same as 3 except date / time y labels. \n\
8429 60: same as 0 except date / time x and y labels. \n\
8430 61: same as 1 except date / time x and y labels. \n\
8431 62: same as 2 except date / time x and y labels. \n\
8432 63: same as 3 except date / time x and y labels. \n\
8433 70: same as 0 except custom x and y labels. \n\
8434 71: same as 1 except custom x and y labels. \n\
8435 72: same as 2 except custom x and y labels. \n\
8436 73: same as 3 except custom x and y labels. \n\
8439 Grid data from irregularly sampled data \n\
8443 Real world data is frequently irregularly sampled, but all PLplot 3D\n\
8444 plots require data placed in a uniform grid. This function takes\n\
8445 irregularly sampled data from three input arrays x[npts], y[npts], and\n\
8446 z[npts], reads the desired grid location from input arrays xg[nptsx]\n\
8447 and yg[nptsy], and returns the gridded data into output array\n\
8448 zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n\
8449 with the argument type which can have one parameter specified in\n\
8452 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8453 \t Perl/PDL: Not available? \n\
8454 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8457 This function is used in example 21. \n\
8463 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8467 x (const PLFLT *, input) : The input x array. \n\
8469 y (const PLFLT *, input) : The input y array. \n\
8471 z (const PLFLT *, input) : The input z array. Each triple x[i],\n\
8472 y[i], z[i] represents one data sample coordinate. \n\
8474 npts (PLINT, input) : The number of data samples in the x, y and z\n\
8477 xg (const PLFLT *, input) : The input array that specifies the grid\n\
8478 spacing in the x direction. Usually xg has nptsx equally spaced\n\
8479 values from the minimum to the maximum values of the x input\n\
8482 nptsx (PLINT, input) : The number of points in the xg array. \n\
8484 yg (const PLFLT *, input) : The input array that specifies the grid\n\
8485 spacing in the y direction. Similar to the xg parameter. \n\
8487 nptsy (PLINT, input) : The number of points in the yg array. \n\
8489 zg (PLFLT **, output) : The output array, where data lies in the\n\
8490 regular grid specified by xg and yg. the zg array must exist or be\n\
8491 allocated by the user prior to the call, and must have dimension\n\
8492 zg[nptsx][nptsy]. \n\
8494 type (PLINT, input) : The type of gridding algorithm to use, which\n\
8495 can be: GRID_CSA: Bivariate Cubic Spline approximation \n\
8496 GRID_DTLI: Delaunay Triangulation Linear Interpolation \n\
8497 GRID_NNI: Natural Neighbors Interpolation \n\
8498 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n\
8499 GRID_NNLI: Nearest Neighbors Linear Interpolation \n\
8500 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8502 For details of the algorithms read the source file plgridd.c. \n\
8504 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8505 which can be specified through this argument. Currently, for\n\
8506 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8507 use, the lower the value, the noisier (more local) the\n\
8508 approximation is. \n\
8509 GRID_NNLI, data specifies what a thin triangle is, in the\n\
8510 range [1. .. 2.]. High values enable the usage of very thin\n\
8511 triangles for interpolation, possibly resulting in error in\n\
8512 the approximation. \n\
8513 GRID_NNI, only weights greater than data will be accepted. If\n\
8514 0, all weights will be accepted. \n\
8517 Clear current (sub)page \n\
8521 Clears the current page, effectively erasing everything that have been\n\
8522 drawn. This command only works with interactive drivers; if the\n\
8523 driver does not support this, the page is filled with the background\n\
8524 color in use. If the current page is divided into subpages, only the\n\
8525 current subpage is erased.\tThe nth subpage can be selected with\n\
8528 Redacted form: General: plclear()\n\
8529 \t Perl/PDL: Not available? \n\
8532 This function is not used in any examples. \n\
8541 Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n\
8545 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8546 and floating point alpha transparency value. This sets the entire\n\
8547 color map -- only as many colors as specified will be allocated. \n\
8549 Redacted form: plscmap0a(r, g, b, alpha)\n\
8551 This function is used in examples 30. \n\
8557 plscmap0a(r, g, b, alpha, ncol0)\n\
8561 r (const PLINT *, input) : Pointer to array with set of unsigned\n\
8562 8-bit integers (0-255) representing the degree of red in the\n\
8565 g (const PLINT *, input) : Pointer to array with set of unsigned\n\
8566 8-bit integers (0-255) representing the degree of green in the\n\
8569 b (const PLINT *, input) : Pointer to array with set of unsigned\n\
8570 8-bit integers (0-255) representing the degree of blue in the\n\
8573 alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n\
8574 values (0.0 - 1.0) representing the alpha transparency of the\n\
8577 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8581 Set 8-bit RGB values for given cmap0 color index \n\
8585 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8586 index. Overwrites the previous color value for the given index and,\n\
8587 thus, does not result in any additional allocation of space for\n\
8590 Redacted form: plscol0(icol0, r, g, b)\n\
8592 This function is used in any example 31. \n\
8598 plscol0(icol0, r, g, b)\n\
8602 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8603 number of colors (which is set by default, by plscmap0n, or even\n\
8606 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8607 degree of red in the color. \n\
8609 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8610 degree of green in the color. \n\
8612 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8613 degree of blue in the color. \n\
8616 Set up transformation from metafile coordinates \n\
8620 Set up transformation from metafile coordinates. The size of the plot\n\
8621 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8622 general-purpose facility just yet (not sure why the user would need\n\
8625 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8628 This function is not used in any examples. \n\
8634 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8638 dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
8640 dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
8642 dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
8644 dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
8646 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8648 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8651 Creates a new stream and makes it the default \n\
8655 Creates a new stream and makes it the default. Differs from using\n\
8656 plsstrm, in that a free stream number is found, and returned.\n\
8657 Unfortunately, I have to start at stream 1 and work upward, since\n\
8658 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8659 that no initial, library-opening call is required.\tSo stream 0 must\n\
8660 be preallocated, and there is no simple way of determining whether it\n\
8661 is already in use or not. \n\
8663 Redacted form: plmkstrm(p_strm)\n\
8665 This function is used in examples 1,20. \n\
8675 p_strm (PLINT *, output) : Pointer to stream number of the created\n\
8679 Get page parameters \n\
8683 Gets the current page configuration. The length and offset values are\n\
8684 expressed in units that are specific to the current driver. For\n\
8685 instance: screen drivers will usually interpret them as number of\n\
8686 pixels, whereas printer drivers will usually use mm. \n\
8688 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8690 This function is used in examples 14 and 31. \n\
8696 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8700 p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
8702 p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n\
8705 p_xleng (PLINT *, output) : Pointer to x page length value. \n\
8707 p_yleng (PLINT *, output) : Pointer to y page length value. \n\
8709 p_xoff (PLINT *, output) : Pointer to x page offset. \n\
8711 p_yoff (PLINT *, output) : Pointer to y page offset. \n\
8714 Set format for date / time labels \n\
8718 Sets the format for date / time labels. To enable date / time format\n\
8719 labels see the options to plbox and plenv. \n\
8721 Redacted form: pltimefmt(fmt)\n\
8723 This function is used in example 29. \n\
8733 fmt (const char *, fmt) : This string is passed directly to the\n\
8734 system strftime. See the system documentation for a full list of\n\
8735 conversion specifications for your system. All conversion\n\
8736 specifications take the form of a \'%\' character followed by\n\
8737 further conversion specification character. All other text is\n\
8738 printed as-is. Common options include: %c: The preferred date and\n\
8739 time representation for the current locale. \n\
8740 %d: The day of the month as a decimal number. \n\
8741 %H: The hour as a decimal number using a 24-hour clock. \n\
8742 %j: The day of the year as a decimal number. \n\
8743 %m: The month as a decimal number. \n\
8744 %M: The minute as a decimal number. \n\
8745 %S: The second as a decimal number. \n\
8746 %y: The year as a decimal number without a century. \n\
8747 %Y: The year as a decimal number including a century. \n\
8750 Specify viewport using aspect ratio only \n\
8754 Sets the viewport so that the ratio of the length of the y axis to\n\
8755 that of the x axis is equal to aspect. \n\
8757 Redacted form: plvasp(aspect)\n\
8759 This function is used in example 13. \n\
8769 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8773 Set output file name \n\
8777 Sets the current output file name, if applicable. If the file name\n\
8778 has not been specified and is required by the driver, the user will be\n\
8779 prompted for it. If using the X-windows output driver, this sets the\n\
8780 display name. This routine, if used, must be called before\n\
8781 initializing PLplot. \n\
8783 Redacted form: plsfnam(fnam)\n\
8785 This function is used in examples 1,20. \n\
8795 fnam (const char *, input) : Pointer to file name string. \n\
8802 Draws a vector plot of the vector (\n\
8808 ny]) . The scaling factor for the vectors is given by scale. A\n\
8809 transformation routine pointed to by pltr with a pointer pltr_data for\n\
8810 additional data required by the transformation routine is used to map\n\
8811 indices within the array to the world coordinates. The style of the\n\
8812 vector arrow may be set using plsvect. \n\
8814 Redacted form: plvect(u, v, scale, pltr, pltr_data)\n\
8816 This function is used in example 22. \n\
8822 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
8826 u, v (const PLFLT * const *, input) : Pointers to a pair of\n\
8827 vectored two-dimensional arrays containing the x and y components\n\
8828 of the vector data to be plotted. \n\
8830 nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n\
8832 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
8833 the vectors for plotting. If scale = 0 then the scaling factor is\n\
8834 automatically calculated for the data. If scale < 0 then the\n\
8835 scaling factor is automatically calculated for the data and then\n\
8837 scale. If scale > 0 then the scaling factor is set to scale. \n\
8839 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8840 Pointer to function that defines transformation between indices\n\
8841 in array z and the world coordinates (C only). Transformation\n\
8842 functions are provided in the PLplot library: pltr0 for identity\n\
8843 mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
8844 defined by one- and two-dimensional arrays. In addition,\n\
8845 user-supplied routines for the transformation can be used as well.\n\
8846 Examples of all of these approaches are given in the PLplot\n\
8847 documentation. The transformation function should have the form\n\
8848 given by any of pltr0, pltr1, or pltr2. \n\
8850 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8851 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8852 externally supplied. \n\
8855 Set parameters that define current plot-space window \n\
8859 Set relative minima and maxima that define the current plot-space\n\
8860 window. If plsdiplt is not called the default values of xmin, ymin,\n\
8861 xmax, and ymax are 0., 0., 1., and 1. \n\
8863 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
8865 This function is used in example 31. \n\
8871 plsdiplt(xmin, ymin, xmax, ymax)\n\
8875 xmin (PLFLT, input) : Relative minimum in x. \n\
8877 ymin (PLFLT, input) : Relative minimum in y. \n\
8879 xmax (PLFLT, input) : Relative maximum in x. \n\
8881 ymax (PLFLT, input) : Relative maximum in y. \n\
8884 Select line style \n\
8888 This sets the line style according to one of eight predefined patterns\n\
8889 (also see plstyl). \n\
8891 Redacted form: pllsty(lin)\n\
8893 This function is used in examples 9,12,22,25. \n\
8903 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
8904 a continuous line, line style 2 is a line with short dashes and\n\
8905 gaps, line style 3 is a line with long dashes and gaps, line style\n\
8906 4 has long dashes and short gaps and so on. \n\
8909 Plot a glyph at the specified points \n\
8913 Plot a glyph at the specified points. (This function is largely\n\
8914 superseded by plstring which gives access to many[!] more glyphs.) \n\
8916 Redacted form: plsym(x, y, code)\n\
8918 This function is used in example 7. \n\
8924 plsym(n, x, y, code)\n\
8928 n (PLINT, input) : Number of points in the x and y arrays. \n\
8930 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
8933 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
8936 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
8937 to be plotted at each of the n points. \n\
8940 Set the device (keyword) name \n\
8944 Set the device (keyword) name. \n\
8946 Redacted form: plsdev(devname)\n\
8948 This function is used in examples 1,14,20. \n\
8958 devname (const char *, input) : Pointer to device (keyword) name\n\
8962 Set the background color by 8-bit RGB value \n\
8966 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
8967 (see the PLplot documentation). \n\
8969 Redacted form: plscolbg(r, g, b)\n\
8971 This function is used in examples 15,31. \n\
8977 plscolbg(r, g, b)\n\
8981 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8982 degree of red in the color. \n\
8984 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8985 degree of green in the color. \n\
8987 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8988 degree of blue in the color. \n\
8991 Set parameters incrementally (zoom mode) that define current plot-space window \n\
8995 Set relative minima and maxima incrementally (zoom mode) that define\n\
8996 the current plot-space window. This function has the same effect as\n\
8997 plsdiplt if that function has not been previously called. Otherwise,\n\
8998 this function implements zoom mode using the transformation min_used =\n\
8999 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9000 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9001 repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
9003 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9005 This function is used in example 31. \n\
9011 plsdiplz(xmin, ymin, xmax, ymax)\n\
9015 xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
9017 ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
9019 xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
9021 ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
9024 Advance to the next family file on the next new page \n\
9028 Advance to the next family file on the next new page. \n\
9030 Redacted form: plfamadv()\n\
9032 This function is not used in any examples. \n\
9041 Set number of colors in cmap0 \n\
9045 Set number of colors in color map0 (see the PLplot documentation).\n\
9046 Allocate (or reallocate) color map0, and fill with default values for\n\
9047 those colors not previously allocated. The first 16 default colors are\n\
9048 given in the plcol0 documentation. For larger indices the default\n\
9051 The drivers are not guaranteed to support more than 16 colors. \n\
9053 Redacted form: plscmap0n(ncol0)\n\
9055 This function is used in examples 15,16,24. \n\
9065 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9066 the map0 palette. If this number is zero or less, then the value\n\
9067 from the previous call to plscmap0n is used and if there is no\n\
9068 previous call, then a default value is used. \n\
9071 Plot latitude and longitude lines \n\
9075 Displays latitude and longitude on the current plot. The lines are\n\
9076 plotted in the current color and line style. \n\
9078 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9081 This function is used in example 19. \n\
9087 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9091 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9092 supplied function to transform the coordinate longitudes and\n\
9093 latitudes to a plot coordinate system. By using this transform, we\n\
9094 can change from a longitude, latitude coordinate to a polar\n\
9095 stereographic project, for example. Initially, x[0]..[n-1] are\n\
9096 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9097 After the call to mapform(), x[] and y[] should be replaced by the\n\
9098 corresponding plot coordinates. If no transform is desired,\n\
9099 mapform can be replaced by NULL. \n\
9101 dlong (PLFLT, input) : The interval in degrees at which the\n\
9102 longitude lines are to be plotted. \n\
9104 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9105 lines are to be plotted. \n\
9107 minlong (PLFLT, input) : The value of the longitude on the left\n\
9108 side of the plot. The value of minlong must be less than the value\n\
9109 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9112 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9113 side of the plot. \n\
9115 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9116 background. One can always use -90.0 as the boundary outside the\n\
9117 plot window will be automatically eliminated. However, the\n\
9118 program will be faster if one can reduce the size of the\n\
9119 background plotted. \n\
9121 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9122 background. One can always use 90.0 as the boundary outside the\n\
9123 plot window will be automatically eliminated. \n\
9126 Convert RGB color to HLS \n\
9130 Convert RGB color coordinates to HLS \n\
9132 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9133 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
9136 This function is used in example 2. \n\
9142 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9146 r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
9148 g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
9150 b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
9152 p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
9153 cone (0.0-360.0) \n\
9155 p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
9156 fraction of the axis of the colour cone (0.0-1.0) \n\
9158 p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
9159 fraction of the radius of the colour cone (0.0-1.0) \n\
9162 Plot a glyph at the specified 3D points \n\
9166 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9167 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9168 this function similar to what is done for plline3. The glyph is\n\
9169 specified with a PLplot user string. Note that the user string is not\n\
9170 actually limited to one glyph so it is possible (but not normally\n\
9171 useful) to plot more than one glyph at the specified points with this\n\
9172 function. As with plmtex and plptex, the user string can contain FCI\n\
9173 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9174 else PLplot escapes for Hershey or unicode text to determine the\n\
9177 Redacted form: plstring3(x, y, z, string)\n\
9179 This function is used in example 18. \n\
9185 plstring3(n, x, y, z, string)\n\
9189 n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
9191 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9194 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9197 z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9200 string (const char *, input) : PLplot user string corresponding to\n\
9201 the glyph to be plotted at each of the n points. \n\
9204 Switch to text screen \n\
9208 Sets an interactive device to text mode, used in conjunction with\n\
9209 plgra to allow graphics and text to be interspersed. On a device\n\
9210 which supports separate text and graphics windows, this command causes\n\
9211 control to be switched to the text window.\tThis can be useful for\n\
9212 printing diagnostic messages or getting user input, which would\n\
9213 otherwise interfere with the plots. The program must switch back to\n\
9214 the graphics window before issuing plot commands, as the text (or\n\
9215 console) device will probably become quite confused otherwise. If\n\
9216 already in text mode, this command is ignored. It is also ignored on\n\
9217 devices which only support a single window or use a different method\n\
9218 for shifting focus (see also plgra). \n\
9220 Redacted form: pltext()\n\
9222 This function is used in example 1. \n\
9231 Get parameters that define current plot-space window \n\
9235 Get relative minima and maxima that define current plot-space window.\n\
9236 If plsdiplt has not been called the default values pointed to by\n\
9237 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
9239 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9241 This function is used in example 31. \n\
9247 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9251 p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
9253 p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
9255 p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
9257 p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
9260 Get the (current) run level \n\
9264 Get the (current) run level. Valid settings are: 0, uninitialized \n\
9265 \t 1,\tinitialized \n\
9266 \t 2,\tviewport defined \n\
9267 \t 3,\tworld coordinates defined \n\
9270 Redacted form: plglevel(p_level)\n\
9272 This function is used in example 31. \n\
9278 plglevel(p_level)\n\
9282 p_level (PLINT *, output) : Pointer to the run level. \n\
9285 Plot a histogram from binned data \n\
9289 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9290 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9291 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9292 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9293 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9294 placed midway between the values in the x array. Also see plhist for\n\
9295 drawing histograms from unbinned data. \n\
9297 Redacted form: General: plbin(x, y, opt)\n\
9298 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9299 \t Python: plbin(nbin, x, y, opt)\n\
9302 This function is not used in any examples. \n\
9308 plbin(nbin, x, y, opt)\n\
9312 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9315 x (const PLFLT *, input) : Pointer to array containing values\n\
9316 associated with bins. These must form a strictly increasing\n\
9319 y (const PLFLT *, input) : Pointer to array containing number of\n\
9320 points in bin. This is a PLFLT (instead of PLINT) array so as to\n\
9321 allow histograms of probabilities, etc. \n\
9323 opt (PLINT, input) : Is a combination of several flags:\n\
9324 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9325 outer bins are expanded to fill up the entire x-axis and bins of\n\
9326 zero height are simply drawn. \n\
9327 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9328 between the x values. If the values in x are equally spaced,\n\
9329 the values are the center values of the bins. \n\
9330 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9331 size as the ones inside. \n\
9332 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9333 (there is a gap for such bins). \n\
9336 Plot a 2D matrix using cmap1 \n\
9340 Plot a 2D matrix using cmap1. \n\
9342 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n\
9343 zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n\
9346 This function is used in example 20. \n\
9352 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9356 idata (const PLFLT * const *, input) : A 2D array of values\n\
9357 (intensities) to plot. Should have dimensions idata[nx][ny]. \n\
9359 nx, ny (PLINT, input) : Dimensions of idata \n\
9361 xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n\
9362 Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n\
9363 idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n\
9365 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9366 (inclusive) will be plotted. \n\
9368 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9369 values to use for value to color mappings. A datum equal to or\n\
9370 less than valuemin will be plotted with color 0.0, while a datum\n\
9371 equal to or greater than valuemax will be plotted with color 1.0. \n\
9372 Data between valuemin and valuemax map linearly to colors between\n\
9375 pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
9376 Pointer to function that defines a transformation between the\n\
9377 data in the array idata and world coordinates. An input\n\
9378 coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n\
9379 while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n\
9380 Some transformation functions are provided in the PLplot library:\n\
9381 pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n\
9382 mappings respectively defined by one- and two-dimensional arrays. \n\
9383 In addition, user-supplied routines for the transformation can be\n\
9384 used as well. Examples of all of these approaches are given in\n\
9385 the PLplot documentation. The transformation function should have\n\
9386 the form given by any of pltr0, pltr1, or pltr2. \n\
9388 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9389 information to pltr0, pltr1, pltr2, or whatever routine is\n\
9390 externally supplied. \n\
9393 Get family, style and weight of the current font \n\
9397 Gets information about current font. See the PLplot documentation for\n\
9398 more information on font selection. \n\
9400 Redacted form: plgfont(p_family, p_style, p_weight)\n\
9402 This function is used in example 23. \n\
9408 plgfont(p_family, p_style, p_weight)\n\
9412 p_family (PLINT *, output) : Pointer to variable with the current\n\
9413 font family. The available values are given by the PL_FCI_*\n\
9414 constants in plplot.h. Current options are PL_FCI_SANS,\n\
9415 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9416 p_family is NULL then the font family is not returned. \n\
9418 p_style (PLINT *, output) : Pointer to variable with the current\n\
9419 font style. The available values are given by the PL_FCI_*\n\
9420 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9421 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
9422 font style is not returned. \n\
9424 p_weight (PLINT *, output) : Pointer to variable with the current\n\
9425 font weight. The available values are given by the PL_FCI_*\n\
9426 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9427 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9431 Get z axis parameters \n\
9435 Identical to plgxax, except that arguments are flags for z axis. See\n\
9436 the description of plgxax for more detail. \n\
9438 Redacted form: plgzax(p_digmax, p_digits)\n\
9440 This function is used in example 31. \n\
9446 plgzax(p_digmax, p_digits)\n\
9450 p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
9451 number of digits for the z axis. If nonzero, the printed label\n\
9452 has been switched to a floating point representation when the\n\
9453 number of digits exceeds p_digmax. \n\
9455 p_digits (PLINT *, output) : Pointer to variable with the actual\n\
9456 number of digits for the numeric labels (z axis) from the last\n\
9460 Write text inside the viewport of a 3D plot \n\
9464 Writes text at a specified position and inclination and with a\n\
9465 specified shear within the viewport. Text is clipped at the viewport\n\
9466 boundaries. The reference point of a string lies along a line passing\n\
9467 through the string at half the height of a capital letter.\tThe\n\
9468 position of the reference point along this line is determined by just,\n\
9469 and the reference point is placed at world coordinates (\n\
9472 wz) within the viewport. The inclination and shear of the string is\n\
9473 specified in terms of differences of world coordinates making it easy\n\
9474 to write text parallel to a line in a graph. \n\
9476 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n\
9478 This function is used in example 28. \n\
9484 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9488 wx (PLFLT, input) : x world coordinate of reference point of\n\
9491 wy (PLFLT, input) : y world coordinate of reference point of\n\
9494 wz (PLFLT, input) : z world coordinate of reference point of\n\
9497 dx (PLFLT, input) : Together with dy and \n\
9498 dz , this specifies the inclination of the string. The baseline of\n\
9499 the string is parallel to a line joining (\n\
9510 dy (PLFLT, input) : Together with dx and \n\
9511 dz, this specifies the inclination of the string. \n\
9513 dz (PLFLT, input) : Together with dx and \n\
9514 dy, this specifies the inclination of the string. \n\
9516 sx (PLFLT, input) : Together with sy and \n\
9517 sz , this specifies the shear of the string. The string is sheared so\n\
9518 that the characters are vertically parallel to a line joining (\n\
9529 sz = 0.) then the text is not sheared. \n\
9531 sy (PLFLT, input) : Together with sx and \n\
9532 sz, this specifies shear of the string. \n\
9534 sz (PLFLT, input) : Together with sx and \n\
9535 sy, this specifies shear of the string. \n\
9537 just (PLFLT, input) : Specifies the position of the string relative\n\
9538 to its reference point. If just=0. , the reference point is at\n\
9539 the left and if just=1. , it is at the right of the string. Other\n\
9540 values of just give intermediate justifications. \n\
9542 text (const char *, input) : The string to be written out. \n\
9545 Draw a box with axes, etc. with arbitrary origin \n\
9549 Draws a box around the currently defined viewport with arbitrary\n\
9550 world-coordinate origin specified by x0 and y0 and labels it with\n\
9551 world coordinate values appropriate to the window.\tThus plaxes should\n\
9552 only be called after defining both viewport and window. The character\n\
9553 strings xopt and yopt specify how the box should be drawn as described\n\
9554 below. If ticks and/or subticks are to be drawn for a particular\n\
9555 axis, the tick intervals and number of subintervals may be specified\n\
9556 explicitly, or they may be defaulted by setting the appropriate\n\
9557 arguments to zero. \n\
9559 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9561 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9565 This function is not used in any examples. \n\
9571 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9575 x0 (PLFLT, input) : World X coordinate of origin. \n\
9577 y0 (PLFLT, input) : World Y coordinate of origin. \n\
9579 xopt (const char *, input) : Pointer to character string specifying\n\
9580 options for horizontal axis. The string can include any\n\
9581 combination of the following letters (upper or lower case) in any\n\
9582 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
9583 is vertical line (x=0). \n\
9584 b: Draws bottom (X) or left (Y) edge of frame. \n\
9585 c: Draws top (X) or right (Y) edge of frame. \n\
9586 d: Plot labels as date / time. Values are assumed to be\n\
9587 seconds since the epoch (as used by gmtime). \n\
9588 f: Always use fixed point numeric labels. \n\
9589 g: Draws a grid at the major tick interval. \n\
9590 h: Draws a grid at the minor tick interval. \n\
9591 i: Inverts tick marks, so they are drawn outwards, rather than\n\
9593 l: Labels axis logarithmically. This only affects the labels,\n\
9594 not the data, and so it is necessary to compute the logarithms\n\
9595 of data points before passing them to any of the drawing\n\
9597 m: Writes numeric labels at major tick intervals in the\n\
9598 unconventional location (above box for X, right of box for Y). \n\
9599 n: Writes numeric labels at major tick intervals in the\n\
9600 conventional location (below box for X, left of box for Y). \n\
9601 o: Use custom labelling function to generate axis label text. \n\
9602 The custom labelling function can be defined with the\n\
9603 plslabelfunc command. \n\
9604 s: Enables subticks between major ticks, only valid if t is\n\
9606 t: Draws major ticks. \n\
9607 u: Exactly like \"b\" except don\'t draw edge line. \n\
9608 w: Exactly like \"c\" except don\'t draw edge line. \n\
9609 x: Exactly like \"t\" (including the side effect of the\n\
9610 numerical labels for the major ticks) except exclude drawing\n\
9611 the major and minor tick marks. \n\
9614 xtick (PLFLT, input) : World coordinate interval between major\n\
9615 ticks on the x axis. If it is set to zero, PLplot automatically\n\
9616 generates a suitable tick interval. \n\
9618 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9619 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9620 generates a suitable minor tick interval. \n\
9622 yopt (const char *, input) : Pointer to character string specifying\n\
9623 options for vertical axis. The string can include any combination\n\
9624 of the letters defined above for xopt, and in addition may\n\
9625 contain: v: Write numeric labels for vertical axis parallel to the\n\
9626 base of the graph, rather than parallel to the axis. \n\
9629 ytick (PLFLT, input) : World coordinate interval between major\n\
9630 ticks on the y axis. If it is set to zero, PLplot automatically\n\
9631 generates a suitable tick interval. \n\
9633 nysub (PLINT, input) : Number of subintervals between major y axis\n\
9634 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9635 generates a suitable minor tick interval. \n\
9638 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
9642 Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
9644 Redacted form: plgcolbg(r, g, b)\n\
9646 This function is used in example 31. \n\
9652 plgcolbg(r, g, b)\n\
9656 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9657 representing the degree of red in the color. \n\
9659 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9660 representing the degree of green in the color. \n\
9662 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9663 representing the degree of blue in the color. \n\
9666 Plot a glyph at the specified 3D points \n\
9670 Plot a glyph at the specified 3D points. (This function is largely\n\
9671 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9672 Set up the call to this function similar to what is done for plline3.\n\
9673 code=-1 means try to just draw a point. Right now it\'s just a move\n\
9674 and a draw at the same place. Not ideal, since a sufficiently\n\
9675 intelligent output device may optimize it away, or there may be faster\n\
9676 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9677 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9678 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9679 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9680 code <= 127 the corresponding printable ASCII character is plotted. \n\
9682 Redacted form: plpoin3(x, y, z, code)\n\
9684 This function is not used in any example. \n\
9690 plpoin3(n, x, y, z, code)\n\
9694 n (PLINT, input) : Number of points in the x and y arrays. \n\
9696 x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9699 y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9702 z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9705 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
9706 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
9707 each of the n points. \n\
9710 Draw a polygon in 3 space \n\
9714 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
9715 like plline3, but differs from that function in that plpoly3 attempts\n\
9716 to determine if the polygon is viewable depending on the order of the\n\
9717 points within the arrays and the value of ifcc. If the back of\n\
9718 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
9719 you want, then use plline3 instead. \n\
9721 The points are assumed to be in a plane, and the directionality of the\n\
9722 plane is determined from the first three points. Additional points do\n\
9723 not have to lie on the plane defined by the first three, but if they\n\
9724 do not, then the determination of visibility obviously can\'t be 100%\n\
9725 accurate... So if you\'re 3 space polygons are too far from planar,\n\
9726 consider breaking them into smaller polygons. 3 points define a plane\n\
9729 Bugs: If one of the first two segments is of zero length, or if they\n\
9730 are co-linear, the calculation of visibility has a 50/50 chance of\n\
9731 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
9732 of this problem. (Search for 20.1). \n\
9734 Redacted form: plpoly3(x, y, z, code)\n\
9736 This function is used in example 18. \n\
9742 plpoly3(n, x, y, z, draw, ifcc)\n\
9746 n (PLINT, input) : Number of points defining line. \n\
9748 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
9751 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9754 z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
9757 draw (const PLBOOL *, input) : Pointer to array which controls\n\
9758 drawing the segments of the polygon. If draw[i] is true, then the\n\
9759 polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n\
9761 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
9762 polygon is determined by assuming the points are laid out in a\n\
9763 counter-clockwise order. Otherwise, the directionality of the\n\
9764 polygon is determined by assuming the points are laid out in a\n\
9765 clockwise order. \n\
9768 Set the background color by 8-bit RGB value and double alpha transparency value. \n\
9772 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9773 (see the PLplot documentation) and double alpha transparency value. \n\
9775 This function is used in example 31. \n\
9781 plscolbga(r, g, b, alpha)\n\
9785 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9786 degree of red in the color. \n\
9788 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9789 degree of green in the color. \n\
9791 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9792 degree of blue in the color. \n\
9794 alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
9795 alpha transparency value of the color. \n\
9798 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n\
9802 Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
9803 alpha transparency value. \n\
9805 This function is used in example 31. \n\
9811 plgcolbga(r, g, b, alpha)\n\
9815 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9816 representing the degree of red in the color. \n\
9818 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9819 representing the degree of green in the color. \n\
9821 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9822 representing the degree of blue in the color. \n\
9824 alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
9828 Draw x error bar \n\
9832 Draws a set of n horizontal error bars, the i\'th error bar extending\n\
9833 from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
9834 error bar are of length equal to the minor tick length (settable using\n\
9837 Redacted form: General: plerrx(xmin, ymax, y)\n\
9838 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
9841 This function is used in example 29. \n\
9847 plerrx(n, xmin, xmax, y)\n\
9851 n (PLINT, input) : Number of error bars to draw. \n\
9853 xmin (const PLFLT *, input) : Pointer to array with x coordinates\n\
9854 of left-hand endpoint of error bars. \n\
9856 xmax (const PLFLT *, input) : Pointer to array with x coordinates\n\
9857 of right-hand endpoint of error bars. \n\
9859 y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9863 Eject current page \n\
9867 Clears the graphics screen of an interactive device, or ejects a page\n\
9868 on a plotter. See plbop for more information. \n\
9870 Redacted form: pleop()\n\
9872 This function is used in example 2,14. \n\
9881 Convert HLS color to RGB \n\
9885 Convert HLS color coordinates to RGB. \n\
9887 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9888 \t Perl/PDL: Not available? Implemented as plhls? \n\
9891 This function is used in example 2. \n\
9897 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9901 h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
9903 l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
9904 of the colour cone (0.0-1.0) \n\
9906 s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
9907 radius of the colour cone (0.0-1.0) \n\
9909 p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
9912 p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
9915 p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
9919 Plot all or a subset of Shapefile data, filling the polygons \n\
9923 As per plmapline, however the items are filled in the same way as\n\
9926 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
9929 This function is used in example 19. \n\
9935 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
9939 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9940 supplied function to transform the coordinates given in the\n\
9941 shapefile into a plot coordinate system. By using this transform,\n\
9942 we can change from a longitude, latitude coordinate to a polar\n\
9943 stereographic project, for example. Initially, x[0]..[n-1] are\n\
9944 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9945 After the call to mapform(), x[] and y[] should be replaced by the\n\
9946 corresponding plot coordinates. If no transform is desired,\n\
9947 mapform can be replaced by NULL. \n\
9949 name (const char *, input) : The file name of a set of Shapefile\n\
9950 files without the file extension. \n\
9952 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
9953 be in the same units as used by the Shapefile. You could use a\n\
9954 very large negative number to plot everything, but you can improve\n\
9955 performance by limiting the area drawn. The units must match those\n\
9956 of the Shapefile projection, which may be for example longitude or\n\
9957 distance. The value of minx must be less than the value of maxx. \n\
9959 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
9960 use a very large number to plot everything, but you can improve\n\
9961 performance by limiting the area drawn. \n\
9963 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
9964 be in the same units as used by the Shapefile. You could use a\n\
9965 very large negative number to plot everything, but you can improve\n\
9966 performance by limiting the area drawn. The units must match those\n\
9967 of the Shapefile projection, which may be for example latitude or\n\
9968 distance. The value of miny must be less than the value of maxy. \n\
9970 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
9971 use a very large number to plot everything, but you can improve\n\
9972 performance by limiting the area drawn. \n\
9974 plotentries (const PLINT *, input) : An array of integers\n\
9975 indicating the elements of the Shapefile (zero indexed) which will\n\
9976 be drawn. Setting plotentries to NULL will plot all elements of\n\
9979 nplotentries (PLINT, input) : The number of items in plotentries.\n\
9980 Ignored if plotentries is NULL. \n\
9983 Draw y error bar \n\
9987 Draws a set of n vertical error bars, the i\'th error bar extending\n\
9988 from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
9989 error bar are of length equal to the minor tick length (settable using\n\
9992 Redacted form: General: plerry(x, ymin, ymax)\n\
9993 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
9996 This function is used in example 29. \n\
10002 plerry(n, x, ymin, ymax)\n\
10006 n (PLINT, input) : Number of error bars to draw. \n\
10008 x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
10011 ymin (const PLFLT *, input) : Pointer to array with y coordinates\n\
10012 of lower endpoint of error bars. \n\
10014 ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n\
10015 upper endpoint of error bar. \n\
10018 Set FCI (font characterization integer) \n\
10022 Sets font characteristics to be used at the start of the next string\n\
10023 using the FCI approach. See the PLplot documentation for more\n\
10026 Redacted form: General: plsfci(fci)\n\
10027 \t Perl/PDL: Not available? \n\
10030 This function is used in example 23. \n\
10040 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10044 Select area fill pattern \n\
10048 Select one of eight predefined area fill patterns to use (also see\n\
10049 plpat). Setting the fill style to 0 gives a solid fill. \n\
10051 Redacted form: plpsty(patt)\n\
10053 This function is used in examples 12,13,15,16,25. \n\
10063 patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
10064 horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
10065 consists of lines at 45 degrees angle (upward), and so on. \n\
10068 Set symbol size \n\
10072 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10073 plsym. The actual height of a symbol is the product of the default\n\
10074 symbol size and a scaling factor as for the character height. \n\
10076 Redacted form: plssym(def, scale)\n\
10078 This function is used in example 29. \n\
10084 plssym(def, scale)\n\
10088 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10089 should be set to zero if the default height is to remain\n\
10092 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10093 actual symbol height. \n\
10100 Alternative to plstar for initializing the plotting package. The\n\
10101 device name keyword for the desired output device must be supplied as\n\
10102 an argument. These keywords are the same as those printed out by\n\
10103 plstar. If the requested device is not available, or if the input\n\
10104 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10105 is used. This routine also divides the output device page into nx by\n\
10106 ny subpages, each of which may be used independently. The subroutine\n\
10107 pladv is used to advance from one subpage to the next. \n\
10109 Redacted form: General: plstart(devname, nx, ny)\n\
10110 \t Perl/PDL: plstart(nx, ny, devname)\n\
10113 This function is not used in any examples. \n\
10119 plstart(devname, nx, ny)\n\
10123 devname (const char *, input) : Device name keyword of the required\n\
10124 output device. If NULL or if the first character is a ``?\'\', the\n\
10125 normal (prompted) start up is used. \n\
10127 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10128 horizontal direction. \n\
10130 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10131 vertical direction. \n\
10136 PLINT *arg2 = (PLINT *) 0 ;
10137 char **arg3 = (
char **) 0 ;
10139 octave_value_list _out;
10140 octave_value_list *_outp=&_out;
10141 octave_value _outv;
10147 if (
_n_dims( args(0) ) > 1 )
10151 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
10152 arg2 =
new PLINT[
Alen];
10153 temp1 = args(0).matrix_value();
10157 charMatrix temp_matrix;
10161 size_t max_length = 0, non_blank_length;
10163 if (
_n_dims( args(1) ) > 2 )
10165 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10167 if ( !args(1).is_empty() )
10169 if (
_dim( args(1), 0 ) != Alen )
10171 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10173 arg3 =
new char*[
Alen];
10174 ifcell = args(1).is_cell();
10177 temp_cell = args(1).cell_value();
10181 temp_matrix = args(1).char_matrix_value();
10183 max_length =
_dim( args(1), 1 ) + 1;
10186 for ( i = 0; i <
Alen; i++ )
10193 if ( temp_cell.elem( i ).is_string() )
10195 str = temp_cell.elem( i ).string_value();
10197 max_length = str.size() + 1;
10198 tmp_cstring = (
char *) str.c_str();
10208 tmp_cstring = (
char *)
"";
10213 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
10215 arg3[i] =
new char[max_length];
10216 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10217 arg3[i][max_length - 1] =
'\0';
10232 non_blank_length = max_length - 2;
10233 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10235 non_blank_length--;
10237 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10239 non_blank_length--;
10241 arg3[i][non_blank_length + 1] =
'\0';
10250 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10251 _outv = octave_value();
10258 if ( arg3 != NULL )
10260 for ( i = 0; i <
Alen; i++ )
10273 int *arg1 = (
int *) 0 ;
10274 int *arg2 = (
int *) 0 ;
10275 int *arg3 = (
int *) 0 ;
10276 char *arg4 = (
char *) 0 ;
10277 int *arg5 = (
int *) 0 ;
10278 int *arg6 = (
int *) 0 ;
10279 PLFLT *arg7 = (PLFLT *) 0 ;
10280 PLFLT *arg8 = (PLFLT *) 0 ;
10281 PLFLT *arg9 = (PLFLT *) 0 ;
10282 PLFLT *arg10 = (PLFLT *) 0 ;
10283 int *arg11 = (
int *) 0 ;
10290 octave_value_list retval4 ;
10305 octave_value_list _out;
10306 octave_value_list *_outp=&_out;
10307 octave_value _outv;
10315 # if OCTAVE_API_VERSION_NUMBER < 45
10316 retval4( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
10318 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10320 arg4 = (
char *) retval4( 0 ).char_matrix_value().data();
10332 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10404 PLFLT *arg1 = (PLFLT *) 0 ;
10405 PLFLT *arg2 = (PLFLT *) 0 ;
10416 octave_value_list _out;
10417 octave_value_list *_outp=&_out;
10418 octave_value _outv;
10430 arg3 = (
PLFLT)(val3);
10435 arg4 = (
PLFLT)(val4);
10457 PLINT *arg1 = (PLINT *) 0 ;
10458 char *arg2 = (
char *) 0 ;
10459 char *arg3 = (
char *) 0 ;
10471 PLINT *arg15 = (PLINT *) 0 ;
10472 PLINT *arg16 = (PLINT *) 0 ;
10473 char *arg17 = (
char *) 0 ;
10474 char *arg18 = (
char *) 0 ;
10475 char *arg19 = (
char *) 0 ;
10476 char *arg20 = (
char *) 0 ;
10477 char *arg21 = (
char *) 0 ;
10478 char *arg22 = (
char *) 0 ;
10479 char *arg23 = (
char *) 0 ;
10533 octave_value_list _out;
10534 octave_value_list *_outp=&_out;
10535 octave_value _outv;
10545 arg2 = (
char *)(buf2);
10550 arg3 = (
char *)(buf3);
10555 arg4 = (
PLFLT)(val4);
10560 arg5 = (
PLFLT)(val5);
10565 arg6 = (
PLFLT)(val6);
10570 arg7 = (
PLFLT)(val7);
10575 arg8 = (
PLFLT)(val8);
10580 arg9 = (
PLFLT)(val9);
10585 arg10 = (
PLFLT)(val10);
10590 arg11 = (
PLBOOL)(val11);
10595 arg12 = (
PLBOOL)(val12);
10600 arg13 = (
PLINT)(val13);
10605 arg14 = (
PLINT)(val14);
10607 if (
_n_dims( args(13) ) > 1 )
10611 Alen = (
PLINT) (
_dim( args(13), 0 ) );
10612 temp15 = args(13).matrix_value();
10613 arg15 =
new PLINT[
Alen];
10617 if (
_n_dims( args(14) ) > 1 )
10621 if (
_dim( args(14), 0 ) != Alen )
10625 temp16 = args(14).matrix_value();
10626 arg16 =
new PLINT[
Alen];
10633 arg17 = (
char *)(buf17);
10638 arg18 = (
char *)(buf18);
10643 arg19 = (
char *)(buf19);
10648 arg20 = (
char *)(buf20);
10653 arg21 = (
char *)(buf21);
10658 arg22 = (
char *)(buf22);
10663 arg23 = (
char *)(buf23);
10664 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);
10665 _outv = octave_value();
10694 PLFLT *arg1 = (PLFLT *) 0 ;
10701 PLFLT *arg8 = (PLFLT *) 0 ;
10703 PLFLT *arg10 = (PLFLT *) 0 ;
10715 octave_value_list _out;
10716 octave_value_list *_outp=&_out;
10717 octave_value _outv;
10723 if (
_n_dims( args(0) ) > 2 )
10725 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10727 temp1 = args(0).matrix_value();
10728 arg1 = &temp1( 0, 0 );
10729 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10736 arg4 = (
PLINT)(val4);
10741 arg5 = (
PLINT)(val5);
10746 arg6 = (
PLINT)(val6);
10751 arg7 = (
PLINT)(val7);
10753 if (
_n_dims( args(5) ) > 1 )
10757 temp8 = args(5).matrix_value();
10758 arg8 = &temp8( 0, 0 );
10759 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10762 if (
_n_dims( args(6) ) > 1 )
10766 if (
_dim( args(6), 0 ) != 6 )
10770 temp10 = args(6).matrix_value();
10771 arg10 = &temp10( 0, 0 );
10773 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
10774 _outv = octave_value();
10791 PLFLT *arg1 = (PLFLT *) 0 ;
10798 PLFLT *arg8 = (PLFLT *) 0 ;
10810 octave_value_list _out;
10811 octave_value_list *_outp=&_out;
10812 octave_value _outv;
10818 if (
_n_dims( args(0) ) > 2 )
10820 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10822 temp1 = args(0).matrix_value();
10823 arg1 = &temp1( 0, 0 );
10824 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10831 arg4 = (
PLINT)(val4);
10836 arg5 = (
PLINT)(val5);
10841 arg6 = (
PLINT)(val6);
10846 arg7 = (
PLINT)(val7);
10848 if (
_n_dims( args(5) ) > 1 )
10852 temp8 = args(5).matrix_value();
10853 arg8 = &temp8( 0, 0 );
10854 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10856 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
10857 _outv = octave_value();
10871 PLFLT *arg1 = (PLFLT *) 0 ;
10878 PLFLT *arg8 = (PLFLT *) 0 ;
10880 PLFLT *arg10 = (PLFLT *) 0 ;
10881 PLFLT *arg11 = (PLFLT *) 0 ;
10894 octave_value_list _out;
10895 octave_value_list *_outp=&_out;
10896 octave_value _outv;
10902 if (
_n_dims( args(0) ) > 2 )
10904 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10906 temp1 = args(0).matrix_value();
10907 arg1 = &temp1( 0, 0 );
10908 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10915 arg4 = (
PLINT)(val4);
10920 arg5 = (
PLINT)(val5);
10925 arg6 = (
PLINT)(val6);
10930 arg7 = (
PLINT)(val7);
10932 if (
_n_dims( args(5) ) > 1 )
10936 temp8 = args(5).matrix_value();
10937 arg8 = &temp8( 0, 0 );
10938 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10941 if (
_n_dims( args(6) ) > 1 )
10945 if (
_dim( args(6), 0 ) != Xlen )
10949 temp10 = args(6).matrix_value();
10950 arg10 = &temp10( 0, 0 );
10953 if (
_n_dims( args(7) ) > 1 )
10961 temp11 = args(7).matrix_value();
10962 arg11 = &temp11( 0, 0 );
10964 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
10965 _outv = octave_value();
10985 PLFLT *arg1 = (PLFLT *) 0 ;
10992 PLFLT *arg8 = (PLFLT *) 0 ;
10994 PLFLT *arg10 = (PLFLT *) 0 ;
10995 PLFLT *arg11 = (PLFLT *) 0 ;
11008 octave_value_list _out;
11009 octave_value_list *_outp=&_out;
11010 octave_value _outv;
11016 if (
_n_dims( args(0) ) > 2 )
11018 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11020 temp1 = args(0).matrix_value();
11021 arg1 = &temp1( 0, 0 );
11022 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11029 arg4 = (
PLINT)(val4);
11034 arg5 = (
PLINT)(val5);
11039 arg6 = (
PLINT)(val6);
11044 arg7 = (
PLINT)(val7);
11046 if (
_n_dims( args(5) ) > 1 )
11050 temp8 = args(5).matrix_value();
11051 arg8 = &temp8( 0, 0 );
11052 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11055 if (
_n_dims( args(6) ) > 2 )
11057 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11059 if (
_dim( args(6), 0 ) != Xlen )
11061 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11065 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11067 temp10 = args(6).matrix_value();
11068 arg10 = &temp10( 0, 0 );
11071 if (
_n_dims( args(7) ) > 2 )
11073 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11075 if (
_dim( args(7), 0 ) != Xlen )
11077 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11081 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11083 temp11 = args(7).matrix_value();
11084 arg11 = &temp11( 0, 0 );
11086 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11087 _outv = octave_value();
11107 PLFLT *arg1 = (PLFLT *) 0 ;
11114 PLFLT *arg8 = (PLFLT *) 0 ;
11116 PLFLT *arg10 = (PLFLT *) 0 ;
11117 PLFLT *arg11 = (PLFLT *) 0 ;
11130 octave_value_list _out;
11131 octave_value_list *_outp=&_out;
11132 octave_value _outv;
11138 if (
_n_dims( args(0) ) > 2 )
11140 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11142 temp1 = args(0).matrix_value();
11143 arg1 = &temp1( 0, 0 );
11144 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11151 arg4 = (
PLINT)(val4);
11156 arg5 = (
PLINT)(val5);
11161 arg6 = (
PLINT)(val6);
11166 arg7 = (
PLINT)(val7);
11168 if (
_n_dims( args(5) ) > 1 )
11172 temp8 = args(5).matrix_value();
11173 arg8 = &temp8( 0, 0 );
11174 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11177 if (
_n_dims( args(6) ) > 2 )
11179 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11181 if (
_dim( args(6), 0 ) != Xlen )
11183 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11187 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11189 temp10 = args(6).matrix_value();
11190 arg10 = &temp10( 0, 0 );
11193 if (
_n_dims( args(7) ) > 2 )
11195 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11197 if (
_dim( args(7), 0 ) != Xlen )
11199 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11203 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11205 temp11 = args(7).matrix_value();
11206 arg11 = &temp11( 0, 0 );
11208 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11209 _outv = octave_value();
11229 PLFLT *arg1 = (PLFLT *) 0 ;
11230 PLFLT *arg2 = (PLFLT *) 0 ;
11231 PLFLT *arg3 = (PLFLT *) 0 ;
11233 PLFLT *arg5 = (PLFLT *) 0 ;
11235 PLFLT *arg7 = (PLFLT *) 0 ;
11237 PLFLT *arg9 = (PLFLT *) 0 ;
11245 octave_value_list retval7 ;
11250 octave_value_list _out;
11251 octave_value_list *_outp=&_out;
11252 octave_value _outv;
11258 if (
_n_dims( args(0) ) > 1 )
11263 temp1 = args(0).matrix_value();
11264 arg1 = &temp1( 0, 0 );
11267 if (
_n_dims( args(1) ) > 1 )
11271 if (
_dim( args(1), 0 ) != Alen )
11275 temp2 = args(1).matrix_value();
11276 arg2 = &temp2( 0, 0 );
11279 if (
_n_dims( args(2) ) > 1 )
11283 if (
_dim( args(2), 0 ) != Alen )
11287 temp3 = args(2).matrix_value();
11288 arg3 = &temp3( 0, 0 );
11292 if (
_n_dims( args(3) ) > 1 )
11296 temp5 = args(3).matrix_value();
11297 arg5 = &temp5( 0, 0 );
11298 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
11301 if (
_n_dims( args(4) ) > 1 )
11305 temp7 = args(4).matrix_value();
11306 arg7 = &temp7( 0, 0 );
11308 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
11309 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11315 arg10 = (
PLINT)(val10);
11320 arg11 = (
PLFLT)(val11);
11321 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
11322 _outv = octave_value();
11348 PLFLT *arg1 = (PLFLT *) 0 ;
11349 PLFLT *arg2 = (PLFLT *) 0 ;
11350 PLFLT *arg3 = (PLFLT *) 0 ;
11359 octave_value_list _out;
11360 octave_value_list *_outp=&_out;
11361 octave_value _outv;
11367 if (
_n_dims( args(0) ) > 1 )
11371 temp1 = args(0).matrix_value();
11372 arg1 = &temp1( 0, 0 );
11376 if (
_n_dims( args(1) ) > 1 )
11380 temp2 = args(1).matrix_value();
11381 arg2 = &temp2( 0, 0 );
11385 if (
_n_dims( args(2) ) > 2 )
11387 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11389 if (
_dim( args(2), 0 ) != Xlen )
11391 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11395 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11397 temp3 = args(2).matrix_value();
11398 arg3 = &temp3( 0, 0 );
11406 arg6 = (
PLINT)(val6);
11407 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
11408 _outv = octave_value();
11425 PLFLT *arg1 = (PLFLT *) 0 ;
11426 PLFLT *arg2 = (PLFLT *) 0 ;
11427 PLFLT *arg3 = (PLFLT *) 0 ;
11431 PLFLT *arg7 = (PLFLT *) 0 ;
11439 octave_value_list _out;
11440 octave_value_list *_outp=&_out;
11441 octave_value _outv;
11447 if (
_n_dims( args(0) ) > 1 )
11451 temp1 = args(0).matrix_value();
11452 arg1 = &temp1( 0, 0 );
11456 if (
_n_dims( args(1) ) > 1 )
11460 temp2 = args(1).matrix_value();
11461 arg2 = &temp2( 0, 0 );
11465 if (
_n_dims( args(2) ) > 2 )
11467 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11469 if (
_dim( args(2), 0 ) != Xlen )
11471 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11475 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11477 temp3 = args(2).matrix_value();
11478 arg3 = &temp3( 0, 0 );
11486 arg6 = (
PLINT)(val6);
11488 if (
_n_dims( args(4) ) > 1 )
11492 temp7 = args(4).matrix_value();
11493 arg7 = &temp7( 0, 0 );
11494 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11496 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11497 _outv = octave_value();
11517 PLFLT *arg1 = (PLFLT *) 0 ;
11518 PLFLT *arg2 = (PLFLT *) 0 ;
11519 PLFLT *arg3 = (PLFLT *) 0 ;
11531 octave_value_list _out;
11532 octave_value_list *_outp=&_out;
11533 octave_value _outv;
11539 if (
_n_dims( args(0) ) > 1 )
11543 temp1 = args(0).matrix_value();
11544 arg1 = &temp1( 0, 0 );
11548 if (
_n_dims( args(1) ) > 1 )
11552 temp2 = args(1).matrix_value();
11553 arg2 = &temp2( 0, 0 );
11557 if (
_n_dims( args(2) ) > 2 )
11559 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11561 if (
_dim( args(2), 0 ) != Xlen )
11563 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11567 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11569 temp3 = args(2).matrix_value();
11570 arg3 = &temp3( 0, 0 );
11578 arg6 = (
PLINT)(val6);
11584 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
11585 _outv = octave_value();
11602 PLFLT *arg1 = (PLFLT *) 0 ;
11603 PLFLT *arg2 = (PLFLT *) 0 ;
11604 PLFLT *arg3 = (PLFLT *) 0 ;
11608 PLFLT *arg7 = (PLFLT *) 0 ;
11616 octave_value_list _out;
11617 octave_value_list *_outp=&_out;
11618 octave_value _outv;
11624 if (
_n_dims( args(0) ) > 1 )
11628 temp1 = args(0).matrix_value();
11629 arg1 = &temp1( 0, 0 );
11633 if (
_n_dims( args(1) ) > 1 )
11637 temp2 = args(1).matrix_value();
11638 arg2 = &temp2( 0, 0 );
11642 if (
_n_dims( args(2) ) > 2 )
11644 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11646 if (
_dim( args(2), 0 ) != Xlen )
11648 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11652 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11654 temp3 = args(2).matrix_value();
11655 arg3 = &temp3( 0, 0 );
11663 arg6 = (
PLINT)(val6);
11665 if (
_n_dims( args(4) ) > 1 )
11669 temp7 = args(4).matrix_value();
11670 arg7 = &temp7( 0, 0 );
11671 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11673 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11674 _outv = octave_value();
11694 PLFLT *arg1 = (PLFLT *) 0 ;
11695 PLFLT *arg2 = (PLFLT *) 0 ;
11696 PLFLT *arg3 = (PLFLT *) 0 ;
11700 PLFLT *arg7 = (PLFLT *) 0 ;
11704 PLINT *arg11 = (PLINT *) 0 ;
11705 PLINT *arg12 = (PLINT *) 0 ;
11716 octave_value_list _out;
11717 octave_value_list *_outp=&_out;
11718 octave_value _outv;
11724 if (
_n_dims( args(0) ) > 1 )
11728 temp1 = args(0).matrix_value();
11729 arg1 = &temp1( 0, 0 );
11733 if (
_n_dims( args(1) ) > 1 )
11737 temp2 = args(1).matrix_value();
11738 arg2 = &temp2( 0, 0 );
11742 if (
_n_dims( args(2) ) > 2 )
11744 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11746 if (
_dim( args(2), 0 ) != Xlen )
11748 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11752 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11754 temp3 = args(2).matrix_value();
11755 arg3 = &temp3( 0, 0 );
11763 arg6 = (
PLINT)(val6);
11765 if (
_n_dims( args(4) ) > 1 )
11769 temp7 = args(4).matrix_value();
11770 arg7 = &temp7( 0, 0 );
11771 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11777 arg9 = (
PLINT)(val9);
11779 if (
_n_dims( args(6) ) > 1 )
11783 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
11784 arg11 =
new PLINT[
Alen];
11785 temp10 = args(6).matrix_value();
11789 if (
_n_dims( args(7) ) > 1 )
11793 if (
_dim( args(7), 0 ) != Alen )
11797 temp12 = args(7).matrix_value();
11798 arg12 =
new PLINT[
Alen];
11801 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);
11802 _outv = octave_value();
11828 PLFLT *arg1 = (PLFLT *) 0 ;
11829 PLFLT *arg2 = (PLFLT *) 0 ;
11830 PLFLT *arg3 = (PLFLT *) 0 ;
11834 PLFLT *arg7 = (PLFLT *) 0 ;
11842 octave_value_list _out;
11843 octave_value_list *_outp=&_out;
11844 octave_value _outv;
11850 if (
_n_dims( args(0) ) > 1 )
11854 temp1 = args(0).matrix_value();
11855 arg1 = &temp1( 0, 0 );
11859 if (
_n_dims( args(1) ) > 1 )
11863 temp2 = args(1).matrix_value();
11864 arg2 = &temp2( 0, 0 );
11868 if (
_n_dims( args(2) ) > 2 )
11870 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11872 if (
_dim( args(2), 0 ) != Xlen )
11874 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11878 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11880 temp3 = args(2).matrix_value();
11881 arg3 = &temp3( 0, 0 );
11889 arg6 = (
PLINT)(val6);
11891 if (
_n_dims( args(4) ) > 1 )
11895 temp7 = args(4).matrix_value();
11896 arg7 = &temp7( 0, 0 );
11897 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11899 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11900 _outv = octave_value();
11920 PLFLT *arg1 = (PLFLT *) 0 ;
11921 PLFLT *arg2 = (PLFLT *) 0 ;
11922 PLFLT *arg3 = (PLFLT *) 0 ;
11926 PLFLT *arg7 = (PLFLT *) 0 ;
11930 PLINT *arg11 = (PLINT *) 0 ;
11931 PLINT *arg12 = (PLINT *) 0 ;
11942 octave_value_list _out;
11943 octave_value_list *_outp=&_out;
11944 octave_value _outv;
11950 if (
_n_dims( args(0) ) > 1 )
11954 temp1 = args(0).matrix_value();
11955 arg1 = &temp1( 0, 0 );
11959 if (
_n_dims( args(1) ) > 1 )
11963 temp2 = args(1).matrix_value();
11964 arg2 = &temp2( 0, 0 );
11968 if (
_n_dims( args(2) ) > 2 )
11970 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11972 if (
_dim( args(2), 0 ) != Xlen )
11974 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11978 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11980 temp3 = args(2).matrix_value();
11981 arg3 = &temp3( 0, 0 );
11989 arg6 = (
PLINT)(val6);
11991 if (
_n_dims( args(4) ) > 1 )
11995 temp7 = args(4).matrix_value();
11996 arg7 = &temp7( 0, 0 );
11997 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12003 arg9 = (
PLINT)(val9);
12005 if (
_n_dims( args(6) ) > 1 )
12009 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12010 arg11 =
new PLINT[
Alen];
12011 temp10 = args(6).matrix_value();
12015 if (
_n_dims( args(7) ) > 1 )
12019 if (
_dim( args(7), 0 ) != Alen )
12023 temp12 = args(7).matrix_value();
12024 arg12 =
new PLINT[
Alen];
12027 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);
12028 _outv = octave_value();
12054 PLFLT *arg1 = (PLFLT *) 0 ;
12057 PLFLT *arg4 = (PLFLT *) 0 ;
12072 PLFLT *arg19 = (PLFLT *) 0 ;
12104 octave_value_list _out;
12105 octave_value_list *_outp=&_out;
12106 octave_value _outv;
12112 if (
_n_dims( args(0) ) > 2 )
12114 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12116 temp1 = args(0).matrix_value();
12117 arg1 = &temp1( 0, 0 );
12118 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12122 if (
_n_dims( args(1) ) > 1 )
12127 temp4 = args(1).matrix_value();
12128 arg4 = &temp4( 0, 0 );
12134 arg5 = (
PLFLT)(val5);
12139 arg6 = (
PLFLT)(val6);
12144 arg7 = (
PLFLT)(val7);
12149 arg8 = (
PLFLT)(val8);
12154 arg9 = (
PLFLT)(val9);
12159 arg10 = (
PLFLT)(val10);
12164 arg11 = (
PLINT)(val11);
12169 arg12 = (
PLFLT)(val12);
12174 arg13 = (
PLINT)(val13);
12179 arg14 = (
PLINT)(val14);
12184 arg15 = (
PLINT)(val15);
12189 arg16 = (
PLINT)(val16);
12194 arg17 = (
PLINT)(val17);
12199 arg18 = (
PLBOOL)(val18);
12201 if (
_n_dims( args(16) ) > 1 )
12205 if (
_dim( args(16), 0 ) != 6 )
12209 temp19 = args(16).matrix_value();
12210 arg19 = &temp19( 0, 0 );
12212 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);
12213 _outv = octave_value();
12230 PLFLT *arg1 = (PLFLT *) 0 ;
12233 char *arg4 = (
char *) 0 ;
12248 PLFLT *arg19 = (PLFLT *) 0 ;
12249 PLFLT *arg20 = (PLFLT *) 0 ;
12284 octave_value_list _out;
12285 octave_value_list *_outp=&_out;
12286 octave_value _outv;
12292 if (
_n_dims( args(0) ) > 2 )
12294 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12296 temp1 = args(0).matrix_value();
12297 arg1 = &temp1( 0, 0 );
12298 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12305 arg4 = (
char *)(buf4);
12310 arg5 = (
PLFLT)(val5);
12315 arg6 = (
PLFLT)(val6);
12320 arg7 = (
PLFLT)(val7);
12325 arg8 = (
PLFLT)(val8);
12330 arg9 = (
PLFLT)(val9);
12335 arg10 = (
PLFLT)(val10);
12340 arg11 = (
PLINT)(val11);
12345 arg12 = (
PLFLT)(val12);
12350 arg13 = (
PLINT)(val13);
12355 arg14 = (
PLINT)(val14);
12360 arg15 = (
PLINT)(val15);
12365 arg16 = (
PLINT)(val16);
12370 arg17 = (
PLINT)(val17);
12375 arg18 = (
PLBOOL)(val18);
12377 if (
_n_dims( args(16) ) > 1 )
12381 if (
_dim( args(16), 0 ) != Xlen )
12385 temp19 = args(16).matrix_value();
12386 arg19 = &temp19( 0, 0 );
12389 if (
_n_dims( args(17) ) > 1 )
12393 if (
_dim( args(17), 0 ) !=
Ylen )
12397 temp20 = args(17).matrix_value();
12398 arg20 = &temp20( 0, 0 );
12400 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);
12401 _outv = octave_value();
12419 PLFLT *arg1 = (PLFLT *) 0 ;
12422 char *arg4 = (
char *) 0 ;
12437 PLFLT *arg19 = (PLFLT *) 0 ;
12438 PLFLT *arg20 = (PLFLT *) 0 ;
12473 octave_value_list _out;
12474 octave_value_list *_outp=&_out;
12475 octave_value _outv;
12481 if (
_n_dims( args(0) ) > 2 )
12483 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12485 temp1 = args(0).matrix_value();
12486 arg1 = &temp1( 0, 0 );
12487 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12494 arg4 = (
char *)(buf4);
12499 arg5 = (
PLFLT)(val5);
12504 arg6 = (
PLFLT)(val6);
12509 arg7 = (
PLFLT)(val7);
12514 arg8 = (
PLFLT)(val8);
12519 arg9 = (
PLFLT)(val9);
12524 arg10 = (
PLFLT)(val10);
12529 arg11 = (
PLINT)(val11);
12534 arg12 = (
PLFLT)(val12);
12539 arg13 = (
PLINT)(val13);
12544 arg14 = (
PLINT)(val14);
12549 arg15 = (
PLINT)(val15);
12554 arg16 = (
PLINT)(val16);
12559 arg17 = (
PLINT)(val17);
12564 arg18 = (
PLBOOL)(val18);
12566 if (
_n_dims( args(16) ) > 2 )
12568 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12570 temp19 = args(16).matrix_value();
12571 arg19 = &temp19( 0, 0 );
12572 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
12576 if (
_n_dims( args(17) ) > 2 )
12578 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12580 temp20 = args(17).matrix_value();
12581 arg20 = &temp20( 0, 0 );
12582 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
12585 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);
12586 _outv = octave_value();
12604 PLFLT *arg1 = (PLFLT *) 0 ;
12611 PLFLT *arg8 = (PLFLT *) 0 ;
12635 octave_value_list _out;
12636 octave_value_list *_outp=&_out;
12637 octave_value _outv;
12643 if (
_n_dims( args(0) ) > 2 )
12645 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12647 temp1 = args(0).matrix_value();
12648 arg1 = &temp1( 0, 0 );
12649 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12656 arg4 = (
PLFLT)(val4);
12661 arg5 = (
PLFLT)(val5);
12666 arg6 = (
PLFLT)(val6);
12671 arg7 = (
PLFLT)(val7);
12673 if (
_n_dims( args(5) ) > 1 )
12677 temp8 = args(5).matrix_value();
12678 arg8 = &temp8( 0, 0 );
12679 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12685 arg10 = (
PLINT)(val10);
12690 arg11 = (
PLINT)(val11);
12695 arg12 = (
PLINT)(val12);
12700 arg13 = (
PLBOOL)(val13);
12701 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
12702 _outv = octave_value();
12716 PLFLT *arg1 = (PLFLT *) 0 ;
12723 PLFLT *arg8 = (PLFLT *) 0 ;
12729 PLFLT *arg14 = (PLFLT *) 0 ;
12749 octave_value_list _out;
12750 octave_value_list *_outp=&_out;
12751 octave_value _outv;
12757 if (
_n_dims( args(0) ) > 2 )
12759 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12761 temp1 = args(0).matrix_value();
12762 arg1 = &temp1( 0, 0 );
12763 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12770 arg4 = (
PLFLT)(val4);
12775 arg5 = (
PLFLT)(val5);
12780 arg6 = (
PLFLT)(val6);
12785 arg7 = (
PLFLT)(val7);
12787 if (
_n_dims( args(5) ) > 1 )
12791 temp8 = args(5).matrix_value();
12792 arg8 = &temp8( 0, 0 );
12793 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12799 arg10 = (
PLINT)(val10);
12804 arg11 = (
PLINT)(val11);
12809 arg12 = (
PLINT)(val12);
12814 arg13 = (
PLBOOL)(val13);
12816 if (
_n_dims( args(10) ) > 1 )
12820 if (
_dim( args(10), 0 ) != 6 )
12824 temp14 = args(10).matrix_value();
12825 arg14 = &temp14( 0, 0 );
12827 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12828 _outv = octave_value();
12845 PLFLT *arg1 = (PLFLT *) 0 ;
12852 PLFLT *arg8 = (PLFLT *) 0 ;
12858 PLFLT *arg14 = (PLFLT *) 0 ;
12859 PLFLT *arg15 = (PLFLT *) 0 ;
12880 octave_value_list _out;
12881 octave_value_list *_outp=&_out;
12882 octave_value _outv;
12888 if (
_n_dims( args(0) ) > 2 )
12890 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12892 temp1 = args(0).matrix_value();
12893 arg1 = &temp1( 0, 0 );
12894 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12901 arg4 = (
PLFLT)(val4);
12906 arg5 = (
PLFLT)(val5);
12911 arg6 = (
PLFLT)(val6);
12916 arg7 = (
PLFLT)(val7);
12918 if (
_n_dims( args(5) ) > 1 )
12922 temp8 = args(5).matrix_value();
12923 arg8 = &temp8( 0, 0 );
12924 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
12930 arg10 = (
PLINT)(val10);
12935 arg11 = (
PLINT)(val11);
12940 arg12 = (
PLINT)(val12);
12945 arg13 = (
PLBOOL)(val13);
12947 if (
_n_dims( args(10) ) > 1 )
12951 if (
_dim( args(10), 0 ) != Xlen )
12955 temp14 = args(10).matrix_value();
12956 arg14 = &temp14( 0, 0 );
12959 if (
_n_dims( args(11) ) > 1 )
12963 if (
_dim( args(11), 0 ) !=
Ylen )
12967 temp15 = args(11).matrix_value();
12968 arg15 = &temp15( 0, 0 );
12970 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);
12971 _outv = octave_value();
12991 PLFLT *arg1 = (PLFLT *) 0 ;
12998 PLFLT *arg8 = (PLFLT *) 0 ;
13004 PLFLT *arg14 = (PLFLT *) 0 ;
13005 PLFLT *arg15 = (PLFLT *) 0 ;
13026 octave_value_list _out;
13027 octave_value_list *_outp=&_out;
13028 octave_value _outv;
13034 if (
_n_dims( args(0) ) > 2 )
13036 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13038 temp1 = args(0).matrix_value();
13039 arg1 = &temp1( 0, 0 );
13040 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13047 arg4 = (
PLFLT)(val4);
13052 arg5 = (
PLFLT)(val5);
13057 arg6 = (
PLFLT)(val6);
13062 arg7 = (
PLFLT)(val7);
13064 if (
_n_dims( args(5) ) > 1 )
13068 temp8 = args(5).matrix_value();
13069 arg8 = &temp8( 0, 0 );
13070 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13076 arg10 = (
PLINT)(val10);
13081 arg11 = (
PLINT)(val11);
13086 arg12 = (
PLINT)(val12);
13091 arg13 = (
PLBOOL)(val13);
13093 if (
_n_dims( args(10) ) > 2 )
13095 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13097 temp14 = args(10).matrix_value();
13098 arg14 = &temp14( 0, 0 );
13099 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
13103 if (
_n_dims( args(11) ) > 2 )
13105 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13107 temp15 = args(11).matrix_value();
13108 arg15 = &temp15( 0, 0 );
13109 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
13112 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);
13113 _outv = octave_value();
13133 PLFLT *arg1 = (PLFLT *) 0 ;
13134 PLFLT *arg2 = (PLFLT *) 0 ;
13138 PLFLT *arg6 = (PLFLT *) 0 ;
13144 octave_value_list _out;
13145 octave_value_list *_outp=&_out;
13146 octave_value _outv;
13152 if (
_n_dims( args(0) ) > 2 )
13154 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13156 temp1 = args(0).matrix_value();
13157 arg1 = &temp1( 0, 0 );
13162 if (
_n_dims( args(1) ) > 2 )
13164 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13166 if (
_dim( args(1), 0 ) != Xlen )
13168 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13172 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13174 temp2 = args(1).matrix_value();
13175 arg2 = &temp2( 0, 0 );
13183 arg5 = (
PLFLT)(val5);
13185 if (
_n_dims( args(3) ) > 1 )
13189 if (
_dim( args(3), 0 ) != 6 )
13193 temp6 = args(3).matrix_value();
13194 arg6 = &temp6( 0, 0 );
13196 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
13197 _outv = octave_value();
13214 PLFLT *arg1 = (PLFLT *) 0 ;
13215 PLFLT *arg2 = (PLFLT *) 0 ;
13219 PLFLT *arg6 = (PLFLT *) 0 ;
13220 PLFLT *arg7 = (PLFLT *) 0 ;
13227 octave_value_list _out;
13228 octave_value_list *_outp=&_out;
13229 octave_value _outv;
13235 if (
_n_dims( args(0) ) > 2 )
13237 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13239 temp1 = args(0).matrix_value();
13240 arg1 = &temp1( 0, 0 );
13245 if (
_n_dims( args(1) ) > 2 )
13247 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13249 if (
_dim( args(1), 0 ) != Xlen )
13251 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13255 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13257 temp2 = args(1).matrix_value();
13258 arg2 = &temp2( 0, 0 );
13266 arg5 = (
PLFLT)(val5);
13268 if (
_n_dims( args(3) ) > 1 )
13272 if (
_dim( args(3), 0 ) != Xlen )
13276 temp6 = args(3).matrix_value();
13277 arg6 = &temp6( 0, 0 );
13280 if (
_n_dims( args(4) ) > 1 )
13288 temp7 = args(4).matrix_value();
13289 arg7 = &temp7( 0, 0 );
13291 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
13292 _outv = octave_value();
13312 PLFLT *arg1 = (PLFLT *) 0 ;
13313 PLFLT *arg2 = (PLFLT *) 0 ;
13317 PLFLT *arg6 = (PLFLT *) 0 ;
13318 PLFLT *arg7 = (PLFLT *) 0 ;
13325 octave_value_list _out;
13326 octave_value_list *_outp=&_out;
13327 octave_value _outv;
13333 if (
_n_dims( args(0) ) > 2 )
13335 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13337 temp1 = args(0).matrix_value();
13338 arg1 = &temp1( 0, 0 );
13343 if (
_n_dims( args(1) ) > 2 )
13345 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13347 if (
_dim( args(1), 0 ) != Xlen )
13349 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13353 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13355 temp2 = args(1).matrix_value();
13356 arg2 = &temp2( 0, 0 );
13364 arg5 = (
PLFLT)(val5);
13366 if (
_n_dims( args(3) ) > 2 )
13368 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13370 temp6 = args(3).matrix_value();
13371 arg6 = &temp6( 0, 0 );
13376 if (
_n_dims( args(4) ) > 2 )
13378 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13380 temp7 = args(4).matrix_value();
13381 arg7 = &temp7( 0, 0 );
13385 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
13386 _outv = octave_value();
13406 PLFLT *arg1 = (PLFLT *) 0 ;
13440 octave_value_list _out;
13441 octave_value_list *_outp=&_out;
13442 octave_value _outv;
13448 if (
_n_dims( args(0) ) > 2 )
13450 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13452 temp1 = args(0).matrix_value();
13453 arg1 = &temp1( 0, 0 );
13454 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13461 arg4 = (
PLFLT)(val4);
13466 arg5 = (
PLFLT)(val5);
13471 arg6 = (
PLFLT)(val6);
13476 arg7 = (
PLFLT)(val7);
13481 arg8 = (
PLFLT)(val8);
13486 arg9 = (
PLFLT)(val9);
13491 arg10 = (
PLFLT)(val10);
13496 arg11 = (
PLFLT)(val11);
13501 arg12 = (
PLFLT)(val12);
13506 arg13 = (
PLFLT)(val13);
13507 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13508 _outv = octave_value();
13519 PLFLT *arg1 = (PLFLT *) 0 ;
13547 octave_value_list _out;
13548 octave_value_list *_outp=&_out;
13549 octave_value _outv;
13555 if (
_n_dims( args(0) ) > 2 )
13557 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13559 temp1 = args(0).matrix_value();
13560 arg1 = &temp1( 0, 0 );
13561 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13568 arg4 = (
PLFLT)(val4);
13573 arg5 = (
PLFLT)(val5);
13578 arg6 = (
PLFLT)(val6);
13583 arg7 = (
PLFLT)(val7);
13588 arg8 = (
PLFLT)(val8);
13593 arg9 = (
PLFLT)(val9);
13598 arg10 = (
PLFLT)(val10);
13603 arg11 = (
PLFLT)(val11);
13604 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13605 _outv = octave_value();
13616 PLFLT *arg1 = (PLFLT *) 0 ;
13627 PLFLT *arg12 = (PLFLT *) 0 ;
13646 octave_value_list _out;
13647 octave_value_list *_outp=&_out;
13648 octave_value _outv;
13654 if (
_n_dims( args(0) ) > 2 )
13656 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13658 temp1 = args(0).matrix_value();
13659 arg1 = &temp1( 0, 0 );
13660 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13667 arg4 = (
PLFLT)(val4);
13672 arg5 = (
PLFLT)(val5);
13677 arg6 = (
PLFLT)(val6);
13682 arg7 = (
PLFLT)(val7);
13687 arg8 = (
PLFLT)(val8);
13692 arg9 = (
PLFLT)(val9);
13697 arg10 = (
PLFLT)(val10);
13702 arg11 = (
PLFLT)(val11);
13704 if (
_n_dims( args(9) ) > 1 )
13708 if (
_dim( args(9), 0 ) != 6 )
13712 temp12 = args(9).matrix_value();
13713 arg12 = &temp12( 0, 0 );
13715 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13716 _outv = octave_value();
13730 PLFLT *arg1 = (PLFLT *) 0 ;
13741 PLFLT *arg12 = (PLFLT *) 0 ;
13742 PLFLT *arg13 = (PLFLT *) 0 ;
13762 octave_value_list _out;
13763 octave_value_list *_outp=&_out;
13764 octave_value _outv;
13770 if (
_n_dims( args(0) ) > 2 )
13772 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13774 temp1 = args(0).matrix_value();
13775 arg1 = &temp1( 0, 0 );
13776 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13783 arg4 = (
PLFLT)(val4);
13788 arg5 = (
PLFLT)(val5);
13793 arg6 = (
PLFLT)(val6);
13798 arg7 = (
PLFLT)(val7);
13803 arg8 = (
PLFLT)(val8);
13808 arg9 = (
PLFLT)(val9);
13813 arg10 = (
PLFLT)(val10);
13818 arg11 = (
PLFLT)(val11);
13820 if (
_n_dims( args(9) ) > 1 )
13824 if (
_dim( args(9), 0 ) != Xlen )
13828 temp12 = args(9).matrix_value();
13829 arg12 = &temp12( 0, 0 );
13832 if (
_n_dims( args(10) ) > 1 )
13836 if (
_dim( args(10), 0 ) !=
Ylen )
13840 temp13 = args(10).matrix_value();
13841 arg13 = &temp13( 0, 0 );
13843 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
13844 _outv = octave_value();
13861 PLFLT *arg1 = (PLFLT *) 0 ;
13872 PLFLT *arg12 = (PLFLT *) 0 ;
13873 PLFLT *arg13 = (PLFLT *) 0 ;
13893 octave_value_list _out;
13894 octave_value_list *_outp=&_out;
13895 octave_value _outv;
13901 if (
_n_dims( args(0) ) > 2 )
13903 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13905 temp1 = args(0).matrix_value();
13906 arg1 = &temp1( 0, 0 );
13907 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13914 arg4 = (
PLFLT)(val4);
13919 arg5 = (
PLFLT)(val5);
13924 arg6 = (
PLFLT)(val6);
13929 arg7 = (
PLFLT)(val7);
13934 arg8 = (
PLFLT)(val8);
13939 arg9 = (
PLFLT)(val9);
13944 arg10 = (
PLFLT)(val10);
13949 arg11 = (
PLFLT)(val11);
13951 if (
_n_dims( args(9) ) > 2 )
13953 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13955 temp12 = args(9).matrix_value();
13956 arg12 = &temp12( 0, 0 );
13961 if (
_n_dims( args(10) ) > 2 )
13963 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13965 temp13 = args(10).matrix_value();
13966 arg13 = &temp13( 0, 0 );
13967 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
13970 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
13971 _outv = octave_value();
13988 PLFLT *arg1 = (PLFLT *) 0 ;
13989 PLFLT *arg2 = (PLFLT *) 0 ;
14004 PLINT *arg17 = (PLINT *) 0 ;
14005 char **arg18 = (
char **) 0 ;
14007 char **arg20 = (
char **) 0 ;
14008 PLFLT *arg21 = (PLFLT *) 0 ;
14009 PLINT *arg22 = (PLINT *) 0 ;
14010 PLINT *arg23 = (PLINT *) 0 ;
14011 PLFLT *arg24 = (PLFLT *) 0 ;
14047 octave_value_list _out;
14048 octave_value_list *_outp=&_out;
14049 octave_value _outv;
14060 arg3 = (
PLINT)(val3);
14065 arg4 = (
PLINT)(val4);
14070 arg5 = (
PLFLT)(val5);
14075 arg6 = (
PLFLT)(val6);
14080 arg7 = (
PLFLT)(val7);
14085 arg8 = (
PLFLT)(val8);
14090 arg9 = (
PLINT)(val9);
14095 arg10 = (
PLINT)(val10);
14100 arg11 = (
PLINT)(val11);
14105 arg12 = (
PLFLT)(val12);
14110 arg13 = (
PLFLT)(val13);
14115 arg14 = (
PLINT)(val14);
14120 arg15 = (
PLFLT)(val15);
14122 if (
_n_dims( args(13) ) > 1 )
14126 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
14127 arg17 =
new PLINT[
Alen];
14128 temp16 = args(13).matrix_value();
14132 charMatrix temp_matrix;
14136 size_t max_length = 0, non_blank_length;
14138 if (
_n_dims( args(14) ) > 2 )
14140 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14142 if ( !args(14).is_empty() )
14144 if (
_dim( args(14), 0 ) != Alen )
14146 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
14148 arg18 =
new char*[
Alen];
14149 ifcell = args(14).is_cell();
14152 temp_cell = args(14).cell_value();
14156 temp_matrix = args(14).char_matrix_value();
14158 max_length =
_dim( args(14), 1 ) + 1;
14161 for ( i = 0; i <
Alen; i++ )
14168 if ( temp_cell.elem( i ).is_string() )
14170 str = temp_cell.elem( i ).string_value();
14172 max_length = str.size() + 1;
14173 tmp_cstring = (
char *) str.c_str();
14183 tmp_cstring = (
char *)
"";
14188 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14190 arg18[i] =
new char[max_length];
14191 strncpy( arg18[i], tmp_cstring, max_length - 1 );
14192 arg18[i][max_length - 1] =
'\0';
14207 non_blank_length = max_length - 2;
14208 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
14210 non_blank_length--;
14212 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
14214 non_blank_length--;
14216 arg18[i][non_blank_length + 1] =
'\0';
14226 charMatrix temp_matrix;
14230 size_t max_length = 0, non_blank_length;
14232 if (
_n_dims( args(15) ) > 2 )
14234 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14236 if ( !args(15).is_empty() )
14238 Alen =
_dim( args(15), 0 );
14240 arg20 =
new char*[
Alen];
14241 ifcell = args(15).is_cell();
14244 temp_cell = args(15).cell_value();
14248 temp_matrix = args(15).char_matrix_value();
14250 max_length =
_dim( args(15), 1 ) + 1;
14253 for ( i = 0; i <
Alen; i++ )
14260 if ( temp_cell.elem( i ).is_string() )
14262 str = temp_cell.elem( i ).string_value();
14264 max_length = str.size() + 1;
14265 tmp_cstring = (
char *) str.c_str();
14275 tmp_cstring = (
char *)
"";
14280 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14282 arg20[i] =
new char[max_length];
14283 strncpy( arg20[i], tmp_cstring, max_length - 1 );
14284 arg20[i][max_length - 1] =
'\0';
14299 non_blank_length = max_length - 2;
14300 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
14302 non_blank_length--;
14304 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
14306 non_blank_length--;
14308 arg20[i][non_blank_length + 1] =
'\0';
14319 if (
_n_dims( args(16) ) > 1 )
14323 if (
_dim( args(16), 0 ) != Alen )
14327 temp21 = args(16).matrix_value();
14328 arg21 = &temp21( 0, 0 );
14331 if (
_n_dims( args(17) ) > 1 )
14335 if (
_dim( args(17), 0 ) != Alen )
14339 temp22 = args(17).matrix_value();
14340 arg22 =
new PLINT[
Alen];
14345 if (
_n_dims( args(18) ) > 1 )
14349 if (
_dim( args(18), 0 ) != Alen )
14354 temp23 = args(18).matrix_value();
14355 arg23 =
new PLINT[
Alen];
14358 for ( i = 0; i <
Xlen; i++ )
14359 if ( arg23[i] >
Ylen )
14363 if (
_n_dims( args(19) ) > 2 )
14365 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14367 if (
_dim( args(19), 0 ) != Xlen )
14369 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14371 if (
_dim( args(19), 1 ) !=
Ylen )
14373 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14375 temp24 = args(19).matrix_value();
14376 arg24 = &temp24( 0, 0 );
14378 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);
14379 _outv = octave_value();
14398 if ( arg18 != NULL )
14400 for ( i = 0; i <
Alen; i++ )
14409 if ( arg20 != NULL )
14411 for ( i = 0; i <
Alen; i++ )
14442 octave_value_list _out;
14443 octave_value_list *_outp=&_out;
14444 octave_value _outv;
14458 arg2 = (int)(val2);
14459 if (arg1) (arg1)->type = arg2;
14460 _outv = octave_value();
14471 octave_value_list _out;
14472 octave_value_list *_outp=&_out;
14473 octave_value _outv;
14484 result = (int) ((arg1)->type);
14494 unsigned int arg2 ;
14497 unsigned int val2 ;
14499 octave_value_list _out;
14500 octave_value_list *_outp=&_out;
14501 octave_value _outv;
14515 arg2 = (
unsigned int)(val2);
14516 if (arg1) (arg1)->state = arg2;
14517 _outv = octave_value();
14528 octave_value_list _out;
14529 octave_value_list *_outp=&_out;
14530 octave_value _outv;
14531 unsigned int result;
14541 result = (
unsigned int) ((arg1)->state);
14551 unsigned int arg2 ;
14554 unsigned int val2 ;
14556 octave_value_list _out;
14557 octave_value_list *_outp=&_out;
14558 octave_value _outv;
14572 arg2 = (
unsigned int)(val2);
14573 if (arg1) (arg1)->keysym = arg2;
14574 _outv = octave_value();
14585 octave_value_list _out;
14586 octave_value_list *_outp=&_out;
14587 octave_value _outv;
14588 unsigned int result;
14598 result = (
unsigned int) ((arg1)->keysym);
14608 unsigned int arg2 ;
14611 unsigned int val2 ;
14613 octave_value_list _out;
14614 octave_value_list *_outp=&_out;
14615 octave_value _outv;
14629 arg2 = (
unsigned int)(val2);
14630 if (arg1) (arg1)->button = arg2;
14631 _outv = octave_value();
14642 octave_value_list _out;
14643 octave_value_list *_outp=&_out;
14644 octave_value _outv;
14645 unsigned int result;
14655 result = (
unsigned int) ((arg1)->button);
14670 octave_value_list _out;
14671 octave_value_list *_outp=&_out;
14672 octave_value _outv;
14686 arg2 = (
PLINT)(val2);
14687 if (arg1) (arg1)->subwindow = arg2;
14688 _outv = octave_value();
14699 octave_value_list _out;
14700 octave_value_list *_outp=&_out;
14701 octave_value _outv;
14712 result = (
PLINT) ((arg1)->subwindow);
14727 octave_value_list _out;
14728 octave_value_list *_outp=&_out;
14729 octave_value _outv;
14743 arg2 = (
char *)(temp2);
14744 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
14745 else memset(arg1->
string,0,16*
sizeof(
char));
14746 _outv = octave_value();
14757 octave_value_list _out;
14758 octave_value_list *_outp=&_out;
14759 octave_value _outv;
14770 result = (
char *)(
char *) ((arg1)->
string);
14774 while (size && (result[size - 1] ==
'\0')) --size;
14791 octave_value_list _out;
14792 octave_value_list *_outp=&_out;
14793 octave_value _outv;
14807 arg2 = (int)(val2);
14808 if (arg1) (arg1)->pX = arg2;
14809 _outv = octave_value();
14820 octave_value_list _out;
14821 octave_value_list *_outp=&_out;
14822 octave_value _outv;
14833 result = (int) ((arg1)->pX);
14848 octave_value_list _out;
14849 octave_value_list *_outp=&_out;
14850 octave_value _outv;
14864 arg2 = (int)(val2);
14865 if (arg1) (arg1)->pY = arg2;
14866 _outv = octave_value();
14877 octave_value_list _out;
14878 octave_value_list *_outp=&_out;
14879 octave_value _outv;
14890 result = (int) ((arg1)->pY);
14905 octave_value_list _out;
14906 octave_value_list *_outp=&_out;
14907 octave_value _outv;
14921 arg2 = (
PLFLT)(val2);
14922 if (arg1) (arg1)->dX = arg2;
14923 _outv = octave_value();
14934 octave_value_list _out;
14935 octave_value_list *_outp=&_out;
14936 octave_value _outv;
14947 result = (
PLFLT) ((arg1)->dX);
14962 octave_value_list _out;
14963 octave_value_list *_outp=&_out;
14964 octave_value _outv;
14978 arg2 = (
PLFLT)(val2);
14979 if (arg1) (arg1)->dY = arg2;
14980 _outv = octave_value();
14991 octave_value_list _out;
14992 octave_value_list *_outp=&_out;
14993 octave_value _outv;
15004 result = (
PLFLT) ((arg1)->dY);
15019 octave_value_list _out;
15020 octave_value_list *_outp=&_out;
15021 octave_value _outv;
15035 arg2 = (
PLFLT)(val2);
15036 if (arg1) (arg1)->wX = arg2;
15037 _outv = octave_value();
15048 octave_value_list _out;
15049 octave_value_list *_outp=&_out;
15050 octave_value _outv;
15061 result = (
PLFLT) ((arg1)->wX);
15076 octave_value_list _out;
15077 octave_value_list *_outp=&_out;
15078 octave_value _outv;
15092 arg2 = (
PLFLT)(val2);
15093 if (arg1) (arg1)->wY = arg2;
15094 _outv = octave_value();
15105 octave_value_list _out;
15106 octave_value_list *_outp=&_out;
15107 octave_value _outv;
15118 result = (
PLFLT) ((arg1)->wY);
15127 octave_value_list _out;
15128 octave_value_list *_outp=&_out;
15129 octave_value _outv;
15147 octave_value_list _out;
15148 octave_value_list *_outp=&_out;
15149 octave_value _outv;
15160 _outv = octave_value();
15193 octave_value_list _out;
15194 octave_value_list *_outp=&_out;
15195 octave_value _outv;
15204 arg1 = (
PLINT)(val1);
15209 arg2 = (
PLINT)(val2);
15211 _outv = octave_value();
15231 octave_value_list _out;
15232 octave_value_list *_outp=&_out;
15233 octave_value _outv;
15242 arg1 = (
PLFLT)(val1);
15247 arg2 = (
PLFLT)(val2);
15252 arg3 = (
PLFLT)(val3);
15257 arg4 = (
PLINT)(val4);
15259 _outv = octave_value();
15270 octave_value_list _out;
15271 octave_value_list *_outp=&_out;
15272 octave_value _outv;
15281 arg1 = (
PLINT)(val1);
15283 _outv = octave_value();
15315 octave_value_list _out;
15316 octave_value_list *_outp=&_out;
15317 octave_value _outv;
15326 arg1 = (
PLFLT)(val1);
15331 arg2 = (
PLFLT)(val2);
15336 arg3 = (
PLFLT)(val3);
15341 arg4 = (
PLFLT)(val4);
15346 arg5 = (
PLFLT)(val5);
15351 arg6 = (
PLFLT)(val6);
15356 arg7 = (
PLFLT)(val7);
15362 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15363 _outv = octave_value();
15373 char *arg3 = (
char *) 0 ;
15376 char *arg6 = (
char *) 0 ;
15397 octave_value_list _out;
15398 octave_value_list *_outp=&_out;
15399 octave_value _outv;
15408 arg1 = (
PLFLT)(val1);
15413 arg2 = (
PLFLT)(val2);
15418 arg3 = (
char *)(buf3);
15423 arg4 = (
PLFLT)(val4);
15428 arg5 = (
PLINT)(val5);
15433 arg6 = (
char *)(buf6);
15438 arg7 = (
PLFLT)(val7);
15443 arg8 = (
PLINT)(val8);
15444 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
15445 _outv = octave_value();
15456 PLFLT *arg2 = (PLFLT *) 0 ;
15457 PLFLT *arg3 = (PLFLT *) 0 ;
15463 octave_value_list _out;
15464 octave_value_list *_outp=&_out;
15465 octave_value _outv;
15471 if (
_n_dims( args(0) ) > 1 )
15475 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
15476 temp1 = args(0).matrix_value();
15477 arg2 = &temp1( 0, 0 );
15480 if (
_n_dims( args(1) ) > 1 )
15484 if (
_dim( args(1), 0 ) != Alen )
15488 temp3 = args(1).matrix_value();
15489 arg3 = &temp3( 0, 0 );
15495 arg4 = (
PLINT)(val4);
15496 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
15497 _outv = octave_value();
15511 PLINT *arg1 = (PLINT *) 0 ;
15512 PLINT *arg2 = (PLINT *) 0 ;
15513 PLINT *arg3 = (PLINT *) 0 ;
15514 PLINT *arg4 = (PLINT *) 0 ;
15515 PLINT *arg5 = (PLINT *) 0 ;
15516 PLFLT *arg6 = (PLFLT *) 0 ;
15532 octave_value_list _out;
15533 octave_value_list *_outp=&_out;
15534 octave_value _outv;
15549 arg7 = (
PLFLT)(val7);
15550 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
15551 _outv = octave_value();
15595 octave_value_list _out;
15596 octave_value_list *_outp=&_out;
15597 octave_value _outv;
15603 _outv = octave_value();
15611 char *arg1 = (
char *) 0 ;
15614 char *arg4 = (
char *) 0 ;
15631 octave_value_list _out;
15632 octave_value_list *_outp=&_out;
15633 octave_value _outv;
15642 arg1 = (
char *)(buf1);
15647 arg2 = (
PLFLT)(val2);
15652 arg3 = (
PLINT)(val3);
15657 arg4 = (
char *)(buf4);
15662 arg5 = (
PLFLT)(val5);
15667 arg6 = (
PLINT)(val6);
15668 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
15669 _outv = octave_value();
15679 char *arg1 = (
char *) 0 ;
15680 char *arg2 = (
char *) 0 ;
15683 char *arg5 = (
char *) 0 ;
15684 char *arg6 = (
char *) 0 ;
15687 char *arg9 = (
char *) 0 ;
15688 char *arg10 = (
char *) 0 ;
15721 octave_value_list _out;
15722 octave_value_list *_outp=&_out;
15723 octave_value _outv;
15732 arg1 = (
char *)(buf1);
15737 arg2 = (
char *)(buf2);
15742 arg3 = (
PLFLT)(val3);
15747 arg4 = (
PLINT)(val4);
15752 arg5 = (
char *)(buf5);
15757 arg6 = (
char *)(buf6);
15762 arg7 = (
PLFLT)(val7);
15767 arg8 = (
PLINT)(val8);
15772 arg9 = (
char *)(buf9);
15777 arg10 = (
char *)(buf10);
15782 arg11 = (
PLFLT)(val11);
15787 arg12 = (
PLINT)(val12);
15788 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);
15789 _outv = octave_value();
15805 PLFLT *arg3 = (PLFLT *) 0 ;
15806 PLFLT *arg4 = (PLFLT *) 0 ;
15807 PLINT *arg5 = (PLINT *) 0 ;
15818 octave_value_list _out;
15819 octave_value_list *_outp=&_out;
15820 octave_value _outv;
15832 arg1 = (
PLFLT)(val1);
15837 arg2 = (
PLFLT)(val2);
15839 _outv = octave_value();
15865 octave_value_list _out;
15866 octave_value_list *_outp=&_out;
15867 octave_value _outv;
15873 _outv = octave_value();
15884 octave_value_list _out;
15885 octave_value_list *_outp=&_out;
15886 octave_value _outv;
15895 arg1 = (
PLINT)(val1);
15897 _outv = octave_value();
15908 octave_value_list _out;
15909 octave_value_list *_outp=&_out;
15910 octave_value _outv;
15919 arg1 = (
PLFLT)(val1);
15921 _outv = octave_value();
15962 octave_value_list _out;
15963 octave_value_list *_outp=&_out;
15964 octave_value _outv;
15973 arg1 = (
PLFLT)(val1);
15978 arg2 = (
PLFLT)(val2);
15983 arg3 = (
PLFLT)(val3);
15988 arg4 = (
PLINT)(val4);
15998 arg6 = (
PLINT)(val6);
16003 arg7 = (
PLINT)(val7);
16008 arg8 = (
PLINT)(val8);
16013 arg9 = (
PLINT)(val9);
16018 arg10 = (
PLINT)(val10);
16023 arg11 = (
PLFLT)(val11);
16024 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16025 _outv = octave_value();
16039 PLFLT *arg7 = (PLFLT *) 0 ;
16054 octave_value_list _out;
16055 octave_value_list *_outp=&_out;
16056 octave_value _outv;
16066 arg1 = (
PLINT)(val1);
16071 arg2 = (
PLINT)(val2);
16076 arg3 = (
PLINT)(val3);
16081 arg4 = (
PLINT)(val4);
16086 arg5 = (
PLINT)(val5);
16091 arg6 = (
PLFLT)(val6);
16092 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16093 _outv = octave_value();
16113 octave_value_list _out;
16114 octave_value_list *_outp=&_out;
16115 octave_value _outv;
16124 arg1 = (
PLINT)(val1);
16131 _outv = octave_value();
16139 octave_value_list _out;
16140 octave_value_list *_outp=&_out;
16141 octave_value _outv;
16147 _outv = octave_value();
16155 octave_value_list _out;
16156 octave_value_list *_outp=&_out;
16157 octave_value _outv;
16163 _outv = octave_value();
16189 octave_value_list _out;
16190 octave_value_list *_outp=&_out;
16191 octave_value _outv;
16200 arg1 = (
PLFLT)(val1);
16205 arg2 = (
PLFLT)(val2);
16210 arg3 = (
PLFLT)(val3);
16215 arg4 = (
PLFLT)(val4);
16220 arg5 = (
PLINT)(val5);
16225 arg6 = (
PLINT)(val6);
16226 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16227 _outv = octave_value();
16253 octave_value_list _out;
16254 octave_value_list *_outp=&_out;
16255 octave_value _outv;
16264 arg1 = (
PLFLT)(val1);
16269 arg2 = (
PLFLT)(val2);
16274 arg3 = (
PLFLT)(val3);
16279 arg4 = (
PLFLT)(val4);
16284 arg5 = (
PLINT)(val5);
16289 arg6 = (
PLINT)(val6);
16290 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
16291 _outv = octave_value();
16299 octave_value_list _out;
16300 octave_value_list *_outp=&_out;
16301 octave_value _outv;
16307 _outv = octave_value();
16316 PLFLT *arg2 = (PLFLT *) 0 ;
16317 PLFLT *arg3 = (PLFLT *) 0 ;
16318 PLFLT *arg4 = (PLFLT *) 0 ;
16322 octave_value_list _out;
16323 octave_value_list *_outp=&_out;
16324 octave_value _outv;
16330 if (
_n_dims( args(0) ) > 1 )
16334 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16335 temp1 = args(0).matrix_value();
16336 arg2 = &temp1( 0, 0 );
16339 if (
_n_dims( args(1) ) > 1 )
16343 if (
_dim( args(1), 0 ) != Alen )
16347 temp3 = args(1).matrix_value();
16348 arg3 = &temp3( 0, 0 );
16351 if (
_n_dims( args(2) ) > 1 )
16355 if (
_dim( args(2), 0 ) != Alen )
16359 temp4 = args(2).matrix_value();
16360 arg4 = &temp4( 0, 0 );
16362 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16363 _outv = octave_value();
16381 PLFLT *arg2 = (PLFLT *) 0 ;
16382 PLFLT *arg3 = (PLFLT *) 0 ;
16383 PLFLT *arg4 = (PLFLT *) 0 ;
16387 octave_value_list _out;
16388 octave_value_list *_outp=&_out;
16389 octave_value _outv;
16395 if (
_n_dims( args(0) ) > 1 )
16399 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16400 temp1 = args(0).matrix_value();
16401 arg2 = &temp1( 0, 0 );
16404 if (
_n_dims( args(1) ) > 1 )
16408 if (
_dim( args(1), 0 ) != Alen )
16412 temp3 = args(1).matrix_value();
16413 arg3 = &temp3( 0, 0 );
16416 if (
_n_dims( args(2) ) > 1 )
16420 if (
_dim( args(2), 0 ) != Alen )
16424 temp4 = args(2).matrix_value();
16425 arg4 = &temp4( 0, 0 );
16427 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16428 _outv = octave_value();
16445 octave_value_list _out;
16446 octave_value_list *_outp=&_out;
16447 octave_value _outv;
16453 _outv = octave_value();
16462 PLFLT *arg2 = (PLFLT *) 0 ;
16463 PLFLT *arg3 = (PLFLT *) 0 ;
16466 octave_value_list _out;
16467 octave_value_list *_outp=&_out;
16468 octave_value _outv;
16474 if (
_n_dims( args(0) ) > 1 )
16478 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16479 temp1 = args(0).matrix_value();
16480 arg2 = &temp1( 0, 0 );
16483 if (
_n_dims( args(1) ) > 1 )
16487 if (
_dim( args(1), 0 ) != Alen )
16491 temp3 = args(1).matrix_value();
16492 arg3 = &temp3( 0, 0 );
16494 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
16495 _outv = octave_value();
16510 PLFLT *arg2 = (PLFLT *) 0 ;
16511 PLFLT *arg3 = (PLFLT *) 0 ;
16512 PLFLT *arg4 = (PLFLT *) 0 ;
16516 octave_value_list _out;
16517 octave_value_list *_outp=&_out;
16518 octave_value _outv;
16524 if (
_n_dims( args(0) ) > 1 )
16528 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16529 temp1 = args(0).matrix_value();
16530 arg2 = &temp1( 0, 0 );
16533 if (
_n_dims( args(1) ) > 1 )
16537 if (
_dim( args(1), 0 ) != Alen )
16541 temp3 = args(1).matrix_value();
16542 arg3 = &temp3( 0, 0 );
16545 if (
_n_dims( args(2) ) > 1 )
16549 if (
_dim( args(2), 0 ) != Alen )
16553 temp4 = args(2).matrix_value();
16554 arg4 = &temp4( 0, 0 );
16556 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16557 _outv = octave_value();
16575 PLFLT *arg2 = (PLFLT *) 0 ;
16576 PLFLT *arg3 = (PLFLT *) 0 ;
16582 octave_value_list _out;
16583 octave_value_list *_outp=&_out;
16584 octave_value _outv;
16590 if (
_n_dims( args(0) ) > 1 )
16594 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16595 temp1 = args(0).matrix_value();
16596 arg2 = &temp1( 0, 0 );
16599 if (
_n_dims( args(1) ) > 1 )
16603 if (
_dim( args(1), 0 ) != Alen )
16607 temp3 = args(1).matrix_value();
16608 arg3 = &temp3( 0, 0 );
16614 arg4 = (
PLFLT)(val4);
16615 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16616 _outv = octave_value();
16630 octave_value_list _out;
16631 octave_value_list *_outp=&_out;
16632 octave_value _outv;
16638 _outv = octave_value();
16649 octave_value_list _out;
16650 octave_value_list *_outp=&_out;
16651 octave_value _outv;
16660 arg1 = (
PLINT)(val1);
16662 _outv = octave_value();
16673 octave_value_list _out;
16674 octave_value_list *_outp=&_out;
16675 octave_value _outv;
16684 arg1 = (
PLINT)(val1);
16686 _outv = octave_value();
16694 PLFLT *arg1 = (PLFLT *) 0 ;
16695 PLFLT *arg2 = (PLFLT *) 0 ;
16700 octave_value_list _out;
16701 octave_value_list *_outp=&_out;
16702 octave_value _outv;
16710 _outv = octave_value();
16731 PLINT *arg2 = (PLINT *) 0 ;
16732 PLINT *arg3 = (PLINT *) 0 ;
16733 PLINT *arg4 = (PLINT *) 0 ;
16742 octave_value_list _out;
16743 octave_value_list *_outp=&_out;
16744 octave_value _outv;
16756 arg1 = (
PLINT)(val1);
16757 plgcol0(arg1,arg2,arg3,arg4);
16758 _outv = octave_value();
16785 PLINT *arg2 = (PLINT *) 0 ;
16786 PLINT *arg3 = (PLINT *) 0 ;
16787 PLINT *arg4 = (PLINT *) 0 ;
16788 PLFLT *arg5 = (PLFLT *) 0 ;
16799 octave_value_list _out;
16800 octave_value_list *_outp=&_out;
16801 octave_value _outv;
16814 arg1 = (
PLINT)(val1);
16815 plgcol0a(arg1,arg2,arg3,arg4,arg5);
16816 _outv = octave_value();
16848 PLINT *arg1 = (PLINT *) 0 ;
16849 PLINT *arg2 = (PLINT *) 0 ;
16850 PLINT *arg3 = (PLINT *) 0 ;
16857 octave_value_list _out;
16858 octave_value_list *_outp=&_out;
16859 octave_value _outv;
16868 _outv = octave_value();
16894 PLINT *arg1 = (PLINT *) 0 ;
16895 PLINT *arg2 = (PLINT *) 0 ;
16896 PLINT *arg3 = (PLINT *) 0 ;
16897 PLFLT *arg4 = (PLFLT *) 0 ;
16906 octave_value_list _out;
16907 octave_value_list *_outp=&_out;
16908 octave_value _outv;
16918 _outv = octave_value();
16950 PLINT *arg1 = (PLINT *) 0 ;
16953 octave_value_list _out;
16954 octave_value_list *_outp=&_out;
16955 octave_value _outv;
16962 _outv = octave_value();
16976 char *arg1 = (
char *) 0 ;
16977 octave_value_list retval1 ;
16978 octave_value_list _out;
16979 octave_value_list *_outp=&_out;
16980 octave_value _outv;
16984 # if OCTAVE_API_VERSION_NUMBER < 45
16985 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
16987 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
16989 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
16995 _outv = octave_value();
17006 PLFLT *arg1 = (PLFLT *) 0 ;
17007 PLFLT *arg2 = (PLFLT *) 0 ;
17008 PLFLT *arg3 = (PLFLT *) 0 ;
17009 PLFLT *arg4 = (PLFLT *) 0 ;
17018 octave_value_list _out;
17019 octave_value_list *_outp=&_out;
17020 octave_value _outv;
17030 _outv = octave_value();
17062 PLFLT *arg1 = (PLFLT *) 0 ;
17065 octave_value_list _out;
17066 octave_value_list *_outp=&_out;
17067 octave_value _outv;
17074 _outv = octave_value();
17088 PLFLT *arg1 = (PLFLT *) 0 ;
17089 PLFLT *arg2 = (PLFLT *) 0 ;
17090 PLFLT *arg3 = (PLFLT *) 0 ;
17091 PLFLT *arg4 = (PLFLT *) 0 ;
17100 octave_value_list _out;
17101 octave_value_list *_outp=&_out;
17102 octave_value _outv;
17112 _outv = octave_value();
17144 PLINT *arg1 = (PLINT *) 0 ;
17145 PLINT *arg2 = (PLINT *) 0 ;
17146 PLINT *arg3 = (PLINT *) 0 ;
17153 octave_value_list _out;
17154 octave_value_list *_outp=&_out;
17155 octave_value _outv;
17164 _outv = octave_value();
17193 octave_value_list _out;
17194 octave_value_list *_outp=&_out;
17195 octave_value _outv;
17202 _outv = octave_value();
17216 char *arg1 = (
char *) 0 ;
17217 octave_value_list retval1 ;
17218 octave_value_list _out;
17219 octave_value_list *_outp=&_out;
17220 octave_value _outv;
17224 # if OCTAVE_API_VERSION_NUMBER < 45
17225 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17227 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17229 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17235 _outv = octave_value();
17246 PLINT *arg1 = (PLINT *) 0 ;
17247 PLINT *arg2 = (PLINT *) 0 ;
17248 PLINT *arg3 = (PLINT *) 0 ;
17255 octave_value_list _out;
17256 octave_value_list *_outp=&_out;
17257 octave_value _outv;
17266 _outv = octave_value();
17292 PLINT *arg1 = (PLINT *) 0 ;
17295 octave_value_list _out;
17296 octave_value_list *_outp=&_out;
17297 octave_value _outv;
17304 _outv = octave_value();
17318 PLFLT *arg1 = (PLFLT *) 0 ;
17319 PLFLT *arg2 = (PLFLT *) 0 ;
17320 PLINT *arg3 = (PLINT *) 0 ;
17321 PLINT *arg4 = (PLINT *) 0 ;
17322 PLINT *arg5 = (PLINT *) 0 ;
17323 PLINT *arg6 = (PLINT *) 0 ;
17336 octave_value_list _out;
17337 octave_value_list *_outp=&_out;
17338 octave_value _outv;
17349 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
17350 _outv = octave_value();
17394 octave_value_list _out;
17395 octave_value_list *_outp=&_out;
17396 octave_value _outv;
17402 _outv = octave_value();
17410 PLFLT *arg1 = (PLFLT *) 0 ;
17411 PLFLT *arg2 = (PLFLT *) 0 ;
17412 PLFLT *arg3 = (PLFLT *) 0 ;
17413 PLFLT *arg4 = (PLFLT *) 0 ;
17422 octave_value_list _out;
17423 octave_value_list *_outp=&_out;
17424 octave_value _outv;
17433 plgspa(arg1,arg2,arg3,arg4);
17434 _outv = octave_value();
17466 PLINT *arg1 = (PLINT *) 0 ;
17469 octave_value_list _out;
17470 octave_value_list *_outp=&_out;
17471 octave_value _outv;
17478 _outv = octave_value();
17492 char *arg1 = (
char *) 0 ;
17493 octave_value_list retval1 ;
17494 octave_value_list _out;
17495 octave_value_list *_outp=&_out;
17496 octave_value _outv;
17500 # if OCTAVE_API_VERSION_NUMBER < 45
17501 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17503 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17505 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17511 _outv = octave_value();
17522 PLFLT *arg1 = (PLFLT *) 0 ;
17523 PLFLT *arg2 = (PLFLT *) 0 ;
17524 PLFLT *arg3 = (PLFLT *) 0 ;
17525 PLFLT *arg4 = (PLFLT *) 0 ;
17534 octave_value_list _out;
17535 octave_value_list *_outp=&_out;
17536 octave_value _outv;
17545 plgvpd(arg1,arg2,arg3,arg4);
17546 _outv = octave_value();
17578 PLFLT *arg1 = (PLFLT *) 0 ;
17579 PLFLT *arg2 = (PLFLT *) 0 ;
17580 PLFLT *arg3 = (PLFLT *) 0 ;
17581 PLFLT *arg4 = (PLFLT *) 0 ;
17590 octave_value_list _out;
17591 octave_value_list *_outp=&_out;
17592 octave_value _outv;
17601 plgvpw(arg1,arg2,arg3,arg4);
17602 _outv = octave_value();
17634 PLINT *arg1 = (PLINT *) 0 ;
17635 PLINT *arg2 = (PLINT *) 0 ;
17640 octave_value_list _out;
17641 octave_value_list *_outp=&_out;
17642 octave_value _outv;
17650 _outv = octave_value();
17670 PLINT *arg1 = (PLINT *) 0 ;
17671 PLINT *arg2 = (PLINT *) 0 ;
17676 octave_value_list _out;
17677 octave_value_list *_outp=&_out;
17678 octave_value _outv;
17686 _outv = octave_value();
17706 PLINT *arg1 = (PLINT *) 0 ;
17707 PLINT *arg2 = (PLINT *) 0 ;
17712 octave_value_list _out;
17713 octave_value_list *_outp=&_out;
17714 octave_value _outv;
17722 _outv = octave_value();
17743 PLFLT *arg2 = (PLFLT *) 0 ;
17757 octave_value_list _out;
17758 octave_value_list *_outp=&_out;
17759 octave_value _outv;
17765 if (
_n_dims( args(0) ) > 1 )
17769 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17770 temp1 = args(0).matrix_value();
17771 arg2 = &temp1( 0, 0 );
17777 arg3 = (
PLFLT)(val3);
17782 arg4 = (
PLFLT)(val4);
17787 arg5 = (
PLINT)(val5);
17792 arg6 = (
PLINT)(val6);
17793 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
17794 _outv = octave_value();
17808 PLFLT *arg4 = (PLFLT *) 0 ;
17809 PLFLT *arg5 = (PLFLT *) 0 ;
17810 PLFLT *arg6 = (PLFLT *) 0 ;
17823 octave_value_list _out;
17824 octave_value_list *_outp=&_out;
17825 octave_value _outv;
17837 arg1 = (
PLFLT)(val1);
17842 arg2 = (
PLFLT)(val2);
17847 arg3 = (
PLFLT)(val3);
17848 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
17849 _outv = octave_value();
17875 octave_value_list _out;
17876 octave_value_list *_outp=&_out;
17877 octave_value _outv;
17883 _outv = octave_value();
17903 octave_value_list _out;
17904 octave_value_list *_outp=&_out;
17905 octave_value _outv;
17914 arg1 = (
PLFLT)(val1);
17919 arg2 = (
PLFLT)(val2);
17924 arg3 = (
PLFLT)(val3);
17929 arg4 = (
PLFLT)(val4);
17930 pljoin(arg1,arg2,arg3,arg4);
17931 _outv = octave_value();
17939 char *arg1 = (
char *) 0 ;
17940 char *arg2 = (
char *) 0 ;
17941 char *arg3 = (
char *) 0 ;
17951 octave_value_list _out;
17952 octave_value_list *_outp=&_out;
17953 octave_value _outv;
17962 arg1 = (
char *)(buf1);
17967 arg2 = (
char *)(buf2);
17972 arg3 = (
char *)(buf3);
17973 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
17974 _outv = octave_value();
17985 PLFLT *arg1 = (PLFLT *) 0 ;
17986 PLFLT *arg2 = (PLFLT *) 0 ;
17998 PLINT *arg14 = (PLINT *) 0 ;
18003 PLINT *arg19 = (PLINT *) 0 ;
18004 char **arg20 = (
char **) 0 ;
18005 PLINT *arg21 = (PLINT *) 0 ;
18006 PLINT *arg22 = (PLINT *) 0 ;
18007 PLFLT *arg23 = (PLFLT *) 0 ;
18008 PLFLT *arg24 = (PLFLT *) 0 ;
18009 PLINT *arg25 = (PLINT *) 0 ;
18010 PLINT *arg26 = (PLINT *) 0 ;
18011 PLFLT *arg27 = (PLFLT *) 0 ;
18012 PLINT *arg28 = (PLINT *) 0 ;
18013 PLFLT *arg29 = (PLFLT *) 0 ;
18014 PLINT *arg30 = (PLINT *) 0 ;
18015 char **arg31 = (
char **) 0 ;
18060 octave_value_list _out;
18061 octave_value_list *_outp=&_out;
18062 octave_value _outv;
18073 arg3 = (
PLINT)(val3);
18078 arg4 = (
PLINT)(val4);
18083 arg5 = (
PLFLT)(val5);
18088 arg6 = (
PLFLT)(val6);
18093 arg7 = (
PLFLT)(val7);
18098 arg8 = (
PLINT)(val8);
18103 arg9 = (
PLINT)(val9);
18108 arg10 = (
PLINT)(val10);
18113 arg11 = (
PLINT)(val11);
18118 arg12 = (
PLINT)(val12);
18120 if (
_n_dims( args(10) ) > 1 )
18124 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
18125 arg14 =
new PLINT[
Alen];
18126 temp13 = args(10).matrix_value();
18133 arg15 = (
PLFLT)(val15);
18138 arg16 = (
PLFLT)(val16);
18143 arg17 = (
PLFLT)(val17);
18148 arg18 = (
PLFLT)(val18);
18150 if (
_n_dims( args(15) ) > 1 )
18154 if (
_dim( args(15), 0 ) != Alen )
18158 temp19 = args(15).matrix_value();
18159 arg19 =
new PLINT[
Alen];
18163 charMatrix temp_matrix;
18167 size_t max_length = 0, non_blank_length;
18169 if (
_n_dims( args(16) ) > 2 )
18171 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
18173 if ( !args(16).is_empty() )
18175 if (
_dim( args(16), 0 ) != Alen )
18177 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
18179 arg20 =
new char*[
Alen];
18180 ifcell = args(16).is_cell();
18183 temp_cell = args(16).cell_value();
18187 temp_matrix = args(16).char_matrix_value();
18189 max_length =
_dim( args(16), 1 ) + 1;
18192 for ( i = 0; i <
Alen; i++ )
18199 if ( temp_cell.elem( i ).is_string() )
18201 str = temp_cell.elem( i ).string_value();
18203 max_length = str.size() + 1;
18204 tmp_cstring = (
char *) str.c_str();
18214 tmp_cstring = (
char *)
"";
18219 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
18221 arg20[i] =
new char[max_length];
18222 strncpy( arg20[i], tmp_cstring, max_length - 1 );
18223 arg20[i][max_length - 1] =
'\0';
18238 non_blank_length = max_length - 2;
18239 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
18241 non_blank_length--;
18243 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
18245 non_blank_length--;
18247 arg20[i][non_blank_length + 1] =
'\0';
18257 if (
_n_dims( args(17) ) > 1 )
18261 if ( !args(17).is_empty() )
18263 if (
_dim( args(17), 0 ) != Alen )
18267 temp21 = args(17).matrix_value();
18268 arg21 =
new PLINT[
Alen];
18277 if (
_n_dims( args(18) ) > 1 )
18281 if ( !args(18).is_empty() )
18283 if (
_dim( args(18), 0 ) != Alen )
18287 temp22 = args(18).matrix_value();
18288 arg22 =
new PLINT[
Alen];
18297 if (
_n_dims( args(19) ) > 1 )
18301 if ( !args(19).is_empty() )
18303 if (
_dim( args(19), 0 ) != Alen )
18307 temp23 = args(19).matrix_value();
18308 arg23 = &temp23( 0, 0 );
18316 if (
_n_dims( args(20) ) > 1 )
18320 if ( !args(20).is_empty() )
18322 if (
_dim( args(20), 0 ) != Alen )
18326 temp24 = args(20).matrix_value();
18327 arg24 = &temp24( 0, 0 );
18335 if (
_n_dims( args(21) ) > 1 )
18339 if ( !args(21).is_empty() )
18341 if (
_dim( args(21), 0 ) != Alen )
18345 temp25 = args(21).matrix_value();
18346 arg25 =
new PLINT[
Alen];
18355 if (
_n_dims( args(22) ) > 1 )
18359 if ( !args(22).is_empty() )
18361 if (
_dim( args(22), 0 ) != Alen )
18365 temp26 = args(22).matrix_value();
18366 arg26 =
new PLINT[
Alen];
18375 if (
_n_dims( args(23) ) > 1 )
18379 if ( !args(23).is_empty() )
18381 if (
_dim( args(23), 0 ) != Alen )
18385 temp27 = args(23).matrix_value();
18386 arg27 = &temp27( 0, 0 );
18394 if (
_n_dims( args(24) ) > 1 )
18398 if ( !args(24).is_empty() )
18400 if (
_dim( args(24), 0 ) != Alen )
18404 temp28 = args(24).matrix_value();
18405 arg28 =
new PLINT[
Alen];
18414 if (
_n_dims( args(25) ) > 1 )
18418 if ( !args(25).is_empty() )
18420 if (
_dim( args(25), 0 ) != Alen )
18424 temp29 = args(25).matrix_value();
18425 arg29 = &temp29( 0, 0 );
18433 if (
_n_dims( args(26) ) > 1 )
18437 if ( !args(26).is_empty() )
18439 if (
_dim( args(26), 0 ) != Alen )
18443 temp30 = args(26).matrix_value();
18444 arg30 =
new PLINT[
Alen];
18453 charMatrix temp_matrix;
18457 size_t max_length = 0, non_blank_length;
18459 if (
_n_dims( args(27) ) > 2 )
18461 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
18463 if ( !args(27).is_empty() )
18465 if (
_dim( args(27), 0 ) != Alen )
18467 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
18469 arg31 =
new char*[
Alen];
18470 ifcell = args(27).is_cell();
18473 temp_cell = args(27).cell_value();
18477 temp_matrix = args(27).char_matrix_value();
18479 max_length =
_dim( args(27), 1 ) + 1;
18482 for ( i = 0; i <
Alen; i++ )
18489 if ( temp_cell.elem( i ).is_string() )
18491 str = temp_cell.elem( i ).string_value();
18493 max_length = str.size() + 1;
18494 tmp_cstring = (
char *) str.c_str();
18504 tmp_cstring = (
char *)
"";
18509 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
18511 arg31[i] =
new char[max_length];
18512 strncpy( arg31[i], tmp_cstring, max_length - 1 );
18513 arg31[i][max_length - 1] =
'\0';
18528 non_blank_length = max_length - 2;
18529 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
18531 non_blank_length--;
18533 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
18535 non_blank_length--;
18537 arg31[i][non_blank_length + 1] =
'\0';
18546 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);
18547 _outv = octave_value();
18569 if ( arg20 != NULL )
18571 for ( i = 0; i <
Alen; i++ )
18579 if ( arg21 != NULL )
18583 if ( arg22 != NULL )
18593 if ( arg25 != NULL )
18597 if ( arg26 != NULL )
18604 if ( arg28 != NULL )
18611 if ( arg30 != NULL )
18616 if ( arg31 != NULL )
18618 for ( i = 0; i <
Alen; i++ )
18640 octave_value_list _out;
18641 octave_value_list *_outp=&_out;
18642 octave_value _outv;
18651 arg1 = (
PLFLT)(val1);
18656 arg2 = (
PLFLT)(val2);
18661 arg3 = (
PLFLT)(val3);
18663 _outv = octave_value();
18672 PLFLT *arg2 = (PLFLT *) 0 ;
18673 PLFLT *arg3 = (PLFLT *) 0 ;
18676 octave_value_list _out;
18677 octave_value_list *_outp=&_out;
18678 octave_value _outv;
18684 if (
_n_dims( args(0) ) > 1 )
18688 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18689 temp1 = args(0).matrix_value();
18690 arg2 = &temp1( 0, 0 );
18693 if (
_n_dims( args(1) ) > 1 )
18697 if (
_dim( args(1), 0 ) != Alen )
18701 temp3 = args(1).matrix_value();
18702 arg3 = &temp3( 0, 0 );
18704 plline(arg1,(
double const *)arg2,(
double const *)arg3);
18705 _outv = octave_value();
18720 PLFLT *arg2 = (PLFLT *) 0 ;
18721 PLFLT *arg3 = (PLFLT *) 0 ;
18722 PLFLT *arg4 = (PLFLT *) 0 ;
18726 octave_value_list _out;
18727 octave_value_list *_outp=&_out;
18728 octave_value _outv;
18734 if (
_n_dims( args(0) ) > 1 )
18738 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18739 temp1 = args(0).matrix_value();
18740 arg2 = &temp1( 0, 0 );
18743 if (
_n_dims( args(1) ) > 1 )
18747 if (
_dim( args(1), 0 ) != Alen )
18751 temp3 = args(1).matrix_value();
18752 arg3 = &temp3( 0, 0 );
18755 if (
_n_dims( args(2) ) > 1 )
18759 if (
_dim( args(2), 0 ) != Alen )
18763 temp4 = args(2).matrix_value();
18764 arg4 = &temp4( 0, 0 );
18766 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18767 _outv = octave_value();
18787 octave_value_list _out;
18788 octave_value_list *_outp=&_out;
18789 octave_value _outv;
18798 arg1 = (
PLINT)(val1);
18800 _outv = octave_value();
18808 PLINT *arg1 = (PLINT *) 0 ;
18811 octave_value_list _out;
18812 octave_value_list *_outp=&_out;
18813 octave_value _outv;
18820 _outv = octave_value();
18834 char *arg1 = (
char *) 0 ;
18838 char *arg5 = (
char *) 0 ;
18851 octave_value_list _out;
18852 octave_value_list *_outp=&_out;
18853 octave_value _outv;
18862 arg1 = (
char *)(buf1);
18867 arg2 = (
PLFLT)(val2);
18872 arg3 = (
PLFLT)(val3);
18877 arg4 = (
PLFLT)(val4);
18882 arg5 = (
char *)(buf5);
18883 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
18884 _outv = octave_value();
18894 char *arg1 = (
char *) 0 ;
18898 char *arg5 = (
char *) 0 ;
18911 octave_value_list _out;
18912 octave_value_list *_outp=&_out;
18913 octave_value _outv;
18922 arg1 = (
char *)(buf1);
18927 arg2 = (
PLFLT)(val2);
18932 arg3 = (
PLFLT)(val3);
18937 arg4 = (
PLFLT)(val4);
18942 arg5 = (
char *)(buf5);
18943 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
18944 _outv = octave_value();
18954 int *arg1 = (
int *) 0 ;
18955 char **arg2 = (
char **) 0 ;
18963 octave_value_list _out;
18964 octave_value_list *_outp=&_out;
18965 octave_value _outv;
18975 arg1 = (
int *)(argp1);
18980 arg2 = (
char **)(argp2);
18985 arg3 = (
PLINT)(val3);
18996 PLINT *arg2 = (PLINT *) 0 ;
18997 PLINT *arg3 = (PLINT *) 0 ;
19000 octave_value_list _out;
19001 octave_value_list *_outp=&_out;
19002 octave_value _outv;
19008 if (
_n_dims( args(0) ) > 1 )
19012 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19013 arg2 =
new PLINT[
Alen];
19014 temp1 = args(0).matrix_value();
19018 if (
_n_dims( args(1) ) > 1 )
19022 if (
_dim( args(1), 0 ) != Alen )
19026 temp3 = args(1).matrix_value();
19027 arg3 =
new PLINT[
Alen];
19030 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
19031 _outv = octave_value();
19060 octave_value_list _out;
19061 octave_value_list *_outp=&_out;
19062 octave_value _outv;
19071 arg1 = (
PLINT)(val1);
19076 arg2 = (
PLFLT)(val2);
19081 arg3 = (
PLFLT)(val3);
19086 arg4 = (
PLFLT)(val4);
19091 arg5 = (
PLFLT)(val5);
19092 plpath(arg1,arg2,arg3,arg4,arg5);
19093 _outv = octave_value();
19102 PLFLT *arg2 = (PLFLT *) 0 ;
19103 PLFLT *arg3 = (PLFLT *) 0 ;
19109 octave_value_list _out;
19110 octave_value_list *_outp=&_out;
19111 octave_value _outv;
19117 if (
_n_dims( args(0) ) > 1 )
19121 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19122 temp1 = args(0).matrix_value();
19123 arg2 = &temp1( 0, 0 );
19126 if (
_n_dims( args(1) ) > 1 )
19130 if (
_dim( args(1), 0 ) != Alen )
19134 temp3 = args(1).matrix_value();
19135 arg3 = &temp3( 0, 0 );
19141 arg4 = (
PLINT)(val4);
19142 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
19143 _outv = octave_value();
19158 PLFLT *arg2 = (PLFLT *) 0 ;
19159 PLFLT *arg3 = (PLFLT *) 0 ;
19160 PLFLT *arg4 = (PLFLT *) 0 ;
19167 octave_value_list _out;
19168 octave_value_list *_outp=&_out;
19169 octave_value _outv;
19175 if (
_n_dims( args(0) ) > 1 )
19179 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19180 temp1 = args(0).matrix_value();
19181 arg2 = &temp1( 0, 0 );
19184 if (
_n_dims( args(1) ) > 1 )
19188 if (
_dim( args(1), 0 ) != Alen )
19192 temp3 = args(1).matrix_value();
19193 arg3 = &temp3( 0, 0 );
19196 if (
_n_dims( args(2) ) > 1 )
19200 if (
_dim( args(2), 0 ) != Alen )
19204 temp4 = args(2).matrix_value();
19205 arg4 = &temp4( 0, 0 );
19211 arg5 = (
PLINT)(val5);
19212 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
19213 _outv = octave_value();
19231 PLFLT *arg2 = (PLFLT *) 0 ;
19232 PLFLT *arg3 = (PLFLT *) 0 ;
19233 PLFLT *arg4 = (PLFLT *) 0 ;
19242 octave_value_list _out;
19243 octave_value_list *_outp=&_out;
19244 octave_value _outv;
19250 if (
_n_dims( args(0) ) > 1 )
19254 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19255 temp1 = args(0).matrix_value();
19256 arg2 = &temp1( 0, 0 );
19259 if (
_n_dims( args(1) ) > 1 )
19263 if (
_dim( args(1), 0 ) != Alen )
19267 temp3 = args(1).matrix_value();
19268 arg3 = &temp3( 0, 0 );
19271 if (
_n_dims( args(2) ) > 1 )
19275 if (
_dim( args(2), 0 ) != Alen )
19279 temp4 = args(2).matrix_value();
19280 arg4 = &temp4( 0, 0 );
19283 if (
_n_dims( args(3) ) > 1 )
19287 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
19289 error(
"argument vector must be same length or one less" );
SWIG_fail;
19291 temp5 = args(3).matrix_value();
19292 arg5 =
new PLINT[
Alen];
19300 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
19301 _outv = octave_value();
19327 octave_value_list _out;
19328 octave_value_list *_outp=&_out;
19329 octave_value _outv;
19338 arg1 = (
PLINT)(val1);
19343 arg2 = (
PLINT)(val2);
19345 _outv = octave_value();
19356 octave_value_list _out;
19357 octave_value_list *_outp=&_out;
19358 octave_value _outv;
19367 arg1 = (
PLINT)(val1);
19369 _outv = octave_value();
19382 char *arg6 = (
char *) 0 ;
19396 octave_value_list _out;
19397 octave_value_list *_outp=&_out;
19398 octave_value _outv;
19407 arg1 = (
PLFLT)(val1);
19412 arg2 = (
PLFLT)(val2);
19417 arg3 = (
PLFLT)(val3);
19422 arg4 = (
PLFLT)(val4);
19427 arg5 = (
PLFLT)(val5);
19432 arg6 = (
char *)(buf6);
19433 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
19434 _outv = octave_value();
19453 char *arg11 = (
char *) 0 ;
19477 octave_value_list _out;
19478 octave_value_list *_outp=&_out;
19479 octave_value _outv;
19488 arg1 = (
PLFLT)(val1);
19493 arg2 = (
PLFLT)(val2);
19498 arg3 = (
PLFLT)(val3);
19503 arg4 = (
PLFLT)(val4);
19508 arg5 = (
PLFLT)(val5);
19513 arg6 = (
PLFLT)(val6);
19518 arg7 = (
PLFLT)(val7);
19523 arg8 = (
PLFLT)(val8);
19528 arg9 = (
PLFLT)(val9);
19533 arg10 = (
PLFLT)(val10);
19538 arg11 = (
char *)(buf11);
19539 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
19540 _outv = octave_value();
19549 octave_value_list _out;
19550 octave_value_list *_outp=&_out;
19551 octave_value _outv;
19566 octave_value_list _out;
19567 octave_value_list *_outp=&_out;
19568 octave_value _outv;
19574 _outv = octave_value();
19585 PLFLT *arg4 = (PLFLT *) 0 ;
19586 PLFLT *arg5 = (PLFLT *) 0 ;
19587 PLFLT *arg6 = (PLFLT *) 0 ;
19600 octave_value_list _out;
19601 octave_value_list *_outp=&_out;
19602 octave_value _outv;
19614 arg1 = (
PLFLT)(val1);
19619 arg2 = (
PLFLT)(val2);
19624 arg3 = (
PLFLT)(val3);
19625 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
19626 _outv = octave_value();
19658 octave_value_list _out;
19659 octave_value_list *_outp=&_out;
19660 octave_value _outv;
19669 arg1 = (
PLFLT)(val1);
19674 arg2 = (
PLFLT)(val2);
19676 _outv = octave_value();
19684 PLINT *arg1 = (PLINT *) 0 ;
19685 PLINT *arg2 = (PLINT *) 0 ;
19686 PLINT *arg3 = (PLINT *) 0 ;
19691 octave_value_list _out;
19692 octave_value_list *_outp=&_out;
19693 octave_value _outv;
19699 if (
_n_dims( args(0) ) > 1 )
19704 temp1 = args(0).matrix_value();
19705 arg1 =
new PLINT[
Alen];
19709 if (
_n_dims( args(1) ) > 1 )
19713 if (
_dim( args(1), 0 ) != Alen )
19717 temp2 = args(1).matrix_value();
19718 arg2 =
new PLINT[
Alen];
19722 if (
_n_dims( args(2) ) > 1 )
19726 if (
_dim( args(2), 0 ) != Alen )
19730 temp3 = args(2).matrix_value();
19731 arg3 =
new PLINT[
Alen];
19735 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
19736 _outv = octave_value();
19753 PLINT *arg1 = (PLINT *) 0 ;
19754 PLINT *arg2 = (PLINT *) 0 ;
19755 PLINT *arg3 = (PLINT *) 0 ;
19756 PLFLT *arg4 = (PLFLT *) 0 ;
19762 octave_value_list _out;
19763 octave_value_list *_outp=&_out;
19764 octave_value _outv;
19770 if (
_n_dims( args(0) ) > 1 )
19775 temp1 = args(0).matrix_value();
19776 arg1 =
new PLINT[
Alen];
19780 if (
_n_dims( args(1) ) > 1 )
19784 if (
_dim( args(1), 0 ) != Alen )
19788 temp2 = args(1).matrix_value();
19789 arg2 =
new PLINT[
Alen];
19793 if (
_n_dims( args(2) ) > 1 )
19797 if (
_dim( args(2), 0 ) != Alen )
19801 temp3 = args(2).matrix_value();
19802 arg3 =
new PLINT[
Alen];
19806 if (
_n_dims( args(3) ) > 1 )
19810 if (
_dim( args(3), 0 ) != Alen )
19814 temp4 = args(3).matrix_value();
19815 arg4 = &temp4( 0, 0 );
19818 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
19819 _outv = octave_value();
19842 octave_value_list _out;
19843 octave_value_list *_outp=&_out;
19844 octave_value _outv;
19853 arg1 = (
PLINT)(val1);
19855 _outv = octave_value();
19863 PLINT *arg1 = (PLINT *) 0 ;
19864 PLINT *arg2 = (PLINT *) 0 ;
19865 PLINT *arg3 = (PLINT *) 0 ;
19870 octave_value_list _out;
19871 octave_value_list *_outp=&_out;
19872 octave_value _outv;
19878 if (
_n_dims( args(0) ) > 1 )
19883 temp1 = args(0).matrix_value();
19884 arg1 =
new PLINT[
Alen];
19888 if (
_n_dims( args(1) ) > 1 )
19892 if (
_dim( args(1), 0 ) != Alen )
19896 temp2 = args(1).matrix_value();
19897 arg2 =
new PLINT[
Alen];
19901 if (
_n_dims( args(2) ) > 1 )
19905 if (
_dim( args(2), 0 ) != Alen )
19909 temp3 = args(2).matrix_value();
19910 arg3 =
new PLINT[
Alen];
19914 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
19915 _outv = octave_value();
19932 PLINT *arg1 = (PLINT *) 0 ;
19933 PLINT *arg2 = (PLINT *) 0 ;
19934 PLINT *arg3 = (PLINT *) 0 ;
19935 PLFLT *arg4 = (PLFLT *) 0 ;
19941 octave_value_list _out;
19942 octave_value_list *_outp=&_out;
19943 octave_value _outv;
19949 if (
_n_dims( args(0) ) > 1 )
19954 temp1 = args(0).matrix_value();
19955 arg1 =
new PLINT[
Alen];
19959 if (
_n_dims( args(1) ) > 1 )
19963 if (
_dim( args(1), 0 ) != Alen )
19967 temp2 = args(1).matrix_value();
19968 arg2 =
new PLINT[
Alen];
19972 if (
_n_dims( args(2) ) > 1 )
19976 if (
_dim( args(2), 0 ) != Alen )
19980 temp3 = args(2).matrix_value();
19981 arg3 =
new PLINT[
Alen];
19985 if (
_n_dims( args(3) ) > 1 )
19989 if (
_dim( args(3), 0 ) != Alen )
19993 temp4 = args(3).matrix_value();
19994 arg4 = &temp4( 0, 0 );
19997 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
19998 _outv = octave_value();
20020 PLFLT *arg3 = (PLFLT *) 0 ;
20021 PLFLT *arg4 = (PLFLT *) 0 ;
20022 PLFLT *arg5 = (PLFLT *) 0 ;
20023 PLFLT *arg6 = (PLFLT *) 0 ;
20032 octave_value_list _out;
20033 octave_value_list *_outp=&_out;
20034 octave_value _outv;
20045 if (
_n_dims( args(1) ) > 1 )
20049 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
20050 temp2 = args(1).matrix_value();
20051 arg3 = &temp2( 0, 0 );
20054 if (
_n_dims( args(2) ) > 1 )
20058 if (
_dim( args(2), 0 ) != Alen )
20062 temp4 = args(2).matrix_value();
20063 arg4 = &temp4( 0, 0 );
20066 if (
_n_dims( args(3) ) > 1 )
20070 if (
_dim( args(3), 0 ) != Alen )
20074 temp5 = args(3).matrix_value();
20075 arg5 = &temp5( 0, 0 );
20078 if (
_n_dims( args(4) ) > 1 )
20082 if (
_dim( args(4), 0 ) != Alen )
20086 temp6 = args(4).matrix_value();
20087 arg6 = &temp6( 0, 0 );
20090 if (
_n_dims( args(5) ) > 1 )
20094 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
20096 error(
"argument vector must be same length or one less" );
SWIG_fail;
20098 temp7 = args(5).matrix_value();
20099 arg7 =
new PLINT[
Alen];
20102 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
20103 _outv = octave_value();
20128 PLFLT *arg3 = (PLFLT *) 0 ;
20129 PLFLT *arg4 = (PLFLT *) 0 ;
20130 PLFLT *arg5 = (PLFLT *) 0 ;
20131 PLFLT *arg6 = (PLFLT *) 0 ;
20132 PLFLT *arg7 = (PLFLT *) 0 ;
20142 octave_value_list _out;
20143 octave_value_list *_outp=&_out;
20144 octave_value _outv;
20155 if (
_n_dims( args(1) ) > 1 )
20159 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
20160 temp2 = args(1).matrix_value();
20161 arg3 = &temp2( 0, 0 );
20164 if (
_n_dims( args(2) ) > 1 )
20168 if (
_dim( args(2), 0 ) != Alen )
20172 temp4 = args(2).matrix_value();
20173 arg4 = &temp4( 0, 0 );
20176 if (
_n_dims( args(3) ) > 1 )
20180 if (
_dim( args(3), 0 ) != Alen )
20184 temp5 = args(3).matrix_value();
20185 arg5 = &temp5( 0, 0 );
20188 if (
_n_dims( args(4) ) > 1 )
20192 if (
_dim( args(4), 0 ) != Alen )
20196 temp6 = args(4).matrix_value();
20197 arg6 = &temp6( 0, 0 );
20200 if (
_n_dims( args(5) ) > 1 )
20204 if (
_dim( args(5), 0 ) != Alen )
20208 temp7 = args(5).matrix_value();
20209 arg7 = &temp7( 0, 0 );
20212 if (
_n_dims( args(6) ) > 1 )
20216 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
20218 error(
"argument vector must be same length or one less" );
SWIG_fail;
20220 temp8 = args(6).matrix_value();
20221 arg8 =
new PLINT[
Alen];
20224 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
20225 _outv = octave_value();
20254 octave_value_list _out;
20255 octave_value_list *_outp=&_out;
20256 octave_value _outv;
20265 arg1 = (
PLINT)(val1);
20267 _outv = octave_value();
20281 octave_value_list _out;
20282 octave_value_list *_outp=&_out;
20283 octave_value _outv;
20292 arg1 = (
PLFLT)(val1);
20297 arg2 = (
PLFLT)(val2);
20299 _outv = octave_value();
20307 PLFLT *arg1 = (PLFLT *) 0 ;
20308 PLFLT *arg2 = (PLFLT *) 0 ;
20313 octave_value_list _out;
20314 octave_value_list *_outp=&_out;
20315 octave_value _outv;
20323 _outv = octave_value();
20355 octave_value_list _out;
20356 octave_value_list *_outp=&_out;
20357 octave_value _outv;
20366 arg1 = (
PLINT)(val1);
20371 arg2 = (
PLINT)(val2);
20376 arg3 = (
PLINT)(val3);
20381 arg4 = (
PLINT)(val4);
20382 plscol0(arg1,arg2,arg3,arg4);
20383 _outv = octave_value();
20406 octave_value_list _out;
20407 octave_value_list *_outp=&_out;
20408 octave_value _outv;
20417 arg1 = (
PLINT)(val1);
20422 arg2 = (
PLINT)(val2);
20427 arg3 = (
PLINT)(val3);
20432 arg4 = (
PLINT)(val4);
20437 arg5 = (
PLFLT)(val5);
20438 plscol0a(arg1,arg2,arg3,arg4,arg5);
20439 _outv = octave_value();
20456 octave_value_list _out;
20457 octave_value_list *_outp=&_out;
20458 octave_value _outv;
20467 arg1 = (
PLINT)(val1);
20472 arg2 = (
PLINT)(val2);
20477 arg3 = (
PLINT)(val3);
20479 _outv = octave_value();
20499 octave_value_list _out;
20500 octave_value_list *_outp=&_out;
20501 octave_value _outv;
20510 arg1 = (
PLINT)(val1);
20515 arg2 = (
PLINT)(val2);
20520 arg3 = (
PLINT)(val3);
20525 arg4 = (
PLFLT)(val4);
20527 _outv = octave_value();
20538 octave_value_list _out;
20539 octave_value_list *_outp=&_out;
20540 octave_value _outv;
20549 arg1 = (
PLINT)(val1);
20551 _outv = octave_value();
20562 octave_value_list _out;
20563 octave_value_list *_outp=&_out;
20564 octave_value _outv;
20573 arg1 = (
PLINT)(val1);
20575 _outv = octave_value();
20583 char *arg1 = (
char *) 0 ;
20587 octave_value_list _out;
20588 octave_value_list *_outp=&_out;
20589 octave_value _outv;
20598 arg1 = (
char *)(buf1);
20599 plsdev((
char const *)arg1);
20600 _outv = octave_value();
20621 octave_value_list _out;
20622 octave_value_list *_outp=&_out;
20623 octave_value _outv;
20632 arg1 = (
PLFLT)(val1);
20637 arg2 = (
PLFLT)(val2);
20642 arg3 = (
PLFLT)(val3);
20647 arg4 = (
PLFLT)(val4);
20649 _outv = octave_value();
20675 octave_value_list _out;
20676 octave_value_list *_outp=&_out;
20677 octave_value _outv;
20686 arg1 = (
PLINT)(val1);
20691 arg2 = (
PLINT)(val2);
20696 arg3 = (
PLINT)(val3);
20701 arg4 = (
PLINT)(val4);
20706 arg5 = (
PLFLT)(val5);
20711 arg6 = (
PLFLT)(val6);
20712 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
20713 _outv = octave_value();
20724 octave_value_list _out;
20725 octave_value_list *_outp=&_out;
20726 octave_value _outv;
20735 arg1 = (
PLFLT)(val1);
20737 _outv = octave_value();
20757 octave_value_list _out;
20758 octave_value_list *_outp=&_out;
20759 octave_value _outv;
20768 arg1 = (
PLFLT)(val1);
20773 arg2 = (
PLFLT)(val2);
20778 arg3 = (
PLFLT)(val3);
20783 arg4 = (
PLFLT)(val4);
20785 _outv = octave_value();
20805 octave_value_list _out;
20806 octave_value_list *_outp=&_out;
20807 octave_value _outv;
20816 arg1 = (
PLFLT)(val1);
20821 arg2 = (
PLFLT)(val2);
20826 arg3 = (
PLFLT)(val3);
20831 arg4 = (
PLFLT)(val4);
20833 _outv = octave_value();
20841 unsigned int arg1 ;
20842 unsigned int val1 ;
20844 octave_value_list _out;
20845 octave_value_list *_outp=&_out;
20846 octave_value _outv;
20855 arg1 = (
unsigned int)(val1);
20857 _outv = octave_value();
20868 octave_value_list _out;
20869 octave_value_list *_outp=&_out;
20870 octave_value _outv;
20879 arg1 = (char)(val1);
20881 _outv = octave_value();
20889 char *arg1 = (
char *) 0 ;
20890 char *arg2 = (
char *) 0 ;
20897 octave_value_list _out;
20898 octave_value_list *_outp=&_out;
20899 octave_value _outv;
20909 arg1 = (
char *)(buf1);
20914 arg2 = (
char *)(buf2);
20915 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
20935 octave_value_list _out;
20936 octave_value_list *_outp=&_out;
20937 octave_value _outv;
20946 arg1 = (
PLINT)(val1);
20951 arg2 = (
PLINT)(val2);
20956 arg3 = (
PLINT)(val3);
20958 _outv = octave_value();
20967 unsigned int val1 ;
20969 octave_value_list _out;
20970 octave_value_list *_outp=&_out;
20971 octave_value _outv;
20982 _outv = octave_value();
20990 char *arg1 = (
char *) 0 ;
20994 octave_value_list _out;
20995 octave_value_list *_outp=&_out;
20996 octave_value _outv;
21005 arg1 = (
char *)(buf1);
21007 _outv = octave_value();
21025 octave_value_list _out;
21026 octave_value_list *_outp=&_out;
21027 octave_value _outv;
21036 arg1 = (
PLINT)(val1);
21041 arg2 = (
PLINT)(val2);
21046 arg3 = (
PLINT)(val3);
21048 _outv = octave_value();
21059 octave_value_list _out;
21060 octave_value_list *_outp=&_out;
21061 octave_value _outv;
21067 octave_value obj = args(0);
21068 if ( !obj.is_empty() )
21070 if ( obj.is_function_handle() || obj.is_inline_function() )
21072 fcnLabelFunc = obj.function_value();
21074 else if ( obj.is_string() )
21076 nameLabelFunc = obj.string_value();
21077 fcnLabelFunc = NULL;
21091 _outv = octave_value();
21105 octave_value_list _out;
21106 octave_value_list *_outp=&_out;
21107 octave_value _outv;
21116 arg1 = (
PLFLT)(val1);
21121 arg2 = (
PLFLT)(val2);
21123 _outv = octave_value();
21137 octave_value_list _out;
21138 octave_value_list *_outp=&_out;
21139 octave_value _outv;
21148 arg1 = (
PLFLT)(val1);
21153 arg2 = (
PLFLT)(val2);
21155 _outv = octave_value();
21166 octave_value_list _out;
21167 octave_value_list *_outp=&_out;
21168 octave_value _outv;
21177 arg1 = (
PLINT)(val1);
21179 _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);
21226 arg3 = (
PLINT)(val3);
21231 arg4 = (
PLINT)(val4);
21236 arg5 = (
PLINT)(val5);
21241 arg6 = (
PLINT)(val6);
21242 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
21243 _outv = octave_value();
21251 char *arg1 = (
char *) 0 ;
21255 octave_value_list _out;
21256 octave_value_list *_outp=&_out;
21257 octave_value _outv;
21266 arg1 = (
char *)(buf1);
21268 _outv = octave_value();
21277 char *arg1 = (
char *) 0 ;
21284 octave_value_list _out;
21285 octave_value_list *_outp=&_out;
21286 octave_value _outv;
21295 arg1 = (
char *)(buf1);
21301 plspal1((
char const *)arg1,arg2);
21302 _outv = octave_value();
21314 octave_value_list _out;
21315 octave_value_list *_outp=&_out;
21316 octave_value _outv;
21327 _outv = octave_value();
21338 octave_value_list _out;
21339 octave_value_list *_outp=&_out;
21340 octave_value _outv;
21349 arg1 = (
PLINT)(val1);
21351 _outv = octave_value();
21365 octave_value_list _out;
21366 octave_value_list *_outp=&_out;
21367 octave_value _outv;
21376 arg1 = (
PLINT)(val1);
21381 arg2 = (
PLINT)(val2);
21383 _outv = octave_value();
21397 octave_value_list _out;
21398 octave_value_list *_outp=&_out;
21399 octave_value _outv;
21408 arg1 = (
PLFLT)(val1);
21413 arg2 = (
PLFLT)(val2);
21415 _outv = octave_value();
21429 octave_value_list _out;
21430 octave_value_list *_outp=&_out;
21431 octave_value _outv;
21440 arg1 = (
PLINT)(val1);
21445 arg2 = (
PLINT)(val2);
21447 _outv = octave_value();
21455 char *arg1 = (
char *) 0 ;
21465 octave_value_list _out;
21466 octave_value_list *_outp=&_out;
21467 octave_value _outv;
21476 arg1 = (
char *)(buf1);
21481 arg2 = (
PLINT)(val2);
21486 arg3 = (
PLINT)(val3);
21487 plstart((
char const *)arg1,arg2,arg3);
21488 _outv = octave_value();
21500 octave_value_list _out;
21501 octave_value_list *_outp=&_out;
21502 octave_value _outv;
21508 octave_value obj = args(0);
21509 if ( !obj.is_empty() )
21511 if ( obj.is_function_handle() || obj.is_inline_function() )
21513 fcnCoordTrans = obj.function_value();
21515 else if ( obj.is_string() )
21517 nameCoordTrans = obj.string_value();
21518 fcnCoordTrans = NULL;
21532 _outv = octave_value();
21541 PLFLT *arg2 = (PLFLT *) 0 ;
21542 PLFLT *arg3 = (PLFLT *) 0 ;
21543 char *arg4 = (
char *) 0 ;
21549 octave_value_list _out;
21550 octave_value_list *_outp=&_out;
21551 octave_value _outv;
21557 if (
_n_dims( args(0) ) > 1 )
21561 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21562 temp1 = args(0).matrix_value();
21563 arg2 = &temp1( 0, 0 );
21566 if (
_n_dims( args(1) ) > 1 )
21570 if (
_dim( args(1), 0 ) != Alen )
21574 temp3 = args(1).matrix_value();
21575 arg3 = &temp3( 0, 0 );
21581 arg4 = (
char *)(buf4);
21582 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
21583 _outv = octave_value();
21599 PLFLT *arg2 = (PLFLT *) 0 ;
21600 PLFLT *arg3 = (PLFLT *) 0 ;
21601 PLFLT *arg4 = (PLFLT *) 0 ;
21602 char *arg5 = (
char *) 0 ;
21609 octave_value_list _out;
21610 octave_value_list *_outp=&_out;
21611 octave_value _outv;
21617 if (
_n_dims( args(0) ) > 1 )
21621 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21622 temp1 = args(0).matrix_value();
21623 arg2 = &temp1( 0, 0 );
21626 if (
_n_dims( args(1) ) > 1 )
21630 if (
_dim( args(1), 0 ) != Alen )
21634 temp3 = args(1).matrix_value();
21635 arg3 = &temp3( 0, 0 );
21638 if (
_n_dims( args(2) ) > 1 )
21642 if (
_dim( args(2), 0 ) != Alen )
21646 temp4 = args(2).matrix_value();
21647 arg4 = &temp4( 0, 0 );
21653 arg5 = (
char *)(buf5);
21654 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
21655 _outv = octave_value();
21685 octave_value_list _out;
21686 octave_value_list *_outp=&_out;
21687 octave_value _outv;
21696 arg1 = (
PLINT)(val1);
21701 arg2 = (
PLINT)(val2);
21706 arg3 = (
PLFLT)(val3);
21711 arg4 = (
PLFLT)(val4);
21713 _outv = octave_value();
21724 octave_value_list _out;
21725 octave_value_list *_outp=&_out;
21726 octave_value _outv;
21735 arg1 = (
PLINT)(val1);
21737 _outv = octave_value();
21746 PLINT *arg2 = (PLINT *) 0 ;
21747 PLINT *arg3 = (PLINT *) 0 ;
21750 octave_value_list _out;
21751 octave_value_list *_outp=&_out;
21752 octave_value _outv;
21758 if (
_n_dims( args(0) ) > 1 )
21762 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
21763 arg2 =
new PLINT[
Alen];
21764 temp1 = args(0).matrix_value();
21768 if (
_n_dims( args(1) ) > 1 )
21772 if (
_dim( args(1), 0 ) != Alen )
21776 temp3 = args(1).matrix_value();
21777 arg3 =
new PLINT[
Alen];
21780 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
21781 _outv = octave_value();
21795 PLFLT *arg1 = (PLFLT *) 0 ;
21796 PLFLT *arg2 = (PLFLT *) 0 ;
21803 octave_value_list _out;
21804 octave_value_list *_outp=&_out;
21805 octave_value _outv;
21811 if (
_n_dims( args(0) ) > 1 )
21815 if ( !args(0).is_empty() )
21818 temp1 = args(0).matrix_value();
21819 arg1 = &temp1( 0, 0 );
21828 if (
_n_dims( args(1) ) > 1 )
21832 if ( !args(1).is_empty() )
21834 if (
_dim( args(1), 0 ) != Alen )
21838 temp2 = args(1).matrix_value();
21839 arg2 = &temp2( 0, 0 );
21853 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
21854 _outv = octave_value();
21880 octave_value_list _out;
21881 octave_value_list *_outp=&_out;
21882 octave_value _outv;
21891 arg1 = (
PLFLT)(val1);
21896 arg2 = (
PLFLT)(val2);
21901 arg3 = (
PLFLT)(val3);
21906 arg4 = (
PLFLT)(val4);
21907 plsvpa(arg1,arg2,arg3,arg4);
21908 _outv = octave_value();
21922 octave_value_list _out;
21923 octave_value_list *_outp=&_out;
21924 octave_value _outv;
21933 arg1 = (
PLINT)(val1);
21938 arg2 = (
PLINT)(val2);
21940 _outv = octave_value();
21954 octave_value_list _out;
21955 octave_value_list *_outp=&_out;
21956 octave_value _outv;
21965 arg1 = (
PLINT)(val1);
21970 arg2 = (
PLINT)(val2);
21972 _outv = octave_value();
21981 PLFLT *arg2 = (PLFLT *) 0 ;
21982 PLFLT *arg3 = (PLFLT *) 0 ;
21988 octave_value_list _out;
21989 octave_value_list *_outp=&_out;
21990 octave_value _outv;
21996 if (
_n_dims( args(0) ) > 1 )
22000 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
22001 temp1 = args(0).matrix_value();
22002 arg2 = &temp1( 0, 0 );
22005 if (
_n_dims( args(1) ) > 1 )
22009 if (
_dim( args(1), 0 ) != Alen )
22013 temp3 = args(1).matrix_value();
22014 arg3 = &temp3( 0, 0 );
22020 arg4 = (
PLINT)(val4);
22021 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
22022 _outv = octave_value();
22042 octave_value_list _out;
22043 octave_value_list *_outp=&_out;
22044 octave_value _outv;
22053 arg1 = (
PLINT)(val1);
22058 arg2 = (
PLINT)(val2);
22060 _outv = octave_value();
22068 octave_value_list _out;
22069 octave_value_list *_outp=&_out;
22070 octave_value _outv;
22076 _outv = octave_value();
22084 char *arg1 = (
char *) 0 ;
22088 octave_value_list _out;
22089 octave_value_list *_outp=&_out;
22090 octave_value _outv;
22099 arg1 = (
char *)(buf1);
22101 _outv = octave_value();
22113 octave_value_list _out;
22114 octave_value_list *_outp=&_out;
22115 octave_value _outv;
22124 arg1 = (
PLFLT)(val1);
22126 _outv = octave_value();
22149 octave_value_list _out;
22150 octave_value_list *_outp=&_out;
22151 octave_value _outv;
22160 arg1 = (
PLFLT)(val1);
22165 arg2 = (
PLFLT)(val2);
22170 arg3 = (
PLFLT)(val3);
22175 arg4 = (
PLFLT)(val4);
22180 arg5 = (
PLFLT)(val5);
22181 plvpas(arg1,arg2,arg3,arg4,arg5);
22182 _outv = octave_value();
22202 octave_value_list _out;
22203 octave_value_list *_outp=&_out;
22204 octave_value _outv;
22213 arg1 = (
PLFLT)(val1);
22218 arg2 = (
PLFLT)(val2);
22223 arg3 = (
PLFLT)(val3);
22228 arg4 = (
PLFLT)(val4);
22229 plvpor(arg1,arg2,arg3,arg4);
22230 _outv = octave_value();
22238 octave_value_list _out;
22239 octave_value_list *_outp=&_out;
22240 octave_value _outv;
22246 _outv = octave_value();
22287 octave_value_list _out;
22288 octave_value_list *_outp=&_out;
22289 octave_value _outv;
22298 arg1 = (
PLFLT)(val1);
22303 arg2 = (
PLFLT)(val2);
22308 arg3 = (
PLFLT)(val3);
22313 arg4 = (
PLFLT)(val4);
22318 arg5 = (
PLFLT)(val5);
22323 arg6 = (
PLFLT)(val6);
22328 arg7 = (
PLFLT)(val7);
22333 arg8 = (
PLFLT)(val8);
22338 arg9 = (
PLFLT)(val9);
22343 arg10 = (
PLFLT)(val10);
22348 arg11 = (
PLFLT)(val11);
22349 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22350 _outv = octave_value();
22361 octave_value_list _out;
22362 octave_value_list *_outp=&_out;
22363 octave_value _outv;
22372 arg1 = (
PLFLT)(val1);
22374 _outv = octave_value();
22394 octave_value_list _out;
22395 octave_value_list *_outp=&_out;
22396 octave_value _outv;
22405 arg1 = (
PLFLT)(val1);
22410 arg2 = (
PLFLT)(val2);
22415 arg3 = (
PLFLT)(val3);
22420 arg4 = (
PLFLT)(val4);
22421 plwind(arg1,arg2,arg3,arg4);
22422 _outv = octave_value();
22436 octave_value_list _out;
22437 octave_value_list *_outp=&_out;
22438 octave_value _outv;
22450 _outv = octave_value();
22465 char *arg2 = (
char *) 0 ;
22481 octave_value_list _out;
22482 octave_value_list *_outp=&_out;
22483 octave_value _outv;
22489 octave_value obj = args(0);
22490 if ( !obj.is_empty() )
22492 if ( obj.is_function_handle() || obj.is_inline_function() )
22494 fcnMapForm = obj.function_value();
22496 else if ( obj.is_string() )
22498 nameMapForm = obj.string_value();
22512 arg2 = (
char *)(buf2);
22517 arg3 = (
PLFLT)(val3);
22522 arg4 = (
PLFLT)(val4);
22527 arg5 = (
PLFLT)(val5);
22532 arg6 = (
PLFLT)(val6);
22533 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
22534 _outv = octave_value();
22544 char *arg2 = (
char *) 0 ;
22549 PLINT *arg7 = (PLINT *) 0 ;
22563 octave_value_list _out;
22564 octave_value_list *_outp=&_out;
22565 octave_value _outv;
22571 octave_value obj = args(0);
22572 if ( !obj.is_empty() )
22574 if ( obj.is_function_handle() || obj.is_inline_function() )
22576 fcnMapForm = obj.function_value();
22578 else if ( obj.is_string() )
22580 nameMapForm = obj.string_value();
22594 arg2 = (
char *)(buf2);
22599 arg3 = (
PLFLT)(val3);
22604 arg4 = (
PLFLT)(val4);
22609 arg5 = (
PLFLT)(val5);
22614 arg6 = (
PLFLT)(val6);
22616 if (
_n_dims( args(6) ) > 1 )
22620 if ( !args(6).is_empty() )
22623 temp7 = args(6).matrix_value();
22624 arg7 =
new PLINT[arg8];
22633 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
22634 _outv = octave_value();
22647 char *arg2 = (
char *) 0 ;
22648 char *arg3 = (
char *) 0 ;
22653 PLINT *arg8 = (PLINT *) 0 ;
22670 octave_value_list _out;
22671 octave_value_list *_outp=&_out;
22672 octave_value _outv;
22678 octave_value obj = args(0);
22679 if ( !obj.is_empty() )
22681 if ( obj.is_function_handle() || obj.is_inline_function() )
22683 fcnMapForm = obj.function_value();
22685 else if ( obj.is_string() )
22687 nameMapForm = obj.string_value();
22701 arg2 = (
char *)(buf2);
22706 arg3 = (
char *)(buf3);
22711 arg4 = (
PLFLT)(val4);
22716 arg5 = (
PLFLT)(val5);
22721 arg6 = (
PLFLT)(val6);
22726 arg7 = (
PLFLT)(val7);
22728 if (
_n_dims( args(7) ) > 1 )
22732 if ( !args(7).is_empty() )
22735 temp8 = args(7).matrix_value();
22736 arg8 =
new PLINT[arg9];
22745 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
22746 _outv = octave_value();
22760 char *arg2 = (
char *) 0 ;
22764 char *arg6 = (
char *) 0 ;
22792 octave_value_list _out;
22793 octave_value_list *_outp=&_out;
22794 octave_value _outv;
22800 octave_value obj = args(0);
22801 if ( !obj.is_empty() )
22803 if ( obj.is_function_handle() || obj.is_inline_function() )
22805 fcnMapForm = obj.function_value();
22807 else if ( obj.is_string() )
22809 nameMapForm = obj.string_value();
22823 arg2 = (
char *)(buf2);
22828 arg3 = (
PLFLT)(val3);
22833 arg4 = (
PLFLT)(val4);
22838 arg5 = (
PLFLT)(val5);
22843 arg6 = (
char *)(buf6);
22848 arg7 = (
PLFLT)(val7);
22853 arg8 = (
PLFLT)(val8);
22858 arg9 = (
PLFLT)(val9);
22863 arg10 = (
PLFLT)(val10);
22868 arg11 = (
PLINT)(val11);
22869 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
22870 _outv = octave_value();
22881 char *arg2 = (
char *) 0 ;
22886 PLINT *arg7 = (PLINT *) 0 ;
22900 octave_value_list _out;
22901 octave_value_list *_outp=&_out;
22902 octave_value _outv;
22908 octave_value obj = args(0);
22909 if ( !obj.is_empty() )
22911 if ( obj.is_function_handle() || obj.is_inline_function() )
22913 fcnMapForm = obj.function_value();
22915 else if ( obj.is_string() )
22917 nameMapForm = obj.string_value();
22931 arg2 = (
char *)(buf2);
22936 arg3 = (
PLFLT)(val3);
22941 arg4 = (
PLFLT)(val4);
22946 arg5 = (
PLFLT)(val5);
22951 arg6 = (
PLFLT)(val6);
22953 if (
_n_dims( args(6) ) > 1 )
22957 if ( !args(6).is_empty() )
22960 temp7 = args(6).matrix_value();
22961 arg7 =
new PLINT[arg8];
22970 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
22971 _outv = octave_value();
23002 octave_value_list _out;
23003 octave_value_list *_outp=&_out;
23004 octave_value _outv;
23010 octave_value obj = args(0);
23011 if ( !obj.is_empty() )
23013 if ( obj.is_function_handle() || obj.is_inline_function() )
23015 fcnMapForm = obj.function_value();
23017 else if ( obj.is_string() )
23019 nameMapForm = obj.string_value();
23033 arg2 = (
PLFLT)(val2);
23038 arg3 = (
PLFLT)(val3);
23043 arg4 = (
PLFLT)(val4);
23048 arg5 = (
PLFLT)(val5);
23053 arg6 = (
PLFLT)(val6);
23058 arg7 = (
PLFLT)(val7);
23060 _outv = octave_value();
23068 octave_value_list _out;
23069 octave_value_list *_outp=&_out;
23070 octave_value _outv;
23076 _outv = octave_value();
23084 octave_value_list _out;
23085 octave_value_list *_outp=&_out;
23086 octave_value _outv;
23092 _outv = octave_value();
23100 char *arg1 = (
char *) 0 ;
23101 char *arg2 = (
char *) 0 ;
23108 octave_value_list _out;
23109 octave_value_list *_outp=&_out;
23110 octave_value _outv;
23119 arg1 = (
char *)(buf1);
23124 arg2 = (
char *)(buf2);
23125 plSetUsage((
char const *)arg1,(
char const *)arg2);
23126 _outv = octave_value();
23136 octave_value_list _out;
23137 octave_value_list *_outp=&_out;
23138 octave_value _outv;
23144 _outv = octave_value();
23153 {
"testppchar",_wrap_testppchar,0,0,2,0},
23155 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
23158 {
"plcont0",_wrap_plcont0,0,0,2,0},
23159 {
"plcont1",_wrap_plcont1,0,0,2,0},
23160 {
"plcont2",_wrap_plcont2,0,0,2,0},
23161 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
23171 {
"plshade1",_wrap_plshade1,0,0,2,_wrap_plshade1_texinfo},
23172 {
"plshade2",_wrap_plshade2,0,0,2,0},
23174 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
23175 {
"plshades1",_wrap_plshades1,0,0,2,0},
23176 {
"plshades2",_wrap_plshades2,0,0,2,0},
23178 {
"plvect1",_wrap_plvect1,0,0,2,0},
23179 {
"plvect2",_wrap_plvect2,0,0,2,0},
23180 {
"pplimage",_wrap_pplimage,0,0,2,0},
23182 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
23183 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
23184 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
23319 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
23470 #define SWIGRUNTIME_DEBUG
23480 clientdata = clientdata;
23483 if (swig_module.
next==0) {
23495 if (!module_head) {
23505 if (iter==&swig_module) {
23510 }
while (iter!= module_head);
23515 swig_module.
next = module_head->
next;
23523 if (init == 0)
return;
23526 #ifdef SWIGRUNTIME_DEBUG
23527 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
23529 for (i = 0; i < swig_module.
size; ++i) {
23534 #ifdef SWIGRUNTIME_DEBUG
23535 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
23539 if (swig_module.
next != &swig_module) {
23544 #ifdef SWIGRUNTIME_DEBUG
23545 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
23549 #ifdef SWIGRUNTIME_DEBUG
23550 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
23559 while (cast->
type) {
23563 #ifdef SWIGRUNTIME_DEBUG
23564 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
23566 if (swig_module.
next != &swig_module) {
23568 #ifdef SWIGRUNTIME_DEBUG
23569 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
23574 #ifdef SWIGRUNTIME_DEBUG
23575 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
23582 #ifdef SWIGRUNTIME_DEBUG
23583 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
23585 if (!ocast) ret = 0;
23590 #ifdef SWIGRUNTIME_DEBUG
23591 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
23602 swig_module.
types[i] = type;
23604 swig_module.
types[i] = 0;
23606 #ifdef SWIGRUNTIME_DEBUG
23607 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23608 for (i = 0; i < swig_module.
size; ++i) {
23611 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
23612 while (cast->
type) {
23613 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
23617 printf(
"---- Total casts: %d\n",j);
23619 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
23632 static int init_run = 0;
23634 if (init_run)
return;
23637 for (i = 0; i < swig_module.
size; i++) {
23645 equiv = equiv->
next;
23663 octave_value_list args;
23665 args.append(octloadfcn->fcn_file_name());
23666 feval(
"autoload", args, 0);
23670 @deftypefn {Loadable Function} {} subclass()\n\
23671 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
23672 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
23674 See the SWIG manual for usage examples.\n\
23679 for (
int j = 0; j < args.length(); ++j) {
23680 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
23683 if (!ost->is_owned()) {
23684 error(
"cannot subclass object not constructed on octave side");
23685 return octave_value_list();
23688 }
else if (args(j).is_function_handle()) {
23689 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
23690 }
else if (args(j).is_string()) {
23691 if (j + 1 >= args.length()) {
23692 error(
"member assignments must be of string,value form");
23693 return octave_value_list();
23695 top->
assign(args(j).string_value(), args(j + 1));
23698 error(
"invalid arguments to subclass()");
23699 return octave_value_list();
23706 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
23707 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
23711 if (args.length() != 1) {
23712 error(
"swig_type() must be called with only a single object");
23713 return octave_value_list();
23717 error(
"object is not a swig_ref");
23718 return octave_value_list();
23724 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
23725 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
23726 otherwise return `<unknown>'.\n\
23729 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
23730 if (args.length() != 1 || !args(0).is_string()) {
23731 error(
"swig_typequery() must be called with single string argument");
23732 return octave_value_list();
23737 return octave_value(
"<unknown>");
23738 return octave_value(type->
name);
23742 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
23743 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
23747 if (args.length() != 1) {
23748 error(
"swig_this() must be called with only a single object");
23749 return octave_value_list();
23751 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
23752 return octave_value(octave_uint64(0));
23755 error(
"object is not a swig_ref");
23756 return octave_value_list();
23758 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
23765 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
23766 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
23767 #define SWIG_OCTAVE_SEGFAULT_HACK
23770 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23771 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
23772 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
23774 _exit(exit_status);
23779 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
23780 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
23782 To load the module into the global namespace:\n\
23786 To access the module through a local variable, without loading it globally:\n\
23790 To access the module locally through a variable named, e.g. @var{modl}:\n\
23799 octave_value_list retval;
23804 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23810 #if OCTAVE_API_VERSION_NUMBER >= 37
23811 octave_value_list eval_args;
23812 eval_args.append(
"base");
23813 eval_args.append(
"function __swig_atexit__; "
23820 "__swig_atexit__; "
23821 "atexit(\"__swig_atexit__\", false); "
23822 "atexit(\"__swig_atexit__\")");
23823 feval(
"evalin", eval_args, 0);
23826 octave_swig_ref::register_type();
23827 octave_swig_packed::register_type();
23831 octave_function *me = octave_call_stack::current();
23841 for (
int j=0;swig_globals[j].
name;++j)
23843 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23851 for (
int j=0;swig_globals[j].
name;++j)
23853 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23855 for (
int j=0;swig_globals[j].
name;++j)
23856 if (swig_globals[j].
method)
23857 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
23862 for (
int j=0;swig_types[j];++j)
23863 if (swig_types[j]->clientdata) {
23874 #if OCTAVE_API_VERSION_NUMBER < 37
23883 if (args.length() == 0 && nargout == 1) {
23884 retval = octave_value(module_ns->
as_value());
23888 else if (args.length() == 0 && nargout == 0) {
23890 octave_function *me = octave_call_stack::current();
23894 if (mb->second.first && mb->second.first->method) {
23897 else if (mb->second.second.is_defined()) {