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 );
f2c( yg, ygg, nx, ny );
2608 grid2.
nx =
nx; grid2.
ny = ny;
2609 grid2.
xg = xgg; grid2.
yg = ygg;
2610 f2c( f, ff, nx, ny );
2611 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2616 void my_plcont2p(
const PLFLT *f, PLINT
nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2617 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2620 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2621 grid2.
nx =
nx; grid2.
ny = ny;
2622 grid2.
xg = xgg; grid2.
yg = ygg;
2623 f2c( f, ff, nx, ny );
2624 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2629 const PLFLT *
xg,
int nptsx,
const PLFLT *
yg,
int nptsy,
2630 PLFLT *zg,
int type, PLFLT data )
2632 f2c( zg, zgg, nptsx, nptsy );
2633 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2634 for (
int i = 0; i < nptsx; i++ )
2635 for (
int j = 0; j < nptsy; j++ )
2636 *( zg + nptsx * j + i ) = zgg[i][j];
2642 void my_plmesh(
const PLFLT *
x,
const PLFLT *
y,
const PLFLT *z, PLINT
nx, PLINT ny, PLINT
opt )
2644 f2c( z, zz, nx, ny );
2645 c_plmesh( x, y, (
const PLFLT **) zz, nx, ny, opt );
2650 void my_plmeshc(
const PLFLT *
x,
const PLFLT *
y,
const PLFLT *z, PLINT
nx, PLINT ny, PLINT
opt,
const PLFLT *clevel, PLINT nlevel )
2652 f2c( z, zz, nx, ny );
2653 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2659 PLINT
nx, PLINT ny, PLINT
opt, PLINT side )
2661 f2c( z, zz, nx, ny )
2662 c_plot3d( x, y, (
const PLFLT **) zz, nx, ny, opt, side );
2667 PLINT
nx, PLINT ny, PLINT
opt,
2668 const PLFLT *clevel, PLINT nlevel )
2670 f2c( z, zz, nx, ny )
2671 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2676 PLINT
nx, PLINT ny, PLINT
opt,
const PLFLT *clevel, PLINT nlevel )
2678 f2c( z, zz, nx, ny )
2679 c_plsurf3d( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2690 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2691 PLFLT shade_min, PLFLT shade_max,
2692 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2693 PLINT min_color, PLINT min_width,
2694 PLINT max_color, PLINT max_width,
2695 PLINT rectangular, PLFLT *tr )
2697 f2c( a, aa, nx, ny );
2698 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2699 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2700 min_color, min_width, max_color, max_width,
2706 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2707 PLFLT shade_min, PLFLT shade_max,
2708 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2709 PLINT min_color, PLINT min_width,
2710 PLINT max_color, PLINT max_width,
2711 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2714 grid1.
nx =
nx; grid1.
ny = ny;
2715 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2716 f2c( a, aa, nx, ny );
2717 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2718 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2719 min_color, min_width, max_color, max_width,
2725 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2726 PLFLT shade_min, PLFLT shade_max,
2727 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2728 PLINT min_color, PLINT min_width,
2729 PLINT max_color, PLINT max_width,
2730 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2733 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2734 grid2.
nx =
nx; grid2.
ny = ny;
2735 grid2.
xg = xgg; grid2.
yg = ygg;
2736 f2c( a, aa, nx, ny );
2737 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2738 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2739 min_color, min_width, max_color, max_width,
2746 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2747 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2751 f2c( a, aa, nx, ny );
2752 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2753 clevel, nlevel, fill_width, cont_color, cont_width,
2754 plfill, rectangular, NULL, NULL );
2758 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2759 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2761 PLINT rectangular, PLFLT *tr )
2763 f2c( a, aa, nx, ny );
2764 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2765 clevel, nlevel, fill_width, cont_color, cont_width,
2770 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2771 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2773 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2776 grid1.
nx =
nx; grid1.
ny = ny;
2777 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2779 f2c( a, aa, nx, ny );
2780 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2781 clevel, nlevel, fill_width, cont_color, cont_width,
2786 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2787 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2789 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2792 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2793 grid2.
nx =
nx; grid2.
ny = ny;
2794 grid2.
xg = xgg; grid2.
yg = ygg;
2795 f2c( a, aa, nx, ny );
2796 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2797 clevel, nlevel, fill_width, cont_color, cont_width,
2805 void my_plvect(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT ny, PLFLT scale, PLFLT *tr )
2807 f2c( u, uu, nx, ny );
2808 f2c( v, vv, nx, ny );
2809 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
xform, tr );
2813 void my_plvect1(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2816 grid1.
nx =
nx; grid1.
ny = ny;
2817 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2818 f2c( u, uu, nx, ny );
2819 f2c( v, vv, nx, ny );
2820 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr1, &grid1 );
2824 void my_plvect2(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2827 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2828 grid2.
nx =
nx; grid2.
ny = ny;
2829 grid2.
xg = xgg; grid2.
yg = ygg;
2830 f2c( u, uu, nx, ny );
2831 f2c( v, vv, nx, ny );
2832 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr2, &grid2 );
2839 PLFLT zmin, PLFLT zmax,
2840 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2842 f2c( a, aa, nx, ny );
2843 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2850 PLFLT zmin, PLFLT zmax,
2851 PLFLT valuemin, PLFLT valuemax )
2853 f2c( a, aa, nx, ny );
2854 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2859 PLFLT zmin, PLFLT zmax,
2860 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2862 f2c( a, aa, nx, ny );
2863 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
2869 PLFLT zmin, PLFLT zmax,
2870 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2873 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
2874 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2875 f2c( a, aa, nx, ny );
2876 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
2882 PLFLT zmin, PLFLT zmax,
2883 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2886 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2887 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
2888 grid2.
xg = xgg; grid2.
yg = ygg;
2889 f2c( a, aa, nx, ny );
2890 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
2904 const PLINT *
n_values,
const PLFLT *a )
2909 for ( i = 0; i <
nx; i++ )
2910 if ( n_values[i] > ny )
2912 f2c( a, aa, nx, ny );
2914 opt, position, x, y,
2916 bg_color, bb_color, bb_style,
2917 low_cap_color, high_cap_color,
2918 cont_color, cont_width,
2919 n_labels, label_opts, label,
2929 if (!ov.is_scalar_type())
2931 if (ov.is_complex_scalar())
2933 if (ov.is_double_type()||ov.is_single_type()) {
2934 double v=ov.double_value();
2940 if (ov.is_int8_type()||ov.is_int16_type()||
2941 ov.is_int32_type()) {
2942 long v=ov.long_value();
2946 if (ov.is_int64_type()) {
2947 long long v=ov.int64_scalar_value().value();
2952 *val = ov.ulong_value();
2963 if ((v > UINT_MAX)) {
2966 if (val) *val = (
unsigned int)(v);
2975 return octave_value(value);
2989 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
2992 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
2993 if (csize <= size) {
2995 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
2996 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3013 static int init = 0;
3026 return std::string(carray,carray+size);
3038 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3039 if (val) *val = (char)(v);
3049 Specify viewport in absolute coordinates \n\
3053 Alternate routine to plvpor for setting up the viewport. This routine\n\
3054 should be used only if the viewport is required to have a definite\n\
3055 size in millimeters. The routine plgspa is useful for finding out the\n\
3056 size of the current subpage. \n\
3058 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3060 This function is used in example 10. \n\
3066 plsvpa(xmin, xmax, ymin, ymax)\n\
3070 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3071 viewport from the left-hand edge of the subpage in millimeters. \n\
3073 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3074 viewport from the left-hand edge of the subpage in millimeters. \n\
3076 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3077 viewport from the bottom edge of the subpage in millimeters. \n\
3079 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3080 from the bottom edge of the subpage in millimeters. \n\
3083 Write text relative to viewport boundaries in 3D plots. \n\
3087 Writes text at a specified position relative to the viewport\n\
3088 boundaries. Text may be written inside or outside the viewport, but\n\
3089 is clipped at the subpage boundaries. The reference point of a string\n\
3090 lies along a line passing through the string at half the height of a\n\
3091 capital letter. The position of the reference point along this line\n\
3092 is determined by just, and the position of the reference point\n\
3093 relative to the viewport is set by disp and pos. \n\
3095 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3097 This function is used in example 28. \n\
3103 plmtex3(side, disp, pos, just, text)\n\
3107 side (const char *, input) : Specifies the side of the viewport\n\
3108 along which the text is to be written. The string should contain\n\
3109 one or more of the following characters: [xyz][ps][v]. Only one\n\
3110 label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3111 both the X and Y axes. x: Label the X axis. \n\
3112 y: Label the Y axis. \n\
3113 z: Label the Z axis. \n\
3114 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3115 For X it is the axis that starts at y-min. For Y it is the\n\
3116 axis that starts at x-min. \n\
3117 s: Label the secondary axis. \n\
3118 v: Draw the text perpendicular to the axis. \n\
3121 disp (PLFLT, input) : Position of the reference point of string,\n\
3122 measured outwards from the specified viewport edge in units of the\n\
3123 current character height. Use negative disp to write within the\n\
3126 pos (PLFLT, input) : Position of the reference point of string\n\
3127 along the specified edge, expressed as a fraction of the length of\n\
3130 just (PLFLT, input) : Specifies the position of the string relative\n\
3131 to its reference point. If just=0., the reference point is at the\n\
3132 left and if just=1., it is at the right of the string. Other\n\
3133 values of just give intermediate justifications. \n\
3135 text (const char *, input) : The string to be written out. \n\
3138 Set color map1 colors using 8-bit RGB values and double alpha values. \n\
3142 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3143 documentation) and double alpha values. This also sets the number of\n\
3146 This function is used in example 31. \n\
3152 plscmap1a(r, g, b, a, ncol1)\n\
3156 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3157 integers (0-255) representing the degree of red in the color. \n\
3159 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3160 integers (0-255) representing the degree of green in the color. \n\
3162 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3163 integers (0-255) representing the degree of blue in the color. \n\
3165 a (PLFLT *, input) : Pointer to array with set of double values\n\
3166 (0.0-1.0) representing the alpha value of the color. \n\
3168 ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n\
3172 Select standard viewport \n\
3176 Sets up a standard viewport, leaving a left-hand margin of seven\n\
3177 character heights, and four character heights around the other three\n\
3180 Redacted form: plvsta()\n\
3182 This function is used in examples 1,12,14,17,25,29. \n\
3191 Switch to graphics screen \n\
3195 Sets an interactive device to graphics mode, used in conjunction with\n\
3196 pltext to allow graphics and text to be interspersed. On a device\n\
3197 which supports separate text and graphics windows, this command causes\n\
3198 control to be switched to the graphics window. If already in graphics\n\
3199 mode, this command is ignored. It is also ignored on devices which\n\
3200 only support a single window or use a different method for shifting\n\
3201 focus. See also pltext. \n\
3203 Redacted form: plgra()\n\
3205 This function is used in example 1. \n\
3214 Set a given color from color map0 by 8 bit RGB value and double alpha value. \n\
3218 Set a given color by 8-bit RGB value and double alpha value for color \n\
3219 map0 (see the PLplot documentation). Overwrites the previous color\n\
3220 value for the given index and, thus, does not result in any\n\
3221 additional allocation of space for colors. \n\
3223 This function is used in example 30. \n\
3229 plscol0a(icol0, r, g, b, a)\n\
3233 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3234 number of colors (which is set by default, by plscmap0n, or even\n\
3237 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3238 degree of red in the color. \n\
3240 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3241 degree of green in the color. \n\
3243 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3244 degree of blue in the color. \n\
3246 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
3247 value of the color. \n\
3250 Set y axis parameters \n\
3254 Identical to plsxax, except that arguments are flags for y axis. See\n\
3255 the description of plsxax for more detail. \n\
3257 Redacted form: plsyax(digmax, digits)\n\
3259 This function is used in examples 1,14,31. \n\
3265 plsyax(digmax, digits)\n\
3269 digmax (PLINT, input) : Variable to set the maximum number of\n\
3270 digits for the y axis. If nonzero, the printed label will be\n\
3271 switched to a floating point representation when the number of\n\
3272 digits exceeds digmax. \n\
3274 digits (PLINT, input) : Field digits value. Currently, changing\n\
3275 its value here has no effect since it is set only by plbox or\n\
3276 plbox3. However, the user may obtain its value after a call to\n\
3277 either of these functions by calling plgyax. \n\
3280 Returns 8-bit RGB values for given color from color map0 \n\
3284 Returns 8-bit RGB values (0-255) for given color from color map0 (see\n\
3285 the PLplot documentation).\tValues are negative if an invalid color id\n\
3288 Redacted form: plgcol0(icol0, r, g, b)\n\
3290 This function is used in example 2. \n\
3296 plgcol0(icol0, r, g, b)\n\
3300 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3302 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3304 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3306 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3309 Set seed for internal random number generator. \n\
3313 Set the seed for the internal random number generator. See plrandd for\n\
3314 further details. \n\
3316 Redacted form: plseed(seed)\n\
3318 This function is used in example 21. \n\
3328 seed (unsigned int, input) : Seed for random number generator. \n\
3331 Get output file name \n\
3335 Gets the current output file name, if applicable. \n\
3337 Redacted form: plgfnam(fnam)\n\
3339 This function is used in example 31. \n\
3349 fnam (char *, output) : Pointer to file name string (a preallocated\n\
3350 string of 80 characters or more). \n\
3353 Specify world coordinates of viewport boundaries \n\
3357 Sets up the world coordinates of the edges of the viewport. \n\
3359 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3361 This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3367 plwind(xmin, xmax, ymin, ymax)\n\
3371 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3372 of the viewport. \n\
3374 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3375 of the viewport. \n\
3377 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3380 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3384 Set color map1 colors using a piece-wise linear relationship \n\
3388 Set color map1 colors using a piece-wise linear relationship between\n\
3389 position in the color map (from 0 to 1) and position in HLS or RGB\n\
3390 color space (see the PLplot documentation). May be called at any\n\
3393 The idea here is to specify a number of control points that define the\n\
3394 mapping between palette 1 input positions (intensities) and HLS (or\n\
3395 RGB). Between these points, linear interpolation is used which gives\n\
3396 a smooth variation of color with input position. Any number of\n\
3397 control points may be specified, located at arbitrary positions,\n\
3398 although typically 2 - 4 are enough. Another way of stating this is\n\
3399 that we are traversing a given number of lines through HLS (or RGB)\n\
3400 space as we move through color map1 entries. The control points at\n\
3401 the minimum and maximum position (0 and 1) must always be specified. \n\
3402 By adding more control points you can get more variation. One good\n\
3403 technique for plotting functions that vary about some expected average\n\
3404 is to use an additional 2 control points in the center (position ~=\n\
3405 0.5) that are the same lightness as the background (typically white\n\
3406 for paper output, black for crt), and same hue as the boundary control\n\
3407 points. This allows the highs and lows to be very easily\n\
3410 Each control point must specify the position in color map1 as well as\n\
3411 three coordinates in HLS or RGB space. The first point must\n\
3412 correspond to position = 0, and the last to position = 1. \n\
3414 The default behaviour is for the hue to be linearly interpolated \n\
3415 between the control points. Since the hue lies in the range [0, 360]\n\
3416 this corresponds to interpolation around the \"front\" of the color\n\
3417 wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3418 alternative interpolation is used between control points i and i+1. If\n\
3419 hue[i+1]-hue[i] > 0 then interpolation is between\thue[i] and\n\
3420 hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n\
3421 consider this as interpolation around the \"back\" or \"reverse\" of the\n\
3422 color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3423 alt_hue_path[] = false for\tevery control point. \n\
3425 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3426 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3427 240]truegreen-yellow-red-magenta-blue[240\n\
3428 120]trueblue-magenta-red-yellow-green\n\
3430 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3431 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3432 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3434 Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n\
3437 This function is used in examples 8,11,12,15,20,21. \n\
3443 plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n\
3447 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3449 npts (PLINT, input) : number of control points \n\
3451 pos (PLFLT *, input) : position for each control point (between 0.0\n\
3452 and 1.0, in ascending order) \n\
3454 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
3457 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
3460 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
3463 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
3464 flag for each control point. (alt_hue_path[i] refers to the\n\
3465 interpolation interval between the i and i + 1 control points). \n\
3468 Set the pause (on end-of-page) status \n\
3472 Set the pause (on end-of-page) status. \n\
3474 Redacted form: plspause(pause)\n\
3476 This function is in examples 14,20. \n\
3486 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3487 end-of-page for those drivers which support this. Otherwise there\n\
3491 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3495 Routine for creating a discrete plot legend with a plotted filled box,\n\
3496 line, and/or line of symbols for each annotated legend entry. (See\n\
3497 plcolorbar for similar functionality for creating continuous color\n\
3498 bars.) The arguments of pllegend provide control over the location\n\
3499 and size of the legend as well as the location and characteristics of\n\
3500 the elements (most of which are optional) within that legend. The\n\
3501 resulting legend is clipped at the boundaries of the current subpage. \n\
3502 (N.B. the adopted coordinate system used for some of the parameters is\n\
3503 defined in the documentation of the position parameter.) \n\
3505 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3506 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3507 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3508 test_justification, text_colors, text, box_colors, box_patterns,\n\
3509 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3510 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3512 This function is used in examples 4, 26, and 33. \n\
3518 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\
3522 p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3523 contains (after the call) the legend width in adopted coordinates.\n\
3524 This quantity is calculated from plot_width, text_offset, ncolumn\n\
3525 (possibly modified inside the routine depending on nlegend and\n\
3526 nrow), and the length (calculated internally) of the longest text\n\
3529 p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3530 contains (after the call) the legend height in adopted\n\
3531 coordinates. This quantity is calculated from text_scale,\n\
3532 text_spacing, and nrow (possibly modified inside the routine\n\
3533 depending on nlegend and nrow). \n\
3535 opt (PLINT, input) : opt contains bits controlling the overall\n\
3536 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3537 on the left of the legend and the plotted area on the right.\n\
3538 Otherwise, put the text area on the right of the legend and the\n\
3539 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3540 plot a (semi-transparent) background for the legend. If the\n\
3541 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3542 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3543 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3544 plot the resulting array of legend entries in row-major order.\n\
3545 Otherwise, plot the legend entries in column-major order. \n\
3547 position (PLINT, input) : position contains bits which control the\n\
3548 overall position of the legend and the definition of the adopted\n\
3549 coordinates used for positions just like what is done for the\n\
3550 position argument for plcolorbar. However, note that the defaults\n\
3551 for the position bits (see below) are different than the\n\
3552 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3553 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3554 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3555 the 16 possible standard positions (the 4 corners and centers of\n\
3556 the 4 sides for both the inside and outside cases) of the legend\n\
3557 relative to the adopted coordinate system. The corner positions\n\
3558 are specified by the appropriate combination of two of the\n\
3559 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3560 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3561 value of one of those bits. The adopted coordinates are\n\
3562 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3563 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3564 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3565 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3566 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3567 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3568 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3569 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3571 x (PLFLT, input) : X offset of the legend position in adopted\n\
3572 coordinates from the specified standard position of the legend.\n\
3573 For positive x, the direction of motion away from the standard\n\
3574 position is inward/outward from the standard corner positions or\n\
3575 standard left or right positions if the\n\
3576 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3577 For the standard top or bottom positions, the direction of motion\n\
3578 is toward positive X. \n\
3580 y (PLFLT, input) : Y offset of the legend position in adopted\n\
3581 coordinates from the specified standard position of the legend.\n\
3582 For positive y, the direction of motion away from the standard\n\
3583 position is inward/outward from the standard corner positions or\n\
3584 standard top or bottom positions if the\n\
3585 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3586 For the standard left or right positions, the direction of motion\n\
3587 is toward positive Y. \n\
3589 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3590 of the plot area (where the colored boxes, lines, and/or lines of\n\
3591 symbols are drawn) of the legend. \n\
3593 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3594 legend (PL_LEGEND_BACKGROUND). \n\
3596 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3597 for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3599 bb_style (PLINT, input) : The pllsty style number for the\n\
3600 bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n\
3602 nrow (PLINT, input) : The cmap0 index of the background color for\n\
3603 the legend (PL_LEGEND_BACKGROUND). \n\
3605 ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3606 for the legend (PL_LEGEND_BACKGROUND). \n\
3608 nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3609 vertical height of the legend in adopted coordinates is calculated\n\
3610 internally from nlegend, text_scale (see below), and text_spacing\n\
3613 opt_array (const PLINT *, input) : Array of nlegend values of\n\
3614 options to control each individual plotted area corresponding to a\n\
3615 legend entry. If the \n\
3616 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3618 PL_LEGEND_COLOR_BOX, \n\
3619 PL_LEGEND_LINE, and/or \n\
3620 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3621 entry is plotted with a colored box; a line; and/or a line of\n\
3624 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3625 area in units of character width. N.B. The total horizontal\n\
3626 width of the legend in adopted coordinates is calculated\n\
3628 plot_width (see above), \n\
3629 text_offset, and length (calculated internally) of the longest text\n\
3632 text_scale (PLFLT, input) : Character height scale for text\n\
3633 annotations. N.B. The total vertical height of the legend in\n\
3634 adopted coordinates is calculated internally from \n\
3635 nlegend (see above), \n\
3637 text_spacing (see below). \n\
3639 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3640 character height from one legend entry to the next. N.B. The\n\
3641 total vertical height of the legend in adopted coordinates is\n\
3642 calculated internally from \n\
3643 nlegend (see above), \n\
3644 text_scale (see above), and \n\
3647 text_justification (PLFLT, input) : Justification parameter used\n\
3648 for text justification. The most common values of\n\
3649 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3650 is left justified, centred, or right justified within the text\n\
3651 area, but other values are allowed as well. \n\
3653 text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n\
3656 text (const char *const *, input) : Array of nlegend text string\n\
3659 box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n\
3660 for the discrete colored boxes (\n\
3661 PL_LEGEND_COLOR_BOX). \n\
3663 box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3664 (plpsty indices) for the discrete colored boxes (\n\
3665 PL_LEGEND_COLOR_BOX). \n\
3667 box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3668 of fraction of character height) for the height of the discrete\n\
3670 PL_LEGEND_COLOR_BOX). \n\
3672 box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3673 widths for the patterns specified by box_patterns (\n\
3674 PL_LEGEND_COLOR_BOX). \n\
3676 line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n\
3678 PL_LEGEND_LINE). \n\
3680 line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3681 (plsty indices) (\n\
3682 PL_LEGEND_LINE). \n\
3684 line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3685 PL_LEGEND_LINE). \n\
3687 symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n\
3689 PL_LEGEND_SYMBOL). \n\
3691 symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3692 values for the symbol height (\n\
3693 PL_LEGEND_SYMBOL). \n\
3695 symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3696 symbols to be drawn across the width of the plotted area (\n\
3697 PL_LEGEND_SYMBOL). \n\
3699 symbols (const char *const *, input) : Array of nlegend symbols\n\
3700 (plpoin indices) (\n\
3701 PL_LEGEND_SYMBOL). \n\
3704 Set number of colors in color map1 \n\
3708 Set number of colors in color map1, (re-)allocate color map1, and set\n\
3709 default values if this is the first allocation (see the PLplot\n\
3712 Redacted form: plscmap1n(ncol1)\n\
3714 This function is used in examples 8,11,20,21. \n\
3724 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3725 the map1 palette. If this number is zero or less, then the value\n\
3726 from the previous call to plscmap1n is used and if there is no\n\
3727 previous call, then a default value is used. \n\
3730 Returns 8-bit RGB values and double alpha value for given color from color map0. \n\
3734 Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n\
3735 for given color from color map0 (see the PLplot documentation). \n\
3736 Values are negative if an invalid color id is given. \n\
3738 This function is used in example 30. \n\
3744 plgcol0a(icol0, r, g, b, a)\n\
3748 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3750 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3752 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3754 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3756 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
3759 Replays contents of plot buffer to current device/file \n\
3763 Replays contents of plot buffer to current device/file. \n\
3765 Redacted form: plreplot()\n\
3767 This function is used in example 1,20. \n\
3776 Simple routine to write labels \n\
3780 Routine for writing simple labels. Use plmtex for more complex labels. \n\
3782 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3784 This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3790 pllab(xlabel, ylabel, tlabel)\n\
3794 xlabel (const char *, input) : Label for horizontal axis. \n\
3796 ylabel (const char *, input) : Label for vertical axis. \n\
3798 tlabel (const char *, input) : Title of graph. \n\
3801 Set parameters that define current device-space window \n\
3805 Set relative margin width, aspect ratio, and relative justification\n\
3806 that define current device-space window. If you want to just use the\n\
3807 previous value for any of these, just pass in the magic value\n\
3808 PL_NOTSET. It is unlikely that one should ever need to change the\n\
3809 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3810 called the default values of mar, jx, and jy are all 0. aspect is set\n\
3811 to a device-specific value. \n\
3813 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3815 This function is used in example 31. \n\
3821 plsdidev(mar, aspect, jx, jy)\n\
3825 mar (PLFLT, input) : Relative margin width. \n\
3827 aspect (PLFLT, input) : Aspect ratio. \n\
3829 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3830 the range -0.5 to 0.5. \n\
3832 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3833 the range -0.5 to 0.5. \n\
3840 Begins a new page.\tFor a file driver, the output file is opened if\n\
3841 necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3842 page break is desired at a particular point when plotting to subpages.\n\
3843 Another use for pleop and plbop is when plotting pages to different\n\
3844 files, since you can manually set the file name by calling plsfnam\n\
3845 after the call to pleop. (In fact some drivers may only support a\n\
3846 single page per file, making this a necessity.) One way to handle\n\
3847 this case automatically is to page advance via pladv, but enable\n\
3848 familying (see plsfam) with a small limit on the file size so that a\n\
3849 new family member file will be created on each page break. \n\
3851 Redacted form: plbop()\n\
3853 This function is used in examples 2,20. \n\
3862 Set color map0 colors by 8-bit RGB values \n\
3866 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
3867 documentation). This sets the entire color map -- only as many colors\n\
3868 as specified will be allocated. \n\
3870 Redacted form: plscmap0(r, g, b, ncol0)\n\
3872 This function is used in examples 2,24. \n\
3878 plscmap0(r, g, b, ncol0)\n\
3882 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3883 integers (0-255) representing the degree of red in the color. \n\
3885 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3886 integers (0-255) representing the degree of green in the color. \n\
3888 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3889 integers (0-255) representing the degree of blue in the color. \n\
3891 ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3894 Set the number of subpages in x and y \n\
3898 Set the number of subpages in x and y. \n\
3900 Redacted form: plssub(nx, ny)\n\
3902 This function is examples 1,2,14,21,25,27. \n\
3912 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
3913 of window columns). \n\
3915 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
3916 of window rows). \n\
3919 Set a global coordinate transform function \n\
3923 This function can be used to define a coordinate transformation which\n\
3924 affects all elements drawn within the current plot window.\tThe\n\
3925 transformation function is similar to that provided for the plmap and\n\
3926 plmeridians functions. The data parameter may be used to pass extra\n\
3927 data to transform_fun. \n\
3929 Redacted form: General: plstransform(transform_fun, data)\n\
3932 This function is used in examples 19 and 22. \n\
3938 plstransform(transform_fun, data)\n\
3942 transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n\
3943 input) : Pointer to a function that defines a transformation\n\
3944 from the input (x, y) coordinate to a new plot world coordinate. A\n\
3945 NULL pointer means that no transform is applied. \n\
3947 data (PLPointer, input) : Optional extra data for \n\
3951 Set color map1 colors using 8-bit RGB values \n\
3955 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3956 documentation). This also sets the number of colors. \n\
3958 Redacted form: plscmap1(r, g, b, ncol1)\n\
3960 This function is used in example 31. \n\
3966 plscmap1(r, g, b, ncol1)\n\
3970 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3971 integers (0-255) representing the degree of red in the color. \n\
3973 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3974 integers (0-255) representing the degree of green in the color. \n\
3976 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3977 integers (0-255) representing the degree of blue in the color. \n\
3979 ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3982 Set length of minor ticks \n\
3986 This sets up the length of the minor ticks and the length of the\n\
3987 terminals on error bars. The actual length is the product of the\n\
3988 default length and a scaling factor as for character height. \n\
3990 Redacted form: plsmin(def, scale)\n\
3992 This function is used in example 29. \n\
3998 plsmin(def, scale)\n\
4002 def (PLFLT, input) : The default length of a minor tick in\n\
4003 millimeters, should be set to zero if the default length is to\n\
4004 remain unchanged. \n\
4006 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4007 actual tick length. \n\
4010 Set character size \n\
4014 This sets up the size of all subsequent characters drawn. The actual\n\
4015 height of a character is the product of the default character size and\n\
4016 a scaling factor. \n\
4018 Redacted form: plschr(def, scale)\n\
4020 This function is used in example 2,13,23,24. \n\
4026 plschr(def, scale)\n\
4030 def (PLFLT, input) : The default height of a character in\n\
4031 millimeters, should be set to zero if the default height is to\n\
4032 remain unchanged. \n\
4034 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4035 actual character height. \n\
4038 Initialize PLplot \n\
4042 Initializing the plotting package.\tThe program prompts for the device\n\
4043 keyword or number of the desired output device. Hitting a RETURN in\n\
4044 response to the prompt is the same as selecting the first device. \n\
4045 plinit will issue no prompt if either the device was specified\n\
4046 previously (via command line flag, the plsetopt function, or the\n\
4047 plsdev function), or if only one device is enabled when PLplot is\n\
4048 installed.\tIf subpages have been specified, the output device is\n\
4049 divided into nx by ny subpages, each of which may be used\n\
4050 independently. If plinit is called again during a program, the\n\
4051 previously opened file will be closed. The subroutine pladv is used\n\
4052 to advance from one subpage to the next. \n\
4054 Redacted form: plinit()\n\
4056 This function is used in all of the examples. \n\
4065 Draw a box with axes, etc\n\
4069 Draws a box around the currently defined viewport, and labels it with\n\
4070 world coordinate values appropriate to the window.\tThus plbox should\n\
4071 only be called after defining both viewport and window. The character\n\
4072 strings xopt and yopt specify how the box should be drawn as described\n\
4073 below. If ticks and/or subticks are to be drawn for a particular\n\
4074 axis, the tick intervals and number of subintervals may be specified\n\
4075 explicitly, or they may be defaulted by setting the appropriate\n\
4076 arguments to zero. \n\
4078 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4079 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4082 This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4088 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4092 xopt (const char *, input) : Pointer to character string specifying\n\
4093 options for horizontal axis. The string can include any\n\
4094 combination of the following letters (upper or lower case) in any\n\
4095 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4096 is vertical line (x=0). \n\
4097 b: Draws bottom (X) or left (Y) edge of frame. \n\
4098 c: Draws top (X) or right (Y) edge of frame. \n\
4099 d: Plot labels as date / time. Values are assumed to be\n\
4100 seconds since the epoch (as used by gmtime). \n\
4101 f: Always use fixed point numeric labels. \n\
4102 g: Draws a grid at the major tick interval. \n\
4103 h: Draws a grid at the minor tick interval. \n\
4104 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4106 l: Labels axis logarithmically. This only affects the labels,\n\
4107 not the data, and so it is necessary to compute the logarithms\n\
4108 of data points before passing them to any of the drawing\n\
4110 m: Writes numeric labels at major tick intervals in the\n\
4111 unconventional location (above box for X, right of box for Y). \n\
4112 n: Writes numeric labels at major tick intervals in the\n\
4113 conventional location (below box for X, left of box for Y). \n\
4114 o: Use custom labelling function to generate axis label text. \n\
4115 The custom labelling function can be defined with the\n\
4116 plslabelfunc command. \n\
4117 s: Enables subticks between major ticks, only valid if t is\n\
4119 t: Draws major ticks. \n\
4120 u: Exactly like \"b\" except don\'t draw edge line. \n\
4121 w: Exactly like \"c\" except don\'t draw edge line. \n\
4122 x: Exactly like \"t\" (including the side effect of the\n\
4123 numerical labels for the major ticks) except exclude drawing\n\
4124 the major and minor tick marks. \n\
4127 xtick (PLFLT, input) : World coordinate interval between major\n\
4128 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4129 generates a suitable tick interval. \n\
4131 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4132 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4133 generates a suitable minor tick interval. \n\
4135 yopt (const char *, input) : Pointer to character string specifying\n\
4136 options for vertical axis. The string can include any combination\n\
4137 of the letters defined above for xopt, and in addition may\n\
4138 contain: v: Write numeric labels for vertical axis parallel to the\n\
4139 base of the graph, rather than parallel to the axis. \n\
4142 ytick (PLFLT, input) : World coordinate interval between major\n\
4143 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4144 generates a suitable tick interval. \n\
4146 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4147 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4148 generates a suitable minor tick interval. \n\
4151 Get parameters that define current device-space window \n\
4155 Get relative margin width, aspect ratio, and relative justification\n\
4156 that define current device-space window. If plsdidev has not been\n\
4157 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4158 p_jy will all be 0. \n\
4160 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4162 This function is used in example 31. \n\
4168 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4172 p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4174 p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4176 p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4178 p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4181 Plot a glyph at the specified points \n\
4185 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4186 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4187 is specified with a PLplot user string. Note that the user string is\n\
4188 not actually limited to one glyph so it is possible (but not normally\n\
4189 useful) to plot more than one glyph at the specified points with this\n\
4190 function. As with plmtex and plptex, the user string can contain FCI\n\
4191 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4192 else PLplot escapes for Hershey or unicode text to determine the\n\
4195 Redacted form: plstring(x, y, string)\n\
4197 This function is used in examples 4, 21 and 26. \n\
4203 plstring(n, x, y, string)\n\
4207 n (PLINT, input) : Number of points in the x and y arrays. \n\
4209 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
4212 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
4215 string (const char *, input) : PLplot user string corresponding to\n\
4216 the glyph to be plotted at each of the n points. \n\
4219 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n\
4223 Sets up plotter environment for simple graphs by calling pladv and\n\
4224 setting up viewport and window to sensible default values.\tplenv0\n\
4225 leaves enough room around most graphs for axis labels and a title.\n\
4226 When these defaults are not suitable, use the individual routines\n\
4227 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4228 defining the window, and plbox for drawing the box. \n\
4230 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4232 This function is used in example 21. \n\
4238 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4242 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4243 world coordinates). \n\
4245 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4246 world coordinates). \n\
4248 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4251 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4254 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4255 scales will not be set, the user must set up the scale before\n\
4256 calling plenv0 using plsvpa, plvasp or other. \n\
4257 0: the x and y axes are scaled independently to use as much of\n\
4258 the screen as possible. \n\
4259 1: the scales of the x and y axes are made equal. \n\
4260 2: the axis of the x and y axes are made equal, and the plot\n\
4261 box will be square. \n\
4264 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4265 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4266 -1: draw box only. \n\
4267 0: draw box, ticks, and numeric tick labels. \n\
4268 1: also draw coordinate axes at x=0 and y=0. \n\
4269 2: also draw a grid at major tick positions in both\n\
4271 3: also draw a grid at minor tick positions in both\n\
4273 10: same as 0 except logarithmic x tick marks. (The x data\n\
4274 have to be converted to logarithms separately.) \n\
4275 11: same as 1 except logarithmic x tick marks. (The x data\n\
4276 have to be converted to logarithms separately.) \n\
4277 12: same as 2 except logarithmic x tick marks. (The x data\n\
4278 have to be converted to logarithms separately.) \n\
4279 13: same as 3 except logarithmic x tick marks. (The x data\n\
4280 have to be converted to logarithms separately.) \n\
4281 20: same as 0 except logarithmic y tick marks. (The y data\n\
4282 have to be converted to logarithms separately.) \n\
4283 21: same as 1 except logarithmic y tick marks. (The y data\n\
4284 have to be converted to logarithms separately.) \n\
4285 22: same as 2 except logarithmic y tick marks. (The y data\n\
4286 have to be converted to logarithms separately.) \n\
4287 23: same as 3 except logarithmic y tick marks. (The y data\n\
4288 have to be converted to logarithms separately.) \n\
4289 30: same as 0 except logarithmic x and y tick marks. (The x\n\
4290 and y data have to be converted to logarithms separately.) \n\
4291 31: same as 1 except logarithmic x and y tick marks. (The x\n\
4292 and y data have to be converted to logarithms separately.) \n\
4293 32: same as 2 except logarithmic x and y tick marks. (The x\n\
4294 and y data have to be converted to logarithms separately.) \n\
4295 33: same as 3 except logarithmic x and y tick marks. (The x\n\
4296 and y data have to be converted to logarithms separately.) \n\
4297 40: same as 0 except date / time x labels. \n\
4298 41: same as 1 except date / time x labels. \n\
4299 42: same as 2 except date / time x labels. \n\
4300 43: same as 3 except date / time x labels. \n\
4301 50: same as 0 except date / time y labels. \n\
4302 51: same as 1 except date / time y labels. \n\
4303 52: same as 2 except date / time y labels. \n\
4304 53: same as 3 except date / time y labels. \n\
4305 60: same as 0 except date / time x and y labels. \n\
4306 61: same as 1 except date / time x and y labels. \n\
4307 62: same as 2 except date / time x and y labels. \n\
4308 63: same as 3 except date / time x and y labels. \n\
4309 70: same as 0 except custom x and y labels. \n\
4310 71: same as 1 except custom x and y labels. \n\
4311 72: same as 2 except custom x and y labels. \n\
4312 73: same as 3 except custom x and y labels. \n\
4315 Set up window for 3-d plotting \n\
4319 Sets up a window for a three-dimensional surface plot within the\n\
4320 currently defined two-dimensional window. The enclosing box for the\n\
4321 surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4322 user-coordinate space is mapped into a box of world coordinate size\n\
4323 basex by basey by height so that xmin maps to -\n\
4324 basex/2, xmax maps to basex/2, ymin maps to -\n\
4325 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4326 The resulting world-coordinate box is then viewed by an observer at\n\
4327 altitude alt and azimuth az. This routine must be called before\n\
4328 plbox3 or plot3d. For a more complete description of\n\
4329 three-dimensional plotting see the PLplot documentation. \n\
4331 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4332 zmin, zmax, alt, az)\n\
4334 This function is examples 8,11,18,21. \n\
4340 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4344 basex (PLFLT, input) : The x coordinate size of the\n\
4345 world-coordinate box. \n\
4347 basey (PLFLT, input) : The y coordinate size of the\n\
4348 world-coordinate box. \n\
4350 height (PLFLT, input) : The z coordinate size of the\n\
4351 world-coordinate box. \n\
4353 xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4355 xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4357 ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4359 ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4361 zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4363 zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4365 alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4368 az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n\
4369 observer is looking face onto the ZX plane, and as az is\n\
4370 increased, the observer moves clockwise around the box when viewed\n\
4371 from above the XY plane. \n\
4374 Draw filled polygon \n\
4378 Fills the polygon defined by the n points (\n\
4380 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4381 style is a solid fill. The routine will automatically close the\n\
4382 polygon between the last and first vertices. If multiple closed\n\
4383 polygons are passed in x and y then plfill will fill in between them. \n\
4385 Redacted form: plfill(x,y)\n\
4387 This function is used in examples 12,13,15,16,21,24,25. \n\
4397 n (PLINT, input) : Number of vertices in polygon. \n\
4399 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4402 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4406 Write text relative to viewport boundaries \n\
4410 Writes text at a specified position relative to the viewport\n\
4411 boundaries. Text may be written inside or outside the viewport, but\n\
4412 is clipped at the subpage boundaries. The reference point of a string\n\
4413 lies along a line passing through the string at half the height of a\n\
4414 capital letter. The position of the reference point along this line\n\
4415 is determined by just, and the position of the reference point\n\
4416 relative to the viewport is set by disp and pos. \n\
4418 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4419 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4422 This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4428 plmtex(side, disp, pos, just, text)\n\
4432 side (const char *, input) : Specifies the side of the viewport\n\
4433 along which the text is to be written. The string must be one of:\n\
4434 b: Bottom of viewport, text written parallel to edge. \n\
4435 bv: Bottom of viewport, text written at right angles to edge. \n\
4436 l: Left of viewport, text written parallel to edge. \n\
4437 lv: Left of viewport, text written at right angles to edge. \n\
4438 r: Right of viewport, text written parallel to edge. \n\
4439 rv: Right of viewport, text written at right angles to edge. \n\
4440 t: Top of viewport, text written parallel to edge. \n\
4441 tv: Top of viewport, text written at right angles to edge. \n\
4444 disp (PLFLT, input) : Position of the reference point of string,\n\
4445 measured outwards from the specified viewport edge in units of the\n\
4446 current character height. Use negative disp to write within the\n\
4449 pos (PLFLT, input) : Position of the reference point of string\n\
4450 along the specified edge, expressed as a fraction of the length of\n\
4453 just (PLFLT, input) : Specifies the position of the string relative\n\
4454 to its reference point. If just=0., the reference point is at the\n\
4455 left and if just=1., it is at the right of the string. Other\n\
4456 values of just give intermediate justifications. \n\
4458 text (const char *, input) : The string to be written out. \n\
4461 Set arrow style for vector plots \n\
4465 Set the style for the arrow used by plvect to plot vectors. \n\
4467 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4469 This function is used in example 22. \n\
4475 plsvect(arrowx, arrowy, npts, fill)\n\
4479 arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n\
4480 containing the x and y points which make up the arrow. The arrow\n\
4481 is plotted by joining these points to form a polygon. The scaling\n\
4482 assumes that the x and y points in the arrow lie in the range -0.5\n\
4483 <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n\
4484 style will be reset to its default. \n\
4486 npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4489 fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4490 fill is false then the arrow is open. \n\
4493 Get family file parameters \n\
4497 Gets information about current family file, if familying is enabled. \n\
4498 See the PLplot documentation for more information. \n\
4500 Redacted form: plgfam(fam, num, bmax)\n\
4502 This function is used in examples 14,31. \n\
4508 plgfam(fam, num, bmax)\n\
4512 fam (PLINT *, output) : Pointer to variable with the Boolean family\n\
4513 flag value. If nonzero, familying is enabled. \n\
4515 num (PLINT *, output) : Pointer to variable with the current family\n\
4518 bmax (PLINT *, output) : Pointer to variable with the maximum file\n\
4519 size (in bytes) for a family file. \n\
4522 Random number generator returning a real random number in the range [0,1]. \n\
4526 Random number generator returning a real random number in the range\n\
4527 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4528 / compilers provide their own random number generator, and so this is\n\
4529 provided purely for convenience and to give a consistent random number\n\
4530 generator across all languages supported by PLplot. This is\n\
4531 particularly useful for comparing results from the test suite of\n\
4534 Redacted form: plrandd()\n\
4536 This function is used in examples 17,21. \n\
4549 This sets up the line style for all lines subsequently drawn. A line\n\
4550 consists of segments in which the pen is alternately down and up. The\n\
4551 lengths of these segments are passed in the arrays mark and space\n\
4552 respectively. The number of mark-space pairs is specified by nels. \n\
4553 In order to return the line style to the default continuous line,\n\
4554 plstyl should be called with nels=0.(see also pllsty) \n\
4556 Redacted form: plstyl(mark, space)\n\
4558 This function is used in examples 1,9,14. \n\
4564 plstyl(nels, mark, space)\n\
4568 nels (PLINT, input) : The number of mark and space elements in a\n\
4569 line. Thus a simple broken line can be obtained by setting\n\
4570 nels=1. A continuous line is specified by setting nels=0. \n\
4572 mark (PLINT *, input) : Pointer to array with the lengths of the\n\
4573 segments during which the pen is down, measured in micrometers. \n\
4575 space (PLINT *, input) : Pointer to array with the lengths of the\n\
4576 segments during which the pen is up, measured in micrometers. \n\
4579 Set the colors for color table 0 from a cmap0 file \n\
4583 Set the colors for color table 0 from a cmap0 file \n\
4585 Redacted form: plspal0(filename)\n\
4587 This function is in example 16. \n\
4593 plspal0(filename)\n\
4597 filename (const char *, input) : The name of the cmap0 file, or a\n\
4598 empty to string to specify the default cmap0 file. \n\
4601 Set the colors for color table 1 from a cmap1 file \n\
4605 Set the colors for color table 1 from a cmap1 file \n\
4607 Redacted form: plspal1(filename)\n\
4609 This function is in example 16. \n\
4615 plspal1(filename)\n\
4619 filename (const char *, input) : The name of the cmap1 file, or a\n\
4620 empty to string to specify the default cmap1 file. \n\
4623 Set current output stream \n\
4627 Sets the number of the current output stream. The stream number\n\
4628 defaults to 0 unless changed by this routine. The first use of this\n\
4629 routine must be followed by a call initializing PLplot (e.g. plstar). \n\
4631 Redacted form: plsstrm(strm)\n\
4633 This function is examples 1,14,20. \n\
4643 strm (PLINT, input) : The current stream number. \n\
4646 Specify viewport using coordinates \n\
4650 Device-independent routine for setting up the viewport. This defines\n\
4651 the viewport in terms of normalized subpage coordinates which run from\n\
4652 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4653 current subpage. Use the alternate routine plsvpa in order to create\n\
4654 a viewport of a definite size. \n\
4656 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4658 This function is used in examples\n\
4659 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
4665 plvpor(xmin, xmax, ymin, ymax)\n\
4669 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4670 left-hand edge of the viewport. \n\
4672 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4673 right-hand edge of the viewport. \n\
4675 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4676 bottom edge of the viewport. \n\
4678 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4679 edge of the viewport. \n\
4682 Write text inside the viewport \n\
4686 Writes text at a specified position and inclination within the\n\
4687 viewport. Text is clipped at the viewport boundaries. The reference\n\
4688 point of a string lies along a line passing through the string at half\n\
4689 the height of a capital letter. The position of the reference point\n\
4690 along this line is determined by just, the reference point is placed\n\
4691 at world coordinates (\n\
4693 y) within the viewport. The inclination of the string is specified in\n\
4694 terms of differences of world coordinates making it easy to write text\n\
4695 parallel to a line in a graph. \n\
4697 Redacted form: plptex(x, y, dx, dy, just, text)\n\
4699 This function is used in example 2-4,10,12-14,20,23,24,26. \n\
4705 plptex(x, y, dx, dy, just, text)\n\
4709 x (PLFLT, input) : x coordinate of reference point of string. \n\
4711 y (PLFLT, input) : y coordinate of reference point of string. \n\
4713 dx (PLFLT, input) : Together with dy, this specifies the\n\
4714 inclination of the string. The baseline of the string is parallel\n\
4715 to a line joining (\n\
4723 dy (PLFLT, input) : Together with dx, this specifies the\n\
4724 inclination of the string. \n\
4726 just (PLFLT, input) : Specifies the position of the string relative\n\
4727 to its reference point. If just=0., the reference point is at the\n\
4728 left and if just=1., it is at the right of the string. Other\n\
4729 values of just give intermediate justifications. \n\
4731 text (const char *, input) : The string to be written out. \n\
4734 Set z axis parameters \n\
4738 Identical to plsxax, except that arguments are flags for z axis. See\n\
4739 the description of plsxax for more detail. \n\
4741 Redacted form: plszax(digmax, digits)\n\
4743 This function is used in example 31. \n\
4749 plszax(digmax, digits)\n\
4753 digmax (PLINT, input) : Variable to set the maximum number of\n\
4754 digits for the z axis. If nonzero, the printed label will be\n\
4755 switched to a floating point representation when the number of\n\
4756 digits exceeds digmax. \n\
4758 digits (PLINT, input) : Field digits value. Currently, changing\n\
4759 its value here has no effect since it is set only by plbox or\n\
4760 plbox3. However, the user may obtain its value after a call to\n\
4761 either of these functions by calling plgzax. \n\
4764 Set character font \n\
4768 Sets the default character font for subsequent character drawing. Also\n\
4769 affects symbols produced by plpoin. This routine has no effect unless\n\
4770 the extended character set is loaded (see plfontld). \n\
4772 Redacted form: plfont(font)\n\
4774 This function is used in examples 1,2,4,7,13,24,26. \n\
4784 font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
4791 Draw a circular or elliptical arc \n\
4795 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
4796 semiminor axis b, starting at angle1 and ending at angle2. \n\
4798 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
4802 This function is used in examples 3 and 27. \n\
4808 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
4812 x (PLFLT, input) : X coordinate of arc center. \n\
4814 y (PLFLT, input) : Y coordinate of arc center. \n\
4816 a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
4818 b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
4820 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
4823 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
4826 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
4829 fill (PLBOOL, input) : Draw a filled arc. \n\
4832 Set area fill pattern \n\
4836 Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
4837 parallel lines with specified inclinations and spacings. The\n\
4838 arguments to this routine are the number of sets to use (1 or 2)\n\
4839 followed by two pointers to integer arrays (of 1 or 2 elements)\n\
4840 specifying the inclinations in tenths of a degree and the spacing in\n\
4841 micrometers. (also see plpsty) \n\
4843 Redacted form: General: plpat(inc, del)\n\
4844 \t Perl/PDL: plpat(nlin, inc, del)\n\
4847 This function is used in example 15. \n\
4853 plpat(nlin, inc, del)\n\
4857 nlin (PLINT, input) : Number of sets of lines making up the\n\
4858 pattern, either 1 or 2. \n\
4860 inc (PLINT *, input) : Pointer to array with nlin elements.\n\
4861 Specifies the line inclination in tenths of a degree. (Should be\n\
4862 between -900 and 900). \n\
4864 del (PLINT *, input) : Pointer to array with nlin elements.\n\
4865 Specifies the spacing in micrometers between the lines making up\n\
4869 Get x axis parameters \n\
4873 Returns current values of the digmax and digits flags for the x axis. \n\
4874 digits is updated after the plot is drawn, so this routine should only\n\
4875 be called after the call to plbox (or plbox3) is complete.\tSee the\n\
4876 PLplot documentation for more information. \n\
4878 Redacted form: plgxax(digmax, digits)\n\
4880 This function is used in example 31. \n\
4886 plgxax(digmax, digits)\n\
4890 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
4891 number of digits for the x axis. If nonzero, the printed label\n\
4892 has been switched to a floating point representation when the\n\
4893 number of digits exceeds digmax. \n\
4895 digits (PLINT *, output) : Pointer to variable with the actual\n\
4896 number of digits for the numeric labels (x axis) from the last\n\
4900 Draw filled polygon in 3D \n\
4904 Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
4905 using the pattern defined by plpsty or plpat. The routine will\n\
4906 automatically close the polygon between the last and first vertices. \n\
4907 If multiple closed polygons are passed in x, y, and z then plfill3\n\
4908 will fill in between them. \n\
4910 Redacted form: General: plfill3(x, y, z)\n\
4911 \t Perl/PDL: plfill3(n, x, y, z)\n\
4914 This function is used in example 15. \n\
4920 plfill3(n, x, y, z)\n\
4924 n (PLINT, input) : Number of vertices in polygon. \n\
4926 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4929 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4932 z (PLFLT *, input) : Pointer to array with z coordinates of\n\
4940 Sets the color for color map0 (see the PLplot documentation). \n\
4942 Redacted form: plcol0(color)\n\
4944 This function is used in examples 1-9,11-16,18-27,29. \n\
4954 color (PLINT, input) : Integer representing the color. The\n\
4955 defaults at present are (these may change): \n\
4956 0 black (default background) \n\
4957 1 red (default foreground) \n\
4973 Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
4974 change an individual color in the map0 color palette. \n\
4977 Draw a line between two points \n\
4981 Joins the point (\n\
4987 Redacted form: pljoin(x1,y1,x2,y2)\n\
4989 This function is used in examples 3,14. \n\
4995 pljoin(x1, y1, x2, y2)\n\
4999 x1 (PLFLT, input) : x coordinate of first point. \n\
5001 y1 (PLFLT, input) : y coordinate of first point. \n\
5003 x2 (PLFLT, input) : x coordinate of second point. \n\
5005 y2 (PLFLT, input) : y coordinate of second point. \n\
5012 Sets the color for color map1 (see the PLplot documentation). \n\
5014 Redacted form: plcol1(col1)\n\
5016 This function is used in examples 12 and 21. \n\
5026 col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
5027 and is mapped to color using the continuous map1 color palette\n\
5028 which by default ranges from blue to the background color to red. \n\
5029 The map1 palette can also be straightforwardly changed by the user\n\
5030 with plscmap1 or plscmap1l. \n\
5037 Set integer plot orientation parameter. This function is identical to\n\
5038 plsdiori except for the type of the argument, and should be used in\n\
5039 the same way. See the PLplot documentation for details. \n\
5041 Redacted form: plsori(ori)\n\
5043 This function is used in example 3. \n\
5053 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5054 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5058 Plot continental outline in world coordinates. \n\
5062 Plots continental outlines in world coordinates. examples/c/x19c\n\
5063 demonstrates how to use this function to create different\n\
5066 Redacted form: General: plmap(mapform, type, minlong, maxlong,\n\
5068 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
5071 This function is used in example 19. \n\
5077 plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n\
5081 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5082 supplied function to transform the coordinate longitudes and\n\
5083 latitudes to a plot coordinate system. By using this transform,\n\
5084 we can change from a longitude, latitude coordinate to a polar\n\
5085 stereographic project, for example. Initially, x[0]..[n-1] are\n\
5086 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5087 After the call to mapform(), x[] and y[] should be replaced by\n\
5088 the corresponding plot coordinates. If no transform is desired,\n\
5089 mapform can be replaced by NULL. \n\
5091 type (char *, input) : type is a character string. The value of\n\
5092 this parameter determines the type of background. The possible\n\
5093 values are: \"globe\" -- continental outlines \n\
5094 \"usa\" -- USA and state boundaries \n\
5095 \"cglobe\" -- continental outlines and countries \n\
5096 \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5099 minlong (PLFLT, input) : The value of the longitude on the left\n\
5100 side of the plot. The value of minlong must be less than the\n\
5101 value of maxlong, and the quantity maxlong-minlong must be less\n\
5102 than or equal to 360. \n\
5104 maxlong (PLFLT, input) : The value of the longitude on the right\n\
5105 side of the plot. \n\
5107 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
5108 background. One can always use -90.0 as the boundary outside the\n\
5109 plot window will be automatically eliminated. However, the\n\
5110 program will be faster if one can reduce the size of the\n\
5111 background plotted. \n\
5113 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
5114 background. One can always use 90.0 as the boundary outside the\n\
5115 plot window will be automatically eliminated. \n\
5118 Get current stream number \n\
5122 Gets the number of the current output stream. See also plsstrm. \n\
5124 Redacted form: plgstrm(strm)\n\
5126 This function is used in example 1,20. \n\
5136 strm (PLINT *, output) : Pointer to current stream value. \n\
5139 Draw a line in 3 space \n\
5143 Draws line in 3 space defined by n points in x, y, and z. You must\n\
5144 first set up the viewport, the 2d viewing window (in world\n\
5145 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
5148 Redacted form: plline3(x, y, z)\n\
5150 This function is used in example 18. \n\
5156 plline3(n, x, y, z)\n\
5160 n (PLINT, input) : Number of points defining line. \n\
5162 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
5164 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
5166 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
5169 Load character font \n\
5173 Sets the character set to use for subsequent character drawing. May\n\
5174 be called before initializing PLplot. \n\
5176 Redacted form: plfontld(set)\n\
5178 This function is used in examples 1,7. \n\
5188 set (PLINT, input) : Specifies the character set to load: 0:\n\
5189 Standard character set \n\
5190 1: Extended character set \n\
5193 Set any command-line option \n\
5197 Set any command-line option internally from a program before it\n\
5198 invokes plinit. opt is the name of the command-line option and optarg\n\
5199 is the corresponding command-line option argument.\t\n\
5201 This function returns 0 on success. \n\
5203 Redacted form: plsetopt(opt, optarg)\n\
5205 This function is used in example 14. \n\
5211 int plsetopt(opt, optarg)\n\
5215 opt (const char *, input) : Pointer to string containing the\n\
5216 command-line option. \n\
5218 optarg (const char *, input) : Pointer to string containing the\n\
5219 argument of the command-line option. \n\
5222 Used to globally turn color output on/off \n\
5226 Used to globally turn color output on/off for those drivers/devices\n\
5227 that support it. \n\
5229 Redacted form: plscolor(color)\n\
5231 This function is used in example 31. \n\
5241 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
5242 turned off. If non-zero, color is turned on. \n\
5245 Get the current device (keyword) name \n\
5249 Get the current device (keyword) name. Note: you must have allocated\n\
5250 space for this (80 characters is safe). \n\
5252 Redacted form: plgdev(p_dev)\n\
5254 This function is used in example 14. \n\
5264 p_dev (char *, output) : Pointer to device (keyword) name string. \n\
5267 Add a point to a strip chart \n\
5271 Add a point to a given pen of a given strip chart. There is no need\n\
5272 for all pens to have the same number of points or to be equally\n\
5273 sampled in the x coordinate. Allocates memory and rescales as\n\
5276 Redacted form: plstripa(id, p, x, y)\n\
5278 This function is used in example 17. \n\
5284 plstripa(id, p, x, y)\n\
5288 id (PLINT, input) : Identification number (set up in plstripc) of\n\
5289 the strip chart. \n\
5291 p (PLINT, input) : Pen number (ranges from 0 to 3). \n\
5293 x (PLFLT, input) : X coordinate of point to plot. \n\
5295 y (PLFLT, input) : Y coordinate of point to plot. \n\
5298 Deletes and releases memory used by a strip chart \n\
5302 Deletes and releases memory used by a strip chart. \n\
5304 Redacted form: plstripd(id)\n\
5306 This function is used in example 17. \n\
5316 id (PLINT, input) : Identification number of strip chart to delete. \n\
5319 Specify viewport using coordinates and aspect ratio \n\
5323 Device-independent routine for setting up the viewport. The viewport\n\
5324 is chosen to be the largest with the given aspect ratio that fits\n\
5325 within the specified region (in terms of normalized subpage\n\
5326 coordinates). This routine is functionally equivalent to plvpor when\n\
5327 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5328 routine reserves no extra space at the edges for labels. \n\
5330 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5332 This function is used in example 9. \n\
5338 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5342 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5343 left-hand edge of the viewport. \n\
5345 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5346 right-hand edge of the viewport. \n\
5348 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5349 bottom edge of the viewport. \n\
5351 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5352 edge of the viewport. \n\
5354 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5358 Assign a function to use for generating custom axis labels \n\
5362 This function allows a user to provide their own function to provide\n\
5363 axis label text. The user function is given the numeric value for a\n\
5364 point on an axis and returns a string label to correspond with that\n\
5365 value. Custom axis labels can be enabled by passing appropriate\n\
5366 arguments to plenv, plbox, plbox3 and similar functions. \n\
5368 This function is used in example 19. \n\
5374 plslabelfunc(label_func, label_data)\n\
5378 label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n\
5379 This is the custom label function. In order to reset to the\n\
5380 default labelling, set this to NULL. The labelling function\n\
5381 parameters are, in order: axis: This indicates which axis a\n\
5382 label is being requested for. The value will be one of PL_X_AXIS,\n\
5383 PL_Y_AXIS or PL_Z_AXIS. \n\
5385 value: This is the value along the axis which is being labelled. \n\
5387 label_text: The string representation of the label value. \n\
5389 length: The maximum length in characters allowed for label_text. \n\
5392 label_data (void *, input) : This parameter may be used to pass\n\
5393 data to the label_func function. \n\
5396 Set length of major ticks \n\
5400 This sets up the length of the major ticks. The actual length is the\n\
5401 product of the default length and a scaling factor as for character\n\
5404 Redacted form: plsmaj(def, scale)\n\
5406 This function is used in example 29. \n\
5412 plsmaj(def, scale)\n\
5416 def (PLFLT, input) : The default length of a major tick in\n\
5417 millimeters, should be set to zero if the default length is to\n\
5418 remain unchanged. \n\
5420 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
5421 actual tick length. \n\
5424 Get the current library version number \n\
5428 Get the current library version number. Note: you must have allocated\n\
5429 space for this (80 characters is safe). \n\
5431 Redacted form: plgver(p_ver)\n\
5433 This function is used in example 1. \n\
5443 p_ver (char *, output) : Pointer to the current library version\n\
5447 Set format of numerical label for contours\n\
5451 Set format of numerical label for contours. \n\
5453 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
5455 This function is used example 9. \n\
5461 pl_setcontlabelformat(lexp, sigdig)\n\
5465 lexp (PLINT, input) : If the contour numerical label is greater\n\
5466 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
5467 format is used. Default value of lexp is 4. \n\
5469 sigdig (PLINT, input) : Number of significant digits. Default\n\
5473 Parse command-line arguments \n\
5477 Parse command-line arguments. \n\
5479 plparseopts removes all recognized flags (decreasing argc\n\
5480 accordingly), so that invalid input may be readily detected. It can\n\
5481 also be used to process user command line flags. The user can merge\n\
5482 an option table of type PLOptionTable into the internal option table\n\
5483 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
5484 the external table(s) be parsed by calling plClearOpts before\n\
5487 The default action taken by plparseopts is as follows: \n\
5488 Returns with an error if an unrecognized option or badly formed\n\
5489 option-value pair are encountered.\t\n\
5490 Returns immediately (return code 0) when the first non-option command\n\
5491 line argument is found. \n\
5492 Returns with the return code of the option handler, if one was called.\n\
5494 Deletes command line arguments from argv list as they are found, and\n\
5495 decrements argc accordingly. \n\
5496 Does not show \"invisible\" options in usage or help messages. \n\
5497 Assumes the program name is contained in argv[0]. \n\
5499 These behaviors may be controlled through the \n\
5502 Redacted form: General: plparseopts(argv, mode)\n\
5503 \t Perl/PDL: Not available? \n\
5506 This function is used in all of the examples. \n\
5512 int plparseopts(p_argc, argv, mode)\n\
5516 p_argc (int *, input) : pointer to number of arguments. \n\
5518 argv (char **, input) : Pointer to character array containing\n\
5519 *p_argc command-line arguments. \n\
5521 mode (PLINT, input) : Parsing mode with the following\n\
5522 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
5523 and all error messages enabled, including program exit when an\n\
5524 error occurs. Anything on the command line that isn\'t recognized\n\
5525 as a valid option or option argument is flagged as an error. \n\
5526 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
5528 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
5530 PL_PARSE_SHOWALL (8) -- Show invisible options \n\
5531 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
5532 pointer to the program name. \n\
5533 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
5534 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
5535 unrecognized arguments. \n\
5542 Initializing the plotting package.\tThe program prompts for the device\n\
5543 keyword or number of the desired output device. Hitting a RETURN in\n\
5544 response to the prompt is the same as selecting the first device. If\n\
5545 only one device is enabled when PLplot is installed, plstar will issue\n\
5546 no prompt.\tThe output device is divided into nx by ny subpages, each\n\
5547 of which may be used independently. The subroutine pladv is used to\n\
5548 advance from one subpage to the next. \n\
5550 Redacted form: plstar(nx, ny)\n\
5552 This function is used in example 1. \n\
5562 nx (PLINT, input) : Number of subpages to divide output page in the\n\
5563 horizontal direction. \n\
5565 ny (PLINT, input) : Number of subpages to divide output page in the\n\
5566 vertical direction. \n\
5569 Get FCI (font characterization integer) \n\
5573 Gets information about the current font using the FCI approach. See\n\
5574 the PLplot documentation for more information. \n\
5576 Redacted form: plgfci(fci)\n\
5578 This function is used in example 23. \n\
5588 fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
5589 integer) variable which is updated with current FCI value. \n\
5592 Set family file parameters \n\
5596 Sets variables dealing with output file familying.\tDoes nothing if\n\
5597 familying not supported by the driver. This routine, if used, must be\n\
5598 called before initializing PLplot.\tSee the PLplot documentation for\n\
5599 more information. \n\
5601 Redacted form: plsfam(fam, num, bmax)\n\
5603 This function is used in examples 14,31. \n\
5609 plsfam(fam, num, bmax)\n\
5613 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
5616 num (PLINT, input) : Current family file number. \n\
5618 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
5622 Set color map1 colors using a piece-wise linear relationship \n\
5626 This is a version of plscmap1l that supports alpha transparency. It\n\
5627 sets color map1 colors using a piece-wise linear relationship between\n\
5628 position in the color map (from 0 to 1) and position in HLS or RGB\n\
5629 color space (see the PLplot documentation) with alpha value (0.0 -\n\
5630 1.0). It may be called at any time. \n\
5632 This function is used in example 30. \n\
5638 plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n\
5642 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
5644 npts (PLINT, input) : number of control points \n\
5646 pos (PLFLT *, input) : position for each control point (between 0.0\n\
5647 and 1.0, in ascending order) \n\
5649 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
5652 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
5655 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
5658 coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n\
5659 each control point \n\
5661 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
5662 flag for each control point. (alt_hue_path[i] refers to the\n\
5663 interpolation interval between the i and i + 1 control points). \n\
5666 Set page parameters \n\
5670 Sets the page configuration (optional). If an individual parameter is\n\
5671 zero then that parameter value is not updated. Not all parameters are\n\
5672 recognized by all drivers and the interpretation is device-dependent.\n\
5673 The X-window driver uses the length and offset parameters to determine\n\
5674 the window size and location. The length and offset values are\n\
5675 expressed in units that are specific to the current driver. For\n\
5676 instance: screen drivers will usually interpret them as number of\n\
5677 pixels, whereas printer drivers will usually use mm. This routine, if\n\
5678 used, must be called before initializing PLplot. \n\
5680 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5682 This function is used in examples 14 and 31. \n\
5688 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5692 xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
5694 yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
5696 xleng (PLINT , input) : Page length, x. \n\
5698 yleng (PLINT, input) : Page length, y. \n\
5700 xoff (PLINT, input) : Page offset, x. \n\
5702 yoff (PLINT, input) : Page offset, y. \n\
5705 Set precision in numeric labels \n\
5709 Sets the number of places after the decimal point in numeric labels. \n\
5711 Redacted form: plprec(set, prec)\n\
5713 This function is used in example 29. \n\
5719 plprec(set, prec)\n\
5723 set (PLINT, input) : If set is equal to 0 then PLplot automatically\n\
5724 determines the number of places to use after the decimal point in\n\
5725 numeric labels (like those used to label axes). If set is 1 then\n\
5726 prec sets the number of places. \n\
5728 prec (PLINT, input) : The number of characters to draw after the\n\
5729 decimal point in numeric labels. \n\
5732 Copy state parameters from the reference stream to the current stream \n\
5736 Copies state parameters from the reference stream to the current\n\
5737 stream. Tell driver interface to map device coordinates unless flags\n\
5740 This function is used for making save files of selected plots (e.g.\n\
5741 from the TK driver). After initializing, you can get a copy of the\n\
5742 current plot to the specified device by switching to this stream and\n\
5743 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5744 appropriate. The plot buffer must have previously been enabled (done\n\
5745 automatically by some display drivers, such as X). \n\
5747 Redacted form: plcpstrm(iplsr, flags)\n\
5749 This function is used in example 1,20. \n\
5755 plcpstrm(iplsr, flags)\n\
5759 iplsr (PLINT, input) : Number of reference stream. \n\
5761 flags (PLBOOL, input) : If flags is set to true the device\n\
5762 coordinates are not copied from the reference to current stream. \n\
5765 Plot a glyph at the specified points \n\
5769 Plot a glyph at the specified points. (This function is largely\n\
5770 superseded by plstring which gives access to many[!] more glyphs.)\n\
5771 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5772 and a draw at the same place. Not ideal, since a sufficiently\n\
5773 intelligent output device may optimize it away, or there may be faster\n\
5774 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5775 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5776 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5777 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5778 code <= 127 the corresponding printable ASCII character is plotted. \n\
5780 Redacted form: plpoin(x, y, code)\n\
5782 This function is used in examples 1,6,14,29. \n\
5788 plpoin(n, x, y, code)\n\
5792 n (PLINT, input) : Number of points in the x and y arrays. \n\
5794 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
5797 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
5800 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5801 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5802 each of the n points. \n\
5805 Enter or leave xor mode \n\
5809 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
5810 those drivers (e.g., the xwin driver) that support it. Enables\n\
5811 erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
5812 is not capable of xor operation it returns a status of false. \n\
5814 Redacted form: plxormod(mode, status)\n\
5816 This function is used in examples 1,20. \n\
5822 plxormod(mode, status)\n\
5826 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
5827 is false means leave xor mode. \n\
5829 status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
5830 of true (false) means driver is capable (incapable) of xor mode. \n\
5833 Get viewport limits in normalized device coordinates \n\
5837 Get viewport limits in normalized device coordinates. \n\
5839 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5840 \t Perl/PDL: Not available? \n\
5843 This function is used in example 31. \n\
5849 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5853 p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5854 device coordinate in x. \n\
5856 p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5857 device coordinate in x. \n\
5859 p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5860 device coordinate in y. \n\
5862 p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5863 device coordinate in y. \n\
5866 End plotting session for current stream \n\
5870 Ends a plotting session for the current output stream only. See\n\
5871 plsstrm for more info. \n\
5873 Redacted form: plend1()\n\
5875 This function is used in examples 1,20. \n\
5884 Get y axis parameters \n\
5888 Identical to plgxax, except that arguments are flags for y axis. See\n\
5889 the description of plgxax for more detail. \n\
5891 Redacted form: plgyax(digmax, digits)\n\
5893 This function is used in example 31. \n\
5899 plgyax(digmax, digits)\n\
5903 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5904 number of digits for the y axis. If nonzero, the printed label\n\
5905 has been switched to a floating point representation when the\n\
5906 number of digits exceeds digmax. \n\
5908 digits (PLINT *, output) : Pointer to variable with the actual\n\
5909 number of digits for the numeric labels (y axis) from the last\n\
5913 Set plot orientation \n\
5917 Set plot orientation parameter which is multiplied by 90 degrees to\n\
5918 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
5919 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
5920 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
5921 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
5922 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
5923 not called the default value of rot is 0. \n\
5925 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
5926 probably want to change the aspect ratio to a value suitable for the\n\
5927 plot orientation using a call to plsdidev or the command-line options\n\
5928 -a or -freeaspect.\tFor more documentation of those options see the\n\
5929 PLplot documentation. Such command-line options can be set internally\n\
5930 using plsetopt or set directly using the command line and parsed using\n\
5931 a call to plparseopts. \n\
5933 Redacted form: plsdiori(rot)\n\
5935 This function is not used in any examples. \n\
5945 rot (PLFLT, input) : Plot orientation parameter. \n\
5948 Plot a histogram from unbinned data \n\
5952 Plots a histogram from n data points stored in the array data. This\n\
5953 routine bins the data into nbin bins equally spaced between datmin and\n\
5954 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
5955 opt allows, among other things, the histogram either to be plotted in\n\
5956 an existing window or causes plhist to call plenv with suitable limits\n\
5957 before plotting the histogram. \n\
5959 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
5961 This function is used in example 5. \n\
5967 plhist(n, data, datmin, datmax, nbin, opt)\n\
5971 n (PLINT, input) : Number of data points. \n\
5973 data (PLFLT *, input) : Pointer to array with values of the n data\n\
5976 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
5978 datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
5980 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
5981 divide the interval xmin to xmax. \n\
5983 opt (PLINT, input) : Is a combination of several flags:\n\
5984 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
5985 the histogram data, the outer bins are expanded to fill up the\n\
5986 entire x-axis, data outside the given extremes are assigned to the\n\
5987 outer bins and bins of zero height are simply drawn. \n\
5988 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
5989 to fit the histogram data, without this flag, plenv is called\n\
5990 to set the world coordinates. \n\
5991 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
5992 extremes are not taken into account. This option should\n\
5993 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
5994 properly present the data. \n\
5995 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
5996 size as the ones inside. \n\
5997 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
5998 (there is a gap for such bins). \n\
6001 End plotting session \n\
6005 Ends a plotting session, tidies up all the output files, switches\n\
6006 interactive devices back into text mode and frees up any memory that\n\
6007 was allocated. Must be called before end of program. \n\
6009 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6010 wait state after a call to plend or other functions which trigger the\n\
6011 end of a plot page. To avoid this, use the plspause function. \n\
6013 Redacted form: plend()\n\
6015 This function is used in all of the examples. \n\
6024 Set device-compression level \n\
6028 Set device-compression level. Only used for drivers that provide\n\
6029 compression. This function, if used, should be invoked before a call\n\
6032 Redacted form: plscompression(compression)\n\
6034 This function is used in example 31. \n\
6040 plscompression(compression)\n\
6044 compression (PLINT, input) : The desired compression level. This is\n\
6045 a device-dependent value. Currently only the jpeg and png devices\n\
6046 use these values. For jpeg value is the jpeg quality which should\n\
6047 normally be in the range 0-95. Higher values denote higher quality\n\
6048 and hence larger image sizes. For png values are in the range -1\n\
6049 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
6050 A value of -1 denotes the default zlib compression level. Values\n\
6051 in the range 10-99 are divided by 10 and then used as the zlib\n\
6052 compression level. Higher compression levels correspond to greater\n\
6053 compression and small file sizes at the expense of more\n\
6057 Get the current device-compression setting \n\
6061 Get the current device-compression setting. This parameter is only\n\
6062 used for drivers that provide compression. \n\
6064 Redacted form: plgcompression(compression)\n\
6066 This function is used in example 31. \n\
6072 plgcompression(compression)\n\
6076 compression (PLINT *, output) : Pointer to a variable to be filled\n\
6077 with the current device-compression setting. \n\
6080 Advance the (sub-)page\n\
6084 Advances to the next subpage if sub=0, performing a page advance if\n\
6085 there are no remaining subpages on the current page. If subpages\n\
6086 aren\'t being used, pladv(0) will always advance the page. If sub>0,\n\
6087 PLplot switches to the specified subpage. Note that this allows you\n\
6088 to overwrite a plot on the specified subpage; if this is not what you\n\
6089 intended, use pleop followed by plbop to first advance the page. This\n\
6090 routine is called automatically (with sub=0) by plenv, but if plenv is\n\
6091 not used, pladv must be called after initializing PLplot but before\n\
6092 defining the viewport. \n\
6094 Redacted form: pladv(sub)\n\
6096 This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
6106 sub (PLINT, input) : Specifies the subpage number (starting from 1\n\
6107 in the top left corner and increasing along the rows) to which to\n\
6108 advance. Set to zero to advance to the next subpage. \n\
6111 Set parameters of contour labelling other than format of numerical label\n\
6115 Set parameters of contour labelling other than those handled by\n\
6116 pl_setcontlabelformat. \n\
6118 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
6120 This function is used in example 9. \n\
6126 pl_setcontlabelparam(offset, size, spacing, active)\n\
6130 offset (PLFLT, input) : Offset of label from contour line (if set\n\
6131 to 0.0, labels are printed on the lines). Default value is 0.006. \n\
6133 size (PLFLT, input) : Font height for contour labels (normalized). \n\
6134 Default value is 0.3. \n\
6136 spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
6137 Default value is 0.1. \n\
6139 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
6140 contour labels on. Default is off (0). \n\
6143 Set family, style and weight of the current font \n\
6147 Sets the current font. See the PLplot documentation for more\n\
6148 information on font selection. \n\
6150 Redacted form: plsfont(family, style, weight)\n\
6152 This function is used in example 23. \n\
6158 plsfont(family, style, weight)\n\
6162 family (PLINT, input) : Font family to select for the current font.\n\
6163 The available values are given by the PL_FCI_* constants in\n\
6164 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n\
6165 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
6166 signifies that the font family should not be altered. \n\
6168 style (PLINT, input) : Font style to select for the current font.\n\
6169 The available values are given by the PL_FCI_* constants in\n\
6170 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
6171 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
6172 should not be altered. \n\
6174 weight (PLINT, input) : Font weight to select for the current font.\n\
6175 The available values are given by the PL_FCI_* constants in\n\
6176 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
6177 negative value signifies that the font weight should not be\n\
6181 Sets the 3D position of the light source \n\
6185 Sets the 3D position of the light source for use with plsurf3d. \n\
6187 Redacted form: pllightsource(x, y, z)\n\
6189 This function is used in example 8. \n\
6195 pllightsource(x, y, z)\n\
6199 x (PLFLT, input) : X-coordinate of the light source. \n\
6201 y (PLFLT, input) : Y-coordinate of the light source. \n\
6203 z (PLFLT, input) : Z-coordinate of the light source. \n\
6210 Draws line defined by n points in x and y. \n\
6212 Redacted form: plline(x, y)\n\
6214 This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
6224 n (PLINT, input) : Number of points defining line. \n\
6226 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
6228 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
6235 Sets the pen width. \n\
6237 Redacted form: plwidth(width)\n\
6239 This function is used in examples 1,2. \n\
6249 width (PLFLT, input) : The desired pen width. If width is negative\n\
6250 or the same as the previous value no action is taken. width = 0.\n\
6251 should be interpreted as as the minimum valid pen width for the\n\
6252 device. The interpretation of positive width values is also\n\
6253 device dependent. \n\
6256 Draw linear gradient inside polygon \n\
6260 Draw a linear gradient using colour map 1 inside the polygon defined\n\
6261 by the n points (\n\
6263 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
6264 polygon coordinates and the gradient angle are all expressed in world\n\
6265 coordinates. The angle from the x axis for both the rotated\n\
6266 coordinate system and the gradient vector is specified by angle. The\n\
6267 magnitude of the gradient vector is the difference between the maximum\n\
6268 and minimum values of x for the vertices in the rotated coordinate\n\
6269 system. The origin of the gradient vector can be interpreted as being\n\
6270 anywhere on the line corresponding to the minimum x value for the\n\
6271 vertices in the rotated coordinate system.\tThe distance along the\n\
6272 gradient vector is linearly transformed to the independent variable of\n\
6273 colour map 1 which ranges from 0. at the tail of the gradient vector\n\
6274 to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
6275 colour corresponding to the independent variable of colour map 1. For\n\
6276 more information about colour map 1 (see the PLplot documentation). \n\
6278 Redacted form: plgradient(x,y,angle)\n\
6280 This function is used in examples 25,30. \n\
6286 plgradient(n, x, y, angle)\n\
6290 n (PLINT, input) : Number of vertices in polygon. \n\
6292 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
6295 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
6298 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
6302 Flushes the output stream \n\
6306 Flushes the output stream. Use sparingly, if at all. \n\
6308 Redacted form: plflush()\n\
6310 This function is used in examples 1,14. \n\
6319 Get plot orientation \n\
6323 Get plot orientation parameter which is multiplied by 90 degrees to\n\
6324 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
6325 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
6326 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
6327 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
6328 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
6329 not been called the default value pointed to by p_rot will be 0. \n\
6331 Redacted form: plgdiori(p_rot)\n\
6333 This function is not used in any examples. \n\
6343 p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
6346 Set x axis parameters \n\
6350 Sets values of the digmax and digits flags for the x axis.\tSee the\n\
6351 PLplot documentation for more information. \n\
6353 Redacted form: plsxax(digmax, digits)\n\
6355 This function is used in example 31. \n\
6361 plsxax(digmax, digits)\n\
6365 digmax (PLINT, input) : Variable to set the maximum number of\n\
6366 digits for the x axis. If nonzero, the printed label will be\n\
6367 switched to a floating point representation when the number of\n\
6368 digits exceeds digmax. \n\
6370 digits (PLINT, input) : Field digits value. Currently, changing\n\
6371 its value here has no effect since it is set only by plbox or\n\
6372 plbox3. However, the user may obtain its value after a call to\n\
6373 either of these functions by calling plgxax. \n\
6376 Get viewport limits in world coordinates \n\
6380 Get viewport limits in world coordinates. \n\
6382 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6383 \t Perl/PDL: Not available? \n\
6386 This function is used in example 31. \n\
6392 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6396 p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
6397 coordinate in x. \n\
6399 p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
6400 coordinate in x. \n\
6402 p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
6403 coordinate in y. \n\
6405 p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
6406 coordinate in y. \n\
6409 Get current subpage parameters \n\
6413 Gets the size of the current subpage in millimeters measured from the\n\
6414 bottom left hand corner of the output device page or screen. Can be\n\
6415 used in conjunction with plsvpa for setting the size of a viewport in\n\
6416 absolute coordinates (millimeters). \n\
6418 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
6420 This function is used in example 23. \n\
6426 plgspa(xmin, xmax, ymin, ymax)\n\
6430 xmin (PLFLT *, output) : Pointer to variable with position of left\n\
6431 hand edge of subpage in millimeters. \n\
6433 xmax (PLFLT *, output) : Pointer to variable with position of right\n\
6434 hand edge of subpage in millimeters. \n\
6436 ymin (PLFLT *, output) : Pointer to variable with position of\n\
6437 bottom edge of subpage in millimeters. \n\
6439 ymax (PLFLT *, output) : Pointer to variable with position of top\n\
6440 edge of subpage in millimeters. \n\
6443 Calculate world coordinates and corresponding window index from relative device coordinates \n\
6447 Calculate world coordinates, wx and wy, and corresponding window index\n\
6448 from relative device coordinates, rx and ry. \n\
6450 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
6451 \t Perl/PDL: Not available? \n\
6454 This function is used in example 31. \n\
6460 plcalc_world(rx, ry, wx, wy, window)\n\
6464 rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
6465 0. to 1.) for the x coordinate. \n\
6467 ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
6468 0. to 1.) for the y coordinate. \n\
6470 wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6471 x corresponding to the relative device coordinates rx and ry. \n\
6473 wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6474 y corresponding to the relative device coordinates rx and ry. \n\
6476 window (PLINT *, output) : Pointer to the returned last defined\n\
6477 window index that corresponds to the input relative device\n\
6478 coordinates (and the returned world coordinates). To give some\n\
6479 background on the window index, for each page the initial window\n\
6480 index is set to zero, and each time plwind is called within the\n\
6481 page, world and device coordinates are stored for the window and\n\
6482 the window index is incremented. Thus, for a simple page layout\n\
6483 with non-overlapping viewports and one window per viewport, window\n\
6484 corresponds to the viewport index (in the order which the\n\
6485 viewport/windows were created) of the only viewport/window\n\
6486 corresponding to rx and ry. However, for more complicated layouts\n\
6487 with potentially overlapping viewports and possibly more than one\n\
6488 window (set of world coordinates) per viewport, window and the\n\
6489 corresponding output world coordinates corresponds to the last\n\
6490 window created that fulfills the criterion that the relative\n\
6491 device coordinates are inside it. Finally, in all cases where the\n\
6492 input relative device coordinates are not inside any\n\
6493 viewport/window, then window is set to -1. \n\
6496 Draw a box with axes, etc, in 3-d \n\
6500 Draws axes, numeric and text labels for a three-dimensional surface\n\
6501 plot. For a more complete description of three-dimensional plotting\n\
6502 see the PLplot documentation. \n\
6504 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6505 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6506 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
6507 xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
6510 This function is used in examples 8,11,18,21. \n\
6516 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6520 xopt (const char *, input) : Pointer to character string specifying\n\
6521 options for the x axis. The string can include any combination of\n\
6522 the following letters (upper or lower case) in any order: b: Draws\n\
6523 axis at base, at height z=\n\
6524 zmin where zmin is defined by call to plw3d. This character must be\n\
6525 specified in order to use any of the other options. \n\
6526 f: Always use fixed point numeric labels. \n\
6527 i: Inverts tick marks, so they are drawn downwards, rather\n\
6529 l: Labels axis logarithmically. This only affects the labels,\n\
6530 not the data, and so it is necessary to compute the logarithms\n\
6531 of data points before passing them to any of the drawing\n\
6533 n: Writes numeric labels at major tick intervals. \n\
6534 o: Use custom labelling function to generate axis label text. \n\
6535 The custom labelling function can be defined with the\n\
6536 plslabelfunc command. \n\
6537 s: Enables subticks between major ticks, only valid if t is\n\
6539 t: Draws major ticks. \n\
6540 u: If this is specified, the text label for the axis is\n\
6541 written under the axis. \n\
6544 xlabel (const char *, input) : Pointer to character string\n\
6545 specifying text label for the x axis. It is only drawn if u is in\n\
6546 the xopt string. \n\
6548 xtick (PLFLT, input) : World coordinate interval between major\n\
6549 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6550 generates a suitable tick interval. \n\
6552 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6553 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6554 generates a suitable minor tick interval. \n\
6556 yopt (const char *, input) : Pointer to character string specifying\n\
6557 options for the y axis. The string is interpreted in the same way\n\
6560 ylabel (const char *, input) : Pointer to character string\n\
6561 specifying text label for the y axis. It is only drawn if u is in\n\
6562 the yopt string. \n\
6564 ytick (PLFLT, input) : World coordinate interval between major\n\
6565 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6566 generates a suitable tick interval. \n\
6568 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6569 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6570 generates a suitable minor tick interval. \n\
6572 zopt (const char *, input) : Pointer to character string specifying\n\
6573 options for the z axis. The string can include any combination of\n\
6574 the following letters (upper or lower case) in any order: b: Draws\n\
6575 z axis to the left of the surface plot. \n\
6576 c: Draws z axis to the right of the surface plot. \n\
6577 d: Draws grid lines parallel to the x-y plane behind the\n\
6578 figure. These lines are not drawn until after plot3d or\n\
6579 plmesh are called because of the need for hidden line removal. \n\
6580 f: Always use fixed point numeric labels. \n\
6581 i: Inverts tick marks, so they are drawn away from the center. \n\
6582 l: Labels axis logarithmically. This only affects the labels,\n\
6583 not the data, and so it is necessary to compute the logarithms\n\
6584 of data points before passing them to any of the drawing\n\
6586 m: Writes numeric labels at major tick intervals on the\n\
6587 right-hand vertical axis. \n\
6588 n: Writes numeric labels at major tick intervals on the\n\
6589 left-hand vertical axis. \n\
6590 o: Use custom labelling function to generate axis label text. \n\
6591 The custom labelling function can be defined with the\n\
6592 plslabelfunc command. \n\
6593 s: Enables subticks between major ticks, only valid if t is\n\
6595 t: Draws major ticks. \n\
6596 u: If this is specified, the text label is written beside the\n\
6598 v: If this is specified, the text label is written beside the\n\
6599 right-hand axis. \n\
6602 zlabel (const char *, input) : Pointer to character string\n\
6603 specifying text label for the z axis. It is only drawn if u or v\n\
6604 are in the zopt string. \n\
6606 ztick (PLFLT, input) : World coordinate interval between major\n\
6607 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6608 generates a suitable tick interval. \n\
6610 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6611 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6612 generates a suitable minor tick interval. \n\
6615 Get character default height and current (scaled) height \n\
6619 Get character default height and current (scaled) height. \n\
6621 Redacted form: plgchr(p_def, p_ht)\n\
6623 This function is used in example 23. \n\
6629 plgchr(p_def, p_ht)\n\
6633 p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
6635 p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
6639 Set the escape character for text strings \n\
6643 Set the escape character for text strings.\tFrom C (in contrast to\n\
6644 Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
6645 selected characters are allowed to prevent the user from shooting\n\
6646 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
6647 with C\'s use of backslash as a character escape). Here are the\n\
6648 allowed escape characters and their corresponding decimal ASCII\n\
6649 values: !, ASCII 33 \n\
6660 Redacted form: General: plsesc(esc)\n\
6661 \t Perl/PDL: Not available? \n\
6664 This function is used in example 29. \n\
6674 esc (char, input) : Escape character. \n\
6677 Draw a line between two points, accounting for coordinate transforms. \n\
6681 Joins the point (\n\
6685 y2). If a global coordinate transform is defined then the line is\n\
6686 broken in to n segments to approximate the path. If no transform is\n\
6687 defined then this simply acts like a call to pljoin. \n\
6689 Redacted form: plpath(n,x1,y1,x2,y2)\n\
6691 This function is used in example 22. \n\
6697 plpath(n, x1, y1, x2, y2)\n\
6701 n (PLINT, input) : number of points to use to approximate the path. \n\
6703 x1 (PLFLT, input) : x coordinate of first point. \n\
6705 y1 (PLFLT, input) : y coordinate of first point. \n\
6707 x2 (PLFLT, input) : x coordinate of second point. \n\
6709 y2 (PLFLT, input) : y coordinate of second point. \n\
6712 Set up standard window and draw box \n\
6716 Sets up plotter environment for simple graphs by calling pladv and\n\
6717 setting up viewport and window to sensible default values.\tplenv\n\
6718 leaves enough room around most graphs for axis labels and a title.\n\
6719 When these defaults are not suitable, use the individual routines\n\
6720 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
6721 defining the window, and plbox for drawing the box. \n\
6723 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6725 This function is used in example 1,3,9,13,14,19-22,29. \n\
6731 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6735 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
6736 world coordinates). \n\
6738 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
6739 world coordinates). \n\
6741 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
6744 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
6747 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
6748 scales will not be set, the user must set up the scale before\n\
6749 calling plenv using plsvpa, plvasp or other. \n\
6750 0: the x and y axes are scaled independently to use as much of\n\
6751 the screen as possible. \n\
6752 1: the scales of the x and y axes are made equal. \n\
6753 2: the axis of the x and y axes are made equal, and the plot\n\
6754 box will be square. \n\
6757 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
6758 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
6759 -1: draw box only. \n\
6760 0: draw box, ticks, and numeric tick labels. \n\
6761 1: also draw coordinate axes at x=0 and y=0. \n\
6762 2: also draw a grid at major tick positions in both\n\
6764 3: also draw a grid at minor tick positions in both\n\
6766 10: same as 0 except logarithmic x tick marks. (The x data\n\
6767 have to be converted to logarithms separately.) \n\
6768 11: same as 1 except logarithmic x tick marks. (The x data\n\
6769 have to be converted to logarithms separately.) \n\
6770 12: same as 2 except logarithmic x tick marks. (The x data\n\
6771 have to be converted to logarithms separately.) \n\
6772 13: same as 3 except logarithmic x tick marks. (The x data\n\
6773 have to be converted to logarithms separately.) \n\
6774 20: same as 0 except logarithmic y tick marks. (The y data\n\
6775 have to be converted to logarithms separately.) \n\
6776 21: same as 1 except logarithmic y tick marks. (The y data\n\
6777 have to be converted to logarithms separately.) \n\
6778 22: same as 2 except logarithmic y tick marks. (The y data\n\
6779 have to be converted to logarithms separately.) \n\
6780 23: same as 3 except logarithmic y tick marks. (The y data\n\
6781 have to be converted to logarithms separately.) \n\
6782 30: same as 0 except logarithmic x and y tick marks. (The x\n\
6783 and y data have to be converted to logarithms separately.) \n\
6784 31: same as 1 except logarithmic x and y tick marks. (The x\n\
6785 and y data have to be converted to logarithms separately.) \n\
6786 32: same as 2 except logarithmic x and y tick marks. (The x\n\
6787 and y data have to be converted to logarithms separately.) \n\
6788 33: same as 3 except logarithmic x and y tick marks. (The x\n\
6789 and y data have to be converted to logarithms separately.) \n\
6790 40: same as 0 except date / time x labels. \n\
6791 41: same as 1 except date / time x labels. \n\
6792 42: same as 2 except date / time x labels. \n\
6793 43: same as 3 except date / time x labels. \n\
6794 50: same as 0 except date / time y labels. \n\
6795 51: same as 1 except date / time y labels. \n\
6796 52: same as 2 except date / time y labels. \n\
6797 53: same as 3 except date / time y labels. \n\
6798 60: same as 0 except date / time x and y labels. \n\
6799 61: same as 1 except date / time x and y labels. \n\
6800 62: same as 2 except date / time x and y labels. \n\
6801 63: same as 3 except date / time x and y labels. \n\
6802 70: same as 0 except custom x and y labels. \n\
6803 71: same as 1 except custom x and y labels. \n\
6804 72: same as 2 except custom x and y labels. \n\
6805 73: same as 3 except custom x and y labels. \n\
6808 Clear current (sub)page \n\
6812 Clears the current page, effectively erasing everything that have been\n\
6813 drawn. This command only works with interactive drivers; if the\n\
6814 driver does not support this, the page is filled with the background\n\
6815 color in use. If the current page is divided into subpages, only the\n\
6816 current subpage is erased.\tThe nth subpage can be selected with\n\
6819 Redacted form: General: plclear()\n\
6820 \t Perl/PDL: Not available? \n\
6823 This function is not used in any examples. \n\
6832 Set color map0 colors by 8-bit RGB values and double alpha value. \n\
6836 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
6837 documentation) and floating point alpha value. This sets the entire\n\
6838 color map -- only as many colors as specified will be allocated. \n\
6840 This function is used in examples 30. \n\
6846 plscmap0a(r, g, b, a, ncol0)\n\
6850 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6851 integers (0-255) representing the degree of red in the color. \n\
6853 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6854 integers (0-255) representing the degree of green in the color. \n\
6856 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6857 integers (0-255) representing the degree of blue in the color. \n\
6859 a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n\
6860 - 1.0) representing the transparency of the color. \n\
6862 ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n\
6866 Set a given color from color map0 by 8 bit RGB value \n\
6870 Set a given color by 8-bit RGB value for color map0 (see the PLplot\n\
6871 documentation). Overwrites the previous color value for the given\n\
6872 index and, thus, does not result in any additional allocation of space\n\
6875 Redacted form: plscol0(icol0, r, g, b)\n\
6877 This function is used in any example 31. \n\
6883 plscol0(icol0, r, g, b)\n\
6887 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6888 number of colors (which is set by default, by plscmap0n, or even\n\
6891 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6892 degree of red in the color. \n\
6894 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6895 degree of green in the color. \n\
6897 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6898 degree of blue in the color. \n\
6901 Set up transformation from metafile coordinates \n\
6905 Set up transformation from metafile coordinates. The size of the plot\n\
6906 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
6907 general-purpose facility just yet (not sure why the user would need\n\
6910 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
6913 This function is not used in any examples. \n\
6919 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
6923 dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
6925 dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
6927 dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
6929 dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
6931 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6933 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6936 Creates a new stream and makes it the default \n\
6940 Creates a new stream and makes it the default. Differs from using\n\
6941 plsstrm, in that a free stream number is found, and returned.\n\
6942 Unfortunately, I have to start at stream 1 and work upward, since\n\
6943 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6944 that no initial, library-opening call is required.\tSo stream 0 must\n\
6945 be preallocated, and there is no simple way of determining whether it\n\
6946 is already in use or not. \n\
6948 Redacted form: plmkstrm(p_strm)\n\
6950 This function is used in examples 1,20. \n\
6960 p_strm (PLINT *, output) : Pointer to stream number of the created\n\
6964 Get page parameters \n\
6968 Gets the current page configuration. The length and offset values are\n\
6969 expressed in units that are specific to the current driver. For\n\
6970 instance: screen drivers will usually interpret them as number of\n\
6971 pixels, whereas printer drivers will usually use mm. \n\
6973 Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6975 This function is used in examples 14 and 31. \n\
6981 plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6985 xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
6987 yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n\
6989 xleng (PLINT *, output) : Pointer to x page length value. \n\
6991 yleng (PLINT *, output) : Pointer to y page length value. \n\
6993 xoff (PLINT *, output) : Pointer to x page offset. \n\
6995 yoff (PLINT *, output) : Pointer to y page offset. \n\
6998 Set format for date / time labels \n\
7002 Sets the format for date / time labels. To enable date / time format\n\
7003 labels see the options to plbox and plenv.\t\n\
7005 Redacted form: pltimefmt(fmt)\n\
7007 This function is used in example 29. \n\
7017 fmt (const char *, fmt) : This string is passed directly to the\n\
7018 system strftime. See the system documentation for a full list of\n\
7019 conversion specifications for your system. All conversion\n\
7020 specifications take the form of a \'%\' character followed by\n\
7021 further conversion specification character. All other text is\n\
7022 printed as-is. Common options include: %c: The preferred date and\n\
7023 time representation for the current locale. \n\
7024 %d: The day of the month as a decimal number. \n\
7025 %H: The hour as a decimal number using a 24-hour clock. \n\
7026 %j: The day of the year as a decimal number. \n\
7027 %m: The month as a decimal number. \n\
7028 %M: The minute as a decimal number. \n\
7029 %S: The second as a decimal number. \n\
7030 %y: The year as a decimal number without a century. \n\
7031 %Y: The year as a decimal number including a century. \n\
7034 Specify viewport using aspect ratio only \n\
7038 Sets the viewport so that the ratio of the length of the y axis to\n\
7039 that of the x axis is equal to aspect. \n\
7041 Redacted form: plvasp(aspect)\n\
7043 This function is used in example 13. \n\
7053 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
7057 Set output file name \n\
7061 Sets the current output file name, if applicable. If the file name\n\
7062 has not been specified and is required by the driver, the user will be\n\
7063 prompted for it. If using the X-windows output driver, this sets the\n\
7064 display name. This routine, if used, must be called before\n\
7065 initializing PLplot. \n\
7067 Redacted form: plsfnam(fnam)\n\
7069 This function is used in examples 1,20. \n\
7079 fnam (const char *, input) : Pointer to file name string. \n\
7082 Set parameters that define current plot-space window \n\
7086 Set relative minima and maxima that define the current plot-space\n\
7087 window. If plsdiplt is not called the default values of xmin, ymin,\n\
7088 xmax, and ymax are 0., 0., 1., and 1. \n\
7090 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
7092 This function is used in example 31. \n\
7098 plsdiplt(xmin, ymin, xmax, ymax)\n\
7102 xmin (PLFLT, input) : Relative minimum in x. \n\
7104 ymin (PLFLT, input) : Relative minimum in y. \n\
7106 xmax (PLFLT, input) : Relative maximum in x. \n\
7108 ymax (PLFLT, input) : Relative maximum in y. \n\
7111 Select line style \n\
7115 This sets the line style according to one of eight predefined patterns\n\
7116 (also see plstyl). \n\
7118 Redacted form: pllsty(n)\n\
7120 This function is used in examples 9,12,22,25. \n\
7130 n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n\
7131 continuous line, line style 2 is a line with short dashes and\n\
7132 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7133 4 has long dashes and short gaps and so on. \n\
7136 Plot a glyph at the specified points \n\
7140 Plot a glyph at the specified points. (This function is largely\n\
7141 superseded by plstring which gives access to many[!] more glyphs.) \n\
7143 Redacted form: plsym(x, y, code)\n\
7145 This function is used in example 7. \n\
7151 plsym(n, x, y, code)\n\
7155 n (PLINT, input) : Number of points in the x and y arrays. \n\
7157 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7160 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7163 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
7164 to be plotted at each of the n points. \n\
7167 Set the device (keyword) name \n\
7171 Set the device (keyword) name. \n\
7173 Redacted form: plsdev(devname)\n\
7175 This function is used in examples 1,14,20. \n\
7185 devname (const char *, input) : Pointer to device (keyword) name\n\
7189 Set the background color by 8-bit RGB value \n\
7193 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7194 (see the PLplot documentation). \n\
7196 Redacted form: plscolbg(r, g, b)\n\
7198 This function is used in examples 15,31. \n\
7204 plscolbg(r, g, b)\n\
7208 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7209 degree of red in the color. \n\
7211 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7212 degree of green in the color. \n\
7214 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7215 degree of blue in the color. \n\
7218 Set parameters incrementally (zoom mode) that define current plot-space window \n\
7222 Set relative minima and maxima incrementally (zoom mode) that define\n\
7223 the current plot-space window. This function has the same effect as\n\
7224 plsdiplt if that function has not been previously called. Otherwise,\n\
7225 this function implements zoom mode using the transformation min_used =\n\
7226 old_min + old_length*min and max_used = old_min + old_length*max for\n\
7227 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
7228 repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
7230 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
7232 This function is used in example 31. \n\
7238 plsdiplz(xmin, ymin, xmax, ymax)\n\
7242 xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
7244 ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
7246 xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
7248 ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
7251 Advance to the next family file on the next new page \n\
7255 Advance to the next family file on the next new page. \n\
7257 Redacted form: plfamadv()\n\
7259 This function is not used in any examples. \n\
7268 Set number of colors in color map0 \n\
7272 Set number of colors in color map0 (see the PLplot documentation).\n\
7273 Allocate (or reallocate) color map0, and fill with default values for\n\
7274 those colors not previously allocated. The first 16 default colors are\n\
7275 given in the plcol0 documentation. For larger indices the default\n\
7278 The drivers are not guaranteed to support more than 16 colors. \n\
7280 Redacted form: plscmap0n(ncol0)\n\
7282 This function is used in examples 15,16,24. \n\
7292 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
7293 the map0 palette. If this number is zero or less, then the value\n\
7294 from the previous call to plscmap0n is used and if there is no\n\
7295 previous call, then a default value is used. \n\
7298 Plot latitude and longitude lines. \n\
7302 Displays latitude and longitude on the current plot. The lines are\n\
7303 plotted in the current color and line style. \n\
7305 Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n\
7306 maxlong, minlat, maxlat)\n\
7307 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
7310 This function is used in example 19. \n\
7316 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7320 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
7321 supplied function to transform the coordinate longitudes and\n\
7322 latitudes to a plot coordinate system. By using this transform,\n\
7323 we can change from a longitude, latitude coordinate to a polar\n\
7324 stereographic project, for example. Initially, x[0]..[n-1] are\n\
7325 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
7326 After the call to mapform(), x[] and y[] should be replaced by\n\
7327 the corresponding plot coordinates. If no transform is desired,\n\
7328 mapform can be replaced by NULL. \n\
7330 dlong (PLFLT, input) : The interval in degrees at which the\n\
7331 longitude lines are to be plotted. \n\
7333 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7334 lines are to be plotted. \n\
7336 minlong (PLFLT, input) : The value of the longitude on the left\n\
7337 side of the plot. The value of minlong must be less than the\n\
7338 value of maxlong, and the quantity maxlong-minlong must be less\n\
7339 than or equal to 360. \n\
7341 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7342 side of the plot. \n\
7344 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7345 background. One can always use -90.0 as the boundary outside the\n\
7346 plot window will be automatically eliminated. However, the\n\
7347 program will be faster if one can reduce the size of the\n\
7348 background plotted. \n\
7350 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7351 background. One can always use 90.0 as the boundary outside the\n\
7352 plot window will be automatically eliminated. \n\
7355 Convert RGB color to HLS \n\
7359 Convert RGB color coordinates to HLS \n\
7361 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7362 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
7365 This function is used in example 2. \n\
7371 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7375 r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
7377 g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
7379 b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
7381 p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
7382 cone (0.0-360.0) \n\
7384 p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
7385 fraction of the axis of the colour cone (0.0-1.0) \n\
7387 p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
7388 fraction of the radius of the colour cone (0.0-1.0) \n\
7391 Plot a glyph at the specified 3D points \n\
7395 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
7396 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
7397 this function similar to what is done for plline3. The glyph is\n\
7398 specified with a PLplot user string. Note that the user string is not\n\
7399 actually limited to one glyph so it is possible (but not normally\n\
7400 useful) to plot more than one glyph at the specified points with this\n\
7401 function. As with plmtex and plptex, the user string can contain FCI\n\
7402 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7403 else PLplot escapes for Hershey or unicode text to determine the\n\
7406 Redacted form: plstring3(x, y, z, string)\n\
7408 This function is used in example 18. \n\
7414 plstring3(n, x, y, z, string)\n\
7418 n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
7420 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7423 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7426 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7429 string (const char *, input) : PLplot user string corresponding to\n\
7430 the glyph to be plotted at each of the n points. \n\
7433 Switch to text screen \n\
7437 Sets an interactive device to text mode, used in conjunction with\n\
7438 plgra to allow graphics and text to be interspersed. On a device\n\
7439 which supports separate text and graphics windows, this command causes\n\
7440 control to be switched to the text window.\tThis can be useful for\n\
7441 printing diagnostic messages or getting user input, which would\n\
7442 otherwise interfere with the plots. The program must switch back to\n\
7443 the graphics window before issuing plot commands, as the text (or\n\
7444 console) device will probably become quite confused otherwise. If\n\
7445 already in text mode, this command is ignored. It is also ignored on\n\
7446 devices which only support a single window or use a different method\n\
7447 for shifting focus (see also plgra). \n\
7449 Redacted form: pltext()\n\
7451 This function is used in example 1. \n\
7460 Get parameters that define current plot-space window \n\
7464 Get relative minima and maxima that define current plot-space window.\n\
7465 If plsdiplt has not been called the default values pointed to by\n\
7466 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
7468 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7470 This function is used in example 31. \n\
7476 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7480 p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
7482 p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
7484 p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
7486 p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
7489 Get the (current) run level \n\
7493 Get the (current) run level. Valid settings are: 0, uninitialized \n\
7494 \t 1,\tinitialized \n\
7495 \t 2,\tviewport defined \n\
7496 \t 3,\tworld coordinates defined \n\
7499 Redacted form: plglevel(p_level)\n\
7501 This function is used in example 31. \n\
7507 plglevel(p_level)\n\
7511 p_level (PLINT *, output) : Pointer to the run level. \n\
7514 Plot a histogram from binned data \n\
7518 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
7519 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
7520 placed in y[i]. For proper operation, the values in x[i] must form a\n\
7521 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
7522 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
7523 placed midway between the values in the x array. Also see plhist for\n\
7524 drawing histograms from unbinned data. \n\
7526 Redacted form: General: plbin(x, y, opt)\n\
7527 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
7528 \t Python: plbin(nbin, x, y, opt)\n\
7531 This function is not used in any examples. \n\
7537 plbin(nbin, x, y, opt)\n\
7541 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
7544 x (PLFLT *, input) : Pointer to array containing values associated\n\
7545 with bins. These must form a strictly increasing sequence. \n\
7547 y (PLFLT *, input) : Pointer to array containing number of points\n\
7548 in bin. This is a PLFLT (instead of PLINT) array so as to allow\n\
7549 histograms of probabilities, etc. \n\
7551 opt (PLINT, input) : Is a combination of several flags:\n\
7552 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
7553 outer bins are expanded to fill up the entire x-axis and bins of\n\
7554 zero height are simply drawn. \n\
7555 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
7556 between the x values. If the values in x are equally spaced,\n\
7557 the values are the center values of the bins. \n\
7558 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
7559 size as the ones inside. \n\
7560 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
7561 (there is a gap for such bins). \n\
7564 Get family, style and weight of the current font \n\
7568 Gets information about current font. See the PLplot documentation for\n\
7569 more information on font selection. \n\
7571 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7573 This function is used in example 23. \n\
7579 plgfont(p_family, p_style, p_weight)\n\
7583 p_family (PLINT *, output) : Pointer to variable with the current\n\
7584 font family. The available values are given by the PL_FCI_*\n\
7585 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7586 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7587 p_family is NULL then the font family is not returned. \n\
7589 p_style (PLINT *, output) : Pointer to variable with the current\n\
7590 font style. The available values are given by the PL_FCI_*\n\
7591 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7592 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
7593 font style is not returned. \n\
7595 p_weight (PLINT *, output) : Pointer to variable with the current\n\
7596 font weight. The available values are given by the PL_FCI_*\n\
7597 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7598 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7602 Get z axis parameters \n\
7606 Identical to plgxax, except that arguments are flags for z axis. See\n\
7607 the description of plgxax for more detail. \n\
7609 Redacted form: plgzax(digmax, digits)\n\
7611 This function is used in example 31. \n\
7617 plgzax(digmax, digits)\n\
7621 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7622 number of digits for the z axis. If nonzero, the printed label\n\
7623 has been switched to a floating point representation when the\n\
7624 number of digits exceeds digmax. \n\
7626 digits (PLINT *, output) : Pointer to variable with the actual\n\
7627 number of digits for the numeric labels (z axis) from the last\n\
7631 Write text inside the viewport of a 3D plot. \n\
7635 Writes text at a specified position and inclination and with a\n\
7636 specified shear within the viewport. Text is clipped at the viewport\n\
7637 boundaries. The reference point of a string lies along a line passing\n\
7638 through the string at half the height of a capital letter.\tThe\n\
7639 position of the reference point along this line is determined by just,\n\
7640 and the reference point is placed at world coordinates (\n\
7643 z) within the viewport. The inclination and shear of the string is\n\
7644 specified in terms of differences of world coordinates making it easy\n\
7645 to write text parallel to a line in a graph. \n\
7647 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7649 This function is used in example 28. \n\
7655 plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7659 x (PLFLT, input) : x coordinate of reference point of string. \n\
7661 y (PLFLT, input) : y coordinate of reference point of string. \n\
7663 z (PLFLT, input) : z coordinate of reference point of string. \n\
7665 dx (PLFLT, input) : Together with dy and \n\
7666 dz, this specifies the inclination of the string. The baseline of\n\
7667 the string is parallel to a line joining (\n\
7678 dy (PLFLT, input) : Together with dx and \n\
7679 dz, this specifies the inclination of the string. \n\
7681 dz (PLFLT, input) : Together with dx and \n\
7682 dy, this specifies the inclination of the string. \n\
7684 sx (PLFLT, input) : Together with sy and \n\
7685 sz, this specifies the shear of the string. The string is sheared so\n\
7686 that the characters are vertically parallel to a line joining (\n\
7697 sz = 0.) then the text is not sheared. \n\
7699 sy (PLFLT, input) : Together with sx and \n\
7700 sz, this specifies shear of the string. \n\
7702 sz (PLFLT, input) : Together with sx and \n\
7703 sy, this specifies shear of the string. \n\
7705 just (PLFLT, input) : Specifies the position of the string relative\n\
7706 to its reference point. If just=0., the reference point is at the\n\
7707 left and if just=1., it is at the right of the string. Other\n\
7708 values of just give intermediate justifications. \n\
7710 text (const char *, input) : The string to be written out. \n\
7713 Draw a box with axes, etc. with arbitrary origin \n\
7717 Draws a box around the currently defined viewport with arbitrary\n\
7718 world-coordinate origin specified by x0 and y0 and labels it with\n\
7719 world coordinate values appropriate to the window.\tThus plaxes should\n\
7720 only be called after defining both viewport and window. The character\n\
7721 strings xopt and yopt specify how the box should be drawn as described\n\
7722 below. If ticks and/or subticks are to be drawn for a particular\n\
7723 axis, the tick intervals and number of subintervals may be specified\n\
7724 explicitly, or they may be defaulted by setting the appropriate\n\
7725 arguments to zero. \n\
7727 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
7729 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
7733 This function is not used in any examples. \n\
7739 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
7743 x0 (PLFLT, input) : World X coordinate of origin. \n\
7745 y0 (PLFLT, input) : World Y coordinate of origin. \n\
7747 xopt (const char *, input) : Pointer to character string specifying\n\
7748 options for horizontal axis. The string can include any\n\
7749 combination of the following letters (upper or lower case) in any\n\
7750 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
7751 is vertical line (x=0). \n\
7752 b: Draws bottom (X) or left (Y) edge of frame. \n\
7753 c: Draws top (X) or right (Y) edge of frame. \n\
7754 d: Plot labels as date / time. Values are assumed to be\n\
7755 seconds since the epoch (as used by gmtime). \n\
7756 f: Always use fixed point numeric labels. \n\
7757 g: Draws a grid at the major tick interval. \n\
7758 h: Draws a grid at the minor tick interval. \n\
7759 i: Inverts tick marks, so they are drawn outwards, rather than\n\
7761 l: Labels axis logarithmically. This only affects the labels,\n\
7762 not the data, and so it is necessary to compute the logarithms\n\
7763 of data points before passing them to any of the drawing\n\
7765 m: Writes numeric labels at major tick intervals in the\n\
7766 unconventional location (above box for X, right of box for Y). \n\
7767 n: Writes numeric labels at major tick intervals in the\n\
7768 conventional location (below box for X, left of box for Y). \n\
7769 o: Use custom labelling function to generate axis label text. \n\
7770 The custom labelling function can be defined with the\n\
7771 plslabelfunc command. \n\
7772 s: Enables subticks between major ticks, only valid if t is\n\
7774 t: Draws major ticks. \n\
7775 u: Exactly like \"b\" except don\'t draw edge line. \n\
7776 w: Exactly like \"c\" except don\'t draw edge line. \n\
7777 x: Exactly like \"t\" (including the side effect of the\n\
7778 numerical labels for the major ticks) except exclude drawing\n\
7779 the major and minor tick marks. \n\
7782 xtick (PLFLT, input) : World coordinate interval between major\n\
7783 ticks on the x axis. If it is set to zero, PLplot automatically\n\
7784 generates a suitable tick interval. \n\
7786 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
7787 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7788 generates a suitable minor tick interval. \n\
7790 yopt (const char *, input) : Pointer to character string specifying\n\
7791 options for vertical axis. The string can include any combination\n\
7792 of the letters defined above for xopt, and in addition may\n\
7793 contain: v: Write numeric labels for vertical axis parallel to the\n\
7794 base of the graph, rather than parallel to the axis. \n\
7797 ytick (PLFLT, input) : World coordinate interval between major\n\
7798 ticks on the y axis. If it is set to zero, PLplot automatically\n\
7799 generates a suitable tick interval. \n\
7801 nysub (PLINT, input) : Number of subintervals between major y axis\n\
7802 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7803 generates a suitable minor tick interval. \n\
7806 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
7810 Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
7812 Redacted form: plgcolbg(r, g, b)\n\
7814 This function is used in example 31. \n\
7820 plgcolbg(r, g, b)\n\
7824 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7825 representing the degree of red in the color. \n\
7827 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7828 representing the degree of green in the color. \n\
7830 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7831 representing the degree of blue in the color. \n\
7834 Plot a glyph at the specified 3D points \n\
7838 Plot a glyph at the specified 3D points. (This function is largely\n\
7839 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
7840 Set up the call to this function similar to what is done for plline3.\n\
7841 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7842 and a draw at the same place. Not ideal, since a sufficiently\n\
7843 intelligent output device may optimize it away, or there may be faster\n\
7844 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7845 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7846 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7847 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7848 code <= 127 the corresponding printable ASCII character is plotted. \n\
7850 Redacted form: plpoin3(x, y, z, code)\n\
7852 This function is not used in any example. \n\
7858 plpoin3(n, x, y, z, code)\n\
7862 n (PLINT, input) : Number of points in the x and y arrays. \n\
7864 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7867 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7870 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7873 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7874 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7875 each of the n points. \n\
7878 Draw a polygon in 3 space \n\
7882 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
7883 like plline3, but differs from that function in that plpoly3 attempts\n\
7884 to determine if the polygon is viewable depending on the order of the\n\
7885 points within the arrays and the value of ifcc. If the back of\n\
7886 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
7887 you want, then use plline3 instead. \n\
7889 The points are assumed to be in a plane, and the directionality of the\n\
7890 plane is determined from the first three points. Additional points do\n\
7891 not have to lie on the plane defined by the first three, but if they\n\
7892 do not, then the determination of visibility obviously can\'t be 100%\n\
7893 accurate... So if you\'re 3 space polygons are too far from planar,\n\
7894 consider breaking them into smaller polygons. 3 points define a plane\n\
7897 Bugs: If one of the first two segments is of zero length, or if they\n\
7898 are co-linear, the calculation of visibility has a 50/50 chance of\n\
7899 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
7900 of this problem. (Search for 20.1). \n\
7902 Redacted form: plpoly3(x, y, z, code)\n\
7904 This function is used in example 18. \n\
7910 plpoly3(n, x, y, z, draw, ifcc)\n\
7914 n (PLINT, input) : Number of points defining line. \n\
7916 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
7918 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
7920 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
7922 draw (PLBOOL *, input) : Pointer to array which controls drawing\n\
7923 the segments of the polygon. If draw[i] is true, then the polygon\n\
7924 segment from index [i] to [i+1] is drawn, otherwise, not. \n\
7926 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
7927 polygon is determined by assuming the points are laid out in a\n\
7928 counter-clockwise order. Otherwise, the directionality of the\n\
7929 polygon is determined by assuming the points are laid out in a\n\
7930 clockwise order. \n\
7933 Set the background color by 8-bit RGB value and double alpha value. \n\
7937 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7938 (see the PLplot documentation) and double alpha value. \n\
7940 This function is used in example 31. \n\
7946 plscolbga(r, g, b, a)\n\
7950 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7951 degree of red in the color. \n\
7953 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7954 degree of green in the color. \n\
7956 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7957 degree of blue in the color. \n\
7959 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
7960 value of the color. \n\
7963 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n\
7967 Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
7970 This function is used in example 31. \n\
7976 plgcolbga(r, g, b, a)\n\
7980 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7981 representing the degree of red in the color. \n\
7983 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7984 representing the degree of green in the color. \n\
7986 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7987 representing the degree of blue in the color. \n\
7989 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
7992 Draw x error bar \n\
7996 Draws a set of n horizontal error bars, the i\'th error bar extending\n\
7997 from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
7998 error bar are of length equal to the minor tick length (settable using\n\
8001 Redacted form: General: plerrx(xmin, ymax, y)\n\
8002 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
8005 This function is used in example 29. \n\
8011 plerrx(n, xmin, xmax, y)\n\
8015 n (PLINT, input) : Number of error bars to draw. \n\
8017 xmin (PLFLT *, input) : Pointer to array with x coordinates of\n\
8018 left-hand endpoint of error bars. \n\
8020 xmax (PLFLT *, input) : Pointer to array with x coordinates of\n\
8021 right-hand endpoint of error bars. \n\
8023 y (PLFLT *, input) : Pointer to array with y coordinates of error\n\
8027 Eject current page \n\
8031 Clears the graphics screen of an interactive device, or ejects a page\n\
8032 on a plotter. See plbop for more information. \n\
8034 Redacted form: pleop()\n\
8036 This function is used in example 2,14. \n\
8045 Convert HLS color to RGB \n\
8049 Convert HLS color coordinates to RGB. \n\
8051 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8052 \t Perl/PDL: Not available? Implemented as plhls? \n\
8055 This function is used in example 2. \n\
8061 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8065 h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
8067 l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
8068 of the colour cone (0.0-1.0) \n\
8070 s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
8071 radius of the colour cone (0.0-1.0) \n\
8073 p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
8076 p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
8079 p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
8083 Draw y error bar \n\
8087 Draws a set of n vertical error bars, the i\'th error bar extending\n\
8088 from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
8089 error bar are of length equal to the minor tick length (settable using\n\
8092 Redacted form: General: plerry(x, ymin, ymax)\n\
8093 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
8096 This function is used in example 29. \n\
8102 plerry(n, x, ymin, ymax)\n\
8106 n (PLINT, input) : Number of error bars to draw. \n\
8108 x (PLFLT *, input) : Pointer to array with x coordinates of error\n\
8111 ymin (PLFLT *, input) : Pointer to array with y coordinates of\n\
8112 lower endpoint of error bars. \n\
8114 ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n\
8115 endpoint of error bar. \n\
8118 Set FCI (font characterization integer) \n\
8122 Sets font characteristics to be used at the start of the next string\n\
8123 using the FCI approach. See the PLplot documentation for more\n\
8126 Redacted form: General: plsfci(fci)\n\
8127 \t Perl/PDL: Not available? \n\
8130 This function is used in example 23. \n\
8140 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
8144 Select area fill pattern \n\
8148 Select one of eight predefined area fill patterns to use (also see\n\
8149 plpat). Setting the fill style to 0 gives a solid fill. \n\
8151 Redacted form: plpsty(n)\n\
8153 This function is used in examples 12,13,15,16,25. \n\
8163 n (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
8164 horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
8165 consists of lines at 45 degrees angle (upward), and so on. \n\
8172 This sets up the size of all subsequent symbols drawn by plpoin and\n\
8173 plsym. The actual height of a symbol is the product of the default\n\
8174 symbol size and a scaling factor as for the character height. \n\
8176 Redacted form: plssym(def, scale)\n\
8178 This function is used in example 29. \n\
8184 plssym(def, scale)\n\
8188 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
8189 should be set to zero if the default height is to remain\n\
8192 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
8193 actual symbol height. \n\
8200 Alternative to plstar for initializing the plotting package. The\n\
8201 device name keyword for the desired output device must be supplied as\n\
8202 an argument. The device keywords are the same as those printed out by\n\
8203 plstar. If the requested device is not available, or if the input\n\
8204 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
8205 is used. This routine also divides the output device into nx by ny\n\
8206 subpages, each of which may be used independently.\tThe subroutine\n\
8207 pladv is used to advance from one subpage to the next. \n\
8209 Redacted form: General: plstart(device, nx, ny)\n\
8210 \t Perl/PDL: plstart(nx, ny, device)\n\
8213 This function is not used in any examples. \n\
8219 plstart(device, nx, ny)\n\
8223 device (const char *, input) : Device name (keyword) of the\n\
8224 required output device. If NULL or if the first character is a\n\
8225 ``?\'\', the normal (prompted) start up is used. \n\
8227 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8228 horizontal direction. \n\
8230 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8231 vertical direction. \n\
8236 PLINT *arg2 = (PLINT *) 0 ;
8237 char **arg3 = (
char **) 0 ;
8239 octave_value_list _out;
8240 octave_value_list *_outp=&_out;
8251 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
8252 arg2 =
new PLINT[
Alen];
8253 temp1 = args(0).matrix_value();
8257 charMatrix temp_matrix;
8261 size_t max_length = 0, non_blank_length;
8265 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
8267 if ( !args(1).is_empty() )
8269 if (
_dim( args(1), 0 ) != Alen )
8271 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
8273 arg3 =
new char*[
Alen];
8274 ifcell = args(1).is_cell();
8277 temp_cell = args(1).cell_value();
8281 temp_matrix = args(1).char_matrix_value();
8283 max_length =
_dim( args(1), 1 ) + 1;
8286 for ( i = 0; i <
Alen; i++ )
8293 if ( temp_cell.elem( i ).is_string() )
8295 str = temp_cell.elem( i ).string_value();
8297 max_length = str.size() + 1;
8298 tmp_cstring = (
char *) str.c_str();
8308 tmp_cstring = (
char *)
"";
8313 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
8315 arg3[i] =
new char[max_length];
8316 strncpy( arg3[i], tmp_cstring, max_length - 1 );
8317 arg3[i][max_length - 1] =
'\0';
8332 non_blank_length = max_length - 2;
8333 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
8337 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
8341 arg3[i][non_blank_length + 1] =
'\0';
8350 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
8351 _outv = octave_value();
8360 for ( i = 0; i <
Alen; i++ )
8373 int *arg1 = (
int *) 0 ;
8374 int *arg2 = (
int *) 0 ;
8375 int *arg3 = (
int *) 0 ;
8376 char *arg4 = (
char *) 0 ;
8377 int *arg5 = (
int *) 0 ;
8378 int *arg6 = (
int *) 0 ;
8379 PLFLT *arg7 = (PLFLT *) 0 ;
8380 PLFLT *arg8 = (PLFLT *) 0 ;
8381 PLFLT *arg9 = (PLFLT *) 0 ;
8382 PLFLT *arg10 = (PLFLT *) 0 ;
8383 int *arg11 = (
int *) 0 ;
8390 octave_value_list retval4 ;
8405 octave_value_list _out;
8406 octave_value_list *_outp=&_out;
8415 # if OCTAVE_API_VERSION_NUMBER < 45
8416 retval4( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
8418 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
8420 arg4 = (
char *) retval4( 0 ).char_matrix_value().data();
8432 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
8504 PLFLT *arg1 = (PLFLT *) 0 ;
8505 PLFLT *arg2 = (PLFLT *) 0 ;
8516 octave_value_list _out;
8517 octave_value_list *_outp=&_out;
8530 arg3 = (
PLFLT)(val3);
8535 arg4 = (
PLFLT)(val4);
8557 PLINT *arg1 = (PLINT *) 0 ;
8558 char *arg2 = (
char *) 0 ;
8559 char *arg3 = (
char *) 0 ;
8571 PLINT *arg15 = (PLINT *) 0 ;
8572 PLINT *arg16 = (PLINT *) 0 ;
8573 char *arg17 = (
char *) 0 ;
8574 char *arg18 = (
char *) 0 ;
8575 char *arg19 = (
char *) 0 ;
8576 char *arg20 = (
char *) 0 ;
8577 char *arg21 = (
char *) 0 ;
8578 char *arg22 = (
char *) 0 ;
8579 char *arg23 = (
char *) 0 ;
8633 octave_value_list _out;
8634 octave_value_list *_outp=&_out;
8645 arg2 = (
char *)(buf2);
8650 arg3 = (
char *)(buf3);
8655 arg4 = (
PLFLT)(val4);
8660 arg5 = (
PLFLT)(val5);
8665 arg6 = (
PLFLT)(val6);
8670 arg7 = (
PLFLT)(val7);
8675 arg8 = (
PLFLT)(val8);
8680 arg9 = (
PLFLT)(val9);
8685 arg10 = (
PLFLT)(val10);
8700 arg13 = (
PLINT)(val13);
8705 arg14 = (
PLINT)(val14);
8707 if (
_n_dims( args(13) ) > 1 )
8712 temp15 = args(13).matrix_value();
8713 arg15 =
new PLINT[
Alen];
8717 if (
_n_dims( args(14) ) > 1 )
8721 if (
_dim( args(14), 0 ) != Alen )
8725 temp16 = args(14).matrix_value();
8726 arg16 =
new PLINT[
Alen];
8733 arg17 = (
char *)(buf17);
8738 arg18 = (
char *)(buf18);
8743 arg19 = (
char *)(buf19);
8748 arg20 = (
char *)(buf20);
8753 arg21 = (
char *)(buf21);
8758 arg22 = (
char *)(buf22);
8763 arg23 = (
char *)(buf23);
8764 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);
8765 _outv = octave_value();
8794 PLFLT *arg1 = (PLFLT *) 0 ;
8801 PLFLT *arg8 = (PLFLT *) 0 ;
8803 PLFLT *arg10 = (PLFLT *) 0 ;
8815 octave_value_list _out;
8816 octave_value_list *_outp=&_out;
8825 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
8827 temp1 = args(0).matrix_value();
8828 arg1 = &temp1( 0, 0 );
8829 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
8836 arg4 = (
PLINT)(val4);
8841 arg5 = (
PLINT)(val5);
8846 arg6 = (
PLINT)(val6);
8851 arg7 = (
PLINT)(val7);
8857 temp8 = args(5).matrix_value();
8858 arg8 = &temp8( 0, 0 );
8859 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
8866 if (
_dim( args(6), 0 ) != 6 )
8870 temp10 = args(6).matrix_value();
8871 arg10 = &temp10( 0, 0 );
8873 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
8874 _outv = octave_value();
8891 PLFLT *arg1 = (PLFLT *) 0 ;
8898 PLFLT *arg8 = (PLFLT *) 0 ;
8910 octave_value_list _out;
8911 octave_value_list *_outp=&_out;
8920 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
8922 temp1 = args(0).matrix_value();
8923 arg1 = &temp1( 0, 0 );
8924 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
8931 arg4 = (
PLINT)(val4);
8936 arg5 = (
PLINT)(val5);
8941 arg6 = (
PLINT)(val6);
8946 arg7 = (
PLINT)(val7);
8952 temp8 = args(5).matrix_value();
8953 arg8 = &temp8( 0, 0 );
8954 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
8956 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
8957 _outv = octave_value();
8971 PLFLT *arg1 = (PLFLT *) 0 ;
8978 PLFLT *arg8 = (PLFLT *) 0 ;
8980 PLFLT *arg10 = (PLFLT *) 0 ;
8981 PLFLT *arg11 = (PLFLT *) 0 ;
8994 octave_value_list _out;
8995 octave_value_list *_outp=&_out;
9004 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9006 temp1 = args(0).matrix_value();
9007 arg1 = &temp1( 0, 0 );
9008 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9015 arg4 = (
PLINT)(val4);
9020 arg5 = (
PLINT)(val5);
9025 arg6 = (
PLINT)(val6);
9030 arg7 = (
PLINT)(val7);
9036 temp8 = args(5).matrix_value();
9037 arg8 = &temp8( 0, 0 );
9038 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9045 if (
_dim( args(6), 0 ) != Xlen )
9049 temp10 = args(6).matrix_value();
9050 arg10 = &temp10( 0, 0 );
9061 temp11 = args(7).matrix_value();
9062 arg11 = &temp11( 0, 0 );
9064 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9065 _outv = octave_value();
9085 PLFLT *arg1 = (PLFLT *) 0 ;
9092 PLFLT *arg8 = (PLFLT *) 0 ;
9094 PLFLT *arg10 = (PLFLT *) 0 ;
9095 PLFLT *arg11 = (PLFLT *) 0 ;
9108 octave_value_list _out;
9109 octave_value_list *_outp=&_out;
9118 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9120 temp1 = args(0).matrix_value();
9121 arg1 = &temp1( 0, 0 );
9122 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9129 arg4 = (
PLINT)(val4);
9134 arg5 = (
PLINT)(val5);
9139 arg6 = (
PLINT)(val6);
9144 arg7 = (
PLINT)(val7);
9150 temp8 = args(5).matrix_value();
9151 arg8 = &temp8( 0, 0 );
9152 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9157 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9159 if (
_dim( args(6), 0 ) != Xlen )
9161 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9165 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9167 temp10 = args(6).matrix_value();
9168 arg10 = &temp10( 0, 0 );
9173 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9175 if (
_dim( args(7), 0 ) != Xlen )
9177 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9181 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9183 temp11 = args(7).matrix_value();
9184 arg11 = &temp11( 0, 0 );
9186 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9187 _outv = octave_value();
9207 PLFLT *arg1 = (PLFLT *) 0 ;
9214 PLFLT *arg8 = (PLFLT *) 0 ;
9216 PLFLT *arg10 = (PLFLT *) 0 ;
9217 PLFLT *arg11 = (PLFLT *) 0 ;
9230 octave_value_list _out;
9231 octave_value_list *_outp=&_out;
9240 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9242 temp1 = args(0).matrix_value();
9243 arg1 = &temp1( 0, 0 );
9244 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9251 arg4 = (
PLINT)(val4);
9256 arg5 = (
PLINT)(val5);
9261 arg6 = (
PLINT)(val6);
9266 arg7 = (
PLINT)(val7);
9272 temp8 = args(5).matrix_value();
9273 arg8 = &temp8( 0, 0 );
9274 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9279 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9281 if (
_dim( args(6), 0 ) != Xlen )
9283 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9287 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9289 temp10 = args(6).matrix_value();
9290 arg10 = &temp10( 0, 0 );
9295 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9297 if (
_dim( args(7), 0 ) != Xlen )
9299 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9303 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9305 temp11 = args(7).matrix_value();
9306 arg11 = &temp11( 0, 0 );
9308 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9309 _outv = octave_value();
9329 PLFLT *arg1 = (PLFLT *) 0 ;
9330 PLFLT *arg2 = (PLFLT *) 0 ;
9331 PLFLT *arg3 = (PLFLT *) 0 ;
9333 PLFLT *arg5 = (PLFLT *) 0 ;
9335 PLFLT *arg7 = (PLFLT *) 0 ;
9337 PLFLT *arg9 = (PLFLT *) 0 ;
9345 octave_value_list retval7 ;
9350 octave_value_list _out;
9351 octave_value_list *_outp=&_out;
9363 temp1 = args(0).matrix_value();
9364 arg1 = &temp1( 0, 0 );
9371 if (
_dim( args(1), 0 ) != Alen )
9375 temp2 = args(1).matrix_value();
9376 arg2 = &temp2( 0, 0 );
9383 if (
_dim( args(2), 0 ) != Alen )
9387 temp3 = args(2).matrix_value();
9388 arg3 = &temp3( 0, 0 );
9396 temp5 = args(3).matrix_value();
9397 arg5 = &temp5( 0, 0 );
9398 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
9405 temp7 = args(4).matrix_value();
9406 arg7 = &temp7( 0, 0 );
9408 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
9409 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
9415 arg10 = (
PLINT)(val10);
9420 arg11 = (
PLFLT)(val11);
9421 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
9422 _outv = octave_value();
9448 PLFLT *arg1 = (PLFLT *) 0 ;
9449 PLFLT *arg2 = (PLFLT *) 0 ;
9450 PLFLT *arg3 = (PLFLT *) 0 ;
9459 octave_value_list _out;
9460 octave_value_list *_outp=&_out;
9471 temp1 = args(0).matrix_value();
9472 arg1 = &temp1( 0, 0 );
9480 temp2 = args(1).matrix_value();
9481 arg2 = &temp2( 0, 0 );
9487 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9489 if (
_dim( args(2), 0 ) != Xlen )
9491 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9495 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9497 temp3 = args(2).matrix_value();
9498 arg3 = &temp3( 0, 0 );
9506 arg6 = (
PLINT)(val6);
9507 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
9508 _outv = octave_value();
9525 PLFLT *arg1 = (PLFLT *) 0 ;
9526 PLFLT *arg2 = (PLFLT *) 0 ;
9527 PLFLT *arg3 = (PLFLT *) 0 ;
9531 PLFLT *arg7 = (PLFLT *) 0 ;
9539 octave_value_list _out;
9540 octave_value_list *_outp=&_out;
9551 temp1 = args(0).matrix_value();
9552 arg1 = &temp1( 0, 0 );
9560 temp2 = args(1).matrix_value();
9561 arg2 = &temp2( 0, 0 );
9567 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9569 if (
_dim( args(2), 0 ) != Xlen )
9571 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9575 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9577 temp3 = args(2).matrix_value();
9578 arg3 = &temp3( 0, 0 );
9586 arg6 = (
PLINT)(val6);
9592 temp7 = args(4).matrix_value();
9593 arg7 = &temp7( 0, 0 );
9594 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9596 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9597 _outv = octave_value();
9617 PLFLT *arg1 = (PLFLT *) 0 ;
9618 PLFLT *arg2 = (PLFLT *) 0 ;
9619 PLFLT *arg3 = (PLFLT *) 0 ;
9631 octave_value_list _out;
9632 octave_value_list *_outp=&_out;
9643 temp1 = args(0).matrix_value();
9644 arg1 = &temp1( 0, 0 );
9652 temp2 = args(1).matrix_value();
9653 arg2 = &temp2( 0, 0 );
9659 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9661 if (
_dim( args(2), 0 ) != Xlen )
9663 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9667 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9669 temp3 = args(2).matrix_value();
9670 arg3 = &temp3( 0, 0 );
9678 arg6 = (
PLINT)(val6);
9684 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
9685 _outv = octave_value();
9702 PLFLT *arg1 = (PLFLT *) 0 ;
9703 PLFLT *arg2 = (PLFLT *) 0 ;
9704 PLFLT *arg3 = (PLFLT *) 0 ;
9708 PLFLT *arg7 = (PLFLT *) 0 ;
9716 octave_value_list _out;
9717 octave_value_list *_outp=&_out;
9728 temp1 = args(0).matrix_value();
9729 arg1 = &temp1( 0, 0 );
9737 temp2 = args(1).matrix_value();
9738 arg2 = &temp2( 0, 0 );
9744 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9746 if (
_dim( args(2), 0 ) != Xlen )
9748 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9752 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9754 temp3 = args(2).matrix_value();
9755 arg3 = &temp3( 0, 0 );
9763 arg6 = (
PLINT)(val6);
9769 temp7 = args(4).matrix_value();
9770 arg7 = &temp7( 0, 0 );
9771 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9773 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9774 _outv = octave_value();
9794 PLFLT *arg1 = (PLFLT *) 0 ;
9795 PLFLT *arg2 = (PLFLT *) 0 ;
9796 PLFLT *arg3 = (PLFLT *) 0 ;
9800 PLFLT *arg7 = (PLFLT *) 0 ;
9808 octave_value_list _out;
9809 octave_value_list *_outp=&_out;
9820 temp1 = args(0).matrix_value();
9821 arg1 = &temp1( 0, 0 );
9829 temp2 = args(1).matrix_value();
9830 arg2 = &temp2( 0, 0 );
9836 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9838 if (
_dim( args(2), 0 ) != Xlen )
9840 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9844 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9846 temp3 = args(2).matrix_value();
9847 arg3 = &temp3( 0, 0 );
9855 arg6 = (
PLINT)(val6);
9861 temp7 = args(4).matrix_value();
9862 arg7 = &temp7( 0, 0 );
9863 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9865 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9866 _outv = octave_value();
9886 PLFLT *arg1 = (PLFLT *) 0 ;
9889 PLFLT *arg4 = (PLFLT *) 0 ;
9904 PLFLT *arg19 = (PLFLT *) 0 ;
9936 octave_value_list _out;
9937 octave_value_list *_outp=&_out;
9946 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9948 temp1 = args(0).matrix_value();
9949 arg1 = &temp1( 0, 0 );
9950 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9959 temp4 = args(1).matrix_value();
9960 arg4 = &temp4( 0, 0 );
9966 arg5 = (
PLFLT)(val5);
9971 arg6 = (
PLFLT)(val6);
9976 arg7 = (
PLFLT)(val7);
9981 arg8 = (
PLFLT)(val8);
9986 arg9 = (
PLFLT)(val9);
9991 arg10 = (
PLFLT)(val10);
9996 arg11 = (
PLINT)(val11);
10001 arg12 = (
PLFLT)(val12);
10006 arg13 = (
PLINT)(val13);
10011 arg14 = (
PLINT)(val14);
10016 arg15 = (
PLINT)(val15);
10021 arg16 = (
PLINT)(val16);
10026 arg17 = (
PLINT)(val17);
10031 arg18 = (
PLBOOL)(val18);
10033 if (
_n_dims( args(16) ) > 1 )
10037 if (
_dim( args(16), 0 ) != 6 )
10041 temp19 = args(16).matrix_value();
10042 arg19 = &temp19( 0, 0 );
10044 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);
10045 _outv = octave_value();
10062 PLFLT *arg1 = (PLFLT *) 0 ;
10065 char *arg4 = (
char *) 0 ;
10080 PLFLT *arg19 = (PLFLT *) 0 ;
10081 PLFLT *arg20 = (PLFLT *) 0 ;
10116 octave_value_list _out;
10117 octave_value_list *_outp=&_out;
10118 octave_value _outv;
10124 if (
_n_dims( args(0) ) > 2 )
10126 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10128 temp1 = args(0).matrix_value();
10129 arg1 = &temp1( 0, 0 );
10130 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10137 arg4 = (
char *)(buf4);
10142 arg5 = (
PLFLT)(val5);
10147 arg6 = (
PLFLT)(val6);
10152 arg7 = (
PLFLT)(val7);
10157 arg8 = (
PLFLT)(val8);
10162 arg9 = (
PLFLT)(val9);
10167 arg10 = (
PLFLT)(val10);
10172 arg11 = (
PLINT)(val11);
10177 arg12 = (
PLFLT)(val12);
10182 arg13 = (
PLINT)(val13);
10187 arg14 = (
PLINT)(val14);
10192 arg15 = (
PLINT)(val15);
10197 arg16 = (
PLINT)(val16);
10202 arg17 = (
PLINT)(val17);
10207 arg18 = (
PLBOOL)(val18);
10209 if (
_n_dims( args(16) ) > 1 )
10213 if (
_dim( args(16), 0 ) != Xlen )
10217 temp19 = args(16).matrix_value();
10218 arg19 = &temp19( 0, 0 );
10221 if (
_n_dims( args(17) ) > 1 )
10225 if (
_dim( args(17), 0 ) !=
Ylen )
10229 temp20 = args(17).matrix_value();
10230 arg20 = &temp20( 0, 0 );
10232 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);
10233 _outv = octave_value();
10251 PLFLT *arg1 = (PLFLT *) 0 ;
10254 char *arg4 = (
char *) 0 ;
10269 PLFLT *arg19 = (PLFLT *) 0 ;
10270 PLFLT *arg20 = (PLFLT *) 0 ;
10305 octave_value_list _out;
10306 octave_value_list *_outp=&_out;
10307 octave_value _outv;
10313 if (
_n_dims( args(0) ) > 2 )
10315 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10317 temp1 = args(0).matrix_value();
10318 arg1 = &temp1( 0, 0 );
10319 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10326 arg4 = (
char *)(buf4);
10331 arg5 = (
PLFLT)(val5);
10336 arg6 = (
PLFLT)(val6);
10341 arg7 = (
PLFLT)(val7);
10346 arg8 = (
PLFLT)(val8);
10351 arg9 = (
PLFLT)(val9);
10356 arg10 = (
PLFLT)(val10);
10361 arg11 = (
PLINT)(val11);
10366 arg12 = (
PLFLT)(val12);
10371 arg13 = (
PLINT)(val13);
10376 arg14 = (
PLINT)(val14);
10381 arg15 = (
PLINT)(val15);
10386 arg16 = (
PLINT)(val16);
10391 arg17 = (
PLINT)(val17);
10396 arg18 = (
PLBOOL)(val18);
10398 if (
_n_dims( args(16) ) > 2 )
10400 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10402 temp19 = args(16).matrix_value();
10403 arg19 = &temp19( 0, 0 );
10404 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
10408 if (
_n_dims( args(17) ) > 2 )
10410 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10412 temp20 = args(17).matrix_value();
10413 arg20 = &temp20( 0, 0 );
10414 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
10417 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);
10418 _outv = octave_value();
10436 PLFLT *arg1 = (PLFLT *) 0 ;
10443 PLFLT *arg8 = (PLFLT *) 0 ;
10467 octave_value_list _out;
10468 octave_value_list *_outp=&_out;
10469 octave_value _outv;
10475 if (
_n_dims( args(0) ) > 2 )
10477 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10479 temp1 = args(0).matrix_value();
10480 arg1 = &temp1( 0, 0 );
10481 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10488 arg4 = (
PLFLT)(val4);
10493 arg5 = (
PLFLT)(val5);
10498 arg6 = (
PLFLT)(val6);
10503 arg7 = (
PLFLT)(val7);
10505 if (
_n_dims( args(5) ) > 1 )
10509 temp8 = args(5).matrix_value();
10510 arg8 = &temp8( 0, 0 );
10511 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10517 arg10 = (
PLINT)(val10);
10522 arg11 = (
PLINT)(val11);
10527 arg12 = (
PLINT)(val12);
10532 arg13 = (
PLBOOL)(val13);
10533 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
10534 _outv = octave_value();
10548 PLFLT *arg1 = (PLFLT *) 0 ;
10555 PLFLT *arg8 = (PLFLT *) 0 ;
10561 PLFLT *arg14 = (PLFLT *) 0 ;
10581 octave_value_list _out;
10582 octave_value_list *_outp=&_out;
10583 octave_value _outv;
10589 if (
_n_dims( args(0) ) > 2 )
10591 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10593 temp1 = args(0).matrix_value();
10594 arg1 = &temp1( 0, 0 );
10595 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10602 arg4 = (
PLFLT)(val4);
10607 arg5 = (
PLFLT)(val5);
10612 arg6 = (
PLFLT)(val6);
10617 arg7 = (
PLFLT)(val7);
10619 if (
_n_dims( args(5) ) > 1 )
10623 temp8 = args(5).matrix_value();
10624 arg8 = &temp8( 0, 0 );
10625 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10631 arg10 = (
PLINT)(val10);
10636 arg11 = (
PLINT)(val11);
10641 arg12 = (
PLINT)(val12);
10646 arg13 = (
PLBOOL)(val13);
10648 if (
_n_dims( args(10) ) > 1 )
10652 if (
_dim( args(10), 0 ) != 6 )
10656 temp14 = args(10).matrix_value();
10657 arg14 = &temp14( 0, 0 );
10659 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
10660 _outv = octave_value();
10677 PLFLT *arg1 = (PLFLT *) 0 ;
10684 PLFLT *arg8 = (PLFLT *) 0 ;
10690 PLFLT *arg14 = (PLFLT *) 0 ;
10691 PLFLT *arg15 = (PLFLT *) 0 ;
10712 octave_value_list _out;
10713 octave_value_list *_outp=&_out;
10714 octave_value _outv;
10720 if (
_n_dims( args(0) ) > 2 )
10722 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10724 temp1 = args(0).matrix_value();
10725 arg1 = &temp1( 0, 0 );
10726 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10733 arg4 = (
PLFLT)(val4);
10738 arg5 = (
PLFLT)(val5);
10743 arg6 = (
PLFLT)(val6);
10748 arg7 = (
PLFLT)(val7);
10750 if (
_n_dims( args(5) ) > 1 )
10754 temp8 = args(5).matrix_value();
10755 arg8 = &temp8( 0, 0 );
10756 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10762 arg10 = (
PLINT)(val10);
10767 arg11 = (
PLINT)(val11);
10772 arg12 = (
PLINT)(val12);
10777 arg13 = (
PLBOOL)(val13);
10779 if (
_n_dims( args(10) ) > 1 )
10783 if (
_dim( args(10), 0 ) != Xlen )
10787 temp14 = args(10).matrix_value();
10788 arg14 = &temp14( 0, 0 );
10791 if (
_n_dims( args(11) ) > 1 )
10795 if (
_dim( args(11), 0 ) !=
Ylen )
10799 temp15 = args(11).matrix_value();
10800 arg15 = &temp15( 0, 0 );
10802 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);
10803 _outv = octave_value();
10823 PLFLT *arg1 = (PLFLT *) 0 ;
10830 PLFLT *arg8 = (PLFLT *) 0 ;
10836 PLFLT *arg14 = (PLFLT *) 0 ;
10837 PLFLT *arg15 = (PLFLT *) 0 ;
10858 octave_value_list _out;
10859 octave_value_list *_outp=&_out;
10860 octave_value _outv;
10866 if (
_n_dims( args(0) ) > 2 )
10868 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10870 temp1 = args(0).matrix_value();
10871 arg1 = &temp1( 0, 0 );
10872 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10879 arg4 = (
PLFLT)(val4);
10884 arg5 = (
PLFLT)(val5);
10889 arg6 = (
PLFLT)(val6);
10894 arg7 = (
PLFLT)(val7);
10896 if (
_n_dims( args(5) ) > 1 )
10900 temp8 = args(5).matrix_value();
10901 arg8 = &temp8( 0, 0 );
10902 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10908 arg10 = (
PLINT)(val10);
10913 arg11 = (
PLINT)(val11);
10918 arg12 = (
PLINT)(val12);
10923 arg13 = (
PLBOOL)(val13);
10925 if (
_n_dims( args(10) ) > 2 )
10927 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10929 temp14 = args(10).matrix_value();
10930 arg14 = &temp14( 0, 0 );
10931 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
10935 if (
_n_dims( args(11) ) > 2 )
10937 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10939 temp15 = args(11).matrix_value();
10940 arg15 = &temp15( 0, 0 );
10941 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
10944 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);
10945 _outv = octave_value();
10965 PLFLT *arg1 = (PLFLT *) 0 ;
10966 PLFLT *arg2 = (PLFLT *) 0 ;
10970 PLFLT *arg6 = (PLFLT *) 0 ;
10976 octave_value_list _out;
10977 octave_value_list *_outp=&_out;
10978 octave_value _outv;
10984 if (
_n_dims( args(0) ) > 2 )
10986 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10988 temp1 = args(0).matrix_value();
10989 arg1 = &temp1( 0, 0 );
10994 if (
_n_dims( args(1) ) > 2 )
10996 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10998 if (
_dim( args(1), 0 ) != Xlen )
11000 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11004 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11006 temp2 = args(1).matrix_value();
11007 arg2 = &temp2( 0, 0 );
11015 arg5 = (
PLFLT)(val5);
11017 if (
_n_dims( args(3) ) > 1 )
11021 if (
_dim( args(3), 0 ) != 6 )
11025 temp6 = args(3).matrix_value();
11026 arg6 = &temp6( 0, 0 );
11028 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
11029 _outv = octave_value();
11046 PLFLT *arg1 = (PLFLT *) 0 ;
11047 PLFLT *arg2 = (PLFLT *) 0 ;
11051 PLFLT *arg6 = (PLFLT *) 0 ;
11052 PLFLT *arg7 = (PLFLT *) 0 ;
11059 octave_value_list _out;
11060 octave_value_list *_outp=&_out;
11061 octave_value _outv;
11067 if (
_n_dims( args(0) ) > 2 )
11069 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11071 temp1 = args(0).matrix_value();
11072 arg1 = &temp1( 0, 0 );
11077 if (
_n_dims( args(1) ) > 2 )
11079 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11081 if (
_dim( args(1), 0 ) != Xlen )
11083 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11087 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11089 temp2 = args(1).matrix_value();
11090 arg2 = &temp2( 0, 0 );
11098 arg5 = (
PLFLT)(val5);
11100 if (
_n_dims( args(3) ) > 1 )
11104 if (
_dim( args(3), 0 ) != Xlen )
11108 temp6 = args(3).matrix_value();
11109 arg6 = &temp6( 0, 0 );
11112 if (
_n_dims( args(4) ) > 1 )
11120 temp7 = args(4).matrix_value();
11121 arg7 = &temp7( 0, 0 );
11123 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
11124 _outv = octave_value();
11144 PLFLT *arg1 = (PLFLT *) 0 ;
11145 PLFLT *arg2 = (PLFLT *) 0 ;
11149 PLFLT *arg6 = (PLFLT *) 0 ;
11150 PLFLT *arg7 = (PLFLT *) 0 ;
11157 octave_value_list _out;
11158 octave_value_list *_outp=&_out;
11159 octave_value _outv;
11165 if (
_n_dims( args(0) ) > 2 )
11167 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11169 temp1 = args(0).matrix_value();
11170 arg1 = &temp1( 0, 0 );
11175 if (
_n_dims( args(1) ) > 2 )
11177 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11179 if (
_dim( args(1), 0 ) != Xlen )
11181 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11185 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11187 temp2 = args(1).matrix_value();
11188 arg2 = &temp2( 0, 0 );
11196 arg5 = (
PLFLT)(val5);
11198 if (
_n_dims( args(3) ) > 2 )
11200 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11202 temp6 = args(3).matrix_value();
11203 arg6 = &temp6( 0, 0 );
11208 if (
_n_dims( args(4) ) > 2 )
11210 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11212 temp7 = args(4).matrix_value();
11213 arg7 = &temp7( 0, 0 );
11217 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
11218 _outv = octave_value();
11238 PLFLT *arg1 = (PLFLT *) 0 ;
11272 octave_value_list _out;
11273 octave_value_list *_outp=&_out;
11274 octave_value _outv;
11280 if (
_n_dims( args(0) ) > 2 )
11282 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11284 temp1 = args(0).matrix_value();
11285 arg1 = &temp1( 0, 0 );
11286 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11293 arg4 = (
PLFLT)(val4);
11298 arg5 = (
PLFLT)(val5);
11303 arg6 = (
PLFLT)(val6);
11308 arg7 = (
PLFLT)(val7);
11313 arg8 = (
PLFLT)(val8);
11318 arg9 = (
PLFLT)(val9);
11323 arg10 = (
PLFLT)(val10);
11328 arg11 = (
PLFLT)(val11);
11333 arg12 = (
PLFLT)(val12);
11338 arg13 = (
PLFLT)(val13);
11339 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
11340 _outv = octave_value();
11351 PLFLT *arg1 = (PLFLT *) 0 ;
11379 octave_value_list _out;
11380 octave_value_list *_outp=&_out;
11381 octave_value _outv;
11387 if (
_n_dims( args(0) ) > 2 )
11389 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11391 temp1 = args(0).matrix_value();
11392 arg1 = &temp1( 0, 0 );
11393 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11400 arg4 = (
PLFLT)(val4);
11405 arg5 = (
PLFLT)(val5);
11410 arg6 = (
PLFLT)(val6);
11415 arg7 = (
PLFLT)(val7);
11420 arg8 = (
PLFLT)(val8);
11425 arg9 = (
PLFLT)(val9);
11430 arg10 = (
PLFLT)(val10);
11435 arg11 = (
PLFLT)(val11);
11436 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11437 _outv = octave_value();
11448 PLFLT *arg1 = (PLFLT *) 0 ;
11459 PLFLT *arg12 = (PLFLT *) 0 ;
11478 octave_value_list _out;
11479 octave_value_list *_outp=&_out;
11480 octave_value _outv;
11486 if (
_n_dims( args(0) ) > 2 )
11488 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11490 temp1 = args(0).matrix_value();
11491 arg1 = &temp1( 0, 0 );
11492 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11499 arg4 = (
PLFLT)(val4);
11504 arg5 = (
PLFLT)(val5);
11509 arg6 = (
PLFLT)(val6);
11514 arg7 = (
PLFLT)(val7);
11519 arg8 = (
PLFLT)(val8);
11524 arg9 = (
PLFLT)(val9);
11529 arg10 = (
PLFLT)(val10);
11534 arg11 = (
PLFLT)(val11);
11536 if (
_n_dims( args(9) ) > 1 )
11540 if (
_dim( args(9), 0 ) != 6 )
11544 temp12 = args(9).matrix_value();
11545 arg12 = &temp12( 0, 0 );
11547 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
11548 _outv = octave_value();
11562 PLFLT *arg1 = (PLFLT *) 0 ;
11573 PLFLT *arg12 = (PLFLT *) 0 ;
11574 PLFLT *arg13 = (PLFLT *) 0 ;
11594 octave_value_list _out;
11595 octave_value_list *_outp=&_out;
11596 octave_value _outv;
11602 if (
_n_dims( args(0) ) > 2 )
11604 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11606 temp1 = args(0).matrix_value();
11607 arg1 = &temp1( 0, 0 );
11608 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11615 arg4 = (
PLFLT)(val4);
11620 arg5 = (
PLFLT)(val5);
11625 arg6 = (
PLFLT)(val6);
11630 arg7 = (
PLFLT)(val7);
11635 arg8 = (
PLFLT)(val8);
11640 arg9 = (
PLFLT)(val9);
11645 arg10 = (
PLFLT)(val10);
11650 arg11 = (
PLFLT)(val11);
11652 if (
_n_dims( args(9) ) > 1 )
11656 if (
_dim( args(9), 0 ) != Xlen )
11660 temp12 = args(9).matrix_value();
11661 arg12 = &temp12( 0, 0 );
11664 if (
_n_dims( args(10) ) > 1 )
11668 if (
_dim( args(10), 0 ) !=
Ylen )
11672 temp13 = args(10).matrix_value();
11673 arg13 = &temp13( 0, 0 );
11675 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
11676 _outv = octave_value();
11693 PLFLT *arg1 = (PLFLT *) 0 ;
11704 PLFLT *arg12 = (PLFLT *) 0 ;
11705 PLFLT *arg13 = (PLFLT *) 0 ;
11725 octave_value_list _out;
11726 octave_value_list *_outp=&_out;
11727 octave_value _outv;
11733 if (
_n_dims( args(0) ) > 2 )
11735 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11737 temp1 = args(0).matrix_value();
11738 arg1 = &temp1( 0, 0 );
11739 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11746 arg4 = (
PLFLT)(val4);
11751 arg5 = (
PLFLT)(val5);
11756 arg6 = (
PLFLT)(val6);
11761 arg7 = (
PLFLT)(val7);
11766 arg8 = (
PLFLT)(val8);
11771 arg9 = (
PLFLT)(val9);
11776 arg10 = (
PLFLT)(val10);
11781 arg11 = (
PLFLT)(val11);
11783 if (
_n_dims( args(9) ) > 2 )
11785 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11787 temp12 = args(9).matrix_value();
11788 arg12 = &temp12( 0, 0 );
11793 if (
_n_dims( args(10) ) > 2 )
11795 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11797 temp13 = args(10).matrix_value();
11798 arg13 = &temp13( 0, 0 );
11799 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
11802 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
11803 _outv = octave_value();
11820 PLFLT *arg1 = (PLFLT *) 0 ;
11821 PLFLT *arg2 = (PLFLT *) 0 ;
11836 PLINT *arg17 = (PLINT *) 0 ;
11837 char **arg18 = (
char **) 0 ;
11839 char **arg20 = (
char **) 0 ;
11840 PLFLT *arg21 = (PLFLT *) 0 ;
11841 PLINT *arg22 = (PLINT *) 0 ;
11842 PLINT *arg23 = (PLINT *) 0 ;
11843 PLFLT *arg24 = (PLFLT *) 0 ;
11879 octave_value_list _out;
11880 octave_value_list *_outp=&_out;
11881 octave_value _outv;
11892 arg3 = (
PLINT)(val3);
11897 arg4 = (
PLINT)(val4);
11902 arg5 = (
PLFLT)(val5);
11907 arg6 = (
PLFLT)(val6);
11912 arg7 = (
PLFLT)(val7);
11917 arg8 = (
PLFLT)(val8);
11922 arg9 = (
PLINT)(val9);
11927 arg10 = (
PLINT)(val10);
11932 arg11 = (
PLINT)(val11);
11937 arg12 = (
PLFLT)(val12);
11942 arg13 = (
PLFLT)(val13);
11947 arg14 = (
PLINT)(val14);
11952 arg15 = (
PLFLT)(val15);
11954 if (
_n_dims( args(13) ) > 1 )
11958 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
11959 arg17 =
new PLINT[
Alen];
11960 temp16 = args(13).matrix_value();
11964 charMatrix temp_matrix;
11968 size_t max_length = 0, non_blank_length;
11970 if (
_n_dims( args(14) ) > 2 )
11972 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
11974 if ( !args(14).is_empty() )
11976 if (
_dim( args(14), 0 ) != Alen )
11978 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
11980 arg18 =
new char*[
Alen];
11981 ifcell = args(14).is_cell();
11984 temp_cell = args(14).cell_value();
11988 temp_matrix = args(14).char_matrix_value();
11990 max_length =
_dim( args(14), 1 ) + 1;
11993 for ( i = 0; i <
Alen; i++ )
12000 if ( temp_cell.elem( i ).is_string() )
12002 str = temp_cell.elem( i ).string_value();
12004 max_length = str.size() + 1;
12005 tmp_cstring = (
char *) str.c_str();
12015 tmp_cstring = (
char *)
"";
12020 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
12022 arg18[i] =
new char[max_length];
12023 strncpy( arg18[i], tmp_cstring, max_length - 1 );
12024 arg18[i][max_length - 1] =
'\0';
12039 non_blank_length = max_length - 2;
12040 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
12042 non_blank_length--;
12044 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
12046 non_blank_length--;
12048 arg18[i][non_blank_length + 1] =
'\0';
12058 charMatrix temp_matrix;
12062 size_t max_length = 0, non_blank_length;
12064 if (
_n_dims( args(15) ) > 2 )
12066 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
12068 if ( !args(15).is_empty() )
12070 Alen =
_dim( args(15), 0 );
12072 arg20 =
new char*[
Alen];
12073 ifcell = args(15).is_cell();
12076 temp_cell = args(15).cell_value();
12080 temp_matrix = args(15).char_matrix_value();
12082 max_length =
_dim( args(15), 1 ) + 1;
12085 for ( i = 0; i <
Alen; i++ )
12092 if ( temp_cell.elem( i ).is_string() )
12094 str = temp_cell.elem( i ).string_value();
12096 max_length = str.size() + 1;
12097 tmp_cstring = (
char *) str.c_str();
12107 tmp_cstring = (
char *)
"";
12112 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
12114 arg20[i] =
new char[max_length];
12115 strncpy( arg20[i], tmp_cstring, max_length - 1 );
12116 arg20[i][max_length - 1] =
'\0';
12131 non_blank_length = max_length - 2;
12132 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
12134 non_blank_length--;
12136 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
12138 non_blank_length--;
12140 arg20[i][non_blank_length + 1] =
'\0';
12151 if (
_n_dims( args(16) ) > 1 )
12155 if (
_dim( args(16), 0 ) != Alen )
12159 temp21 = args(16).matrix_value();
12160 arg21 = &temp21( 0, 0 );
12163 if (
_n_dims( args(17) ) > 1 )
12167 if (
_dim( args(17), 0 ) != Alen )
12171 temp22 = args(17).matrix_value();
12172 arg22 =
new PLINT[
Alen];
12177 if (
_n_dims( args(18) ) > 1 )
12181 if (
_dim( args(18), 0 ) != Alen )
12186 temp23 = args(18).matrix_value();
12187 arg23 =
new PLINT[
Alen];
12190 for ( i = 0; i <
Xlen; i++ )
12191 if ( arg23[i] >
Ylen )
12195 if (
_n_dims( args(19) ) > 2 )
12197 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12199 if (
_dim( args(19), 0 ) != Xlen )
12201 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12203 if (
_dim( args(19), 1 ) !=
Ylen )
12205 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12207 temp24 = args(19).matrix_value();
12208 arg24 = &temp24( 0, 0 );
12210 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);
12211 _outv = octave_value();
12230 if ( arg18 != NULL )
12232 for ( i = 0; i <
Alen; i++ )
12241 if ( arg20 != NULL )
12243 for ( i = 0; i <
Alen; i++ )
12274 octave_value_list _out;
12275 octave_value_list *_outp=&_out;
12276 octave_value _outv;
12290 arg2 = (int)(val2);
12291 if (arg1) (arg1)->type = arg2;
12292 _outv = octave_value();
12303 octave_value_list _out;
12304 octave_value_list *_outp=&_out;
12305 octave_value _outv;
12316 result = (int) ((arg1)->type);
12326 unsigned int arg2 ;
12329 unsigned int val2 ;
12331 octave_value_list _out;
12332 octave_value_list *_outp=&_out;
12333 octave_value _outv;
12347 arg2 = (
unsigned int)(val2);
12348 if (arg1) (arg1)->state = arg2;
12349 _outv = octave_value();
12360 octave_value_list _out;
12361 octave_value_list *_outp=&_out;
12362 octave_value _outv;
12363 unsigned int result;
12373 result = (
unsigned int) ((arg1)->state);
12383 unsigned int arg2 ;
12386 unsigned int val2 ;
12388 octave_value_list _out;
12389 octave_value_list *_outp=&_out;
12390 octave_value _outv;
12404 arg2 = (
unsigned int)(val2);
12405 if (arg1) (arg1)->keysym = arg2;
12406 _outv = octave_value();
12417 octave_value_list _out;
12418 octave_value_list *_outp=&_out;
12419 octave_value _outv;
12420 unsigned int result;
12430 result = (
unsigned int) ((arg1)->keysym);
12440 unsigned int arg2 ;
12443 unsigned int val2 ;
12445 octave_value_list _out;
12446 octave_value_list *_outp=&_out;
12447 octave_value _outv;
12461 arg2 = (
unsigned int)(val2);
12462 if (arg1) (arg1)->button = arg2;
12463 _outv = octave_value();
12474 octave_value_list _out;
12475 octave_value_list *_outp=&_out;
12476 octave_value _outv;
12477 unsigned int result;
12487 result = (
unsigned int) ((arg1)->button);
12502 octave_value_list _out;
12503 octave_value_list *_outp=&_out;
12504 octave_value _outv;
12518 arg2 = (
PLINT)(val2);
12519 if (arg1) (arg1)->subwindow = arg2;
12520 _outv = octave_value();
12531 octave_value_list _out;
12532 octave_value_list *_outp=&_out;
12533 octave_value _outv;
12544 result = (
PLINT) ((arg1)->subwindow);
12559 octave_value_list _out;
12560 octave_value_list *_outp=&_out;
12561 octave_value _outv;
12575 arg2 = (
char *)(temp2);
12576 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
12577 else memset(arg1->
string,0,16*
sizeof(
char));
12578 _outv = octave_value();
12589 octave_value_list _out;
12590 octave_value_list *_outp=&_out;
12591 octave_value _outv;
12602 result = (
char *)(
char *) ((arg1)->
string);
12606 while (size && (result[size - 1] ==
'\0')) --size;
12623 octave_value_list _out;
12624 octave_value_list *_outp=&_out;
12625 octave_value _outv;
12639 arg2 = (int)(val2);
12640 if (arg1) (arg1)->pX = arg2;
12641 _outv = octave_value();
12652 octave_value_list _out;
12653 octave_value_list *_outp=&_out;
12654 octave_value _outv;
12665 result = (int) ((arg1)->pX);
12680 octave_value_list _out;
12681 octave_value_list *_outp=&_out;
12682 octave_value _outv;
12696 arg2 = (int)(val2);
12697 if (arg1) (arg1)->pY = arg2;
12698 _outv = octave_value();
12709 octave_value_list _out;
12710 octave_value_list *_outp=&_out;
12711 octave_value _outv;
12722 result = (int) ((arg1)->pY);
12737 octave_value_list _out;
12738 octave_value_list *_outp=&_out;
12739 octave_value _outv;
12753 arg2 = (
PLFLT)(val2);
12754 if (arg1) (arg1)->dX = arg2;
12755 _outv = octave_value();
12766 octave_value_list _out;
12767 octave_value_list *_outp=&_out;
12768 octave_value _outv;
12779 result = (
PLFLT) ((arg1)->dX);
12794 octave_value_list _out;
12795 octave_value_list *_outp=&_out;
12796 octave_value _outv;
12810 arg2 = (
PLFLT)(val2);
12811 if (arg1) (arg1)->dY = arg2;
12812 _outv = octave_value();
12823 octave_value_list _out;
12824 octave_value_list *_outp=&_out;
12825 octave_value _outv;
12836 result = (
PLFLT) ((arg1)->dY);
12851 octave_value_list _out;
12852 octave_value_list *_outp=&_out;
12853 octave_value _outv;
12867 arg2 = (
PLFLT)(val2);
12868 if (arg1) (arg1)->wX = arg2;
12869 _outv = octave_value();
12880 octave_value_list _out;
12881 octave_value_list *_outp=&_out;
12882 octave_value _outv;
12893 result = (
PLFLT) ((arg1)->wX);
12908 octave_value_list _out;
12909 octave_value_list *_outp=&_out;
12910 octave_value _outv;
12924 arg2 = (
PLFLT)(val2);
12925 if (arg1) (arg1)->wY = arg2;
12926 _outv = octave_value();
12937 octave_value_list _out;
12938 octave_value_list *_outp=&_out;
12939 octave_value _outv;
12950 result = (
PLFLT) ((arg1)->wY);
12959 octave_value_list _out;
12960 octave_value_list *_outp=&_out;
12961 octave_value _outv;
12979 octave_value_list _out;
12980 octave_value_list *_outp=&_out;
12981 octave_value _outv;
12992 _outv = octave_value();
13025 octave_value_list _out;
13026 octave_value_list *_outp=&_out;
13027 octave_value _outv;
13036 arg1 = (
PLINT)(val1);
13041 arg2 = (
PLINT)(val2);
13043 _outv = octave_value();
13063 octave_value_list _out;
13064 octave_value_list *_outp=&_out;
13065 octave_value _outv;
13074 arg1 = (
PLFLT)(val1);
13079 arg2 = (
PLFLT)(val2);
13084 arg3 = (
PLFLT)(val3);
13089 arg4 = (
PLINT)(val4);
13091 _outv = octave_value();
13102 octave_value_list _out;
13103 octave_value_list *_outp=&_out;
13104 octave_value _outv;
13113 arg1 = (
PLINT)(val1);
13115 _outv = octave_value();
13147 octave_value_list _out;
13148 octave_value_list *_outp=&_out;
13149 octave_value _outv;
13158 arg1 = (
PLFLT)(val1);
13163 arg2 = (
PLFLT)(val2);
13168 arg3 = (
PLFLT)(val3);
13173 arg4 = (
PLFLT)(val4);
13178 arg5 = (
PLFLT)(val5);
13183 arg6 = (
PLFLT)(val6);
13188 arg7 = (
PLFLT)(val7);
13194 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
13195 _outv = octave_value();
13205 char *arg3 = (
char *) 0 ;
13208 char *arg6 = (
char *) 0 ;
13229 octave_value_list _out;
13230 octave_value_list *_outp=&_out;
13231 octave_value _outv;
13240 arg1 = (
PLFLT)(val1);
13245 arg2 = (
PLFLT)(val2);
13250 arg3 = (
char *)(buf3);
13255 arg4 = (
PLFLT)(val4);
13260 arg5 = (
PLINT)(val5);
13265 arg6 = (
char *)(buf6);
13270 arg7 = (
PLFLT)(val7);
13275 arg8 = (
PLINT)(val8);
13276 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
13277 _outv = octave_value();
13288 PLFLT *arg2 = (PLFLT *) 0 ;
13289 PLFLT *arg3 = (PLFLT *) 0 ;
13295 octave_value_list _out;
13296 octave_value_list *_outp=&_out;
13297 octave_value _outv;
13303 if (
_n_dims( args(0) ) > 1 )
13307 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
13308 temp1 = args(0).matrix_value();
13309 arg2 = &temp1( 0, 0 );
13312 if (
_n_dims( args(1) ) > 1 )
13316 if (
_dim( args(1), 0 ) != Alen )
13320 temp3 = args(1).matrix_value();
13321 arg3 = &temp3( 0, 0 );
13327 arg4 = (
PLINT)(val4);
13328 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13329 _outv = octave_value();
13343 PLINT *arg1 = (PLINT *) 0 ;
13344 PLINT *arg2 = (PLINT *) 0 ;
13345 PLINT *arg3 = (PLINT *) 0 ;
13346 PLINT *arg4 = (PLINT *) 0 ;
13347 PLINT *arg5 = (PLINT *) 0 ;
13348 PLFLT *arg6 = (PLFLT *) 0 ;
13364 octave_value_list _out;
13365 octave_value_list *_outp=&_out;
13366 octave_value _outv;
13381 arg7 = (
PLFLT)(val7);
13382 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13383 _outv = octave_value();
13427 octave_value_list _out;
13428 octave_value_list *_outp=&_out;
13429 octave_value _outv;
13435 _outv = octave_value();
13443 char *arg1 = (
char *) 0 ;
13446 char *arg4 = (
char *) 0 ;
13463 octave_value_list _out;
13464 octave_value_list *_outp=&_out;
13465 octave_value _outv;
13474 arg1 = (
char *)(buf1);
13479 arg2 = (
PLFLT)(val2);
13484 arg3 = (
PLINT)(val3);
13489 arg4 = (
char *)(buf4);
13494 arg5 = (
PLFLT)(val5);
13499 arg6 = (
PLINT)(val6);
13500 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
13501 _outv = octave_value();
13511 char *arg1 = (
char *) 0 ;
13512 char *arg2 = (
char *) 0 ;
13515 char *arg5 = (
char *) 0 ;
13516 char *arg6 = (
char *) 0 ;
13519 char *arg9 = (
char *) 0 ;
13520 char *arg10 = (
char *) 0 ;
13553 octave_value_list _out;
13554 octave_value_list *_outp=&_out;
13555 octave_value _outv;
13564 arg1 = (
char *)(buf1);
13569 arg2 = (
char *)(buf2);
13574 arg3 = (
PLFLT)(val3);
13579 arg4 = (
PLINT)(val4);
13584 arg5 = (
char *)(buf5);
13589 arg6 = (
char *)(buf6);
13594 arg7 = (
PLFLT)(val7);
13599 arg8 = (
PLINT)(val8);
13604 arg9 = (
char *)(buf9);
13609 arg10 = (
char *)(buf10);
13614 arg11 = (
PLFLT)(val11);
13619 arg12 = (
PLINT)(val12);
13620 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);
13621 _outv = octave_value();
13637 PLFLT *arg3 = (PLFLT *) 0 ;
13638 PLFLT *arg4 = (PLFLT *) 0 ;
13639 PLINT *arg5 = (PLINT *) 0 ;
13650 octave_value_list _out;
13651 octave_value_list *_outp=&_out;
13652 octave_value _outv;
13664 arg1 = (
PLFLT)(val1);
13669 arg2 = (
PLFLT)(val2);
13671 _outv = octave_value();
13697 octave_value_list _out;
13698 octave_value_list *_outp=&_out;
13699 octave_value _outv;
13705 _outv = octave_value();
13716 octave_value_list _out;
13717 octave_value_list *_outp=&_out;
13718 octave_value _outv;
13727 arg1 = (
PLINT)(val1);
13729 _outv = octave_value();
13740 octave_value_list _out;
13741 octave_value_list *_outp=&_out;
13742 octave_value _outv;
13751 arg1 = (
PLFLT)(val1);
13753 _outv = octave_value();
13794 octave_value_list _out;
13795 octave_value_list *_outp=&_out;
13796 octave_value _outv;
13805 arg1 = (
PLFLT)(val1);
13810 arg2 = (
PLFLT)(val2);
13815 arg3 = (
PLFLT)(val3);
13820 arg4 = (
PLINT)(val4);
13830 arg6 = (
PLINT)(val6);
13835 arg7 = (
PLINT)(val7);
13840 arg8 = (
PLINT)(val8);
13845 arg9 = (
PLINT)(val9);
13850 arg10 = (
PLINT)(val10);
13855 arg11 = (
PLFLT)(val11);
13856 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13857 _outv = octave_value();
13871 PLFLT *arg7 = (PLFLT *) 0 ;
13886 octave_value_list _out;
13887 octave_value_list *_outp=&_out;
13888 octave_value _outv;
13898 arg1 = (
PLINT)(val1);
13903 arg2 = (
PLINT)(val2);
13908 arg3 = (
PLINT)(val3);
13913 arg4 = (
PLINT)(val4);
13918 arg5 = (
PLINT)(val5);
13923 arg6 = (
PLFLT)(val6);
13924 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13925 _outv = octave_value();
13945 octave_value_list _out;
13946 octave_value_list *_outp=&_out;
13947 octave_value _outv;
13956 arg1 = (
PLINT)(val1);
13963 _outv = octave_value();
13971 octave_value_list _out;
13972 octave_value_list *_outp=&_out;
13973 octave_value _outv;
13979 _outv = octave_value();
13987 octave_value_list _out;
13988 octave_value_list *_outp=&_out;
13989 octave_value _outv;
13995 _outv = octave_value();
14021 octave_value_list _out;
14022 octave_value_list *_outp=&_out;
14023 octave_value _outv;
14032 arg1 = (
PLFLT)(val1);
14037 arg2 = (
PLFLT)(val2);
14042 arg3 = (
PLFLT)(val3);
14047 arg4 = (
PLFLT)(val4);
14052 arg5 = (
PLINT)(val5);
14057 arg6 = (
PLINT)(val6);
14058 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
14059 _outv = octave_value();
14085 octave_value_list _out;
14086 octave_value_list *_outp=&_out;
14087 octave_value _outv;
14096 arg1 = (
PLFLT)(val1);
14101 arg2 = (
PLFLT)(val2);
14106 arg3 = (
PLFLT)(val3);
14111 arg4 = (
PLFLT)(val4);
14116 arg5 = (
PLINT)(val5);
14121 arg6 = (
PLINT)(val6);
14122 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
14123 _outv = octave_value();
14131 octave_value_list _out;
14132 octave_value_list *_outp=&_out;
14133 octave_value _outv;
14139 _outv = octave_value();
14148 PLFLT *arg2 = (PLFLT *) 0 ;
14149 PLFLT *arg3 = (PLFLT *) 0 ;
14150 PLFLT *arg4 = (PLFLT *) 0 ;
14154 octave_value_list _out;
14155 octave_value_list *_outp=&_out;
14156 octave_value _outv;
14162 if (
_n_dims( args(0) ) > 1 )
14166 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14167 temp1 = args(0).matrix_value();
14168 arg2 = &temp1( 0, 0 );
14171 if (
_n_dims( args(1) ) > 1 )
14175 if (
_dim( args(1), 0 ) != Alen )
14179 temp3 = args(1).matrix_value();
14180 arg3 = &temp3( 0, 0 );
14183 if (
_n_dims( args(2) ) > 1 )
14187 if (
_dim( args(2), 0 ) != Alen )
14191 temp4 = args(2).matrix_value();
14192 arg4 = &temp4( 0, 0 );
14194 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14195 _outv = octave_value();
14213 PLFLT *arg2 = (PLFLT *) 0 ;
14214 PLFLT *arg3 = (PLFLT *) 0 ;
14215 PLFLT *arg4 = (PLFLT *) 0 ;
14219 octave_value_list _out;
14220 octave_value_list *_outp=&_out;
14221 octave_value _outv;
14227 if (
_n_dims( args(0) ) > 1 )
14231 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14232 temp1 = args(0).matrix_value();
14233 arg2 = &temp1( 0, 0 );
14236 if (
_n_dims( args(1) ) > 1 )
14240 if (
_dim( args(1), 0 ) != Alen )
14244 temp3 = args(1).matrix_value();
14245 arg3 = &temp3( 0, 0 );
14248 if (
_n_dims( args(2) ) > 1 )
14252 if (
_dim( args(2), 0 ) != Alen )
14256 temp4 = args(2).matrix_value();
14257 arg4 = &temp4( 0, 0 );
14259 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14260 _outv = octave_value();
14277 octave_value_list _out;
14278 octave_value_list *_outp=&_out;
14279 octave_value _outv;
14285 _outv = octave_value();
14294 PLFLT *arg2 = (PLFLT *) 0 ;
14295 PLFLT *arg3 = (PLFLT *) 0 ;
14298 octave_value_list _out;
14299 octave_value_list *_outp=&_out;
14300 octave_value _outv;
14306 if (
_n_dims( args(0) ) > 1 )
14310 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14311 temp1 = args(0).matrix_value();
14312 arg2 = &temp1( 0, 0 );
14315 if (
_n_dims( args(1) ) > 1 )
14319 if (
_dim( args(1), 0 ) != Alen )
14323 temp3 = args(1).matrix_value();
14324 arg3 = &temp3( 0, 0 );
14326 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
14327 _outv = octave_value();
14342 PLFLT *arg2 = (PLFLT *) 0 ;
14343 PLFLT *arg3 = (PLFLT *) 0 ;
14344 PLFLT *arg4 = (PLFLT *) 0 ;
14348 octave_value_list _out;
14349 octave_value_list *_outp=&_out;
14350 octave_value _outv;
14356 if (
_n_dims( args(0) ) > 1 )
14360 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14361 temp1 = args(0).matrix_value();
14362 arg2 = &temp1( 0, 0 );
14365 if (
_n_dims( args(1) ) > 1 )
14369 if (
_dim( args(1), 0 ) != Alen )
14373 temp3 = args(1).matrix_value();
14374 arg3 = &temp3( 0, 0 );
14377 if (
_n_dims( args(2) ) > 1 )
14381 if (
_dim( args(2), 0 ) != Alen )
14385 temp4 = args(2).matrix_value();
14386 arg4 = &temp4( 0, 0 );
14388 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14389 _outv = octave_value();
14407 PLFLT *arg2 = (PLFLT *) 0 ;
14408 PLFLT *arg3 = (PLFLT *) 0 ;
14414 octave_value_list _out;
14415 octave_value_list *_outp=&_out;
14416 octave_value _outv;
14422 if (
_n_dims( args(0) ) > 1 )
14426 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14427 temp1 = args(0).matrix_value();
14428 arg2 = &temp1( 0, 0 );
14431 if (
_n_dims( args(1) ) > 1 )
14435 if (
_dim( args(1), 0 ) != Alen )
14439 temp3 = args(1).matrix_value();
14440 arg3 = &temp3( 0, 0 );
14446 arg4 = (
PLFLT)(val4);
14447 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
14448 _outv = octave_value();
14462 octave_value_list _out;
14463 octave_value_list *_outp=&_out;
14464 octave_value _outv;
14470 _outv = octave_value();
14481 octave_value_list _out;
14482 octave_value_list *_outp=&_out;
14483 octave_value _outv;
14492 arg1 = (
PLINT)(val1);
14494 _outv = octave_value();
14505 octave_value_list _out;
14506 octave_value_list *_outp=&_out;
14507 octave_value _outv;
14516 arg1 = (
PLINT)(val1);
14518 _outv = octave_value();
14526 PLFLT *arg1 = (PLFLT *) 0 ;
14527 PLFLT *arg2 = (PLFLT *) 0 ;
14532 octave_value_list _out;
14533 octave_value_list *_outp=&_out;
14534 octave_value _outv;
14542 _outv = octave_value();
14563 PLINT *arg2 = (PLINT *) 0 ;
14564 PLINT *arg3 = (PLINT *) 0 ;
14565 PLINT *arg4 = (PLINT *) 0 ;
14574 octave_value_list _out;
14575 octave_value_list *_outp=&_out;
14576 octave_value _outv;
14588 arg1 = (
PLINT)(val1);
14589 plgcol0(arg1,arg2,arg3,arg4);
14590 _outv = octave_value();
14617 PLINT *arg2 = (PLINT *) 0 ;
14618 PLINT *arg3 = (PLINT *) 0 ;
14619 PLINT *arg4 = (PLINT *) 0 ;
14620 PLFLT *arg5 = (PLFLT *) 0 ;
14631 octave_value_list _out;
14632 octave_value_list *_outp=&_out;
14633 octave_value _outv;
14646 arg1 = (
PLINT)(val1);
14647 plgcol0a(arg1,arg2,arg3,arg4,arg5);
14648 _outv = octave_value();
14680 PLINT *arg1 = (PLINT *) 0 ;
14681 PLINT *arg2 = (PLINT *) 0 ;
14682 PLINT *arg3 = (PLINT *) 0 ;
14689 octave_value_list _out;
14690 octave_value_list *_outp=&_out;
14691 octave_value _outv;
14700 _outv = octave_value();
14726 PLINT *arg1 = (PLINT *) 0 ;
14727 PLINT *arg2 = (PLINT *) 0 ;
14728 PLINT *arg3 = (PLINT *) 0 ;
14729 PLFLT *arg4 = (PLFLT *) 0 ;
14738 octave_value_list _out;
14739 octave_value_list *_outp=&_out;
14740 octave_value _outv;
14750 _outv = octave_value();
14782 PLINT *arg1 = (PLINT *) 0 ;
14785 octave_value_list _out;
14786 octave_value_list *_outp=&_out;
14787 octave_value _outv;
14794 _outv = octave_value();
14808 char *arg1 = (
char *) 0 ;
14809 octave_value_list retval1 ;
14810 octave_value_list _out;
14811 octave_value_list *_outp=&_out;
14812 octave_value _outv;
14816 # if OCTAVE_API_VERSION_NUMBER < 45
14817 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
14819 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
14821 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
14827 _outv = octave_value();
14838 PLFLT *arg1 = (PLFLT *) 0 ;
14839 PLFLT *arg2 = (PLFLT *) 0 ;
14840 PLFLT *arg3 = (PLFLT *) 0 ;
14841 PLFLT *arg4 = (PLFLT *) 0 ;
14850 octave_value_list _out;
14851 octave_value_list *_outp=&_out;
14852 octave_value _outv;
14862 _outv = octave_value();
14894 PLFLT *arg1 = (PLFLT *) 0 ;
14897 octave_value_list _out;
14898 octave_value_list *_outp=&_out;
14899 octave_value _outv;
14906 _outv = octave_value();
14920 PLFLT *arg1 = (PLFLT *) 0 ;
14921 PLFLT *arg2 = (PLFLT *) 0 ;
14922 PLFLT *arg3 = (PLFLT *) 0 ;
14923 PLFLT *arg4 = (PLFLT *) 0 ;
14932 octave_value_list _out;
14933 octave_value_list *_outp=&_out;
14934 octave_value _outv;
14944 _outv = octave_value();
14976 PLINT *arg1 = (PLINT *) 0 ;
14977 PLINT *arg2 = (PLINT *) 0 ;
14978 PLINT *arg3 = (PLINT *) 0 ;
14985 octave_value_list _out;
14986 octave_value_list *_outp=&_out;
14987 octave_value _outv;
14996 _outv = octave_value();
15025 octave_value_list _out;
15026 octave_value_list *_outp=&_out;
15027 octave_value _outv;
15034 _outv = octave_value();
15048 char *arg1 = (
char *) 0 ;
15049 octave_value_list retval1 ;
15050 octave_value_list _out;
15051 octave_value_list *_outp=&_out;
15052 octave_value _outv;
15056 # if OCTAVE_API_VERSION_NUMBER < 45
15057 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
15059 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15061 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
15067 _outv = octave_value();
15078 PLINT *arg1 = (PLINT *) 0 ;
15079 PLINT *arg2 = (PLINT *) 0 ;
15080 PLINT *arg3 = (PLINT *) 0 ;
15087 octave_value_list _out;
15088 octave_value_list *_outp=&_out;
15089 octave_value _outv;
15098 _outv = octave_value();
15124 PLINT *arg1 = (PLINT *) 0 ;
15127 octave_value_list _out;
15128 octave_value_list *_outp=&_out;
15129 octave_value _outv;
15136 _outv = octave_value();
15150 PLFLT *arg1 = (PLFLT *) 0 ;
15151 PLFLT *arg2 = (PLFLT *) 0 ;
15152 PLINT *arg3 = (PLINT *) 0 ;
15153 PLINT *arg4 = (PLINT *) 0 ;
15154 PLINT *arg5 = (PLINT *) 0 ;
15155 PLINT *arg6 = (PLINT *) 0 ;
15168 octave_value_list _out;
15169 octave_value_list *_outp=&_out;
15170 octave_value _outv;
15181 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
15182 _outv = octave_value();
15226 octave_value_list _out;
15227 octave_value_list *_outp=&_out;
15228 octave_value _outv;
15234 _outv = octave_value();
15242 PLFLT *arg1 = (PLFLT *) 0 ;
15243 PLFLT *arg2 = (PLFLT *) 0 ;
15244 PLFLT *arg3 = (PLFLT *) 0 ;
15245 PLFLT *arg4 = (PLFLT *) 0 ;
15254 octave_value_list _out;
15255 octave_value_list *_outp=&_out;
15256 octave_value _outv;
15265 plgspa(arg1,arg2,arg3,arg4);
15266 _outv = octave_value();
15298 PLINT *arg1 = (PLINT *) 0 ;
15301 octave_value_list _out;
15302 octave_value_list *_outp=&_out;
15303 octave_value _outv;
15310 _outv = octave_value();
15324 char *arg1 = (
char *) 0 ;
15325 octave_value_list retval1 ;
15326 octave_value_list _out;
15327 octave_value_list *_outp=&_out;
15328 octave_value _outv;
15332 # if OCTAVE_API_VERSION_NUMBER < 45
15333 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
15335 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15337 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
15343 _outv = octave_value();
15354 PLFLT *arg1 = (PLFLT *) 0 ;
15355 PLFLT *arg2 = (PLFLT *) 0 ;
15356 PLFLT *arg3 = (PLFLT *) 0 ;
15357 PLFLT *arg4 = (PLFLT *) 0 ;
15366 octave_value_list _out;
15367 octave_value_list *_outp=&_out;
15368 octave_value _outv;
15377 plgvpd(arg1,arg2,arg3,arg4);
15378 _outv = octave_value();
15410 PLFLT *arg1 = (PLFLT *) 0 ;
15411 PLFLT *arg2 = (PLFLT *) 0 ;
15412 PLFLT *arg3 = (PLFLT *) 0 ;
15413 PLFLT *arg4 = (PLFLT *) 0 ;
15422 octave_value_list _out;
15423 octave_value_list *_outp=&_out;
15424 octave_value _outv;
15433 plgvpw(arg1,arg2,arg3,arg4);
15434 _outv = octave_value();
15466 PLINT *arg1 = (PLINT *) 0 ;
15467 PLINT *arg2 = (PLINT *) 0 ;
15472 octave_value_list _out;
15473 octave_value_list *_outp=&_out;
15474 octave_value _outv;
15482 _outv = octave_value();
15502 PLINT *arg1 = (PLINT *) 0 ;
15503 PLINT *arg2 = (PLINT *) 0 ;
15508 octave_value_list _out;
15509 octave_value_list *_outp=&_out;
15510 octave_value _outv;
15518 _outv = octave_value();
15538 PLINT *arg1 = (PLINT *) 0 ;
15539 PLINT *arg2 = (PLINT *) 0 ;
15544 octave_value_list _out;
15545 octave_value_list *_outp=&_out;
15546 octave_value _outv;
15554 _outv = octave_value();
15575 PLFLT *arg2 = (PLFLT *) 0 ;
15589 octave_value_list _out;
15590 octave_value_list *_outp=&_out;
15591 octave_value _outv;
15597 if (
_n_dims( args(0) ) > 1 )
15601 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
15602 temp1 = args(0).matrix_value();
15603 arg2 = &temp1( 0, 0 );
15609 arg3 = (
PLFLT)(val3);
15614 arg4 = (
PLFLT)(val4);
15619 arg5 = (
PLINT)(val5);
15624 arg6 = (
PLINT)(val6);
15625 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
15626 _outv = octave_value();
15640 PLFLT *arg4 = (PLFLT *) 0 ;
15641 PLFLT *arg5 = (PLFLT *) 0 ;
15642 PLFLT *arg6 = (PLFLT *) 0 ;
15655 octave_value_list _out;
15656 octave_value_list *_outp=&_out;
15657 octave_value _outv;
15669 arg1 = (
PLFLT)(val1);
15674 arg2 = (
PLFLT)(val2);
15679 arg3 = (
PLFLT)(val3);
15680 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
15681 _outv = octave_value();
15707 octave_value_list _out;
15708 octave_value_list *_outp=&_out;
15709 octave_value _outv;
15715 _outv = octave_value();
15735 octave_value_list _out;
15736 octave_value_list *_outp=&_out;
15737 octave_value _outv;
15746 arg1 = (
PLFLT)(val1);
15751 arg2 = (
PLFLT)(val2);
15756 arg3 = (
PLFLT)(val3);
15761 arg4 = (
PLFLT)(val4);
15762 pljoin(arg1,arg2,arg3,arg4);
15763 _outv = octave_value();
15771 char *arg1 = (
char *) 0 ;
15772 char *arg2 = (
char *) 0 ;
15773 char *arg3 = (
char *) 0 ;
15783 octave_value_list _out;
15784 octave_value_list *_outp=&_out;
15785 octave_value _outv;
15794 arg1 = (
char *)(buf1);
15799 arg2 = (
char *)(buf2);
15804 arg3 = (
char *)(buf3);
15805 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
15806 _outv = octave_value();
15817 PLFLT *arg1 = (PLFLT *) 0 ;
15818 PLFLT *arg2 = (PLFLT *) 0 ;
15830 PLINT *arg14 = (PLINT *) 0 ;
15835 PLINT *arg19 = (PLINT *) 0 ;
15836 char **arg20 = (
char **) 0 ;
15837 PLINT *arg21 = (PLINT *) 0 ;
15838 PLINT *arg22 = (PLINT *) 0 ;
15839 PLFLT *arg23 = (PLFLT *) 0 ;
15840 PLFLT *arg24 = (PLFLT *) 0 ;
15841 PLINT *arg25 = (PLINT *) 0 ;
15842 PLINT *arg26 = (PLINT *) 0 ;
15843 PLFLT *arg27 = (PLFLT *) 0 ;
15844 PLINT *arg28 = (PLINT *) 0 ;
15845 PLFLT *arg29 = (PLFLT *) 0 ;
15846 PLINT *arg30 = (PLINT *) 0 ;
15847 char **arg31 = (
char **) 0 ;
15892 octave_value_list _out;
15893 octave_value_list *_outp=&_out;
15894 octave_value _outv;
15905 arg3 = (
PLINT)(val3);
15910 arg4 = (
PLINT)(val4);
15915 arg5 = (
PLFLT)(val5);
15920 arg6 = (
PLFLT)(val6);
15925 arg7 = (
PLFLT)(val7);
15930 arg8 = (
PLINT)(val8);
15935 arg9 = (
PLINT)(val9);
15940 arg10 = (
PLINT)(val10);
15945 arg11 = (
PLINT)(val11);
15950 arg12 = (
PLINT)(val12);
15952 if (
_n_dims( args(10) ) > 1 )
15956 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
15957 arg14 =
new PLINT[
Alen];
15958 temp13 = args(10).matrix_value();
15965 arg15 = (
PLFLT)(val15);
15970 arg16 = (
PLFLT)(val16);
15975 arg17 = (
PLFLT)(val17);
15980 arg18 = (
PLFLT)(val18);
15982 if (
_n_dims( args(15) ) > 1 )
15986 if (
_dim( args(15), 0 ) != Alen )
15990 temp19 = args(15).matrix_value();
15991 arg19 =
new PLINT[
Alen];
15995 charMatrix temp_matrix;
15999 size_t max_length = 0, non_blank_length;
16001 if (
_n_dims( args(16) ) > 2 )
16003 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
16005 if ( !args(16).is_empty() )
16007 if (
_dim( args(16), 0 ) != Alen )
16009 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
16011 arg20 =
new char*[
Alen];
16012 ifcell = args(16).is_cell();
16015 temp_cell = args(16).cell_value();
16019 temp_matrix = args(16).char_matrix_value();
16021 max_length =
_dim( args(16), 1 ) + 1;
16024 for ( i = 0; i <
Alen; i++ )
16031 if ( temp_cell.elem( i ).is_string() )
16033 str = temp_cell.elem( i ).string_value();
16035 max_length = str.size() + 1;
16036 tmp_cstring = (
char *) str.c_str();
16046 tmp_cstring = (
char *)
"";
16051 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
16053 arg20[i] =
new char[max_length];
16054 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16055 arg20[i][max_length - 1] =
'\0';
16070 non_blank_length = max_length - 2;
16071 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16073 non_blank_length--;
16075 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16077 non_blank_length--;
16079 arg20[i][non_blank_length + 1] =
'\0';
16089 if (
_n_dims( args(17) ) > 1 )
16093 if ( !args(17).is_empty() )
16095 if (
_dim( args(17), 0 ) != Alen )
16099 temp21 = args(17).matrix_value();
16100 arg21 =
new PLINT[
Alen];
16109 if (
_n_dims( args(18) ) > 1 )
16113 if ( !args(18).is_empty() )
16115 if (
_dim( args(18), 0 ) != Alen )
16119 temp22 = args(18).matrix_value();
16120 arg22 =
new PLINT[
Alen];
16129 if (
_n_dims( args(19) ) > 1 )
16133 if ( !args(19).is_empty() )
16135 if (
_dim( args(19), 0 ) != Alen )
16139 temp23 = args(19).matrix_value();
16140 arg23 = &temp23( 0, 0 );
16148 if (
_n_dims( args(20) ) > 1 )
16152 if ( !args(20).is_empty() )
16154 if (
_dim( args(20), 0 ) != Alen )
16158 temp24 = args(20).matrix_value();
16159 arg24 = &temp24( 0, 0 );
16167 if (
_n_dims( args(21) ) > 1 )
16171 if ( !args(21).is_empty() )
16173 if (
_dim( args(21), 0 ) != Alen )
16177 temp25 = args(21).matrix_value();
16178 arg25 =
new PLINT[
Alen];
16187 if (
_n_dims( args(22) ) > 1 )
16191 if ( !args(22).is_empty() )
16193 if (
_dim( args(22), 0 ) != Alen )
16197 temp26 = args(22).matrix_value();
16198 arg26 =
new PLINT[
Alen];
16207 if (
_n_dims( args(23) ) > 1 )
16211 if ( !args(23).is_empty() )
16213 if (
_dim( args(23), 0 ) != Alen )
16217 temp27 = args(23).matrix_value();
16218 arg27 = &temp27( 0, 0 );
16226 if (
_n_dims( args(24) ) > 1 )
16230 if ( !args(24).is_empty() )
16232 if (
_dim( args(24), 0 ) != Alen )
16236 temp28 = args(24).matrix_value();
16237 arg28 =
new PLINT[
Alen];
16246 if (
_n_dims( args(25) ) > 1 )
16250 if ( !args(25).is_empty() )
16252 if (
_dim( args(25), 0 ) != Alen )
16256 temp29 = args(25).matrix_value();
16257 arg29 = &temp29( 0, 0 );
16265 if (
_n_dims( args(26) ) > 1 )
16269 if ( !args(26).is_empty() )
16271 if (
_dim( args(26), 0 ) != Alen )
16275 temp30 = args(26).matrix_value();
16276 arg30 =
new PLINT[
Alen];
16285 charMatrix temp_matrix;
16289 size_t max_length = 0, non_blank_length;
16291 if (
_n_dims( args(27) ) > 2 )
16293 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
16295 if ( !args(27).is_empty() )
16297 if (
_dim( args(27), 0 ) != Alen )
16299 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
16301 arg31 =
new char*[
Alen];
16302 ifcell = args(27).is_cell();
16305 temp_cell = args(27).cell_value();
16309 temp_matrix = args(27).char_matrix_value();
16311 max_length =
_dim( args(27), 1 ) + 1;
16314 for ( i = 0; i <
Alen; i++ )
16321 if ( temp_cell.elem( i ).is_string() )
16323 str = temp_cell.elem( i ).string_value();
16325 max_length = str.size() + 1;
16326 tmp_cstring = (
char *) str.c_str();
16336 tmp_cstring = (
char *)
"";
16341 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
16343 arg31[i] =
new char[max_length];
16344 strncpy( arg31[i], tmp_cstring, max_length - 1 );
16345 arg31[i][max_length - 1] =
'\0';
16360 non_blank_length = max_length - 2;
16361 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
16363 non_blank_length--;
16365 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
16367 non_blank_length--;
16369 arg31[i][non_blank_length + 1] =
'\0';
16378 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);
16379 _outv = octave_value();
16401 if ( arg20 != NULL )
16403 for ( i = 0; i <
Alen; i++ )
16411 if ( arg21 != NULL )
16415 if ( arg22 != NULL )
16425 if ( arg25 != NULL )
16429 if ( arg26 != NULL )
16436 if ( arg28 != NULL )
16443 if ( arg30 != NULL )
16448 if ( arg31 != NULL )
16450 for ( i = 0; i <
Alen; i++ )
16472 octave_value_list _out;
16473 octave_value_list *_outp=&_out;
16474 octave_value _outv;
16483 arg1 = (
PLFLT)(val1);
16488 arg2 = (
PLFLT)(val2);
16493 arg3 = (
PLFLT)(val3);
16495 _outv = octave_value();
16504 PLFLT *arg2 = (PLFLT *) 0 ;
16505 PLFLT *arg3 = (PLFLT *) 0 ;
16508 octave_value_list _out;
16509 octave_value_list *_outp=&_out;
16510 octave_value _outv;
16516 if (
_n_dims( args(0) ) > 1 )
16520 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16521 temp1 = args(0).matrix_value();
16522 arg2 = &temp1( 0, 0 );
16525 if (
_n_dims( args(1) ) > 1 )
16529 if (
_dim( args(1), 0 ) != Alen )
16533 temp3 = args(1).matrix_value();
16534 arg3 = &temp3( 0, 0 );
16536 plline(arg1,(
double const *)arg2,(
double const *)arg3);
16537 _outv = octave_value();
16552 PLFLT *arg2 = (PLFLT *) 0 ;
16553 PLFLT *arg3 = (PLFLT *) 0 ;
16554 PLFLT *arg4 = (PLFLT *) 0 ;
16558 octave_value_list _out;
16559 octave_value_list *_outp=&_out;
16560 octave_value _outv;
16566 if (
_n_dims( args(0) ) > 1 )
16570 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16571 temp1 = args(0).matrix_value();
16572 arg2 = &temp1( 0, 0 );
16575 if (
_n_dims( args(1) ) > 1 )
16579 if (
_dim( args(1), 0 ) != Alen )
16583 temp3 = args(1).matrix_value();
16584 arg3 = &temp3( 0, 0 );
16587 if (
_n_dims( args(2) ) > 1 )
16591 if (
_dim( args(2), 0 ) != Alen )
16595 temp4 = args(2).matrix_value();
16596 arg4 = &temp4( 0, 0 );
16598 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
16599 _outv = octave_value();
16619 octave_value_list _out;
16620 octave_value_list *_outp=&_out;
16621 octave_value _outv;
16630 arg1 = (
PLINT)(val1);
16632 _outv = octave_value();
16640 PLINT *arg1 = (PLINT *) 0 ;
16643 octave_value_list _out;
16644 octave_value_list *_outp=&_out;
16645 octave_value _outv;
16652 _outv = octave_value();
16666 char *arg1 = (
char *) 0 ;
16670 char *arg5 = (
char *) 0 ;
16683 octave_value_list _out;
16684 octave_value_list *_outp=&_out;
16685 octave_value _outv;
16694 arg1 = (
char *)(buf1);
16699 arg2 = (
PLFLT)(val2);
16704 arg3 = (
PLFLT)(val3);
16709 arg4 = (
PLFLT)(val4);
16714 arg5 = (
char *)(buf5);
16715 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
16716 _outv = octave_value();
16726 char *arg1 = (
char *) 0 ;
16730 char *arg5 = (
char *) 0 ;
16743 octave_value_list _out;
16744 octave_value_list *_outp=&_out;
16745 octave_value _outv;
16754 arg1 = (
char *)(buf1);
16759 arg2 = (
PLFLT)(val2);
16764 arg3 = (
PLFLT)(val3);
16769 arg4 = (
PLFLT)(val4);
16774 arg5 = (
char *)(buf5);
16775 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
16776 _outv = octave_value();
16786 int *arg1 = (
int *) 0 ;
16787 char **arg2 = (
char **) 0 ;
16795 octave_value_list _out;
16796 octave_value_list *_outp=&_out;
16797 octave_value _outv;
16807 arg1 = (
int *)(argp1);
16812 arg2 = (
char **)(argp2);
16817 arg3 = (
PLINT)(val3);
16828 PLINT *arg2 = (PLINT *) 0 ;
16829 PLINT *arg3 = (PLINT *) 0 ;
16832 octave_value_list _out;
16833 octave_value_list *_outp=&_out;
16834 octave_value _outv;
16840 if (
_n_dims( args(0) ) > 1 )
16844 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16845 arg2 =
new PLINT[
Alen];
16846 temp1 = args(0).matrix_value();
16850 if (
_n_dims( args(1) ) > 1 )
16854 if (
_dim( args(1), 0 ) != Alen )
16858 temp3 = args(1).matrix_value();
16859 arg3 =
new PLINT[
Alen];
16862 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
16863 _outv = octave_value();
16892 octave_value_list _out;
16893 octave_value_list *_outp=&_out;
16894 octave_value _outv;
16903 arg1 = (
PLINT)(val1);
16908 arg2 = (
PLFLT)(val2);
16913 arg3 = (
PLFLT)(val3);
16918 arg4 = (
PLFLT)(val4);
16923 arg5 = (
PLFLT)(val5);
16924 plpath(arg1,arg2,arg3,arg4,arg5);
16925 _outv = octave_value();
16934 PLFLT *arg2 = (PLFLT *) 0 ;
16935 PLFLT *arg3 = (PLFLT *) 0 ;
16941 octave_value_list _out;
16942 octave_value_list *_outp=&_out;
16943 octave_value _outv;
16949 if (
_n_dims( args(0) ) > 1 )
16953 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16954 temp1 = args(0).matrix_value();
16955 arg2 = &temp1( 0, 0 );
16958 if (
_n_dims( args(1) ) > 1 )
16962 if (
_dim( args(1), 0 ) != Alen )
16966 temp3 = args(1).matrix_value();
16967 arg3 = &temp3( 0, 0 );
16973 arg4 = (
PLINT)(val4);
16974 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16975 _outv = octave_value();
16990 PLFLT *arg2 = (PLFLT *) 0 ;
16991 PLFLT *arg3 = (PLFLT *) 0 ;
16992 PLFLT *arg4 = (PLFLT *) 0 ;
16999 octave_value_list _out;
17000 octave_value_list *_outp=&_out;
17001 octave_value _outv;
17007 if (
_n_dims( args(0) ) > 1 )
17011 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17012 temp1 = args(0).matrix_value();
17013 arg2 = &temp1( 0, 0 );
17016 if (
_n_dims( args(1) ) > 1 )
17020 if (
_dim( args(1), 0 ) != Alen )
17024 temp3 = args(1).matrix_value();
17025 arg3 = &temp3( 0, 0 );
17028 if (
_n_dims( args(2) ) > 1 )
17032 if (
_dim( args(2), 0 ) != Alen )
17036 temp4 = args(2).matrix_value();
17037 arg4 = &temp4( 0, 0 );
17043 arg5 = (
PLINT)(val5);
17044 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
17045 _outv = octave_value();
17063 PLFLT *arg2 = (PLFLT *) 0 ;
17064 PLFLT *arg3 = (PLFLT *) 0 ;
17065 PLFLT *arg4 = (PLFLT *) 0 ;
17074 octave_value_list _out;
17075 octave_value_list *_outp=&_out;
17076 octave_value _outv;
17082 if (
_n_dims( args(0) ) > 1 )
17086 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17087 temp1 = args(0).matrix_value();
17088 arg2 = &temp1( 0, 0 );
17091 if (
_n_dims( args(1) ) > 1 )
17095 if (
_dim( args(1), 0 ) != Alen )
17099 temp3 = args(1).matrix_value();
17100 arg3 = &temp3( 0, 0 );
17103 if (
_n_dims( args(2) ) > 1 )
17107 if (
_dim( args(2), 0 ) != Alen )
17111 temp4 = args(2).matrix_value();
17112 arg4 = &temp4( 0, 0 );
17115 if (
_n_dims( args(3) ) > 1 )
17119 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
17121 error(
"argument vector must be same length or one less" );
SWIG_fail;
17123 temp5 = args(3).matrix_value();
17124 arg5 =
new PLINT[
Alen];
17132 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
17133 _outv = octave_value();
17159 octave_value_list _out;
17160 octave_value_list *_outp=&_out;
17161 octave_value _outv;
17170 arg1 = (
PLINT)(val1);
17175 arg2 = (
PLINT)(val2);
17177 _outv = octave_value();
17188 octave_value_list _out;
17189 octave_value_list *_outp=&_out;
17190 octave_value _outv;
17199 arg1 = (
PLINT)(val1);
17201 _outv = octave_value();
17214 char *arg6 = (
char *) 0 ;
17228 octave_value_list _out;
17229 octave_value_list *_outp=&_out;
17230 octave_value _outv;
17239 arg1 = (
PLFLT)(val1);
17244 arg2 = (
PLFLT)(val2);
17249 arg3 = (
PLFLT)(val3);
17254 arg4 = (
PLFLT)(val4);
17259 arg5 = (
PLFLT)(val5);
17264 arg6 = (
char *)(buf6);
17265 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
17266 _outv = octave_value();
17285 char *arg11 = (
char *) 0 ;
17309 octave_value_list _out;
17310 octave_value_list *_outp=&_out;
17311 octave_value _outv;
17320 arg1 = (
PLFLT)(val1);
17325 arg2 = (
PLFLT)(val2);
17330 arg3 = (
PLFLT)(val3);
17335 arg4 = (
PLFLT)(val4);
17340 arg5 = (
PLFLT)(val5);
17345 arg6 = (
PLFLT)(val6);
17350 arg7 = (
PLFLT)(val7);
17355 arg8 = (
PLFLT)(val8);
17360 arg9 = (
PLFLT)(val9);
17365 arg10 = (
PLFLT)(val10);
17370 arg11 = (
char *)(buf11);
17371 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
17372 _outv = octave_value();
17381 octave_value_list _out;
17382 octave_value_list *_outp=&_out;
17383 octave_value _outv;
17398 octave_value_list _out;
17399 octave_value_list *_outp=&_out;
17400 octave_value _outv;
17406 _outv = octave_value();
17417 PLFLT *arg4 = (PLFLT *) 0 ;
17418 PLFLT *arg5 = (PLFLT *) 0 ;
17419 PLFLT *arg6 = (PLFLT *) 0 ;
17432 octave_value_list _out;
17433 octave_value_list *_outp=&_out;
17434 octave_value _outv;
17446 arg1 = (
PLFLT)(val1);
17451 arg2 = (
PLFLT)(val2);
17456 arg3 = (
PLFLT)(val3);
17457 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
17458 _outv = octave_value();
17490 octave_value_list _out;
17491 octave_value_list *_outp=&_out;
17492 octave_value _outv;
17501 arg1 = (
PLFLT)(val1);
17506 arg2 = (
PLFLT)(val2);
17508 _outv = octave_value();
17516 PLINT *arg1 = (PLINT *) 0 ;
17517 PLINT *arg2 = (PLINT *) 0 ;
17518 PLINT *arg3 = (PLINT *) 0 ;
17523 octave_value_list _out;
17524 octave_value_list *_outp=&_out;
17525 octave_value _outv;
17531 if (
_n_dims( args(0) ) > 1 )
17536 temp1 = args(0).matrix_value();
17537 arg1 =
new PLINT[
Alen];
17541 if (
_n_dims( args(1) ) > 1 )
17545 if (
_dim( args(1), 0 ) != Alen )
17549 temp2 = args(1).matrix_value();
17550 arg2 =
new PLINT[
Alen];
17554 if (
_n_dims( args(2) ) > 1 )
17558 if (
_dim( args(2), 0 ) != Alen )
17562 temp3 = args(2).matrix_value();
17563 arg3 =
new PLINT[
Alen];
17567 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
17568 _outv = octave_value();
17585 PLINT *arg1 = (PLINT *) 0 ;
17586 PLINT *arg2 = (PLINT *) 0 ;
17587 PLINT *arg3 = (PLINT *) 0 ;
17588 PLFLT *arg4 = (PLFLT *) 0 ;
17594 octave_value_list _out;
17595 octave_value_list *_outp=&_out;
17596 octave_value _outv;
17602 if (
_n_dims( args(0) ) > 1 )
17607 temp1 = args(0).matrix_value();
17608 arg1 =
new PLINT[
Alen];
17612 if (
_n_dims( args(1) ) > 1 )
17616 if (
_dim( args(1), 0 ) != Alen )
17620 temp2 = args(1).matrix_value();
17621 arg2 =
new PLINT[
Alen];
17625 if (
_n_dims( args(2) ) > 1 )
17629 if (
_dim( args(2), 0 ) != Alen )
17633 temp3 = args(2).matrix_value();
17634 arg3 =
new PLINT[
Alen];
17638 if (
_n_dims( args(3) ) > 1 )
17642 if (
_dim( args(3), 0 ) != Alen )
17646 temp4 = args(3).matrix_value();
17647 arg4 = &temp4( 0, 0 );
17650 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
17651 _outv = octave_value();
17674 octave_value_list _out;
17675 octave_value_list *_outp=&_out;
17676 octave_value _outv;
17685 arg1 = (
PLINT)(val1);
17687 _outv = octave_value();
17695 PLINT *arg1 = (PLINT *) 0 ;
17696 PLINT *arg2 = (PLINT *) 0 ;
17697 PLINT *arg3 = (PLINT *) 0 ;
17702 octave_value_list _out;
17703 octave_value_list *_outp=&_out;
17704 octave_value _outv;
17710 if (
_n_dims( args(0) ) > 1 )
17715 temp1 = args(0).matrix_value();
17716 arg1 =
new PLINT[
Alen];
17720 if (
_n_dims( args(1) ) > 1 )
17724 if (
_dim( args(1), 0 ) != Alen )
17728 temp2 = args(1).matrix_value();
17729 arg2 =
new PLINT[
Alen];
17733 if (
_n_dims( args(2) ) > 1 )
17737 if (
_dim( args(2), 0 ) != Alen )
17741 temp3 = args(2).matrix_value();
17742 arg3 =
new PLINT[
Alen];
17746 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
17747 _outv = octave_value();
17764 PLINT *arg1 = (PLINT *) 0 ;
17765 PLINT *arg2 = (PLINT *) 0 ;
17766 PLINT *arg3 = (PLINT *) 0 ;
17767 PLFLT *arg4 = (PLFLT *) 0 ;
17773 octave_value_list _out;
17774 octave_value_list *_outp=&_out;
17775 octave_value _outv;
17781 if (
_n_dims( args(0) ) > 1 )
17786 temp1 = args(0).matrix_value();
17787 arg1 =
new PLINT[
Alen];
17791 if (
_n_dims( args(1) ) > 1 )
17795 if (
_dim( args(1), 0 ) != Alen )
17799 temp2 = args(1).matrix_value();
17800 arg2 =
new PLINT[
Alen];
17804 if (
_n_dims( args(2) ) > 1 )
17808 if (
_dim( args(2), 0 ) != Alen )
17812 temp3 = args(2).matrix_value();
17813 arg3 =
new PLINT[
Alen];
17817 if (
_n_dims( args(3) ) > 1 )
17821 if (
_dim( args(3), 0 ) != Alen )
17825 temp4 = args(3).matrix_value();
17826 arg4 = &temp4( 0, 0 );
17829 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
17830 _outv = octave_value();
17852 PLFLT *arg3 = (PLFLT *) 0 ;
17853 PLFLT *arg4 = (PLFLT *) 0 ;
17854 PLFLT *arg5 = (PLFLT *) 0 ;
17855 PLFLT *arg6 = (PLFLT *) 0 ;
17864 octave_value_list _out;
17865 octave_value_list *_outp=&_out;
17866 octave_value _outv;
17877 if (
_n_dims( args(1) ) > 1 )
17881 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
17882 temp2 = args(1).matrix_value();
17883 arg3 = &temp2( 0, 0 );
17886 if (
_n_dims( args(2) ) > 1 )
17890 if (
_dim( args(2), 0 ) != Alen )
17894 temp4 = args(2).matrix_value();
17895 arg4 = &temp4( 0, 0 );
17898 if (
_n_dims( args(3) ) > 1 )
17902 if (
_dim( args(3), 0 ) != Alen )
17906 temp5 = args(3).matrix_value();
17907 arg5 = &temp5( 0, 0 );
17910 if (
_n_dims( args(4) ) > 1 )
17914 if (
_dim( args(4), 0 ) != Alen )
17918 temp6 = args(4).matrix_value();
17919 arg6 = &temp6( 0, 0 );
17922 if (
_n_dims( args(5) ) > 1 )
17926 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
17928 error(
"argument vector must be same length or one less" );
SWIG_fail;
17930 temp7 = args(5).matrix_value();
17931 arg7 =
new PLINT[
Alen];
17934 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
17935 _outv = octave_value();
17960 PLFLT *arg3 = (PLFLT *) 0 ;
17961 PLFLT *arg4 = (PLFLT *) 0 ;
17962 PLFLT *arg5 = (PLFLT *) 0 ;
17963 PLFLT *arg6 = (PLFLT *) 0 ;
17964 PLFLT *arg7 = (PLFLT *) 0 ;
17974 octave_value_list _out;
17975 octave_value_list *_outp=&_out;
17976 octave_value _outv;
17987 if (
_n_dims( args(1) ) > 1 )
17991 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
17992 temp2 = args(1).matrix_value();
17993 arg3 = &temp2( 0, 0 );
17996 if (
_n_dims( args(2) ) > 1 )
18000 if (
_dim( args(2), 0 ) != Alen )
18004 temp4 = args(2).matrix_value();
18005 arg4 = &temp4( 0, 0 );
18008 if (
_n_dims( args(3) ) > 1 )
18012 if (
_dim( args(3), 0 ) != Alen )
18016 temp5 = args(3).matrix_value();
18017 arg5 = &temp5( 0, 0 );
18020 if (
_n_dims( args(4) ) > 1 )
18024 if (
_dim( args(4), 0 ) != Alen )
18028 temp6 = args(4).matrix_value();
18029 arg6 = &temp6( 0, 0 );
18032 if (
_n_dims( args(5) ) > 1 )
18036 if (
_dim( args(5), 0 ) != Alen )
18040 temp7 = args(5).matrix_value();
18041 arg7 = &temp7( 0, 0 );
18044 if (
_n_dims( args(6) ) > 1 )
18048 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
18050 error(
"argument vector must be same length or one less" );
SWIG_fail;
18052 temp8 = args(6).matrix_value();
18053 arg8 =
new PLINT[
Alen];
18056 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
18057 _outv = octave_value();
18086 octave_value_list _out;
18087 octave_value_list *_outp=&_out;
18088 octave_value _outv;
18097 arg1 = (
PLINT)(val1);
18099 _outv = octave_value();
18113 octave_value_list _out;
18114 octave_value_list *_outp=&_out;
18115 octave_value _outv;
18124 arg1 = (
PLFLT)(val1);
18129 arg2 = (
PLFLT)(val2);
18131 _outv = octave_value();
18139 PLFLT *arg1 = (PLFLT *) 0 ;
18140 PLFLT *arg2 = (PLFLT *) 0 ;
18145 octave_value_list _out;
18146 octave_value_list *_outp=&_out;
18147 octave_value _outv;
18155 _outv = octave_value();
18187 octave_value_list _out;
18188 octave_value_list *_outp=&_out;
18189 octave_value _outv;
18198 arg1 = (
PLINT)(val1);
18203 arg2 = (
PLINT)(val2);
18208 arg3 = (
PLINT)(val3);
18213 arg4 = (
PLINT)(val4);
18214 plscol0(arg1,arg2,arg3,arg4);
18215 _outv = octave_value();
18238 octave_value_list _out;
18239 octave_value_list *_outp=&_out;
18240 octave_value _outv;
18249 arg1 = (
PLINT)(val1);
18254 arg2 = (
PLINT)(val2);
18259 arg3 = (
PLINT)(val3);
18264 arg4 = (
PLINT)(val4);
18269 arg5 = (
PLFLT)(val5);
18270 plscol0a(arg1,arg2,arg3,arg4,arg5);
18271 _outv = octave_value();
18288 octave_value_list _out;
18289 octave_value_list *_outp=&_out;
18290 octave_value _outv;
18299 arg1 = (
PLINT)(val1);
18304 arg2 = (
PLINT)(val2);
18309 arg3 = (
PLINT)(val3);
18311 _outv = octave_value();
18331 octave_value_list _out;
18332 octave_value_list *_outp=&_out;
18333 octave_value _outv;
18342 arg1 = (
PLINT)(val1);
18347 arg2 = (
PLINT)(val2);
18352 arg3 = (
PLINT)(val3);
18357 arg4 = (
PLFLT)(val4);
18359 _outv = octave_value();
18370 octave_value_list _out;
18371 octave_value_list *_outp=&_out;
18372 octave_value _outv;
18381 arg1 = (
PLINT)(val1);
18383 _outv = octave_value();
18394 octave_value_list _out;
18395 octave_value_list *_outp=&_out;
18396 octave_value _outv;
18405 arg1 = (
PLINT)(val1);
18407 _outv = octave_value();
18415 char *arg1 = (
char *) 0 ;
18419 octave_value_list _out;
18420 octave_value_list *_outp=&_out;
18421 octave_value _outv;
18430 arg1 = (
char *)(buf1);
18431 plsdev((
char const *)arg1);
18432 _outv = octave_value();
18453 octave_value_list _out;
18454 octave_value_list *_outp=&_out;
18455 octave_value _outv;
18464 arg1 = (
PLFLT)(val1);
18469 arg2 = (
PLFLT)(val2);
18474 arg3 = (
PLFLT)(val3);
18479 arg4 = (
PLFLT)(val4);
18481 _outv = octave_value();
18507 octave_value_list _out;
18508 octave_value_list *_outp=&_out;
18509 octave_value _outv;
18518 arg1 = (
PLINT)(val1);
18523 arg2 = (
PLINT)(val2);
18528 arg3 = (
PLINT)(val3);
18533 arg4 = (
PLINT)(val4);
18538 arg5 = (
PLFLT)(val5);
18543 arg6 = (
PLFLT)(val6);
18544 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
18545 _outv = octave_value();
18556 octave_value_list _out;
18557 octave_value_list *_outp=&_out;
18558 octave_value _outv;
18567 arg1 = (
PLFLT)(val1);
18569 _outv = octave_value();
18589 octave_value_list _out;
18590 octave_value_list *_outp=&_out;
18591 octave_value _outv;
18600 arg1 = (
PLFLT)(val1);
18605 arg2 = (
PLFLT)(val2);
18610 arg3 = (
PLFLT)(val3);
18615 arg4 = (
PLFLT)(val4);
18617 _outv = octave_value();
18637 octave_value_list _out;
18638 octave_value_list *_outp=&_out;
18639 octave_value _outv;
18648 arg1 = (
PLFLT)(val1);
18653 arg2 = (
PLFLT)(val2);
18658 arg3 = (
PLFLT)(val3);
18663 arg4 = (
PLFLT)(val4);
18665 _outv = octave_value();
18673 unsigned int arg1 ;
18674 unsigned int val1 ;
18676 octave_value_list _out;
18677 octave_value_list *_outp=&_out;
18678 octave_value _outv;
18687 arg1 = (
unsigned int)(val1);
18689 _outv = octave_value();
18700 octave_value_list _out;
18701 octave_value_list *_outp=&_out;
18702 octave_value _outv;
18711 arg1 = (char)(val1);
18713 _outv = octave_value();
18721 char *arg1 = (
char *) 0 ;
18722 char *arg2 = (
char *) 0 ;
18729 octave_value_list _out;
18730 octave_value_list *_outp=&_out;
18731 octave_value _outv;
18741 arg1 = (
char *)(buf1);
18746 arg2 = (
char *)(buf2);
18747 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
18767 octave_value_list _out;
18768 octave_value_list *_outp=&_out;
18769 octave_value _outv;
18778 arg1 = (
PLINT)(val1);
18783 arg2 = (
PLINT)(val2);
18788 arg3 = (
PLINT)(val3);
18790 _outv = octave_value();
18799 unsigned int val1 ;
18801 octave_value_list _out;
18802 octave_value_list *_outp=&_out;
18803 octave_value _outv;
18814 _outv = octave_value();
18822 char *arg1 = (
char *) 0 ;
18826 octave_value_list _out;
18827 octave_value_list *_outp=&_out;
18828 octave_value _outv;
18837 arg1 = (
char *)(buf1);
18839 _outv = octave_value();
18857 octave_value_list _out;
18858 octave_value_list *_outp=&_out;
18859 octave_value _outv;
18868 arg1 = (
PLINT)(val1);
18873 arg2 = (
PLINT)(val2);
18878 arg3 = (
PLINT)(val3);
18880 _outv = octave_value();
18891 octave_value_list _out;
18892 octave_value_list *_outp=&_out;
18893 octave_value _outv;
18899 octave_value obj = args(0);
18900 if ( !obj.is_empty() )
18902 if ( obj.is_function_handle() || obj.is_inline_function() )
18904 fcnLabelFunc = obj.function_value();
18906 else if ( obj.is_string() )
18908 nameLabelFunc = obj.string_value();
18909 fcnLabelFunc = NULL;
18923 _outv = octave_value();
18937 octave_value_list _out;
18938 octave_value_list *_outp=&_out;
18939 octave_value _outv;
18948 arg1 = (
PLFLT)(val1);
18953 arg2 = (
PLFLT)(val2);
18955 _outv = octave_value();
18969 octave_value_list _out;
18970 octave_value_list *_outp=&_out;
18971 octave_value _outv;
18980 arg1 = (
PLFLT)(val1);
18985 arg2 = (
PLFLT)(val2);
18987 _outv = octave_value();
18998 octave_value_list _out;
18999 octave_value_list *_outp=&_out;
19000 octave_value _outv;
19009 arg1 = (
PLINT)(val1);
19011 _outv = octave_value();
19037 octave_value_list _out;
19038 octave_value_list *_outp=&_out;
19039 octave_value _outv;
19048 arg1 = (
PLFLT)(val1);
19053 arg2 = (
PLFLT)(val2);
19058 arg3 = (
PLINT)(val3);
19063 arg4 = (
PLINT)(val4);
19068 arg5 = (
PLINT)(val5);
19073 arg6 = (
PLINT)(val6);
19074 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
19075 _outv = octave_value();
19083 char *arg1 = (
char *) 0 ;
19087 octave_value_list _out;
19088 octave_value_list *_outp=&_out;
19089 octave_value _outv;
19098 arg1 = (
char *)(buf1);
19100 _outv = octave_value();
19109 char *arg1 = (
char *) 0 ;
19116 octave_value_list _out;
19117 octave_value_list *_outp=&_out;
19118 octave_value _outv;
19127 arg1 = (
char *)(buf1);
19133 plspal1((
char const *)arg1,arg2);
19134 _outv = octave_value();
19146 octave_value_list _out;
19147 octave_value_list *_outp=&_out;
19148 octave_value _outv;
19159 _outv = octave_value();
19170 octave_value_list _out;
19171 octave_value_list *_outp=&_out;
19172 octave_value _outv;
19181 arg1 = (
PLINT)(val1);
19183 _outv = octave_value();
19197 octave_value_list _out;
19198 octave_value_list *_outp=&_out;
19199 octave_value _outv;
19208 arg1 = (
PLINT)(val1);
19213 arg2 = (
PLINT)(val2);
19215 _outv = octave_value();
19229 octave_value_list _out;
19230 octave_value_list *_outp=&_out;
19231 octave_value _outv;
19240 arg1 = (
PLFLT)(val1);
19245 arg2 = (
PLFLT)(val2);
19247 _outv = octave_value();
19261 octave_value_list _out;
19262 octave_value_list *_outp=&_out;
19263 octave_value _outv;
19272 arg1 = (
PLINT)(val1);
19277 arg2 = (
PLINT)(val2);
19279 _outv = octave_value();
19287 char *arg1 = (
char *) 0 ;
19297 octave_value_list _out;
19298 octave_value_list *_outp=&_out;
19299 octave_value _outv;
19308 arg1 = (
char *)(buf1);
19313 arg2 = (
PLINT)(val2);
19318 arg3 = (
PLINT)(val3);
19319 plstart((
char const *)arg1,arg2,arg3);
19320 _outv = octave_value();
19332 octave_value_list _out;
19333 octave_value_list *_outp=&_out;
19334 octave_value _outv;
19340 octave_value obj = args(0);
19341 if ( !obj.is_empty() )
19343 if ( obj.is_function_handle() || obj.is_inline_function() )
19345 fcnCoordTrans = obj.function_value();
19347 else if ( obj.is_string() )
19349 nameCoordTrans = obj.string_value();
19350 fcnCoordTrans = NULL;
19364 _outv = octave_value();
19373 PLFLT *arg2 = (PLFLT *) 0 ;
19374 PLFLT *arg3 = (PLFLT *) 0 ;
19375 char *arg4 = (
char *) 0 ;
19381 octave_value_list _out;
19382 octave_value_list *_outp=&_out;
19383 octave_value _outv;
19389 if (
_n_dims( args(0) ) > 1 )
19393 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19394 temp1 = args(0).matrix_value();
19395 arg2 = &temp1( 0, 0 );
19398 if (
_n_dims( args(1) ) > 1 )
19402 if (
_dim( args(1), 0 ) != Alen )
19406 temp3 = args(1).matrix_value();
19407 arg3 = &temp3( 0, 0 );
19413 arg4 = (
char *)(buf4);
19414 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
19415 _outv = octave_value();
19431 PLFLT *arg2 = (PLFLT *) 0 ;
19432 PLFLT *arg3 = (PLFLT *) 0 ;
19433 PLFLT *arg4 = (PLFLT *) 0 ;
19434 char *arg5 = (
char *) 0 ;
19441 octave_value_list _out;
19442 octave_value_list *_outp=&_out;
19443 octave_value _outv;
19449 if (
_n_dims( args(0) ) > 1 )
19453 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19454 temp1 = args(0).matrix_value();
19455 arg2 = &temp1( 0, 0 );
19458 if (
_n_dims( args(1) ) > 1 )
19462 if (
_dim( args(1), 0 ) != Alen )
19466 temp3 = args(1).matrix_value();
19467 arg3 = &temp3( 0, 0 );
19470 if (
_n_dims( args(2) ) > 1 )
19474 if (
_dim( args(2), 0 ) != Alen )
19478 temp4 = args(2).matrix_value();
19479 arg4 = &temp4( 0, 0 );
19485 arg5 = (
char *)(buf5);
19486 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
19487 _outv = octave_value();
19517 octave_value_list _out;
19518 octave_value_list *_outp=&_out;
19519 octave_value _outv;
19528 arg1 = (
PLINT)(val1);
19533 arg2 = (
PLINT)(val2);
19538 arg3 = (
PLFLT)(val3);
19543 arg4 = (
PLFLT)(val4);
19545 _outv = octave_value();
19556 octave_value_list _out;
19557 octave_value_list *_outp=&_out;
19558 octave_value _outv;
19567 arg1 = (
PLINT)(val1);
19569 _outv = octave_value();
19578 PLINT *arg2 = (PLINT *) 0 ;
19579 PLINT *arg3 = (PLINT *) 0 ;
19582 octave_value_list _out;
19583 octave_value_list *_outp=&_out;
19584 octave_value _outv;
19590 if (
_n_dims( args(0) ) > 1 )
19594 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19595 arg2 =
new PLINT[
Alen];
19596 temp1 = args(0).matrix_value();
19600 if (
_n_dims( args(1) ) > 1 )
19604 if (
_dim( args(1), 0 ) != Alen )
19608 temp3 = args(1).matrix_value();
19609 arg3 =
new PLINT[
Alen];
19612 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
19613 _outv = octave_value();
19627 PLFLT *arg1 = (PLFLT *) 0 ;
19628 PLFLT *arg2 = (PLFLT *) 0 ;
19635 octave_value_list _out;
19636 octave_value_list *_outp=&_out;
19637 octave_value _outv;
19643 if (
_n_dims( args(0) ) > 1 )
19647 if ( !args(0).is_empty() )
19650 temp1 = args(0).matrix_value();
19651 arg1 = &temp1( 0, 0 );
19660 if (
_n_dims( args(1) ) > 1 )
19664 if ( !args(1).is_empty() )
19666 if (
_dim( args(1), 0 ) != Alen )
19670 temp2 = args(1).matrix_value();
19671 arg2 = &temp2( 0, 0 );
19685 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
19686 _outv = octave_value();
19712 octave_value_list _out;
19713 octave_value_list *_outp=&_out;
19714 octave_value _outv;
19723 arg1 = (
PLFLT)(val1);
19728 arg2 = (
PLFLT)(val2);
19733 arg3 = (
PLFLT)(val3);
19738 arg4 = (
PLFLT)(val4);
19739 plsvpa(arg1,arg2,arg3,arg4);
19740 _outv = octave_value();
19754 octave_value_list _out;
19755 octave_value_list *_outp=&_out;
19756 octave_value _outv;
19765 arg1 = (
PLINT)(val1);
19770 arg2 = (
PLINT)(val2);
19772 _outv = octave_value();
19786 octave_value_list _out;
19787 octave_value_list *_outp=&_out;
19788 octave_value _outv;
19797 arg1 = (
PLINT)(val1);
19802 arg2 = (
PLINT)(val2);
19804 _outv = octave_value();
19813 PLFLT *arg2 = (PLFLT *) 0 ;
19814 PLFLT *arg3 = (PLFLT *) 0 ;
19820 octave_value_list _out;
19821 octave_value_list *_outp=&_out;
19822 octave_value _outv;
19828 if (
_n_dims( args(0) ) > 1 )
19832 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19833 temp1 = args(0).matrix_value();
19834 arg2 = &temp1( 0, 0 );
19837 if (
_n_dims( args(1) ) > 1 )
19841 if (
_dim( args(1), 0 ) != Alen )
19845 temp3 = args(1).matrix_value();
19846 arg3 = &temp3( 0, 0 );
19852 arg4 = (
PLINT)(val4);
19853 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
19854 _outv = octave_value();
19874 octave_value_list _out;
19875 octave_value_list *_outp=&_out;
19876 octave_value _outv;
19885 arg1 = (
PLINT)(val1);
19890 arg2 = (
PLINT)(val2);
19892 _outv = octave_value();
19900 octave_value_list _out;
19901 octave_value_list *_outp=&_out;
19902 octave_value _outv;
19908 _outv = octave_value();
19916 char *arg1 = (
char *) 0 ;
19920 octave_value_list _out;
19921 octave_value_list *_outp=&_out;
19922 octave_value _outv;
19931 arg1 = (
char *)(buf1);
19933 _outv = octave_value();
19945 octave_value_list _out;
19946 octave_value_list *_outp=&_out;
19947 octave_value _outv;
19956 arg1 = (
PLFLT)(val1);
19958 _outv = octave_value();
19981 octave_value_list _out;
19982 octave_value_list *_outp=&_out;
19983 octave_value _outv;
19992 arg1 = (
PLFLT)(val1);
19997 arg2 = (
PLFLT)(val2);
20002 arg3 = (
PLFLT)(val3);
20007 arg4 = (
PLFLT)(val4);
20012 arg5 = (
PLFLT)(val5);
20013 plvpas(arg1,arg2,arg3,arg4,arg5);
20014 _outv = octave_value();
20034 octave_value_list _out;
20035 octave_value_list *_outp=&_out;
20036 octave_value _outv;
20045 arg1 = (
PLFLT)(val1);
20050 arg2 = (
PLFLT)(val2);
20055 arg3 = (
PLFLT)(val3);
20060 arg4 = (
PLFLT)(val4);
20061 plvpor(arg1,arg2,arg3,arg4);
20062 _outv = octave_value();
20070 octave_value_list _out;
20071 octave_value_list *_outp=&_out;
20072 octave_value _outv;
20078 _outv = octave_value();
20119 octave_value_list _out;
20120 octave_value_list *_outp=&_out;
20121 octave_value _outv;
20130 arg1 = (
PLFLT)(val1);
20135 arg2 = (
PLFLT)(val2);
20140 arg3 = (
PLFLT)(val3);
20145 arg4 = (
PLFLT)(val4);
20150 arg5 = (
PLFLT)(val5);
20155 arg6 = (
PLFLT)(val6);
20160 arg7 = (
PLFLT)(val7);
20165 arg8 = (
PLFLT)(val8);
20170 arg9 = (
PLFLT)(val9);
20175 arg10 = (
PLFLT)(val10);
20180 arg11 = (
PLFLT)(val11);
20181 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
20182 _outv = octave_value();
20193 octave_value_list _out;
20194 octave_value_list *_outp=&_out;
20195 octave_value _outv;
20204 arg1 = (
PLINT)(val1);
20206 _outv = octave_value();
20226 octave_value_list _out;
20227 octave_value_list *_outp=&_out;
20228 octave_value _outv;
20237 arg1 = (
PLFLT)(val1);
20242 arg2 = (
PLFLT)(val2);
20247 arg3 = (
PLFLT)(val3);
20252 arg4 = (
PLFLT)(val4);
20253 plwind(arg1,arg2,arg3,arg4);
20254 _outv = octave_value();
20268 octave_value_list _out;
20269 octave_value_list *_outp=&_out;
20270 octave_value _outv;
20282 _outv = octave_value();
20297 char *arg2 = (
char *) 0 ;
20313 octave_value_list _out;
20314 octave_value_list *_outp=&_out;
20315 octave_value _outv;
20321 octave_value obj = args(0);
20322 if ( !obj.is_empty() )
20324 if ( obj.is_function_handle() || obj.is_inline_function() )
20326 fcnMapForm = obj.function_value();
20328 else if ( obj.is_string() )
20330 nameMapForm = obj.string_value();
20344 arg2 = (
char *)(buf2);
20349 arg3 = (
PLFLT)(val3);
20354 arg4 = (
PLFLT)(val4);
20359 arg5 = (
PLFLT)(val5);
20364 arg6 = (
PLFLT)(val6);
20365 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
20366 _outv = octave_value();
20394 octave_value_list _out;
20395 octave_value_list *_outp=&_out;
20396 octave_value _outv;
20402 octave_value obj = args(0);
20403 if ( !obj.is_empty() )
20405 if ( obj.is_function_handle() || obj.is_inline_function() )
20407 fcnMapForm = obj.function_value();
20409 else if ( obj.is_string() )
20411 nameMapForm = obj.string_value();
20425 arg2 = (
PLFLT)(val2);
20430 arg3 = (
PLFLT)(val3);
20435 arg4 = (
PLFLT)(val4);
20440 arg5 = (
PLFLT)(val5);
20445 arg6 = (
PLFLT)(val6);
20450 arg7 = (
PLFLT)(val7);
20452 _outv = octave_value();
20460 octave_value_list _out;
20461 octave_value_list *_outp=&_out;
20462 octave_value _outv;
20468 _outv = octave_value();
20476 octave_value_list _out;
20477 octave_value_list *_outp=&_out;
20478 octave_value _outv;
20484 _outv = octave_value();
20492 char *arg1 = (
char *) 0 ;
20493 char *arg2 = (
char *) 0 ;
20500 octave_value_list _out;
20501 octave_value_list *_outp=&_out;
20502 octave_value _outv;
20511 arg1 = (
char *)(buf1);
20516 arg2 = (
char *)(buf2);
20517 plSetUsage((
char const *)arg1,(
char const *)arg2);
20518 _outv = octave_value();
20528 octave_value_list _out;
20529 octave_value_list *_outp=&_out;
20530 octave_value _outv;
20536 _outv = octave_value();
20545 {
"testppchar",_wrap_testppchar,0,0,2,0},
20547 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
20550 {
"plcont0",_wrap_plcont0,0,0,2,0},
20551 {
"plcont1",_wrap_plcont1,0,0,2,0},
20552 {
"plcont2",_wrap_plcont2,0,0,2,0},
20553 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
20561 {
"plshade1",_wrap_plshade1,0,0,2,0},
20562 {
"plshade2",_wrap_plshade2,0,0,2,0},
20564 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
20565 {
"plshades1",_wrap_plshades1,0,0,2,0},
20566 {
"plshades2",_wrap_plshades2,0,0,2,0},
20568 {
"plvect1",_wrap_plvect1,0,0,2,0},
20569 {
"plvect2",_wrap_plvect2,0,0,2,0},
20570 {
"pplimage",_wrap_pplimage,0,0,2,0},
20572 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
20573 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
20574 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
20709 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
20856 #define SWIGRUNTIME_DEBUG
20866 clientdata = clientdata;
20869 if (swig_module.
next==0) {
20881 if (!module_head) {
20891 if (iter==&swig_module) {
20896 }
while (iter!= module_head);
20901 swig_module.
next = module_head->
next;
20909 if (init == 0)
return;
20912 #ifdef SWIGRUNTIME_DEBUG
20913 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
20915 for (i = 0; i < swig_module.
size; ++i) {
20920 #ifdef SWIGRUNTIME_DEBUG
20921 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
20925 if (swig_module.
next != &swig_module) {
20930 #ifdef SWIGRUNTIME_DEBUG
20931 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
20935 #ifdef SWIGRUNTIME_DEBUG
20936 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
20945 while (cast->
type) {
20949 #ifdef SWIGRUNTIME_DEBUG
20950 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
20952 if (swig_module.
next != &swig_module) {
20954 #ifdef SWIGRUNTIME_DEBUG
20955 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
20960 #ifdef SWIGRUNTIME_DEBUG
20961 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
20968 #ifdef SWIGRUNTIME_DEBUG
20969 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
20971 if (!ocast) ret = 0;
20976 #ifdef SWIGRUNTIME_DEBUG
20977 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
20988 swig_module.
types[i] = type;
20990 swig_module.
types[i] = 0;
20992 #ifdef SWIGRUNTIME_DEBUG
20993 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
20994 for (i = 0; i < swig_module.
size; ++i) {
20997 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
20998 while (cast->
type) {
20999 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
21003 printf(
"---- Total casts: %d\n",j);
21005 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21018 static int init_run = 0;
21020 if (init_run)
return;
21023 for (i = 0; i < swig_module.
size; i++) {
21031 equiv = equiv->
next;
21049 octave_value_list args;
21051 args.append(octloadfcn->fcn_file_name());
21052 feval(
"autoload", args, 0);
21056 @deftypefn {Loadable Function} {} subclass()\n\
21057 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
21058 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
21060 See the SWIG manual for usage examples.\n\
21065 for (
int j = 0; j < args.length(); ++j) {
21066 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
21069 if (!ost->is_owned()) {
21070 error(
"cannot subclass object not constructed on octave side");
21071 return octave_value_list();
21074 }
else if (args(j).is_function_handle()) {
21075 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
21076 }
else if (args(j).is_string()) {
21077 if (j + 1 >= args.length()) {
21078 error(
"member assignments must be of string,value form");
21079 return octave_value_list();
21081 top->
assign(args(j).string_value(), args(j + 1));
21084 error(
"invalid arguments to subclass()");
21085 return octave_value_list();
21092 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
21093 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
21097 if (args.length() != 1) {
21098 error(
"swig_type() must be called with only a single object");
21099 return octave_value_list();
21103 error(
"object is not a swig_ref");
21104 return octave_value_list();
21110 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
21111 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
21112 otherwise return `<unknown>'.\n\
21115 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
21116 if (args.length() != 1 || !args(0).is_string()) {
21117 error(
"swig_typequery() must be called with single string argument");
21118 return octave_value_list();
21123 return octave_value(
"<unknown>");
21124 return octave_value(type->
name);
21128 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
21129 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
21133 if (args.length() != 1) {
21134 error(
"swig_this() must be called with only a single object");
21135 return octave_value_list();
21137 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
21138 return octave_value(octave_uint64(0));
21141 error(
"object is not a swig_ref");
21142 return octave_value_list();
21144 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
21151 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
21152 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
21153 #define SWIG_OCTAVE_SEGFAULT_HACK
21156 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21157 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
21158 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
21160 _exit(exit_status);
21165 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
21166 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
21168 To load the module into the global namespace:\n\
21172 To access the module through a local variable, without loading it globally:\n\
21176 To access the module locally through a variable named, e.g. @var{modl}:\n\
21185 octave_value_list retval;
21190 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21196 #if OCTAVE_API_VERSION_NUMBER >= 37
21197 octave_value_list eval_args;
21198 eval_args.append(
"base");
21199 eval_args.append(
"function __swig_atexit__; "
21206 "__swig_atexit__; "
21207 "atexit(\"__swig_atexit__\", false); "
21208 "atexit(\"__swig_atexit__\")");
21209 feval(
"evalin", eval_args, 0);
21212 octave_swig_ref::register_type();
21213 octave_swig_packed::register_type();
21217 octave_function *me = octave_call_stack::current();
21227 for (
int j=0;swig_globals[j].
name;++j)
21229 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21237 for (
int j=0;swig_globals[j].
name;++j)
21239 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21241 for (
int j=0;swig_globals[j].
name;++j)
21242 if (swig_globals[j].
method)
21243 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21248 for (
int j=0;swig_types[j];++j)
21249 if (swig_types[j]->clientdata) {
21260 #if OCTAVE_API_VERSION_NUMBER < 37
21269 if (args.length() == 0 && nargout == 1) {
21270 retval = octave_value(module_ns->
as_value());
21274 else if (args.length() == 0 && nargout == 0) {
21276 octave_function *me = octave_call_stack::current();
21280 if (mb->second.first && mb->second.first->method) {
21283 else if (mb->second.second.is_defined()) {