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
154 #include <octave/oct.h>
155 #include <octave/Cell.h>
156 #include <octave/dynamic-ld.h>
157 #include <octave/oct-env.h>
158 #include <octave/oct-map.h>
159 #include <octave/ov-fcn-handle.h>
160 #include <octave/parse.h>
161 #include <octave/toplev.h>
162 #include <octave/unwind-prot.h>
173 #define SWIG_RUNTIME_VERSION "4"
176 #ifdef SWIG_TYPE_TABLE
177 # define SWIG_QUOTE_STRING(x) #x
178 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
179 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
181 # define SWIG_TYPE_TABLE_NAME
194 # define SWIGRUNTIME SWIGINTERN
197 #ifndef SWIGRUNTIMEINLINE
198 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
202 #ifndef SWIG_BUFFER_SIZE
203 # define SWIG_BUFFER_SIZE 1024
207 #define SWIG_POINTER_DISOWN 0x1
208 #define SWIG_CAST_NEW_MEMORY 0x2
211 #define SWIG_POINTER_OWN 0x1
294 #define SWIG_ERROR (-1)
295 #define SWIG_IsOK(r) (r >= 0)
296 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
299 #define SWIG_CASTRANKLIMIT (1 << 8)
301 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
303 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
305 #define SWIG_BADOBJ (SWIG_ERROR)
306 #define SWIG_OLDOBJ (SWIG_OK)
307 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
308 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
310 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
311 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
312 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
313 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
314 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
315 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
318 #if defined(SWIG_CASTRANK_MODE)
319 # ifndef SWIG_TypeRank
320 # define SWIG_TypeRank unsigned long
322 # ifndef SWIG_MAXCASTRANK
323 # define SWIG_MAXCASTRANK (2)
325 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
326 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
331 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
334 # define SWIG_AddCast(r) (r)
335 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
345 typedef void *(*swig_converter_func)(
void *,
int *);
387 const char *f2,
const char *l2) {
388 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
389 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
390 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
391 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
393 return (
int)((l1 - f1) - (l2 - f2));
403 const char* te = tb + strlen(tb);
405 while (equiv != 0 && *ne) {
406 for (nb = ne; *ne; ++ne) {
407 if (*ne ==
'|')
break;
432 if (strcmp(iter->
type->
name, c) == 0) {
433 if (iter == ty->
cast)
459 if (iter->
type == from) {
460 if (iter == ty->
cast)
492 if (!ty || !ty->
dcast)
return ty;
493 while (ty && (ty->
dcast)) {
494 ty = (*ty->
dcast)(ptr);
518 if (!type)
return NULL;
519 if (type->
str != NULL) {
520 const char *last_name = type->
str;
522 for (s = type->
str; *s; s++)
523 if (*s ==
'|') last_name = s+1;
570 register size_t l = 0;
571 register size_t r = iter->
size - 1;
574 register size_t i = (l + r) >> 1;
575 const char *iname = iter->
types[i]->
name;
577 register int compare = strcmp(name, iname);
579 return iter->
types[i];
580 }
else if (compare < 0) {
586 }
else if (compare > 0) {
595 }
while (iter != end);
621 register size_t i = 0;
622 for (; i < iter->
size; ++i) {
624 return iter->
types[i];
627 }
while (iter != end);
639 static const char hex[17] =
"0123456789abcdef";
640 register const unsigned char *u = (
unsigned char *) ptr;
641 register const unsigned char *eu = u + sz;
642 for (; u != eu; ++u) {
643 register unsigned char uu = *u;
644 *(c++) = hex[(uu & 0xf0) >> 4];
645 *(c++) = hex[uu & 0xf];
655 register unsigned char *u = (
unsigned char *) ptr;
656 register const unsigned char *eu = u + sz;
657 for (; u != eu; ++u) {
658 register char d = *(c++);
659 register unsigned char uu;
660 if ((d >=
'0') && (d <=
'9'))
661 uu = ((d -
'0') << 4);
662 else if ((d >=
'a') && (d <=
'f'))
663 uu = ((d - (
'a'-10)) << 4);
667 if ((d >=
'0') && (d <=
'9'))
669 else if ((d >=
'a') && (d <=
'f'))
670 uu |= (d - (
'a'-10));
684 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
687 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
695 if (strcmp(c,
"NULL") == 0) {
708 size_t lname = (name ? strlen(name) : 0);
709 if ((2*sz + 2 + lname) > bsz)
return 0;
713 strncpy(r,name,lname+1);
723 if (strcmp(c,
"NULL") == 0) {
738 #define SWIG_UnknownError -1
739 #define SWIG_IOError -2
740 #define SWIG_RuntimeError -3
741 #define SWIG_IndexError -4
742 #define SWIG_TypeError -5
743 #define SWIG_DivisionByZero -6
744 #define SWIG_OverflowError -7
745 #define SWIG_SyntaxError -8
746 #define SWIG_ValueError -9
747 #define SWIG_SystemError -10
748 #define SWIG_AttributeError -11
749 #define SWIG_MemoryError -12
750 #define SWIG_NullReferenceError -13
755 #include <octave/version.h>
756 #ifndef OCTAVE_API_VERSION_NUMBER
759 #define ComplexLU __ignore
760 #include <octave/CmplxLU.h>
762 #ifdef octave_Complex_LU_h
763 # define OCTAVE_API_VERSION_NUMBER 36
765 # define OCTAVE_API_VERSION_NUMBER 37
770 #if OCTAVE_API_VERSION_NUMBER < 37
771 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
773 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
777 if (num_args > max_args && !varargs)
778 error(
"function %s takes at most %i arguments", func_name, max_args);
779 else if (num_args < min_args)
780 error(
"function %s requires at least %i arguments", func_name, min_args);
794 return "SWIG_MemoryError";
796 return "SWIG_IOError";
798 return "SWIG_RuntimeError";
800 return "SWIG_IndexError";
802 return "SWIG_TypeError";
804 return "SWIG_DivisionByZero";
806 return "SWIG_OverflowError";
808 return "SWIG_SyntaxError";
810 return "SWIG_ValueError";
812 return "SWIG_SystemError";
814 return "SWIG_AttributeError";
816 return "SWIG unknown error";
822 r +=
" (" + type.string_value() +
")";
824 return octave_value(r);
827 #define SWIG_fail goto fail
829 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
830 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
831 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
832 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
833 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
834 #define swig_owntype int
836 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
837 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
839 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
840 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
842 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
843 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
845 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
846 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
847 #define SWIG_MODULE_CLIENTDATA_TYPE void*
849 #define Octave_Error_Occurred() 0
850 #define SWIG_Octave_AddErrorMsg(msg) {;}
856 #define SWIG_POINTER_EXCEPTION 0
857 #define SWIG_arg_fail(arg) 0
865 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
870 #ifdef SWIG_DIRECTORS
874 typedef std::map < void *, Director * > rtdir_map;
891 #ifdef SWIG_DIRECTORS
892 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
893 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
894 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
941 std::vector < type_ptr_pair >
types;
945 typedef std::map < std::string, member_value_pair >
member_map;
973 member_map::iterator it =
members.find(name);
977 for (
unsigned int j = 0; j <
types.size(); ++j)
979 return &
members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
980 if (!insert_if_not_found)
987 for (
unsigned int j = 0; j <
types.size(); ++j) {
988 assert(
types[j].first->clientdata);
990 if (cj->
name == name)
991 return types[j].first;
1008 if (cj->
name == name)
1016 if (out.find(m->name) == out.end())
1017 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1037 for (
unsigned int j = 0; j <
types.size(); ++j)
1038 if (
types[j].first->clientdata)
1043 if (m->second.is_defined())
1044 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1045 else if (m->first && m->first->method)
1046 return m->first->method(args, nargout);
1047 error(
"member not defined or not invocable");
1048 return octave_value_list();
1053 if (!m || m->first->is_static() || m->first->is_global())
1055 octave_value_list args;
1058 if (argout.length() < 1)
1066 if (!m || m->first->is_static() || m->first->is_global())
1068 octave_value_list args;
1072 if (argout.length() < 1)
1078 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret) {
1080 if (!m || m->first->is_static() || m->first->is_global())
1082 octave_value_list args;
1086 if (argout.length() >= 1)
1092 if (m->second.is_defined())
1094 else if (m->first) {
1095 if (m->first->get_method)
1096 return m->first->get_method(args, 1);
1097 else if (m->first->method)
1098 return octave_value(
new octave_builtin(m->first->method));
1100 error(
"undefined member");
1101 return octave_value_list();
1106 return octave_value((octave_base_value *) &x);
1114 bool _always_static =
false)
1118 types.push_back(std::make_pair(_type, _ptr));
1119 #ifdef SWIG_DIRECTORS
1121 Swig::Director *d = Swig::get_rtdir(_ptr);
1123 Swig::swig_director_set_self(d,
this);
1131 for (
unsigned int j = 0; j <
types.size(); ++j) {
1132 if (!
types[j].first || !
types[j].first->clientdata)
1140 #ifdef SWIG_DIRECTORS
1141 for (
unsigned int j = 0; j <
types.size(); ++j)
1142 Swig::erase_rtdir(
types[j].second.ptr);
1152 if (!m)
return dim_vector(1,1);
1155 octave_value_list inarg;
1157 octave_value_list outarg = nc_this->
member_invoke(m, inarg, 1);
1160 if (outarg.length() < 1)
return dim_vector(1,1);
1162 octave_value & out = outarg(0);
1165 if (out.is_cell()) {
1166 const Cell & c=out.cell_value();
1167 int ndim = c.rows();
1168 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1171 d.resize(ndim < 2 ? 2 : ndim);
1175 for (
int k=0;k<ndim;k++) {
1176 const octave_value& obj = c(k);
1177 d.elem(k) = obj.int_value();
1180 if (error_state)
return dim_vector(1,1);
1183 }
else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1184 if (out.rows()==1 || out.columns()==1) {
1185 Array<int>
a = out.int_vector_value();
1186 if (error_state)
return dim_vector(1,1);
1188 d.resize(a.numel() < 2 ? 2 : a.numel());
1190 for (
int k=0;k<a.numel();k++) {
1195 return dim_vector(1,1);
1198 return dim_vector(1,1);
1219 return (
long)
types[0].second.ptr;
1224 if (!
types[0].first->clientdata)
1234 for (
unsigned int j = 0; j <
types.size(); ++j) {
1237 if (
types[j].first->clientdata) {
1241 ret +=
types[j].first->name;
1248 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1249 assert(!rhs.
types[j].second.destroyed);
1250 #ifdef SWIG_DIRECTORS
1251 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1253 Swig::swig_director_set_self(d,
this);
1271 if (!type &&
types.size())
1272 return types[0].second.ptr;
1273 for (
unsigned int j = 0; j <
types.size(); ++j)
1274 if (type ==
types[j].first)
1275 return types[j].second.ptr;
1276 for (
unsigned int j = 0; j <
types.size(); ++j) {
1292 #ifdef SWIG_DIRECTORS
1293 void director_destroyed(Swig::Director *d) {
1295 for (
unsigned int j = 0; j <
types.size(); ++j) {
1296 Swig::Director *dj = Swig::get_rtdir(
types[j].second.ptr);
1298 types[j].second.destroyed =
true;
1311 members[
name] = std::make_pair(m, octave_value());
1334 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1335 octave_value_list ovl =
subsref(ops, idx, 1);
1336 return ovl.length()? ovl(0) : octave_value();
1339 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1340 assert(ops.size() > 0);
1341 assert(ops.size() == idx.size());
1343 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1345 octave_value_list sub_ovl;
1352 error(
"cannot create instance");
1353 return octave_value_list();
1355 octave_value_list args;
1358 args.append(*idx_it++);
1363 else if (ops[skip] ==
'.') {
1364 std::string subname;
1367 octave_value_list subname_ovl(*idx_it++);
1369 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1370 subname = subname_ovl(0).string_value();
1373 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1379 if (!base || !(m->first =
find_member(base, subname)))
1382 error(
"member not found");
1383 return octave_value_list();
1386 octave_value_list args;
1388 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1390 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1391 ((m->first && m->first->method) || m->second.is_function() ||
1392 m->second.is_function_handle())) {
1393 args.append(*idx_it++);
1402 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1403 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1404 octave_value_list args;
1405 args.append(*idx_it++);
1408 error(
"error evaluating index operator");
1409 return octave_value_list();
1412 error(
"unsupported subsref");
1413 return octave_value_list();
1417 if (skip >= (
int) ops.size())
1419 if (sub_ovl.length() < 1) {
1420 error(
"bad subs ref");
1421 return octave_value_list();
1423 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1426 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1427 assert(ops.size() > 0);
1428 assert(ops.size() == idx.size());
1430 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1433 if (ops.size() > 1) {
1434 std::list < octave_value_list >::const_iterator last = idx.end();
1436 std::list < octave_value_list > next_idx(idx.begin(), last);
1437 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1438 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1441 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1442 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1445 octave_value_list args;
1447 args.append(*idx_it);
1451 error(
"%s member not found", op_name);
1454 else if (ops[skip] ==
'.') {
1455 octave_value_list subname_ovl(*idx_it++);
1457 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1458 std::string subname = subname_ovl(0).string_value();
1461 if (!m->first || !m->first->set_method) {
1464 }
else if (m->first->set_method) {
1465 octave_value_list args;
1466 if (!m->first->is_static() && !m->first->is_global())
1469 m->first->set_method(args, 1);
1471 error(
"member not assignable");
1473 error(
"unsupported subsasgn");
1491 error(
"__str__ method not defined");
1492 return std::string();
1495 if (outarg.length() < 1 || !outarg(0).is_string()) {
1496 error(
"__str__ method did not return a string");
1497 return std::string();
1499 return outarg(0).string_value();
1502 #if OCTAVE_API_VERSION_NUMBER >= 40
1504 return octave_map();
1508 return Octave_map();
1516 string_vector keys(tmp.size());
1518 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1519 keys(k++) = it->first;
1537 oct_mach_info::float_format fmt) {
1541 #if defined (HAVE_HDF5)
1543 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1548 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1553 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1561 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1565 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1568 ret = fcn->do_multi_index_op(1, args)(0);
1577 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1580 octave_value_list args;
1585 error(
"could not dispatch unary operator");
1586 return octave_value();
1589 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1594 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1597 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1598 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1600 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1603 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1608 octave_value_list args;
1639 error(
"could not dispatch binary operator");
1640 return octave_value();
1643 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1653 os <<
"{"; newline(os);
1654 increment_indent_level();
1655 for (
unsigned int j = 0; j <
types.size(); ++j) {
1657 if (
types[j].first->clientdata) {
1659 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1661 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1664 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1666 if (it->second.first) {
1667 const char *objtype = it->second.first->method ?
"method" :
"variable";
1668 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1669 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1670 assert(it->second.first->name == it->first);
1672 os << it->first; newline(os);
1675 decrement_indent_level();
1677 os <<
"}"; newline(os);
1720 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
1723 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1726 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1738 #if OCTAVE_API_VERSION_NUMBER >= 40
1759 oct_mach_info::float_format fmt)
1762 #if defined (HAVE_HDF5)
1764 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
1765 {
return ptr->save_hdf5(loc_id, name, save_as_floats); }
1768 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug)
1769 {
return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1772 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
1778 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const
1779 {
return ptr->
print(os, pr_as_read_syntax); }
1794 :
type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len) {
1798 if (outtype && outtype !=
type)
1800 assert(sz <=
buf.size());
1801 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
1817 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1819 os <<
"swig packed type: name = " << (
type ?
type->
name : std::string()) <<
", len = " <<
buf.size(); newline(os);
1836 oct_mach_info::float_format fmt) {
1840 #if defined (HAVE_HDF5)
1842 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats) {
1847 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug) {
1860 error(
"attempt to set immutable member variable");
1861 return octave_value_list();
1869 :
ovl(_ovl),
j(_j) { }
1871 operator octave_value()
const {
1888 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1889 ov = ov.cell_value()(0);
1894 if (ov.type_id() != octave_swig_ref::static_type_id())
1903 #define swig_unary_op(name) \
1904 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1905 return octave_swig_type::dispatch_unary_op(x,#name); \
1907 #define swig_binary_op(name) \
1908 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1909 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1911 #define swigreg_unary_op(name) \
1912 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1913 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1914 #define swigreg_binary_op(name) \
1915 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1916 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1985 for (
int j = 0; j < tid; ++j) {
1994 #ifdef SWIG_DIRECTORS
1995 Swig::Director *d = Swig::get_rtdir(ptr);
1996 if (d && Swig::swig_director_get_self(d))
1997 return Swig::swig_director_get_self(d)->as_value();
2003 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2004 ov = ov.cell_value()(0);
2005 if (!ov.is_defined() ||
2006 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2011 if (ov.type_id() != octave_swig_ref::static_type_id())
2015 void *vptr = ost->
cast(type, own, flags);
2028 if (!ov.is_defined())
2030 if (ov.type_id() != octave_swig_packed::static_type_id())
2037 module_ns->
assign(name, ov);
2041 return get_global_value(name,
true);
2045 set_global_value(name, value);
2049 #if OCTAVE_API_VERSION_NUMBER < 37
2050 link_to_global_variable(curr_sym_tab->lookup(name,
true));
2052 symbol_table::varref(name);
2053 symbol_table::mark_global(name);
2059 if (!ov.is_defined() ||
2060 ov.type_id() != octave_swig_packed::static_type_id())
2076 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2078 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2084 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2085 #define SWIGTYPE_p_char swig_types[1]
2086 #define SWIGTYPE_p_double swig_types[2]
2087 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2088 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2089 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2090 #define SWIGTYPE_p_int swig_types[6]
2091 #define SWIGTYPE_p_p_char swig_types[7]
2092 #define SWIGTYPE_p_unsigned_int swig_types[8]
2095 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2096 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2101 #define SWIGVERSION 0x020011
2102 #define SWIG_VERSION SWIGVERSION
2105 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2106 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2109 #include <stdexcept>
2119 #ifdef OCTAVE_EXPORT
2120 #if defined ( __GNUC__ ) && __GNUC__ > 3
2121 #undef OCTAVE_EXPORT
2122 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2142 return a >= b ? a : b;
2146 return a >= b ? a : b;
2160 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2172 if (
max( o_obj.columns(), 1 ) > 1 )
2177 else if (
max( o_obj.rows(), 1 ) > 1 )
2187 _dim(
const octave_value &o_obj,
int dim_idx )
2190 return max( o_obj.rows(), 0 );
2194 else if ( dim_idx == 1 )
2195 return max( o_obj.columns(), 0 );
2208 template <
class FLOAT>
2212 while ( n_el-- > 0 )
2213 *out_arr++ = (FLOAT) ( *in_arr++ );
2219 template void _cvt_double_to(
unsigned long *,
double *,
unsigned );
2221 template void _cvt_double_to(
unsigned short *,
double *,
unsigned );
2232 template <
class FLOAT>
2236 while ( n_el-- > 0 )
2237 *d_arr++ = double(*arr++);
2243 template void _cvt_to_double(
unsigned long *,
double *,
unsigned );
2245 template void _cvt_to_double(
unsigned short *,
double *,
unsigned );
2268 octave_value_list functionArguments;
2269 octave_value_list retval;
2276 for ( i = 0; i < n; i++ )
2282 functionArguments( 0 ) = xin;
2283 functionArguments( 1 ) = yin;
2285 if ( fcnMapForm != NULL )
2286 retval = feval( fcnMapForm, functionArguments, 1 );
2288 retval = feval( nameMapForm, functionArguments, 1 );
2291 if ( retval.length() >= 2 )
2293 xout = retval( 0 ).matrix_value();
2294 yout = retval( 1 ).matrix_value();
2296 for ( i = 0; i < n; i++ )
2298 x[i] = xout( i, 0 );
2299 y[i] = yout( i, 0 );
2311 octave_value_list functionArguments;
2312 octave_value_list retval;
2314 Matrix inAxis( 1, 1 );
2315 Matrix inValue( 1, 1 );
2316 inAxis( 0, 0 ) = axis;
2317 inValue( 0, 0 ) =
value;
2319 functionArguments( 0 ) = inAxis;
2320 functionArguments( 1 ) = inValue;
2322 if ( fcnLabelFunc != NULL )
2323 retval = feval( fcnLabelFunc, functionArguments, 1 );
2325 retval = feval( nameLabelFunc, functionArguments, 1 );
2327 strncpy( label, retval( 0 ).string_value().c_str(), length );
2337 octave_value_list functionArguments;
2338 octave_value_list retval;
2348 functionArguments( 0 ) = xin;
2349 functionArguments( 1 ) = yin;
2351 if ( fcnCoordTrans != NULL )
2352 retval = feval( fcnCoordTrans, functionArguments, 1 );
2354 retval = feval( nameCoordTrans, functionArguments, 1 );
2357 if ( retval.length() >= 2 )
2359 xout = retval( 0 ).matrix_value();
2360 yout = retval( 1 ).matrix_value();
2371 printf(
"nlegend =%d\n", nlegend );
2372 for ( i = 0; i < nlegend; i++ )
2374 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2375 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen( text[i] ) );
2376 printf(
"text[%d] =%s\n", i, text[i] );
2382 #if !defined(SWIG_NO_LLONG_MAX)
2383 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2384 # define LLONG_MAX __LONG_LONG_MAX__
2385 # define LLONG_MIN (-LLONG_MAX - 1LL)
2386 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2393 if (!ov.is_scalar_type())
2395 if (ov.is_complex_scalar())
2397 if (ov.is_double_type()||ov.is_single_type()) {
2398 double v=ov.double_value();
2403 *val = ov.long_value();
2414 if ((v < INT_MIN || v > INT_MAX)) {
2417 if (val) *val = (int)(v);
2424 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 )
2432 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2440 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2441 ov = ov.cell_value()(0);
2442 if (!ov.is_string())
2445 std::string str=ov.string_value();
2446 size_t len=str.size();
2447 char* cstr=(
char*)str.c_str();
2449 *cptr = (
char*)(memcpy((
new char[len + 1]), cstr,
sizeof(
char)*(len + 1)));
2464 return octave_value(value);
2477 return octave_value(value);
2486 gin.
dX = x_in; gin.
dY = y_in;
2488 *x = gin.
wX; *y = gin.
wY;
2495 if (!ov.is_scalar_type())
2497 if (ov.is_complex_scalar())
2500 *val = ov.double_value();
2509 PLFLT xlpos, PLFLT ylpos,
2511 PLINT colbox, PLINT collab,
2512 const PLINT *colline,
const PLINT *styline,
2513 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2514 const char *labx,
const char *laby,
const char *labtop )
2516 const char *legline[4];
2517 legline[0] = legline1; legline[1] = legline2;
2518 legline[2] = legline3; legline[3] = legline4;
2519 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2520 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2521 labx, laby, labtop );
2539 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2540 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2545 #define f2c( f, ff, nx, ny ) \
2547 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2548 for ( int i = 0; i < nx; i++ ) { \
2549 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2550 for ( int j = 0; j < ny; j++ ) \
2551 *( ff[i] + j ) = *( f + nx * j + i );}
2555 void my_plcont(
const PLFLT *f, PLINT
nx, PLINT
ny, PLINT kx, PLINT lx, PLINT ky,
2556 PLINT ly,
const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2558 f2c( f, ff, nx, ny );
2559 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2565 PLINT ly,
const PLFLT *clevel, PLINT nlevel )
2567 f2c( f, ff, nx, ny );
2568 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2574 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2578 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2579 f2c( f, ff, nx, ny );
2580 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2585 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2588 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2590 grid2.
xg = xgg; grid2.
yg = ygg;
2591 f2c( f, ff, nx, ny );
2592 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2598 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *
xg,
const PLFLT *
yg )
2601 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2603 grid2.
xg = xgg; grid2.
yg = ygg;
2604 f2c( f, ff, nx, ny );
2605 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2610 const PLFLT *
xg,
int nptsx,
const PLFLT *
yg,
int nptsy,
2611 PLFLT *zg,
int type, PLFLT data )
2613 f2c( zg, zgg, nptsx, nptsy );
2614 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2615 for (
int i = 0; i < nptsx; i++ )
2616 for (
int j = 0; j < nptsy; j++ )
2617 *( zg + nptsx * j + i ) = zgg[i][j];
2625 f2c( z, zz, nx, ny );
2626 c_plmesh( x, y, (
const PLFLT **) zz, nx, ny, opt );
2631 void my_plmeshc(
const PLFLT *
x,
const PLFLT *
y,
const PLFLT *z, PLINT
nx, PLINT
ny, PLINT
opt,
const PLFLT *clevel, PLINT nlevel )
2633 f2c( z, zz, nx, ny );
2634 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2640 PLINT
nx, PLINT
ny, PLINT
opt, PLINT side )
2642 f2c( z, zz, nx, ny )
2643 c_plot3d( x, y, (
const PLFLT **) zz, nx, ny, opt, side );
2648 PLINT
nx, PLINT
ny, PLINT
opt,
2649 const PLFLT *clevel, PLINT nlevel )
2651 f2c( z, zz, nx, ny )
2652 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2657 PLINT
nx, PLINT
ny, PLINT
opt,
const PLFLT *clevel, PLINT nlevel )
2659 f2c( z, zz, nx, ny )
2660 c_plsurf3d( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2671 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2672 PLFLT shade_min, PLFLT shade_max,
2673 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2674 PLINT min_color, PLINT min_width,
2675 PLINT max_color, PLINT max_width,
2676 PLINT rectangular, PLFLT *tr )
2678 f2c( a, aa, nx, ny );
2679 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2680 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2681 min_color, min_width, max_color, max_width,
2687 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2688 PLFLT shade_min, PLFLT shade_max,
2689 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2690 PLINT min_color, PLINT min_width,
2691 PLINT max_color, PLINT max_width,
2692 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2696 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
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 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2716 grid2.
xg = xgg; grid2.
yg = ygg;
2717 f2c( a, aa, nx, ny );
2718 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2719 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2720 min_color, min_width, max_color, max_width,
2727 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2728 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2732 f2c( a, aa, nx, ny );
2733 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2734 clevel, nlevel, fill_width, cont_color, cont_width,
2735 plfill, rectangular, NULL, NULL );
2739 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2740 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2742 PLINT rectangular, PLFLT *tr )
2744 f2c( a, aa, nx, ny );
2745 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2746 clevel, nlevel, fill_width, cont_color, cont_width,
2751 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2752 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2754 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2758 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2760 f2c( a, aa, nx, ny );
2761 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2762 clevel, nlevel, fill_width, cont_color, cont_width,
2767 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2768 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2770 PLINT rectangular,
const PLFLT *
xg,
const PLFLT *
yg )
2773 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2775 grid2.
xg = xgg; grid2.
yg = ygg;
2776 f2c( a, aa, nx, ny );
2777 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2778 clevel, nlevel, fill_width, cont_color, cont_width,
2786 void my_plvect(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT
ny, PLFLT scale, PLFLT *tr )
2788 f2c( u, uu, nx, ny );
2789 f2c( v, vv, nx, ny );
2790 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
xform, tr );
2794 void my_plvect1(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT
ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2798 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2799 f2c( u, uu, nx, ny );
2800 f2c( v, vv, nx, ny );
2801 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr1, &grid1 );
2805 void my_plvect2(
const PLFLT *u,
const PLFLT *v, PLINT
nx, PLINT
ny, PLFLT scale,
const PLFLT *
xg,
const PLFLT *
yg )
2808 f2c( xg, xgg, nx, ny );
f2c( yg, ygg, nx, ny );
2810 grid2.
xg = xgg; grid2.
yg = ygg;
2811 f2c( u, uu, nx, ny );
2812 f2c( v, vv, nx, ny );
2813 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr2, &grid2 );
2820 PLFLT zmin, PLFLT zmax,
2821 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2823 f2c( a, aa, nx, ny );
2824 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2831 PLFLT zmin, PLFLT zmax,
2832 PLFLT valuemin, PLFLT valuemax )
2834 f2c( a, aa, nx, ny );
2835 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2840 PLFLT zmin, PLFLT zmax,
2841 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2843 f2c( a, aa, nx, ny );
2844 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
2850 PLFLT zmin, PLFLT zmax,
2851 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2854 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
2855 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2856 f2c( a, aa, nx, ny );
2857 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
2863 PLFLT zmin, PLFLT zmax,
2864 PLFLT valuemin, PLFLT valuemax,
const PLFLT *
xg,
const PLFLT *
yg )
2867 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2868 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
2869 grid2.
xg = xgg; grid2.
yg = ygg;
2870 f2c( a, aa, nx, ny );
2871 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
2890 for ( i = 0; i <
nx; i++ )
2891 if ( n_values[i] > ny )
2893 f2c( a, aa, nx, ny );
2895 opt, position, x, y,
2897 bg_color, bb_color, bb_style,
2898 low_cap_color, high_cap_color,
2899 cont_color, cont_width,
2900 n_labels, label_opts, label,
2910 if (!ov.is_scalar_type())
2912 if (ov.is_complex_scalar())
2914 if (ov.is_double_type()||ov.is_single_type()) {
2915 double v=ov.double_value();
2921 if (ov.is_int8_type()||ov.is_int16_type()||
2922 ov.is_int32_type()) {
2923 long v=ov.long_value();
2927 if (ov.is_int64_type()) {
2928 long long v=ov.int64_scalar_value().value();
2933 *val = ov.ulong_value();
2944 if ((v > UINT_MAX)) {
2947 if (val) *val = (
unsigned int)(v);
2956 return octave_value(value);
2970 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
2973 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
2974 if (csize <= size) {
2976 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
2977 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
2994 static int init = 0;
3007 return std::string(carray,carray+size);
3019 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3020 if (val) *val = (char)(v);
3030 Specify viewport in absolute coordinates \n\
3034 Alternate routine to plvpor for setting up the viewport. This routine\n\
3035 should be used only if the viewport is required to have a definite\n\
3036 size in millimeters. The routine plgspa is useful for finding out the\n\
3037 size of the current subpage. \n\
3039 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3041 This function is used in example 10. \n\
3047 plsvpa(xmin, xmax, ymin, ymax)\n\
3051 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3052 viewport from the left-hand edge of the subpage in millimeters. \n\
3054 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3055 viewport from the left-hand edge of the subpage in millimeters. \n\
3057 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3058 viewport from the bottom edge of the subpage in millimeters. \n\
3060 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3061 from the bottom edge of the subpage in millimeters. \n\
3064 Write text relative to viewport boundaries in 3D plots. \n\
3068 Writes text at a specified position relative to the viewport\n\
3069 boundaries. Text may be written inside or outside the viewport, but\n\
3070 is clipped at the subpage boundaries. The reference point of a string\n\
3071 lies along a line passing through the string at half the height of a\n\
3072 capital letter. The position of the reference point along this line\n\
3073 is determined by just, and the position of the reference point\n\
3074 relative to the viewport is set by disp and pos. \n\
3076 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3078 This function is used in example 28. \n\
3084 plmtex3(side, disp, pos, just, text)\n\
3088 side (const char *, input) : Specifies the side of the viewport\n\
3089 along which the text is to be written. The string should contain\n\
3090 one or more of the following characters: [xyz][ps][v]. Only one\n\
3091 label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3092 both the X and Y axes. x: Label the X axis. \n\
3093 y: Label the Y axis. \n\
3094 z: Label the Z axis. \n\
3095 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3096 For X it is the axis that starts at y-min. For Y it is the\n\
3097 axis that starts at x-min. \n\
3098 s: Label the secondary axis. \n\
3099 v: Draw the text perpendicular to the axis. \n\
3102 disp (PLFLT, input) : Position of the reference point of string,\n\
3103 measured outwards from the specified viewport edge in units of the\n\
3104 current character height. Use negative disp to write within the\n\
3107 pos (PLFLT, input) : Position of the reference point of string\n\
3108 along the specified edge, expressed as a fraction of the length of\n\
3111 just (PLFLT, input) : Specifies the position of the string relative\n\
3112 to its reference point. If just=0., the reference point is at the\n\
3113 left and if just=1., it is at the right of the string. Other\n\
3114 values of just give intermediate justifications. \n\
3116 text (const char *, input) : The string to be written out. \n\
3119 Set color map1 colors using 8-bit RGB values and double alpha values. \n\
3123 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3124 documentation) and double alpha values. This also sets the number of\n\
3127 This function is used in example 31. \n\
3133 plscmap1a(r, g, b, a, ncol1)\n\
3137 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3138 integers (0-255) representing the degree of red in the color. \n\
3140 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3141 integers (0-255) representing the degree of green in the color. \n\
3143 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3144 integers (0-255) representing the degree of blue in the color. \n\
3146 a (PLFLT *, input) : Pointer to array with set of double values\n\
3147 (0.0-1.0) representing the alpha value of the color. \n\
3149 ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n\
3153 Select standard viewport \n\
3157 Sets up a standard viewport, leaving a left-hand margin of seven\n\
3158 character heights, and four character heights around the other three\n\
3161 Redacted form: plvsta()\n\
3163 This function is used in examples 1,12,14,17,25,29. \n\
3172 Switch to graphics screen \n\
3176 Sets an interactive device to graphics mode, used in conjunction with\n\
3177 pltext to allow graphics and text to be interspersed. On a device\n\
3178 which supports separate text and graphics windows, this command causes\n\
3179 control to be switched to the graphics window. If already in graphics\n\
3180 mode, this command is ignored. It is also ignored on devices which\n\
3181 only support a single window or use a different method for shifting\n\
3182 focus. See also pltext. \n\
3184 Redacted form: plgra()\n\
3186 This function is used in example 1. \n\
3195 Set a given color from color map0 by 8 bit RGB value and double alpha value. \n\
3199 Set a given color by 8-bit RGB value and double alpha value for color \n\
3200 map0 (see the PLplot documentation). Overwrites the previous color\n\
3201 value for the given index and, thus, does not result in any\n\
3202 additional allocation of space for colors. \n\
3204 This function is used in example 30. \n\
3210 plscol0a(icol0, r, g, b, a)\n\
3214 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3215 number of colors (which is set by default, by plscmap0n, or even\n\
3218 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3219 degree of red in the color. \n\
3221 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3222 degree of green in the color. \n\
3224 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3225 degree of blue in the color. \n\
3227 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
3228 value of the color. \n\
3231 Set y axis parameters \n\
3235 Identical to plsxax, except that arguments are flags for y axis. See\n\
3236 the description of plsxax for more detail. \n\
3238 Redacted form: plsyax(digmax, digits)\n\
3240 This function is used in examples 1,14,31. \n\
3246 plsyax(digmax, digits)\n\
3250 digmax (PLINT, input) : Variable to set the maximum number of\n\
3251 digits for the y axis. If nonzero, the printed label will be\n\
3252 switched to a floating point representation when the number of\n\
3253 digits exceeds digmax. \n\
3255 digits (PLINT, input) : Field digits value. Currently, changing\n\
3256 its value here has no effect since it is set only by plbox or\n\
3257 plbox3. However, the user may obtain its value after a call to\n\
3258 either of these functions by calling plgyax. \n\
3261 Returns 8-bit RGB values for given color from color map0 \n\
3265 Returns 8-bit RGB values (0-255) for given color from color map0 (see\n\
3266 the PLplot documentation).\tValues are negative if an invalid color id\n\
3269 Redacted form: plgcol0(icol0, r, g, b)\n\
3271 This function is used in example 2. \n\
3277 plgcol0(icol0, r, g, b)\n\
3281 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3283 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3285 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3287 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3290 Set seed for internal random number generator. \n\
3294 Set the seed for the internal random number generator. See plrandd for\n\
3295 further details. \n\
3297 Redacted form: plseed(seed)\n\
3299 This function is used in example 21. \n\
3309 seed (unsigned int, input) : Seed for random number generator. \n\
3312 Get output file name \n\
3316 Gets the current output file name, if applicable. \n\
3318 Redacted form: plgfnam(fnam)\n\
3320 This function is used in example 31. \n\
3330 fnam (char *, output) : Pointer to file name string (a preallocated\n\
3331 string of 80 characters or more). \n\
3334 Specify world coordinates of viewport boundaries \n\
3338 Sets up the world coordinates of the edges of the viewport. \n\
3340 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3342 This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3348 plwind(xmin, xmax, ymin, ymax)\n\
3352 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3353 of the viewport. \n\
3355 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3356 of the viewport. \n\
3358 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3361 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3365 Set color map1 colors using a piece-wise linear relationship \n\
3369 Set color map1 colors using a piece-wise linear relationship between\n\
3370 position in the color map (from 0 to 1) and position in HLS or RGB\n\
3371 color space (see the PLplot documentation). May be called at any\n\
3374 The idea here is to specify a number of control points that define the\n\
3375 mapping between palette 1 input positions (intensities) and HLS (or\n\
3376 RGB). Between these points, linear interpolation is used which gives\n\
3377 a smooth variation of color with input position. Any number of\n\
3378 control points may be specified, located at arbitrary positions,\n\
3379 although typically 2 - 4 are enough. Another way of stating this is\n\
3380 that we are traversing a given number of lines through HLS (or RGB)\n\
3381 space as we move through color map1 entries. The control points at\n\
3382 the minimum and maximum position (0 and 1) must always be specified. \n\
3383 By adding more control points you can get more variation. One good\n\
3384 technique for plotting functions that vary about some expected average\n\
3385 is to use an additional 2 control points in the center (position ~=\n\
3386 0.5) that are the same lightness as the background (typically white\n\
3387 for paper output, black for crt), and same hue as the boundary control\n\
3388 points. This allows the highs and lows to be very easily\n\
3391 Each control point must specify the position in color map1 as well as\n\
3392 three coordinates in HLS or RGB space. The first point must\n\
3393 correspond to position = 0, and the last to position = 1. \n\
3395 The default behaviour is for the hue to be linearly interpolated \n\
3396 between the control points. Since the hue lies in the range [0, 360]\n\
3397 this corresponds to interpolation around the \"front\" of the color\n\
3398 wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3399 alternative interpolation is used between control points i and i+1. If\n\
3400 hue[i+1]-hue[i] > 0 then interpolation is between\thue[i] and\n\
3401 hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n\
3402 consider this as interpolation around the \"back\" or \"reverse\" of the\n\
3403 color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3404 alt_hue_path[] = false for\tevery control point. \n\
3406 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3407 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3408 240]truegreen-yellow-red-magenta-blue[240\n\
3409 120]trueblue-magenta-red-yellow-green\n\
3411 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3412 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3413 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3415 Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n\
3418 This function is used in examples 8,11,12,15,20,21. \n\
3424 plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n\
3428 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3430 npts (PLINT, input) : number of control points \n\
3432 pos (PLFLT *, input) : position for each control point (between 0.0\n\
3433 and 1.0, in ascending order) \n\
3435 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
3438 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
3441 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
3444 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
3445 flag for each control point. (alt_hue_path[i] refers to the\n\
3446 interpolation interval between the i and i + 1 control points). \n\
3449 Set the pause (on end-of-page) status \n\
3453 Set the pause (on end-of-page) status. \n\
3455 Redacted form: plspause(pause)\n\
3457 This function is in examples 14,20. \n\
3467 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3468 end-of-page for those drivers which support this. Otherwise there\n\
3472 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3476 Routine for creating a discrete plot legend with a plotted filled box,\n\
3477 line, and/or line of symbols for each annotated legend entry. The\n\
3478 arguments of pllegend provide control over the location and size of\n\
3479 the legend as well as the location and characteristics of the elements\n\
3480 (most of which are optional) within that legend. The resulting legend\n\
3481 is clipped at the boundaries of the current subpage. (N.B. the adopted\n\
3482 coordinate system used for some of the parameters is defined in the\n\
3483 documentation of the position parameter.) \n\
3485 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3486 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3487 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3488 test_justification, text_colors, text, box_colors, box_patterns,\n\
3489 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3490 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3492 This function is used in examples 4 and 26. \n\
3498 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\
3502 p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3503 contains (after the call) the legend width in adopted coordinates.\n\
3504 This quantity is calculated from plot_width, text_offset, ncolumn\n\
3505 (possibly modified inside the routine depending on nlegend and\n\
3506 nrow), and the length (calculated internally) of the longest text\n\
3509 p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3510 contains (after the call) the legend height in adopted\n\
3511 coordinates. This quantity is calculated from text_scale,\n\
3512 text_spacing, and nrow (possibly modified inside the routine\n\
3513 depending on nlegend and nrow). \n\
3515 opt (PLINT, input) : opt contains bits controlling the overall\n\
3516 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3517 on the left of the legend and the plotted area on the right.\n\
3518 Otherwise, put the text area on the right of the legend and the\n\
3519 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3520 plot a (semi-transparent) background for the legend. If the\n\
3521 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3522 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3523 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3524 plot the resulting array of legend entries in row-major order.\n\
3525 Otherwise, plot the legend entries in column-major order. \n\
3527 position (PLINT, input) : position contains bits controlling the\n\
3528 overall position of the legend and the definition of the adopted\n\
3529 coordinates used for positions. The combination of the\n\
3530 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n\
3531 PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n\
3532 bits specifies one of the 16 possible standard positions (the 4\n\
3533 corners and 4 side centers for both the inside and outside cases)\n\
3534 of the legend relative to the adopted coordinate system. The\n\
3535 adopted coordinates are normalized viewport coordinates if the\n\
3536 PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n\
3537 if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n\
3538 none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n\
3539 PL_POSITION_BOTTOM are set, then use the combination of\n\
3540 PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n\
3541 PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n\
3542 PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3543 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3545 x (PLFLT, input) : X offset of the legend position in adopted\n\
3546 coordinates from the specified standard position of the legend.\n\
3547 For positive x, the direction of motion away from the standard\n\
3548 position is inward/outward from the standard corner positions or\n\
3549 standard left or right positions if the\n\
3550 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3551 For the standard top or bottom positions, the direction of motion\n\
3552 is toward positive X. \n\
3554 y (PLFLT, input) : Y offset of the legend position in adopted\n\
3555 coordinates from the specified standard position of the legend.\n\
3556 For positive y, the direction of motion away from the standard\n\
3557 position is inward/outward from the standard corner positions or\n\
3558 standard top or bottom positions if the\n\
3559 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3560 For the standard left or right positions, the direction of motion\n\
3561 is toward positive Y. \n\
3563 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3564 of the plot area (where the colored boxes, lines, and/or lines of\n\
3565 symbols are drawn) of the legend. \n\
3567 bg_color (PLINT, input) : The cmap0 index of the background color\n\
3568 for the legend (PL_LEGEND_BACKGROUND). \n\
3570 bb_color (PLINT, input) : The cmap0 index of the color of the\n\
3571 bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3573 bb_style (PLINT, input) : The cmap0 index of the background color\n\
3574 for the legend (PL_LEGEND_BACKGROUND). \n\
3576 nrow (PLINT, input) : The cmap0 index of the background color for\n\
3577 the legend (PL_LEGEND_BACKGROUND). \n\
3579 ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3580 for the legend (PL_LEGEND_BACKGROUND). \n\
3582 nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3583 vertical height of the legend in adopted coordinates is calculated\n\
3584 internally from nlegend, text_scale (see below), and text_spacing\n\
3587 opt_array (const PLINT *, input) : Array of nlegend values of\n\
3588 options to control each individual plotted area corresponding to a\n\
3589 legend entry. If the \n\
3590 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3592 PL_LEGEND_COLOR_BOX, \n\
3593 PL_LEGEND_LINE, and/or \n\
3594 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3595 entry is plotted with a colored box; a line; and/or a line of\n\
3598 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3599 area in units of character width. N.B. The total horizontal\n\
3600 width of the legend in adopted coordinates is calculated\n\
3602 plot_width (see above), \n\
3603 text_offset, and length (calculated internally) of the longest text\n\
3606 text_scale (PLFLT, input) : Character height scale for text\n\
3607 annotations. N.B. The total vertical height of the legend in\n\
3608 adopted coordinates is calculated internally from \n\
3609 nlegend (see above), \n\
3611 text_spacing (see below). \n\
3613 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3614 character height from one legend entry to the next. N.B. The\n\
3615 total vertical height of the legend in adopted coordinates is\n\
3616 calculated internally from \n\
3617 nlegend (see above), \n\
3618 text_scale (see above), and \n\
3621 text_justification (PLFLT, input) : Justification parameter used\n\
3622 for text justification. The most common values of\n\
3623 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3624 is left justified, centred, or right justified within the text\n\
3625 area, but other values are allowed as well. \n\
3627 text_colors (const PLINT *, input) : Array of nlegend text colors\n\
3628 (cmap0 indices). \n\
3630 text (const char **, input) : Array of nlegend text string\n\
3633 box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n\
3634 indices) for the discrete colored boxes (\n\
3635 PL_LEGEND_COLOR_BOX). \n\
3637 box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3638 (plpsty indices) for the discrete colored boxes (\n\
3639 PL_LEGEND_COLOR_BOX). \n\
3641 box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3642 of fraction of character height) for the height of the discrete\n\
3644 PL_LEGEND_COLOR_BOX). \n\
3646 box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3647 widths for the patterns specified by box_patterns (\n\
3648 PL_LEGEND_COLOR_BOX). \n\
3650 line_colors (const PLINT *, input) : Array of nlegend line colors\n\
3651 (cmap0 indices) (\n\
3652 PL_LEGEND_LINE). \n\
3654 line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3655 (plsty indices) (\n\
3656 PL_LEGEND_LINE). \n\
3658 line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3659 PL_LEGEND_LINE). \n\
3661 symbol_colors (const PLINT *, input) : Array of nlegend symbol\n\
3662 colors (cmap0 indices) (\n\
3663 PL_LEGEND_SYMBOL). \n\
3665 symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3666 values for the symbol height (\n\
3667 PL_LEGEND_SYMBOL). \n\
3669 symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3670 symbols to be drawn across the width of the plotted area (\n\
3671 PL_LEGEND_SYMBOL). \n\
3673 symbols (const char **, input) : Array of nlegend symbols (plpoin\n\
3675 PL_LEGEND_SYMBOL). \n\
3678 Set number of colors in color map1 \n\
3682 Set number of colors in color map1, (re-)allocate color map1, and set\n\
3683 default values if this is the first allocation (see the PLplot\n\
3686 Redacted form: plscmap1n(ncol1)\n\
3688 This function is used in examples 8,11,20,21. \n\
3698 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3699 the map1 palette. If this number is zero or less, then the value\n\
3700 from the previous call to plscmap1n is used and if there is no\n\
3701 previous call, then a default value is used. \n\
3704 Returns 8-bit RGB values and double alpha value for given color from color map0. \n\
3708 Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n\
3709 for given color from color map0 (see the PLplot documentation). \n\
3710 Values are negative if an invalid color id is given. \n\
3712 This function is used in example 30. \n\
3718 plgcol0a(icol0, r, g, b, a)\n\
3722 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3724 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3726 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3728 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3730 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
3733 Replays contents of plot buffer to current device/file \n\
3737 Replays contents of plot buffer to current device/file. \n\
3739 Redacted form: plreplot()\n\
3741 This function is used in example 1,20. \n\
3750 Simple routine to write labels \n\
3754 Routine for writing simple labels. Use plmtex for more complex labels. \n\
3756 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3758 This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3764 pllab(xlabel, ylabel, tlabel)\n\
3768 xlabel (const char *, input) : Label for horizontal axis. \n\
3770 ylabel (const char *, input) : Label for vertical axis. \n\
3772 tlabel (const char *, input) : Title of graph. \n\
3775 Set parameters that define current device-space window \n\
3779 Set relative margin width, aspect ratio, and relative justification\n\
3780 that define current device-space window. If you want to just use the\n\
3781 previous value for any of these, just pass in the magic value\n\
3782 PL_NOTSET. It is unlikely that one should ever need to change the\n\
3783 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3784 called the default values of mar, jx, and jy are all 0. aspect is set\n\
3785 to a device-specific value. \n\
3787 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3789 This function is used in example 31. \n\
3795 plsdidev(mar, aspect, jx, jy)\n\
3799 mar (PLFLT, input) : Relative margin width. \n\
3801 aspect (PLFLT, input) : Aspect ratio. \n\
3803 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3804 the range -0.5 to 0.5. \n\
3806 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3807 the range -0.5 to 0.5. \n\
3814 Begins a new page.\tFor a file driver, the output file is opened if\n\
3815 necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3816 page break is desired at a particular point when plotting to subpages.\n\
3817 Another use for pleop and plbop is when plotting pages to different\n\
3818 files, since you can manually set the file name by calling plsfnam\n\
3819 after the call to pleop. (In fact some drivers may only support a\n\
3820 single page per file, making this a necessity.) One way to handle\n\
3821 this case automatically is to page advance via pladv, but enable\n\
3822 familying (see plsfam) with a small limit on the file size so that a\n\
3823 new family member file will be created on each page break. \n\
3825 Redacted form: plbop()\n\
3827 This function is used in examples 2,20. \n\
3836 Set color map0 colors by 8-bit RGB values \n\
3840 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
3841 documentation). This sets the entire color map -- only as many colors\n\
3842 as specified will be allocated. \n\
3844 Redacted form: plscmap0(r, g, b, ncol0)\n\
3846 This function is used in examples 2,24. \n\
3852 plscmap0(r, g, b, ncol0)\n\
3856 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3857 integers (0-255) representing the degree of red in the color. \n\
3859 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3860 integers (0-255) representing the degree of green in the color. \n\
3862 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3863 integers (0-255) representing the degree of blue in the color. \n\
3865 ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3868 Set the number of subpages in x and y \n\
3872 Set the number of subpages in x and y. \n\
3874 Redacted form: plssub(nx, ny)\n\
3876 This function is examples 1,2,14,21,25,27. \n\
3886 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
3887 of window columns). \n\
3889 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
3890 of window rows). \n\
3893 Set a global coordinate transform function \n\
3897 This function can be used to define a coordinate transformation which\n\
3898 affects all elements drawn within the current plot window.\tThe\n\
3899 transformation function is similar to that provided for the plmap and\n\
3900 plmeridians functions. The data parameter may be used to pass extra\n\
3901 data to transform_fun. \n\
3903 Redacted form: General: plstransform(transform_fun, data)\n\
3906 This function is used in example 19. \n\
3912 plstransform(transform_fun, data)\n\
3916 transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n\
3917 input) : Pointer to a function that defines a transformation\n\
3918 from the input (x, y) coordinate to a new plot world coordiante. \n\
3920 data (PLPointer, input) : Optional extra data for \n\
3924 Set color map1 colors using 8-bit RGB values \n\
3928 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3929 documentation). This also sets the number of colors. \n\
3931 Redacted form: plscmap1(r, g, b, ncol1)\n\
3933 This function is used in example 31. \n\
3939 plscmap1(r, g, b, ncol1)\n\
3943 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3944 integers (0-255) representing the degree of red in the color. \n\
3946 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3947 integers (0-255) representing the degree of green in the color. \n\
3949 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3950 integers (0-255) representing the degree of blue in the color. \n\
3952 ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3955 Set length of minor ticks \n\
3959 This sets up the length of the minor ticks and the length of the\n\
3960 terminals on error bars. The actual length is the product of the\n\
3961 default length and a scaling factor as for character height. \n\
3963 Redacted form: plsmin(def, scale)\n\
3965 This function is used in example 29. \n\
3971 plsmin(def, scale)\n\
3975 def (PLFLT, input) : The default length of a minor tick in\n\
3976 millimeters, should be set to zero if the default length is to\n\
3977 remain unchanged. \n\
3979 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
3980 actual tick length. \n\
3983 Set character size \n\
3987 This sets up the size of all subsequent characters drawn. The actual\n\
3988 height of a character is the product of the default character size and\n\
3989 a scaling factor. \n\
3991 Redacted form: plschr(def, scale)\n\
3993 This function is used in example 2,13,23,24. \n\
3999 plschr(def, scale)\n\
4003 def (PLFLT, input) : The default height of a character in\n\
4004 millimeters, should be set to zero if the default height is to\n\
4005 remain unchanged. \n\
4007 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4008 actual character height. \n\
4011 Initialize PLplot \n\
4015 Initializing the plotting package.\tThe program prompts for the device\n\
4016 keyword or number of the desired output device. Hitting a RETURN in\n\
4017 response to the prompt is the same as selecting the first device. \n\
4018 plinit will issue no prompt if either the device was specified\n\
4019 previously (via command line flag, the plsetopt function, or the\n\
4020 plsdev function), or if only one device is enabled when PLplot is\n\
4021 installed.\tIf subpages have been specified, the output device is\n\
4022 divided into nx by ny subpages, each of which may be used\n\
4023 independently. If plinit is called again during a program, the\n\
4024 previously opened file will be closed. The subroutine pladv is used\n\
4025 to advance from one subpage to the next. \n\
4027 Redacted form: plinit()\n\
4029 This function is used in all of the examples. \n\
4038 Draw a box with axes, etc\n\
4042 Draws a box around the currently defined viewport, and labels it with\n\
4043 world coordinate values appropriate to the window.\tThus plbox should\n\
4044 only be called after defining both viewport and window. The character\n\
4045 strings xopt and yopt specify how the box should be drawn as described\n\
4046 below. If ticks and/or subticks are to be drawn for a particular\n\
4047 axis, the tick intervals and number of subintervals may be specified\n\
4048 explicitly, or they may be defaulted by setting the appropriate\n\
4049 arguments to zero. \n\
4051 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4052 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4055 This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4061 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4065 xopt (const char *, input) : Pointer to character string specifying\n\
4066 options for horizontal axis. The string can include any\n\
4067 combination of the following letters (upper or lower case) in any\n\
4068 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4069 is vertical line (x=0). \n\
4070 b: Draws bottom (X) or left (Y) edge of frame. \n\
4071 c: Draws top (X) or right (Y) edge of frame. \n\
4072 d: Plot labels as date / time. Values are assumed to be\n\
4073 seconds since the epoch (as used by gmtime). \n\
4074 f: Always use fixed point numeric labels. \n\
4075 g: Draws a grid at the major tick interval. \n\
4076 h: Draws a grid at the minor tick interval. \n\
4077 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4079 l: Labels axis logarithmically. This only affects the labels,\n\
4080 not the data, and so it is necessary to compute the logarithms\n\
4081 of data points before passing them to any of the drawing\n\
4083 m: Writes numeric labels at major tick intervals in the\n\
4084 unconventional location (above box for X, right of box for Y). \n\
4085 n: Writes numeric labels at major tick intervals in the\n\
4086 conventional location (below box for X, left of box for Y). \n\
4087 o: Use custom labeling function to generate axis label text. \n\
4088 The custom labeling function can be defined with the\n\
4089 plslabelfuncplslabelfunc; command. \n\
4090 s: Enables subticks between major ticks, only valid if t is\n\
4092 t: Draws major ticks. \n\
4093 u: Exactly like \"b\" except don\'t draw edge line. \n\
4094 w: Exactly like \"c\" except don\'t draw edge line. \n\
4097 xtick (PLFLT, input) : World coordinate interval between major\n\
4098 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4099 generates a suitable tick interval. \n\
4101 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4102 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4103 generates a suitable minor tick interval. \n\
4105 yopt (const char *, input) : Pointer to character string specifying\n\
4106 options for vertical axis. The string can include any combination\n\
4107 of the letters defined above for xopt, and in addition may\n\
4108 contain: v: Write numeric labels for vertical axis parallel to the\n\
4109 base of the graph, rather than parallel to the axis. \n\
4112 ytick (PLFLT, input) : World coordinate interval between major\n\
4113 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4114 generates a suitable tick interval. \n\
4116 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4117 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4118 generates a suitable minor tick interval. \n\
4121 Get parameters that define current device-space window \n\
4125 Get relative margin width, aspect ratio, and relative justification\n\
4126 that define current device-space window. If plsdidev has not been\n\
4127 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4128 p_jy will all be 0. \n\
4130 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4132 This function is used in example 31. \n\
4138 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4142 p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4144 p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4146 p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4148 p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4151 Plot a glyph at the specified points \n\
4155 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4156 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4157 is specified with a PLplot user string. Note that the user string is\n\
4158 not actually limited to one glyph so it is possible (but not normally\n\
4159 useful) to plot more than one glyph at the specified points with this\n\
4160 function. As with plmtex and plptex, the user string can contain FCI\n\
4161 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4162 else PLplot escapes for Hershey or unicode text to determine the\n\
4165 Redacted form: plstring(x, y, string)\n\
4167 This function is used in examples 4, 21 and 26. \n\
4173 plstring(n, x, y, string)\n\
4177 n (PLINT, input) : Number of points in the x and y arrays. \n\
4179 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
4182 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
4185 string (const char *, input) : PLplot user string corresponding to\n\
4186 the glyph to be plotted at each of the n points. \n\
4189 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n\
4193 Sets up plotter environment for simple graphs by calling pladv and\n\
4194 setting up viewport and window to sensible default values.\tplenv0\n\
4195 leaves enough room around most graphs for axis labels and a title.\n\
4196 When these defaults are not suitable, use the individual routines\n\
4197 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4198 defining the window, and plbox for drawing the box. \n\
4200 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4202 This function is used in example 21. \n\
4208 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4212 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4213 world coordinates). \n\
4215 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4216 world coordinates). \n\
4218 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4221 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4224 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4225 scales will not be set, the user must set up the scale before\n\
4226 calling plenv0 using plsvpa, plvasp or other. \n\
4227 0: the x and y axes are scaled independently to use as much of\n\
4228 the screen as possible. \n\
4229 1: the scales of the x and y axes are made equal. \n\
4230 2: the axis of the x and y axes are made equal, and the plot\n\
4231 box will be square. \n\
4234 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4235 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4236 -1: draw box only. \n\
4237 0: draw box, ticks, and numeric tick labels. \n\
4238 1: also draw coordinate axes at x=0 and y=0. \n\
4239 2: also draw a grid at major tick positions in both\n\
4241 3: also draw a grid at minor tick positions in both\n\
4243 10: same as 0 except logarithmic x tick marks. (The x data\n\
4244 have to be converted to logarithms separately.) \n\
4245 11: same as 1 except logarithmic x tick marks. (The x data\n\
4246 have to be converted to logarithms separately.) \n\
4247 12: same as 2 except logarithmic x tick marks. (The x data\n\
4248 have to be converted to logarithms separately.) \n\
4249 13: same as 3 except logarithmic x tick marks. (The x data\n\
4250 have to be converted to logarithms separately.) \n\
4251 20: same as 0 except logarithmic y tick marks. (The y data\n\
4252 have to be converted to logarithms separately.) \n\
4253 21: same as 1 except logarithmic y tick marks. (The y data\n\
4254 have to be converted to logarithms separately.) \n\
4255 22: same as 2 except logarithmic y tick marks. (The y data\n\
4256 have to be converted to logarithms separately.) \n\
4257 23: same as 3 except logarithmic y tick marks. (The y data\n\
4258 have to be converted to logarithms separately.) \n\
4259 30: same as 0 except logarithmic x and y tick marks. (The x\n\
4260 and y data have to be converted to logarithms separately.) \n\
4261 31: same as 1 except logarithmic x and y tick marks. (The x\n\
4262 and y data have to be converted to logarithms separately.) \n\
4263 32: same as 2 except logarithmic x and y tick marks. (The x\n\
4264 and y data have to be converted to logarithms separately.) \n\
4265 33: same as 3 except logarithmic x and y tick marks. (The x\n\
4266 and y data have to be converted to logarithms separately.) \n\
4267 40: same as 0 except date / time x labels. \n\
4268 41: same as 1 except date / time x labels. \n\
4269 42: same as 2 except date / time x labels. \n\
4270 43: same as 3 except date / time x labels. \n\
4271 50: same as 0 except date / time y labels. \n\
4272 51: same as 1 except date / time y labels. \n\
4273 52: same as 2 except date / time y labels. \n\
4274 53: same as 3 except date / time y labels. \n\
4275 60: same as 0 except date / time x and y labels. \n\
4276 61: same as 1 except date / time x and y labels. \n\
4277 62: same as 2 except date / time x and y labels. \n\
4278 63: same as 3 except date / time x and y labels. \n\
4279 70: same as 0 except custom x and y labels. \n\
4280 71: same as 1 except custom x and y labels. \n\
4281 72: same as 2 except custom x and y labels. \n\
4282 73: same as 3 except custom x and y labels. \n\
4285 Set up window for 3-d plotting \n\
4289 Sets up a window for a three-dimensional surface plot within the\n\
4290 currently defined two-dimensional window. The enclosing box for the\n\
4291 surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4292 user-coordinate space is mapped into a box of world coordinate size\n\
4293 basex by basey by height so that xmin maps to -\n\
4294 basex/2, xmax maps to basex/2, ymin maps to -\n\
4295 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4296 The resulting world-coordinate box is then viewed by an observer at\n\
4297 altitude alt and azimuth az. This routine must be called before\n\
4298 plbox3 or plot3d. For a more complete description of\n\
4299 three-dimensional plotting see the PLplot documentation. \n\
4301 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4302 zmin, zmax, alt, az)\n\
4304 This function is examples 8,11,18,21. \n\
4310 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4314 basex (PLFLT, input) : The x coordinate size of the\n\
4315 world-coordinate box. \n\
4317 basey (PLFLT, input) : The y coordinate size of the\n\
4318 world-coordinate box. \n\
4320 height (PLFLT, input) : The z coordinate size of the\n\
4321 world-coordinate box. \n\
4323 xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4325 xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4327 ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4329 ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4331 zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4333 zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4335 alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4338 az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n\
4339 observer is looking face onto the ZX plane, and as az is\n\
4340 increased, the observer moves clockwise around the box when viewed\n\
4341 from above the XY plane. \n\
4344 Draw filled polygon \n\
4348 Fills the polygon defined by the n points (\n\
4350 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4351 style is a solid fill. The routine will automatically close the\n\
4352 polygon between the last and first vertices. If multiple closed\n\
4353 polygons are passed in x and y then plfill will fill in between them. \n\
4355 Redacted form: plfill(x,y)\n\
4357 This function is used in examples 12,13,15,16,21,24,25. \n\
4367 n (PLINT, input) : Number of vertices in polygon. \n\
4369 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4372 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4376 Write text relative to viewport boundaries \n\
4380 Writes text at a specified position relative to the viewport\n\
4381 boundaries. Text may be written inside or outside the viewport, but\n\
4382 is clipped at the subpage boundaries. The reference point of a string\n\
4383 lies along a line passing through the string at half the height of a\n\
4384 capital letter. The position of the reference point along this line\n\
4385 is determined by just, and the position of the reference point\n\
4386 relative to the viewport is set by disp and pos. \n\
4388 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4389 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4392 This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4398 plmtex(side, disp, pos, just, text)\n\
4402 side (const char *, input) : Specifies the side of the viewport\n\
4403 along which the text is to be written. The string must be one of:\n\
4404 b: Bottom of viewport, text written parallel to edge. \n\
4405 bv: Bottom of viewport, text written at right angles to edge. \n\
4406 l: Left of viewport, text written parallel to edge. \n\
4407 lv: Left of viewport, text written at right angles to edge. \n\
4408 r: Right of viewport, text written parallel to edge. \n\
4409 rv: Right of viewport, text written at right angles to edge. \n\
4410 t: Top of viewport, text written parallel to edge. \n\
4411 tv: Top of viewport, text written at right angles to edge. \n\
4414 disp (PLFLT, input) : Position of the reference point of string,\n\
4415 measured outwards from the specified viewport edge in units of the\n\
4416 current character height. Use negative disp to write within the\n\
4419 pos (PLFLT, input) : Position of the reference point of string\n\
4420 along the specified edge, expressed as a fraction of the length of\n\
4423 just (PLFLT, input) : Specifies the position of the string relative\n\
4424 to its reference point. If just=0., the reference point is at the\n\
4425 left and if just=1., it is at the right of the string. Other\n\
4426 values of just give intermediate justifications. \n\
4428 text (const char *, input) : The string to be written out. \n\
4431 Set arrow style for vector plots \n\
4435 Set the style for the arrow used by plvect to plot vectors. \n\
4437 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4439 This function is used in example 22. \n\
4445 plsvect(arrowx, arrowy, npts, fill)\n\
4449 arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n\
4450 containing the x and y points which make up the arrow. The arrow\n\
4451 is plotted by joining these points to form a polygon. The scaling\n\
4452 assumes that the x and y points in the arrow lie in the range -0.5\n\
4455 npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4458 fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4459 fill is false then the arrow is open. \n\
4462 Get family file parameters \n\
4466 Gets information about current family file, if familying is enabled. \n\
4467 See the PLplot documentation for more information. \n\
4469 Redacted form: plgfam(fam, num, bmax)\n\
4471 This function is used in examples 14,31. \n\
4477 plgfam(fam, num, bmax)\n\
4481 fam (PLINT *, output) : Pointer to variable with the Boolean family\n\
4482 flag value. If nonzero, familying is enabled. \n\
4484 num (PLINT *, output) : Pointer to variable with the current family\n\
4487 bmax (PLINT *, output) : Pointer to variable with the maximum file\n\
4488 size (in bytes) for a family file. \n\
4491 Random number generator returning a real random number in the range [0,1]. \n\
4495 Random number generator returning a real random number in the range\n\
4496 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4497 / compilers provide their own random number generator, and so this is\n\
4498 provided purely for convenience and to give a consistent random number\n\
4499 generator across all languages supported by PLplot. This is\n\
4500 particularly useful for comparing results from the test suite of\n\
4503 Redacted form: plrandd()\n\
4505 This function is used in examples 17,21. \n\
4518 This sets up the line style for all lines subsequently drawn. A line\n\
4519 consists of segments in which the pen is alternately down and up. The\n\
4520 lengths of these segments are passed in the arrays mark and space\n\
4521 respectively. The number of mark-space pairs is specified by nels. \n\
4522 In order to return the line style to the default continuous line,\n\
4523 plstyl should be called with nels=0.(see also pllsty) \n\
4525 Redacted form: plstyl(mark, space)\n\
4527 This function is used in examples 1,9,14. \n\
4533 plstyl(nels, mark, space)\n\
4537 nels (PLINT, input) : The number of mark and space elements in a\n\
4538 line. Thus a simple broken line can be obtained by setting\n\
4539 nels=1. A continuous line is specified by setting nels=0. \n\
4541 mark (PLINT *, input) : Pointer to array with the lengths of the\n\
4542 segments during which the pen is down, measured in micrometers. \n\
4544 space (PLINT *, input) : Pointer to array with the lengths of the\n\
4545 segments during which the pen is up, measured in micrometers. \n\
4548 Set the colors for color table 0 from a cmap0 file \n\
4552 Set the colors for color table 0 from a cmap0 file \n\
4554 Redacted form: plspal0(filename)\n\
4556 This function is in example 16. \n\
4562 plspal0(filename)\n\
4566 filename (const char *, input) : The name of the cmap0 file, or a\n\
4567 empty to string to specify the default cmap0 file. \n\
4570 Set the colors for color table 1 from a cmap1 file \n\
4574 Set the colors for color table 1 from a cmap1 file \n\
4576 Redacted form: plspal1(filename)\n\
4578 This function is in example 16. \n\
4584 plspal1(filename)\n\
4588 filename (const char *, input) : The name of the cmap1 file, or a\n\
4589 empty to string to specify the default cmap1 file. \n\
4592 Set current output stream \n\
4596 Sets the number of the current output stream. The stream number\n\
4597 defaults to 0 unless changed by this routine. The first use of this\n\
4598 routine must be followed by a call initializing PLplot (e.g. plstar). \n\
4600 Redacted form: plsstrm(strm)\n\
4602 This function is examples 1,14,20. \n\
4612 strm (PLINT, input) : The current stream number. \n\
4615 Specify viewport using coordinates \n\
4619 Device-independent routine for setting up the viewport. This defines\n\
4620 the viewport in terms of normalized subpage coordinates which run from\n\
4621 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4622 current subpage. Use the alternate routine plsvpa in order to create\n\
4623 a viewport of a definite size. \n\
4625 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4627 This function is used in examples\n\
4628 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
4634 plvpor(xmin, xmax, ymin, ymax)\n\
4638 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4639 left-hand edge of the viewport. \n\
4641 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4642 right-hand edge of the viewport. \n\
4644 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4645 bottom edge of the viewport. \n\
4647 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4648 edge of the viewport. \n\
4651 Write text inside the viewport \n\
4655 Writes text at a specified position and inclination within the\n\
4656 viewport. Text is clipped at the viewport boundaries. The reference\n\
4657 point of a string lies along a line passing through the string at half\n\
4658 the height of a capital letter. The position of the reference point\n\
4659 along this line is determined by just, the reference point is placed\n\
4660 at world coordinates (\n\
4662 y) within the viewport. The inclination of the string is specified in\n\
4663 terms of differences of world coordinates making it easy to write text\n\
4664 parallel to a line in a graph. \n\
4666 Redacted form: plptex(x, y, dx, dy, just, text)\n\
4668 This function is used in example 2-4,10,12-14,20,23,24,26. \n\
4674 plptex(x, y, dx, dy, just, text)\n\
4678 x (PLFLT, input) : x coordinate of reference point of string. \n\
4680 y (PLFLT, input) : y coordinate of reference point of string. \n\
4682 dx (PLFLT, input) : Together with dy, this specifies the\n\
4683 inclination of the string. The baseline of the string is parallel\n\
4684 to a line joining (\n\
4692 dy (PLFLT, input) : Together with dx, this specifies the\n\
4693 inclination of the string. \n\
4695 just (PLFLT, input) : Specifies the position of the string relative\n\
4696 to its reference point. If just=0., the reference point is at the\n\
4697 left and if just=1., it is at the right of the string. Other\n\
4698 values of just give intermediate justifications. \n\
4700 text (const char *, input) : The string to be written out. \n\
4703 Set z axis parameters \n\
4707 Identical to plsxax, except that arguments are flags for z axis. See\n\
4708 the description of plsxax for more detail. \n\
4710 Redacted form: plszax(digmax, digits)\n\
4712 This function is used in example 31. \n\
4718 plszax(digmax, digits)\n\
4722 digmax (PLINT, input) : Variable to set the maximum number of\n\
4723 digits for the z axis. If nonzero, the printed label will be\n\
4724 switched to a floating point representation when the number of\n\
4725 digits exceeds digmax. \n\
4727 digits (PLINT, input) : Field digits value. Currently, changing\n\
4728 its value here has no effect since it is set only by plbox or\n\
4729 plbox3. However, the user may obtain its value after a call to\n\
4730 either of these functions by calling plgzax. \n\
4733 Set character font \n\
4737 Sets the default character font for subsequent character drawing. Also\n\
4738 affects symbols produced by plpoin. This routine has no effect unless\n\
4739 the extended character set is loaded (see plfontld). \n\
4741 Redacted form: plfont(font)\n\
4743 This function is used in examples 1,2,4,7,13,24,26. \n\
4753 font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
4760 Draw a circular or elliptical arc \n\
4764 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
4765 semiminor axis b, starting at angle1 and ending at angle2. \n\
4767 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
4771 This function is used in examples 3 and 27. \n\
4777 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
4781 x (PLFLT, input) : X coordinate of arc center. \n\
4783 y (PLFLT, input) : Y coordinate of arc center. \n\
4785 a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
4787 b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
4789 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
4792 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
4795 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
4798 fill (PLBOOL, input) : Draw a filled arc. \n\
4801 Set area fill pattern \n\
4805 Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
4806 parallel lines with specified inclinations and spacings. The\n\
4807 arguments to this routine are the number of sets to use (1 or 2)\n\
4808 followed by two pointers to integer arrays (of 1 or 2 elements)\n\
4809 specifying the inclinations in tenths of a degree and the spacing in\n\
4810 micrometers. (also see plpsty) \n\
4812 Redacted form: General: plpat(inc, del)\n\
4813 \t Perl/PDL: plpat(nlin, inc, del)\n\
4816 This function is used in example 15. \n\
4822 plpat(nlin, inc, del)\n\
4826 nlin (PLINT, input) : Number of sets of lines making up the\n\
4827 pattern, either 1 or 2. \n\
4829 inc (PLINT *, input) : Pointer to array with nlin elements.\n\
4830 Specifies the line inclination in tenths of a degree. (Should be\n\
4831 between -900 and 900). \n\
4833 del (PLINT *, input) : Pointer to array with nlin elements.\n\
4834 Specifies the spacing in micrometers between the lines making up\n\
4838 Get x axis parameters \n\
4842 Returns current values of the digmax and digits flags for the x axis. \n\
4843 digits is updated after the plot is drawn, so this routine should only\n\
4844 be called after the call to plbox (or plbox3) is complete.\tSee the\n\
4845 PLplot documentation for more information. \n\
4847 Redacted form: plgxax(digmax, digits)\n\
4849 This function is used in example 31. \n\
4855 plgxax(digmax, digits)\n\
4859 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
4860 number of digits for the x axis. If nonzero, the printed label\n\
4861 has been switched to a floating point representation when the\n\
4862 number of digits exceeds digmax. \n\
4864 digits (PLINT *, output) : Pointer to variable with the actual\n\
4865 number of digits for the numeric labels (x axis) from the last\n\
4869 Draw filled polygon in 3D \n\
4873 Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
4874 using the pattern defined by plpsty or plpat. The routine will\n\
4875 automatically close the polygon between the last and first vertices. \n\
4876 If multiple closed polygons are passed in x, y, and z then plfill3\n\
4877 will fill in between them. \n\
4879 Redacted form: General: plfill3(x, y, z)\n\
4880 \t Perl/PDL: plfill3(n, x, y, z)\n\
4883 This function is used in example 15. \n\
4889 plfill3(n, x, y, z)\n\
4893 n (PLINT, input) : Number of vertices in polygon. \n\
4895 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4898 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4901 z (PLFLT *, input) : Pointer to array with z coordinates of\n\
4909 Sets the color for color map0 (see the PLplot documentation). \n\
4911 Redacted form: plcol0(color)\n\
4913 This function is used in examples 1-9,11-16,18-27,29. \n\
4923 color (PLINT, input) : Integer representing the color. The\n\
4924 defaults at present are (these may change): \n\
4925 0 black (default background) \n\
4926 1 red (default foreground) \n\
4942 Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
4943 change an individual color in the map0 color palette. \n\
4946 Draw a line between two points \n\
4950 Joins the point (\n\
4956 Redacted form: pljoin(x1,y1,x2,y2)\n\
4958 This function is used in examples 3,14. \n\
4964 pljoin(x1, y1, x2, y2)\n\
4968 x1 (PLFLT, input) : x coordinate of first point. \n\
4970 y1 (PLFLT, input) : y coordinate of first point. \n\
4972 x2 (PLFLT, input) : x coordinate of second point. \n\
4974 y2 (PLFLT, input) : y coordinate of second point. \n\
4981 Sets the color for color map1 (see the PLplot documentation). \n\
4983 Redacted form: plcol1(col1)\n\
4985 This function is used in examples 12 and 21. \n\
4995 col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
4996 and is mapped to color using the continuous map1 color palette\n\
4997 which by default ranges from blue to the background color to red. \n\
4998 The map1 palette can also be straightforwardly changed by the user\n\
4999 with plscmap1 or plscmap1l. \n\
5006 Set integer plot orientation parameter. This function is identical to\n\
5007 plsdiori except for the type of the argument, and should be used in\n\
5008 the same way. See the PLplot documentation for details. \n\
5010 Redacted form: plsori(ori)\n\
5012 This function is used in example 3. \n\
5022 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5023 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5027 Plot continental outline in world coordinates. \n\
5031 Plots continental outlines in world coordinates. examples/c/x19c\n\
5032 demonstrates how to use this function to create different\n\
5035 Redacted form: General: plmap(mapform, type, minlong, maxlong,\n\
5037 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
5040 This function is used in example 19. \n\
5046 plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n\
5050 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5051 supplied function to transform the coordinate longitudes and\n\
5052 latitudes to a plot coordinate system. By using this transform,\n\
5053 we can change from a longitude, latitude coordinate to a polar\n\
5054 stereographic project, for example. Initially, x[0]..[n-1] are\n\
5055 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5056 After the call to mapform(), x[] and y[] should be replaced by\n\
5057 the corresponding plot coordinates. If no transform is desired,\n\
5058 mapform can be replaced by NULL. \n\
5060 type (char *, input) : type is a character string. The value of\n\
5061 this parameter determines the type of background. The possible\n\
5062 values are: \"globe\" -- continental outlines \n\
5063 \"usa\" -- USA and state boundaries \n\
5064 \"cglobe\" -- continental outlines and countries \n\
5065 \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5068 minlong (PLFLT, input) : The value of the longitude on the left\n\
5069 side of the plot. The value of minlong must be less than the\n\
5070 value of maxlong, and the quantity maxlong-minlong must be less\n\
5071 than or equal to 360. \n\
5073 maxlong (PLFLT, input) : The value of the longitude on the right\n\
5074 side of the plot. \n\
5076 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
5077 background. One can always use -90.0 as the boundary outside the\n\
5078 plot window will be automatically eliminated. However, the\n\
5079 program will be faster if one can reduce the size of the\n\
5080 background plotted. \n\
5082 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
5083 background. One can always use 90.0 as the boundary outside the\n\
5084 plot window will be automatically eliminated. \n\
5087 Get current stream number \n\
5091 Gets the number of the current output stream. See also plsstrm. \n\
5093 Redacted form: plgstrm(strm)\n\
5095 This function is used in example 1,20. \n\
5105 strm (PLINT *, output) : Pointer to current stream value. \n\
5108 Draw a line in 3 space \n\
5112 Draws line in 3 space defined by n points in x, y, and z. You must\n\
5113 first set up the viewport, the 2d viewing window (in world\n\
5114 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
5117 Redacted form: plline3(x, y, z)\n\
5119 This function is used in example 18. \n\
5125 plline3(n, x, y, z)\n\
5129 n (PLINT, input) : Number of points defining line. \n\
5131 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
5133 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
5135 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
5138 Load character font \n\
5142 Sets the character set to use for subsequent character drawing. May\n\
5143 be called before initializing PLplot. \n\
5145 Redacted form: plfontld(set)\n\
5147 This function is used in examples 1,7. \n\
5157 set (PLINT, input) : Specifies the character set to load: 0:\n\
5158 Standard character set \n\
5159 1: Extended character set \n\
5162 Set any command-line option \n\
5166 Set any command-line option internally from a program before it\n\
5167 invokes plinit. opt is the name of the command-line option and optarg\n\
5168 is the corresponding command-line option argument.\t\n\
5170 This function returns 0 on success. \n\
5172 Redacted form: plsetopt(opt, optarg)\n\
5174 This function is used in example 14. \n\
5180 int plsetopt(opt, optarg)\n\
5184 opt (const char *, input) : Pointer to string containing the\n\
5185 command-line option. \n\
5187 optarg (const char *, input) : Pointer to string containing the\n\
5188 argument of the command-line option. \n\
5191 Used to globally turn color output on/off \n\
5195 Used to globally turn color output on/off for those drivers/devices\n\
5196 that support it. \n\
5198 Redacted form: plscolor(color)\n\
5200 This function is used in example 31. \n\
5210 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
5211 turned off. If non-zero, color is turned on. \n\
5214 Get the current device (keyword) name \n\
5218 Get the current device (keyword) name. Note: you must have allocated\n\
5219 space for this (80 characters is safe). \n\
5221 Redacted form: plgdev(p_dev)\n\
5223 This function is used in example 14. \n\
5233 p_dev (char *, output) : Pointer to device (keyword) name string. \n\
5236 Add a point to a stripchart \n\
5240 Add a point to a given pen of a given stripchart. There is no need for\n\
5241 all pens to have the same number of points or to be equally sampled in\n\
5242 the x coordinate. Allocates memory and rescales as necessary. \n\
5244 Redacted form: plstripa(id, p, x, y)\n\
5246 This function is used in example 17. \n\
5252 plstripa(id, p, x, y)\n\
5256 id (PLINT, input) : Identification number (set up in plstripc) of\n\
5259 p (PLINT, input) : Pen number (ranges from 0 to 3). \n\
5261 x (PLFLT, input) : X coordinate of point to plot. \n\
5263 y (PLFLT, input) : Y coordinate of point to plot. \n\
5266 Deletes and releases memory used by a stripchart \n\
5270 Deletes and releases memory used by a stripchart. \n\
5272 Redacted form: plstripd(id)\n\
5274 This function is used in example 17. \n\
5284 id (PLINT, input) : Identification number of stripchart to delete. \n\
5287 Specify viewport using coordinates and aspect ratio \n\
5291 Device-independent routine for setting up the viewport. The viewport\n\
5292 is chosen to be the largest with the given aspect ratio that fits\n\
5293 within the specified region (in terms of normalized subpage\n\
5294 coordinates). This routine is functionally equivalent to plvpor when\n\
5295 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5296 routine reserves no extra space at the edges for labels. \n\
5298 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5300 This function is used in example 9. \n\
5306 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5310 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5311 left-hand edge of the viewport. \n\
5313 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5314 right-hand edge of the viewport. \n\
5316 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5317 bottom edge of the viewport. \n\
5319 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5320 edge of the viewport. \n\
5322 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5326 Assign a function to use for generating custom axis labels \n\
5330 This function allows a user to provide their own function to provide\n\
5331 axis label text. The user function is given the numeric value for a\n\
5332 point on an axis and returns a string label to correspond with that\n\
5333 value. Custom axis labels can be enabled by passing appropriate\n\
5334 arguments to plenv, plbox, plbox3 and similar functions. \n\
5336 This function is used in example 19. \n\
5342 plslabelfunc(label_func, label_data)\n\
5346 label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n\
5347 This is the custom label function. In order to reset to the\n\
5348 default labeling, set this to NULL. The labeling function\n\
5349 parameters are, in order: axis: This indicates which axis a\n\
5350 label is being requested for. The value will be one of PL_X_AXIS,\n\
5351 PL_Y_AXIS or PL_Z_AXIS. \n\
5353 value: This is the value along the axis which is being labeled. \n\
5355 label_text: The string representation of the label value. \n\
5357 length: The maximum length in characters allowed for label_text. \n\
5360 label_data (void *, input) : This parameter may be used to pass\n\
5361 data to the label_func function. \n\
5364 Set length of major ticks \n\
5368 This sets up the length of the major ticks. The actual length is the\n\
5369 product of the default length and a scaling factor as for character\n\
5372 Redacted form: plsmaj(def, scale)\n\
5374 This function is used in example 29. \n\
5380 plsmaj(def, scale)\n\
5384 def (PLFLT, input) : The default length of a major tick in\n\
5385 millimeters, should be set to zero if the default length is to\n\
5386 remain unchanged. \n\
5388 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
5389 actual tick length. \n\
5392 Get the current library version number \n\
5396 Get the current library version number. Note: you must have allocated\n\
5397 space for this (80 characters is safe). \n\
5399 Redacted form: plgver(p_ver)\n\
5401 This function is used in example 1. \n\
5411 p_ver (char *, output) : Pointer to the current library version\n\
5415 Set format of numerical label for contours\n\
5419 Set format of numerical label for contours. \n\
5421 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
5423 This function is used example 9. \n\
5429 pl_setcontlabelformat(lexp, sigdig)\n\
5433 lexp (PLINT, input) : If the contour numerical label is greater\n\
5434 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
5435 format is used. Default value of lexp is 4. \n\
5437 sigdig (PLINT, input) : Number of significant digits. Default\n\
5441 Parse command-line arguments \n\
5445 Parse command-line arguments. \n\
5447 plparseopts removes all recognized flags (decreasing argc\n\
5448 accordingly), so that invalid input may be readily detected. It can\n\
5449 also be used to process user command line flags. The user can merge\n\
5450 an option table of type PLOptionTable into the internal option table\n\
5451 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
5452 the external table(s) be parsed by calling plClearOpts before\n\
5455 The default action taken by plparseopts is as follows: \n\
5456 Returns with an error if an unrecognized option or badly formed\n\
5457 option-value pair are encountered.\t\n\
5458 Returns immediately (return code 0) when the first non-option command\n\
5459 line argument is found. \n\
5460 Returns with the return code of the option handler, if one was called.\n\
5462 Deletes command line arguments from argv list as they are found, and\n\
5463 decrements argc accordingly. \n\
5464 Does not show \"invisible\" options in usage or help messages. \n\
5465 Assumes the program name is contained in argv[0]. \n\
5467 These behaviors may be controlled through the \n\
5470 Redacted form: General: plparseopts(argv, mode)\n\
5471 \t Perl/PDL: Not available? \n\
5474 This function is used in all of the examples. \n\
5480 int plparseopts(p_argc, argv, mode)\n\
5484 p_argc (int *, input) : pointer to number of arguments. \n\
5486 argv (char **, input) : Pointer to character array containing\n\
5487 *p_argc command-line arguments. \n\
5489 mode (PLINT, input) : Parsing mode with the following\n\
5490 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
5491 and all error messages enabled, including program exit when an\n\
5492 error occurs. Anything on the command line that isn\'t recognized\n\
5493 as a valid option or option argument is flagged as an error. \n\
5494 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
5496 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
5498 PL_PARSE_SHOWALL (8) -- Show invisible options \n\
5499 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
5500 pointer to the program name. \n\
5501 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
5502 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
5503 unrecognized arguments. \n\
5510 Initializing the plotting package.\tThe program prompts for the device\n\
5511 keyword or number of the desired output device. Hitting a RETURN in\n\
5512 response to the prompt is the same as selecting the first device. If\n\
5513 only one device is enabled when PLplot is installed, plstar will issue\n\
5514 no prompt.\tThe output device is divided into nx by ny subpages, each\n\
5515 of which may be used independently. The subroutine pladv is used to\n\
5516 advance from one subpage to the next. \n\
5518 Redacted form: plstar(nx, ny)\n\
5520 This function is used in example 1. \n\
5530 nx (PLINT, input) : Number of subpages to divide output page in the\n\
5531 horizontal direction. \n\
5533 ny (PLINT, input) : Number of subpages to divide output page in the\n\
5534 vertical direction. \n\
5537 Get FCI (font characterization integer) \n\
5541 Gets information about the current font using the FCI approach. See\n\
5542 the PLplot documentation for more information. \n\
5544 Redacted form: plgfci(fci)\n\
5546 This function is used in example 23. \n\
5556 fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
5557 integer) variable which is updated with current FCI value. \n\
5560 Set family file parameters \n\
5564 Sets variables dealing with output file familying.\tDoes nothing if\n\
5565 familying not supported by the driver. This routine, if used, must be\n\
5566 called before initializing PLplot.\tSee the PLplot documentation for\n\
5567 more information. \n\
5569 Redacted form: plsfam(fam, num, bmax)\n\
5571 This function is used in examples 14,31. \n\
5577 plsfam(fam, num, bmax)\n\
5581 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
5584 num (PLINT, input) : Current family file number. \n\
5586 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
5590 Set color map1 colors using a piece-wise linear relationship \n\
5594 This is a version of plscmap1l that supports alpha transparency. It\n\
5595 sets color map1 colors using a piece-wise linear relationship between\n\
5596 position in the color map (from 0 to 1) and position in HLS or RGB\n\
5597 color space (see the PLplot documentation) with alpha value (0.0 -\n\
5598 1.0). It may be called at any time. \n\
5600 This function is used in example 30. \n\
5606 plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n\
5610 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
5612 npts (PLINT, input) : number of control points \n\
5614 pos (PLFLT *, input) : position for each control point (between 0.0\n\
5615 and 1.0, in ascending order) \n\
5617 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
5620 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
5623 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
5626 coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n\
5627 each control point \n\
5629 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
5630 flag for each control point. (alt_hue_path[i] refers to the\n\
5631 interpolation interval between the i and i + 1 control points). \n\
5634 Set page parameters \n\
5638 Sets the page configuration (optional). If an individual parameter is\n\
5639 zero then that parameter value is not updated. Not all parameters are\n\
5640 recognized by all drivers and the interpretation is device-dependent.\n\
5641 The X-window driver uses the length and offset parameters to determine\n\
5642 the window size and location. The length and offset values are\n\
5643 expressed in units that are specific to the current driver. For\n\
5644 instance: screen drivers will usually interpret them as number of\n\
5645 pixels, whereas printer drivers will usually use mm. This routine, if\n\
5646 used, must be called before initializing PLplot. \n\
5648 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5650 This function is used in examples 14 and 31. \n\
5656 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5660 xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
5662 yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
5664 xleng (PLINT , input) : Page length, x. \n\
5666 yleng (PLINT, input) : Page length, y. \n\
5668 xoff (PLINT, input) : Page offset, x. \n\
5670 yoff (PLINT, input) : Page offset, y. \n\
5673 Set precision in numeric labels \n\
5677 Sets the number of places after the decimal point in numeric labels. \n\
5679 Redacted form: plprec(set, prec)\n\
5681 This function is used in example 29. \n\
5687 plprec(set, prec)\n\
5691 set (PLINT, input) : If set is equal to 0 then PLplot automatically\n\
5692 determines the number of places to use after the decimal point in\n\
5693 numeric labels (like those used to label axes). If set is 1 then\n\
5694 prec sets the number of places. \n\
5696 prec (PLINT, input) : The number of characters to draw after the\n\
5697 decimal point in numeric labels. \n\
5700 Copy state parameters from the reference stream to the current stream \n\
5704 Copies state parameters from the reference stream to the current\n\
5705 stream. Tell driver interface to map device coordinates unless flags\n\
5708 This function is used for making save files of selected plots (e.g.\n\
5709 from the TK driver). After initializing, you can get a copy of the\n\
5710 current plot to the specified device by switching to this stream and\n\
5711 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5712 appropriate. The plot buffer must have previously been enabled (done\n\
5713 automatically by some display drivers, such as X). \n\
5715 Redacted form: plcpstrm(iplsr, flags)\n\
5717 This function is used in example 1,20. \n\
5723 plcpstrm(iplsr, flags)\n\
5727 iplsr (PLINT, input) : Number of reference stream. \n\
5729 flags (PLBOOL, input) : If flags is set to true the device\n\
5730 coordinates are not copied from the reference to current stream. \n\
5733 Plot a glyph at the specified points \n\
5737 Plot a glyph at the specified points. (This function is largely\n\
5738 superseded by plstring which gives access to many[!] more glyphs.)\n\
5739 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5740 and a draw at the same place. Not ideal, since a sufficiently\n\
5741 intelligent output device may optimize it away, or there may be faster\n\
5742 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5743 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5744 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5745 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5746 code <= 127 the corresponding printable ASCII character is plotted. \n\
5748 Redacted form: plpoin(x, y, code)\n\
5750 This function is used in examples 1,6,14,29. \n\
5756 plpoin(n, x, y, code)\n\
5760 n (PLINT, input) : Number of points in the x and y arrays. \n\
5762 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
5765 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
5768 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5769 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5770 each of the n points. \n\
5773 Enter or leave xor mode \n\
5777 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
5778 those drivers (e.g., the xwin driver) that support it. Enables\n\
5779 erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
5780 is not capable of xor operation it returns a status of false. \n\
5782 Redacted form: plxormod(mode, status)\n\
5784 This function is used in examples 1,20. \n\
5790 plxormod(mode, status)\n\
5794 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
5795 is false means leave xor mode. \n\
5797 status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
5798 of true (false) means driver is capable (incapable) of xor mode. \n\
5801 Get viewport limits in normalized device coordinates \n\
5805 Get viewport limits in normalized device coordinates. \n\
5807 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5808 \t Perl/PDL: Not available? \n\
5811 This function is used in example 31. \n\
5817 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5821 p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5822 device coordinate in x. \n\
5824 p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5825 device coordinate in x. \n\
5827 p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5828 device coordinate in y. \n\
5830 p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5831 device coordinate in y. \n\
5834 End plotting session for current stream \n\
5838 Ends a plotting session for the current output stream only. See\n\
5839 plsstrm for more info. \n\
5841 Redacted form: plend1()\n\
5843 This function is used in examples 1,20. \n\
5852 Get y axis parameters \n\
5856 Identical to plgxax, except that arguments are flags for y axis. See\n\
5857 the description of plgxax for more detail. \n\
5859 Redacted form: plgyax(digmax, digits)\n\
5861 This function is used in example 31. \n\
5867 plgyax(digmax, digits)\n\
5871 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5872 number of digits for the y axis. If nonzero, the printed label\n\
5873 has been switched to a floating point representation when the\n\
5874 number of digits exceeds digmax. \n\
5876 digits (PLINT *, output) : Pointer to variable with the actual\n\
5877 number of digits for the numeric labels (y axis) from the last\n\
5881 Set plot orientation \n\
5885 Set plot orientation parameter which is multiplied by 90 degrees to\n\
5886 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
5887 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
5888 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
5889 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
5890 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
5891 not called the default value of rot is 0. \n\
5893 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
5894 probably want to change the aspect ratio to a value suitable for the\n\
5895 plot orientation using a call to plsdidev or the command-line options\n\
5896 -a or -freeaspect.\tFor more documentation of those options see the\n\
5897 PLplot documentation. Such command-line options can be set internally\n\
5898 using plsetopt or set directly using the command line and parsed using\n\
5899 a call to plparseopts. \n\
5901 Redacted form: plsdiori(rot)\n\
5903 This function is not used in any examples. \n\
5913 rot (PLFLT, input) : Plot orientation parameter. \n\
5916 Plot a histogram from unbinned data \n\
5920 Plots a histogram from n data points stored in the array data. This\n\
5921 routine bins the data into nbin bins equally spaced between datmin and\n\
5922 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
5923 opt allows, among other things, the histogram either to be plotted in\n\
5924 an existing window or causes plhist to call plenv with suitable limits\n\
5925 before plotting the histogram. \n\
5927 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
5929 This function is used in example 5. \n\
5935 plhist(n, data, datmin, datmax, nbin, opt)\n\
5939 n (PLINT, input) : Number of data points. \n\
5941 data (PLFLT *, input) : Pointer to array with values of the n data\n\
5944 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
5946 datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
5948 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
5949 divide the interval xmin to xmax. \n\
5951 opt (PLINT, input) : Is a combination of several flags:\n\
5952 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
5953 the histogram data, the outer bins are expanded to fill up the\n\
5954 entire x-axis, data outside the given extremes are assigned to the\n\
5955 outer bins and bins of zero height are simply drawn. \n\
5956 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
5957 to fit the histogram data, without this flag, plenv is called\n\
5958 to set the world coordinates. \n\
5959 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
5960 extremes are not taken into account. This option should\n\
5961 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
5962 properly present the data. \n\
5963 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
5964 size as the ones inside. \n\
5965 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
5966 (there is a gap for such bins). \n\
5969 End plotting session \n\
5973 Ends a plotting session, tidies up all the output files, switches\n\
5974 interactive devices back into text mode and frees up any memory that\n\
5975 was allocated. Must be called before end of program. \n\
5977 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
5978 wait state after a call to plend or other functions which trigger the\n\
5979 end of a plot page. To avoid this, use the plspause function. \n\
5981 Redacted form: plend()\n\
5983 This function is used in all of the examples. \n\
5992 Set device-compression level \n\
5996 Set device-compression level. Only used for drivers that provide\n\
5997 compression. This function, if used, should be invoked before a call\n\
6000 Redacted form: plscompression(compression)\n\
6002 This function is used in example 31. \n\
6008 plscompression(compression)\n\
6012 compression (PLINT, input) : The desired compression level. This is\n\
6013 a device-dependent value. Currently only the jpeg and png devices\n\
6014 use these values. For jpeg value is the jpeg quality which should\n\
6015 normally be in the range 0-95. Higher values denote higher quality\n\
6016 and hence larger image sizes. For png values are in the range -1\n\
6017 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
6018 A value of -1 denotes the default zlib compression level. Values\n\
6019 in the range 10-99 are divided by 10 and then used as the zlib\n\
6020 compression level. Higher compression levels correspond to greater\n\
6021 compression and small file sizes at the expense of more\n\
6025 Get the current device-compression setting \n\
6029 Get the current device-compression setting. This parameter is only\n\
6030 used for drivers that provide compression. \n\
6032 Redacted form: plgcompression(compression)\n\
6034 This function is used in example 31. \n\
6040 plgcompression(compression)\n\
6044 compression (PLINT *, output) : Pointer to a variable to be filled\n\
6045 with the current device-compression setting. \n\
6048 Advance the (sub-)page\n\
6052 Advances to the next subpage if sub=0, performing a page advance if\n\
6053 there are no remaining subpages on the current page. If subpages\n\
6054 aren\'t being used, pladv(0) will always advance the page. If sub>0,\n\
6055 PLplot switches to the specified subpage. Note that this allows you\n\
6056 to overwrite a plot on the specified subpage; if this is not what you\n\
6057 intended, use pleop followed by plbop to first advance the page. This\n\
6058 routine is called automatically (with sub=0) by plenv, but if plenv is\n\
6059 not used, pladv must be called after initializing PLplot but before\n\
6060 defining the viewport. \n\
6062 Redacted form: pladv(sub)\n\
6064 This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
6074 sub (PLINT, input) : Specifies the subpage number (starting from 1\n\
6075 in the top left corner and increasing along the rows) to which to\n\
6076 advance. Set to zero to advance to the next subpage. \n\
6079 Set parameters of contour labelling other than format of numerical label\n\
6083 Set parameters of contour labelling other than those handled by\n\
6084 pl_setcontlabelformat. \n\
6086 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
6088 This function is used in example 9. \n\
6094 pl_setcontlabelparam(offset, size, spacing, active)\n\
6098 offset (PLFLT, input) : Offset of label from contour line (if set\n\
6099 to 0.0, labels are printed on the lines). Default value is 0.006. \n\
6101 size (PLFLT, input) : Font height for contour labels (normalized). \n\
6102 Default value is 0.3. \n\
6104 spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
6105 Default value is 0.1. \n\
6107 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
6108 contour labels on. Default is off (0). \n\
6111 Set family, style and weight of the current font \n\
6115 Sets the current font. See the PLplot documentation for more\n\
6116 information on font selection. \n\
6118 Redacted form: plsfont(family, style, weight)\n\
6120 This function is used in example 23. \n\
6126 plsfont(family, style, weight)\n\
6130 family (PLINT, input) : Font family to select for the current font.\n\
6131 The available values are given by the PL_FCI_* constants in\n\
6132 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n\
6133 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
6134 signifies that the font family should not be altered. \n\
6136 style (PLINT, input) : Font style to select for the current font.\n\
6137 The available values are given by the PL_FCI_* constants in\n\
6138 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
6139 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
6140 should not be altered. \n\
6142 weight (PLINT, input) : Font weight to select for the current font.\n\
6143 The available values are given by the PL_FCI_* constants in\n\
6144 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
6145 negative value signifies that the font weight should not be\n\
6149 Sets the 3D position of the light source \n\
6153 Sets the 3D position of the light source for use with plsurf3d. \n\
6155 Redacted form: pllightsource(x, y, z)\n\
6157 This function is used in example 8. \n\
6163 pllightsource(x, y, z)\n\
6167 x (PLFLT, input) : X-coordinate of the light source. \n\
6169 y (PLFLT, input) : Y-coordinate of the light source. \n\
6171 z (PLFLT, input) : Z-coordinate of the light source. \n\
6178 Draws line defined by n points in x and y. \n\
6180 Redacted form: plline(x, y)\n\
6182 This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
6192 n (PLINT, input) : Number of points defining line. \n\
6194 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
6196 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
6203 Sets the pen width. \n\
6205 Redacted form: plwidth(width)\n\
6207 This function is used in examples 1,2. \n\
6217 width (PLINT, input) : The desired pen width. If width is negative\n\
6218 or the same as the previous value no action is taken. width = 0\n\
6219 should be interpreted as as the minimum valid pen width for the\n\
6220 device. The interpretation of positive width values is also\n\
6221 device dependent. \n\
6224 Draw linear gradient inside polygon \n\
6228 Draw a linear gradient using colour map 1 inside the polygon defined\n\
6229 by the n points (\n\
6231 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
6232 polygon coordinates and the gradient angle are all expressed in world\n\
6233 coordinates. The angle from the x axis for both the rotated\n\
6234 coordinate system and the gradient vector is specified by angle. The\n\
6235 magnitude of the gradient vector is the difference between the maximum\n\
6236 and minimum values of x for the vertices in the rotated coordinate\n\
6237 system. The origin of the gradient vector can be interpreted as being\n\
6238 anywhere on the line corresponding to the minimum x value for the\n\
6239 vertices in the rotated coordinate system.\tThe distance along the\n\
6240 gradient vector is linearly transformed to the independent variable of\n\
6241 colour map 1 which ranges from 0. at the tail of the gradient vector\n\
6242 to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
6243 colour corresponding to the independent variable of colour map 1. For\n\
6244 more information about colour map 1 (see the PLplot documentation). \n\
6246 Redacted form: plgradient(x,y,angle)\n\
6248 This function is used in examples 25,30. \n\
6254 plgradient(n, x, y, angle)\n\
6258 n (PLINT, input) : Number of vertices in polygon. \n\
6260 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
6263 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
6266 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
6270 Flushes the output stream \n\
6274 Flushes the output stream. Use sparingly, if at all. \n\
6276 Redacted form: plflush()\n\
6278 This function is used in examples 1,14. \n\
6287 Get plot orientation \n\
6291 Get plot orientation parameter which is multiplied by 90 degrees to\n\
6292 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
6293 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
6294 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
6295 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
6296 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
6297 not been called the default value pointed to by p_rot will be 0. \n\
6299 Redacted form: plgdiori(p_rot)\n\
6301 This function is not used in any examples. \n\
6311 p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
6314 Set x axis parameters \n\
6318 Sets values of the digmax and digits flags for the x axis.\tSee the\n\
6319 PLplot documentation for more information. \n\
6321 Redacted form: plsxax(digmax, digits)\n\
6323 This function is used in example 31. \n\
6329 plsxax(digmax, digits)\n\
6333 digmax (PLINT, input) : Variable to set the maximum number of\n\
6334 digits for the x axis. If nonzero, the printed label will be\n\
6335 switched to a floating point representation when the number of\n\
6336 digits exceeds digmax. \n\
6338 digits (PLINT, input) : Field digits value. Currently, changing\n\
6339 its value here has no effect since it is set only by plbox or\n\
6340 plbox3. However, the user may obtain its value after a call to\n\
6341 either of these functions by calling plgxax. \n\
6344 Get viewport limits in world coordinates \n\
6348 Get viewport limits in world coordinates. \n\
6350 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6351 \t Perl/PDL: Not available? \n\
6354 This function is used in example 31. \n\
6360 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6364 p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
6365 coordinate in x. \n\
6367 p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
6368 coordinate in x. \n\
6370 p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
6371 coordinate in y. \n\
6373 p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
6374 coordinate in y. \n\
6377 Get current subpage parameters \n\
6381 Gets the size of the current subpage in millimeters measured from the\n\
6382 bottom left hand corner of the output device page or screen. Can be\n\
6383 used in conjunction with plsvpa for setting the size of a viewport in\n\
6384 absolute coordinates (millimeters). \n\
6386 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
6388 This function is used in example 23. \n\
6394 plgspa(xmin, xmax, ymin, ymax)\n\
6398 xmin (PLFLT *, output) : Pointer to variable with position of left\n\
6399 hand edge of subpage in millimeters. \n\
6401 xmax (PLFLT *, output) : Pointer to variable with position of right\n\
6402 hand edge of subpage in millimeters. \n\
6404 ymin (PLFLT *, output) : Pointer to variable with position of\n\
6405 bottom edge of subpage in millimeters. \n\
6407 ymax (PLFLT *, output) : Pointer to variable with position of top\n\
6408 edge of subpage in millimeters. \n\
6411 Calculate world coordinates and corresponding window index from relative device coordinates \n\
6415 Calculate world coordinates, wx and wy, and corresponding window index\n\
6416 from relative device coordinates, rx and ry. \n\
6418 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
6419 \t Perl/PDL: Not available? \n\
6422 This function is used in example 31. \n\
6428 plcalc_world(rx, ry, wx, wy, window)\n\
6432 rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
6433 0. to 1.) for the x coordinate. \n\
6435 ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
6436 0. to 1.) for the y coordinate. \n\
6438 wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6439 x corresponding to the relative device coordinates rx and ry. \n\
6441 wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6442 y corresponding to the relative device coordinates rx and ry. \n\
6444 window (PLINT *, output) : Pointer to the returned last defined\n\
6445 window index that corresponds to the input relative device\n\
6446 coordinates (and the returned world coordinates). To give some\n\
6447 background on the window index, for each page the initial window\n\
6448 index is set to zero, and each time plwind is called within the\n\
6449 page, world and device coordinates are stored for the window and\n\
6450 the window index is incremented. Thus, for a simple page layout\n\
6451 with non-overlapping viewports and one window per viewport, window\n\
6452 corresponds to the viewport index (in the order which the\n\
6453 viewport/windows were created) of the only viewport/window\n\
6454 corresponding to rx and ry. However, for more complicated layouts\n\
6455 with potentially overlapping viewports and possibly more than one\n\
6456 window (set of world coordinates) per viewport, window and the\n\
6457 corresponding output world coordinates corresponds to the last\n\
6458 window created that fulfils the criterion that the relative device\n\
6459 coordinates are inside it. Finally, in all cases where the input\n\
6460 relative device coordinates are not inside any viewport/window,\n\
6461 then window is set to -1. \n\
6464 Draw a box with axes, etc, in 3-d \n\
6468 Draws axes, numeric and text labels for a three-dimensional surface\n\
6469 plot. For a more complete description of three-dimensional plotting\n\
6470 see the PLplot documentation. \n\
6472 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6473 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6474 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
6475 xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
6478 This function is used in examples 8,11,18,21. \n\
6484 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6488 xopt (const char *, input) : Pointer to character string specifying\n\
6489 options for the x axis. The string can include any combination of\n\
6490 the following letters (upper or lower case) in any order: b: Draws\n\
6491 axis at base, at height z=\n\
6492 zmin where zmin is defined by call to plw3d. This character must be\n\
6493 specified in order to use any of the other options. \n\
6494 f: Always use fixed point numeric labels. \n\
6495 i: Inverts tick marks, so they are drawn downwards, rather\n\
6497 l: Labels axis logarithmically. This only affects the labels,\n\
6498 not the data, and so it is necessary to compute the logarithms\n\
6499 of data points before passing them to any of the drawing\n\
6501 n: Writes numeric labels at major tick intervals. \n\
6502 o: Use custom labeling function to generate axis label text. \n\
6503 The custom labeling function can be defined with the\n\
6504 plslabelfuncplslabelfunc; command. \n\
6505 s: Enables subticks between major ticks, only valid if t is\n\
6507 t: Draws major ticks. \n\
6508 u: If this is specified, the text label for the axis is\n\
6509 written under the axis. \n\
6512 xlabel (const char *, input) : Pointer to character string\n\
6513 specifying text label for the x axis. It is only drawn if u is in\n\
6514 the xopt string. \n\
6516 xtick (PLFLT, input) : World coordinate interval between major\n\
6517 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6518 generates a suitable tick interval. \n\
6520 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6521 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6522 generates a suitable minor tick interval. \n\
6524 yopt (const char *, input) : Pointer to character string specifying\n\
6525 options for the y axis. The string is interpreted in the same way\n\
6528 ylabel (const char *, input) : Pointer to character string\n\
6529 specifying text label for the y axis. It is only drawn if u is in\n\
6530 the yopt string. \n\
6532 ytick (PLFLT, input) : World coordinate interval between major\n\
6533 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6534 generates a suitable tick interval. \n\
6536 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6537 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6538 generates a suitable minor tick interval. \n\
6540 zopt (const char *, input) : Pointer to character string specifying\n\
6541 options for the z axis. The string can include any combination of\n\
6542 the following letters (upper or lower case) in any order: b: Draws\n\
6543 z axis to the left of the surface plot. \n\
6544 c: Draws z axis to the right of the surface plot. \n\
6545 d: Draws grid lines parallel to the x-y plane behind the\n\
6546 figure. These lines are not drawn until after plot3d or\n\
6547 plmesh are called because of the need for hidden line removal. \n\
6548 f: Always use fixed point numeric labels. \n\
6549 i: Inverts tick marks, so they are drawn away from the center. \n\
6550 l: Labels axis logarithmically. This only affects the labels,\n\
6551 not the data, and so it is necessary to compute the logarithms\n\
6552 of data points before passing them to any of the drawing\n\
6554 m: Writes numeric labels at major tick intervals on the\n\
6555 right-hand vertical axis. \n\
6556 n: Writes numeric labels at major tick intervals on the\n\
6557 left-hand vertical axis. \n\
6558 o: Use custom labeling function to generate axis label text. \n\
6559 The custom labeling function can be defined with the\n\
6560 plslabelfuncplslabelfunc; command. \n\
6561 s: Enables subticks between major ticks, only valid if t is\n\
6563 t: Draws major ticks. \n\
6564 u: If this is specified, the text label is written beside the\n\
6566 v: If this is specified, the text label is written beside the\n\
6567 right-hand axis. \n\
6570 zlabel (const char *, input) : Pointer to character string\n\
6571 specifying text label for the z axis. It is only drawn if u or v\n\
6572 are in the zopt string. \n\
6574 ztick (PLFLT, input) : World coordinate interval between major\n\
6575 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6576 generates a suitable tick interval. \n\
6578 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6579 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6580 generates a suitable minor tick interval. \n\
6583 Get character default height and current (scaled) height \n\
6587 Get character default height and current (scaled) height. \n\
6589 Redacted form: plgchr(p_def, p_ht)\n\
6591 This function is used in example 23. \n\
6597 plgchr(p_def, p_ht)\n\
6601 p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
6603 p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
6607 Set the escape character for text strings \n\
6611 Set the escape character for text strings.\tFrom C (in contrast to\n\
6612 Fortran 77, see plsescfortran77) you pass esc as a character. Only\n\
6613 selected characters are allowed to prevent the user from shooting\n\
6614 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
6615 with C\'s use of backslash as a character escape). Here are the\n\
6616 allowed escape characters and their corresponding decimal ASCII\n\
6617 values: !, ASCII 33 \n\
6628 Redacted form: General: plsesc(esc)\n\
6629 \t Perl/PDL: Not available? \n\
6632 This function is used in example 29. \n\
6642 esc (char, input) : Escape character. \n\
6645 Set up standard window and draw box \n\
6649 Sets up plotter environment for simple graphs by calling pladv and\n\
6650 setting up viewport and window to sensible default values.\tplenv\n\
6651 leaves enough room around most graphs for axis labels and a title.\n\
6652 When these defaults are not suitable, use the individual routines\n\
6653 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
6654 defining the window, and plbox for drawing the box. \n\
6656 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6658 This function is used in example 1,3,9,13,14,19-22,29. \n\
6664 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6668 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
6669 world coordinates). \n\
6671 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
6672 world coordinates). \n\
6674 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
6677 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
6680 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
6681 scales will not be set, the user must set up the scale before\n\
6682 calling plenv using plsvpa, plvasp or other. \n\
6683 0: the x and y axes are scaled independently to use as much of\n\
6684 the screen as possible. \n\
6685 1: the scales of the x and y axes are made equal. \n\
6686 2: the axis of the x and y axes are made equal, and the plot\n\
6687 box will be square. \n\
6690 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
6691 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
6692 -1: draw box only. \n\
6693 0: draw box, ticks, and numeric tick labels. \n\
6694 1: also draw coordinate axes at x=0 and y=0. \n\
6695 2: also draw a grid at major tick positions in both\n\
6697 3: also draw a grid at minor tick positions in both\n\
6699 10: same as 0 except logarithmic x tick marks. (The x data\n\
6700 have to be converted to logarithms separately.) \n\
6701 11: same as 1 except logarithmic x tick marks. (The x data\n\
6702 have to be converted to logarithms separately.) \n\
6703 12: same as 2 except logarithmic x tick marks. (The x data\n\
6704 have to be converted to logarithms separately.) \n\
6705 13: same as 3 except logarithmic x tick marks. (The x data\n\
6706 have to be converted to logarithms separately.) \n\
6707 20: same as 0 except logarithmic y tick marks. (The y data\n\
6708 have to be converted to logarithms separately.) \n\
6709 21: same as 1 except logarithmic y tick marks. (The y data\n\
6710 have to be converted to logarithms separately.) \n\
6711 22: same as 2 except logarithmic y tick marks. (The y data\n\
6712 have to be converted to logarithms separately.) \n\
6713 23: same as 3 except logarithmic y tick marks. (The y data\n\
6714 have to be converted to logarithms separately.) \n\
6715 30: same as 0 except logarithmic x and y tick marks. (The x\n\
6716 and y data have to be converted to logarithms separately.) \n\
6717 31: same as 1 except logarithmic x and y tick marks. (The x\n\
6718 and y data have to be converted to logarithms separately.) \n\
6719 32: same as 2 except logarithmic x and y tick marks. (The x\n\
6720 and y data have to be converted to logarithms separately.) \n\
6721 33: same as 3 except logarithmic x and y tick marks. (The x\n\
6722 and y data have to be converted to logarithms separately.) \n\
6723 40: same as 0 except date / time x labels. \n\
6724 41: same as 1 except date / time x labels. \n\
6725 42: same as 2 except date / time x labels. \n\
6726 43: same as 3 except date / time x labels. \n\
6727 50: same as 0 except date / time y labels. \n\
6728 51: same as 1 except date / time y labels. \n\
6729 52: same as 2 except date / time y labels. \n\
6730 53: same as 3 except date / time y labels. \n\
6731 60: same as 0 except date / time x and y labels. \n\
6732 61: same as 1 except date / time x and y labels. \n\
6733 62: same as 2 except date / time x and y labels. \n\
6734 63: same as 3 except date / time x and y labels. \n\
6735 70: same as 0 except custom x and y labels. \n\
6736 71: same as 1 except custom x and y labels. \n\
6737 72: same as 2 except custom x and y labels. \n\
6738 73: same as 3 except custom x and y labels. \n\
6741 Clear current (sub)page \n\
6745 Clears the current page, effectively erasing everything that have been\n\
6746 drawn. This command only works with interactive drivers; if the\n\
6747 driver does not support this, the page is filled with the background\n\
6748 color in use. If the current page is divided into subpages, only the\n\
6749 current subpage is erased.\tThe nth subpage can be selected with\n\
6752 Redacted form: General: plclear()\n\
6753 \t Perl/PDL: Not available? \n\
6756 This function is not used in any examples. \n\
6765 Set color map0 colors by 8-bit RGB values and double alpha value. \n\
6769 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
6770 documentation) and floating point alpha value. This sets the entire\n\
6771 color map -- only as many colors as specified will be allocated. \n\
6773 This function is used in examples 30. \n\
6779 plscmap0a(r, g, b, a, ncol0)\n\
6783 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6784 integers (0-255) representing the degree of red in the color. \n\
6786 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6787 integers (0-255) representing the degree of green in the color. \n\
6789 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6790 integers (0-255) representing the degree of blue in the color. \n\
6792 a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n\
6793 - 1.0) representing the transparency of the color. \n\
6795 ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n\
6799 Set a given color from color map0 by 8 bit RGB value \n\
6803 Set a given color by 8-bit RGB value for color map0 (see the PLplot\n\
6804 documentation). Overwrites the previous color value for the given\n\
6805 index and, thus, does not result in any additional allocation of space\n\
6808 Redacted form: plscol0(icol0, r, g, b)\n\
6810 This function is not used in any examples. \n\
6816 plscol0(icol0, r, g, b)\n\
6820 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6821 number of colors (which is set by default, by plscmap0n, or even\n\
6824 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6825 degree of red in the color. \n\
6827 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6828 degree of green in the color. \n\
6830 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6831 degree of blue in the color. \n\
6834 Set up transformation from metafile coordinates \n\
6838 Set up transformation from metafile coordinates. The size of the plot\n\
6839 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
6840 general-purpose facility just yet (not sure why the user would need\n\
6843 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
6846 This function is not used in any examples. \n\
6852 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
6856 dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
6858 dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
6860 dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
6862 dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
6864 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6866 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6869 Creates a new stream and makes it the default \n\
6873 Creates a new stream and makes it the default. Differs from using\n\
6874 plsstrm, in that a free stream number is found, and returned.\n\
6875 Unfortunately, I have to start at stream 1 and work upward, since\n\
6876 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6877 that no initial, library-opening call is required.\tSo stream 0 must\n\
6878 be preallocated, and there is no simple way of determining whether it\n\
6879 is already in use or not. \n\
6881 Redacted form: plmkstrm(p_strm)\n\
6883 This function is used in examples 1,20. \n\
6893 p_strm (PLINT *, output) : Pointer to stream number of the created\n\
6897 Get page parameters \n\
6901 Gets the current page configuration. The length and offset values are\n\
6902 expressed in units that are specific to the current driver. For\n\
6903 instance: screen drivers will usually interpret them as number of\n\
6904 pixels, whereas printer drivers will usually use mm. \n\
6906 Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6908 This function is used in examples 14 and 31. \n\
6914 plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6918 xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
6920 yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n\
6922 xleng (PLINT *, output) : Pointer to x page length value. \n\
6924 yleng (PLINT *, output) : Pointer to y page length value. \n\
6926 xoff (PLINT *, output) : Pointer to x page offset. \n\
6928 yoff (PLINT *, output) : Pointer to y page offset. \n\
6931 Set format for date / time labels \n\
6935 Sets the format for date / time labels. To enable date / time format\n\
6936 labels see the options to plbox and plenv.\t\n\
6938 Redacted form: pltimefmt(fmt)\n\
6940 This function is used in example 29. \n\
6950 fmt (const char *, fmt) : This string is passed directly to the\n\
6951 system strftime. See the system documentation for a full list of\n\
6952 conversion specifications for your system. All conversion\n\
6953 specifications take the form of a \'%\' character followed by\n\
6954 further conversion specification character. All other text is\n\
6955 printed as-is. Common options include: %c: The preferred date and\n\
6956 time representation for the current locale. \n\
6957 %d: The day of the month as a decimal number. \n\
6958 %H: The hour as a decimal number using a 24-hour clock. \n\
6959 %j: The day of the year as a decimal number. \n\
6960 %m: The month as a decimal number. \n\
6961 %M: The minute as a decimal number. \n\
6962 %S: The second as a decimal number. \n\
6963 %y: The year as a decimal number without a century. \n\
6964 %Y: The year as a decimal number including a century. \n\
6967 Specify viewport using aspect ratio only \n\
6971 Sets the viewport so that the ratio of the length of the y axis to\n\
6972 that of the x axis is equal to aspect. \n\
6974 Redacted form: plvasp(aspect)\n\
6976 This function is used in example 13. \n\
6986 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6990 Set output file name \n\
6994 Sets the current output file name, if applicable. If the file name\n\
6995 has not been specified and is required by the driver, the user will be\n\
6996 prompted for it. If using the X-windows output driver, this sets the\n\
6997 display name. This routine, if used, must be called before\n\
6998 initializing PLplot. \n\
7000 Redacted form: plsfnam(fnam)\n\
7002 This function is used in examples 1,20. \n\
7012 fnam (const char *, input) : Pointer to file name string. \n\
7015 Set parameters that define current plot-space window \n\
7019 Set relative minima and maxima that define the current plot-space\n\
7020 window. If plsdiplt is not called the default values of xmin, ymin,\n\
7021 xmax, and ymax are 0., 0., 1., and 1. \n\
7023 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
7025 This function is used in example 31. \n\
7031 plsdiplt(xmin, ymin, xmax, ymax)\n\
7035 xmin (PLFLT, input) : Relative minimum in x. \n\
7037 ymin (PLFLT, input) : Relative minimum in y. \n\
7039 xmax (PLFLT, input) : Relative maximum in x. \n\
7041 ymax (PLFLT, input) : Relative maximum in y. \n\
7044 Select line style \n\
7048 This sets the line style according to one of eight predefined patterns\n\
7049 (also see plstyl). \n\
7051 Redacted form: pllsty(n)\n\
7053 This function is used in examples 9,12,22,25. \n\
7063 n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n\
7064 continuous line, line style 2 is a line with short dashes and\n\
7065 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7066 4 has long dashes and short gaps and so on. \n\
7069 Plot a glyph at the specified points \n\
7073 Plot a glyph at the specified points. (This function is largely\n\
7074 superseded by plstring which gives access to many[!] more glyphs.) \n\
7076 Redacted form: plsym(x, y, code)\n\
7078 This function is used in example 7. \n\
7084 plsym(n, x, y, code)\n\
7088 n (PLINT, input) : Number of points in the x and y arrays. \n\
7090 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7093 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7096 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
7097 to be plotted at each of the n points. \n\
7100 Set the device (keyword) name \n\
7104 Set the device (keyword) name. \n\
7106 Redacted form: plsdev(devname)\n\
7108 This function is used in examples 1,14,20. \n\
7118 devname (const char *, input) : Pointer to device (keyword) name\n\
7122 Set the background color by 8-bit RGB value \n\
7126 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7127 (see the PLplot documentation). \n\
7129 Redacted form: plscolbg(r, g, b)\n\
7131 This function is used in examples 15,31. \n\
7137 plscolbg(r, g, b)\n\
7141 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7142 degree of red in the color. \n\
7144 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7145 degree of green in the color. \n\
7147 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7148 degree of blue in the color. \n\
7151 Set parameters incrementally (zoom mode) that define current plot-space window \n\
7155 Set relative minima and maxima incrementally (zoom mode) that define\n\
7156 the current plot-space window. This function has the same effect as\n\
7157 plsdiplt if that function has not been previously called. Otherwise,\n\
7158 this function implements zoom mode using the transformation min_used =\n\
7159 old_min + old_length*min and max_used = old_min + old_length*max for\n\
7160 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
7161 repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
7163 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
7165 This function is used in example 31. \n\
7171 plsdiplz(xmin, ymin, xmax, ymax)\n\
7175 xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
7177 ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
7179 xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
7181 ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
7184 Advance to the next family file on the next new page \n\
7188 Advance to the next family file on the next new page. \n\
7190 Redacted form: plfamadv()\n\
7192 This function is not used in any examples. \n\
7201 Set number of colors in color map0 \n\
7205 Set number of colors in color map0 (see the PLplot documentation).\n\
7206 Allocate (or reallocate) color map0, and fill with default values for\n\
7207 those colors not previously allocated. The first 16 default colors are\n\
7208 given in the plcol0 documentation. For larger indices the default\n\
7211 The drivers are not guaranteed to support more than 16 colors. \n\
7213 Redacted form: plscmap0n(ncol0)\n\
7215 This function is used in examples 15,16,24. \n\
7225 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
7226 the map0 palette. If this number is zero or less, then the value\n\
7227 from the previous call to plscmap0n is used and if there is no\n\
7228 previous call, then a default value is used. \n\
7231 Plot latitude and longitude lines. \n\
7235 Displays latitude and longitude on the current plot. The lines are\n\
7236 plotted in the current color and line style. \n\
7238 Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n\
7239 maxlong, minlat, maxlat)\n\
7240 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
7243 This function is used in example 19. \n\
7249 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7253 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
7254 supplied function to transform the coordinate longitudes and\n\
7255 latitudes to a plot coordinate system. By using this transform,\n\
7256 we can change from a longitude, latitude coordinate to a polar\n\
7257 stereographic project, for example. Initially, x[0]..[n-1] are\n\
7258 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
7259 After the call to mapform(), x[] and y[] should be replaced by\n\
7260 the corresponding plot coordinates. If no transform is desired,\n\
7261 mapform can be replaced by NULL. \n\
7263 dlong (PLFLT, input) : The interval in degrees at which the\n\
7264 longitude lines are to be plotted. \n\
7266 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7267 lines are to be plotted. \n\
7269 minlong (PLFLT, input) : The value of the longitude on the left\n\
7270 side of the plot. The value of minlong must be less than the\n\
7271 value of maxlong, and the quantity maxlong-minlong must be less\n\
7272 than or equal to 360. \n\
7274 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7275 side of the plot. \n\
7277 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7278 background. One can always use -90.0 as the boundary outside the\n\
7279 plot window will be automatically eliminated. However, the\n\
7280 program will be faster if one can reduce the size of the\n\
7281 background plotted. \n\
7283 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7284 background. One can always use 90.0 as the boundary outside the\n\
7285 plot window will be automatically eliminated. \n\
7288 Convert RGB color to HLS \n\
7292 Convert RGB color coordinates to HLS \n\
7294 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7295 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
7298 This function is used in example 2. \n\
7304 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7308 r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
7310 g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
7312 b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
7314 p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
7315 cone (0.0-360.0) \n\
7317 p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
7318 fraction of the axis of the colour cone (0.0-1.0) \n\
7320 p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
7321 fraction of the radius of the colour cone (0.0-1.0) \n\
7324 Plot a glyph at the specified 3D points \n\
7328 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
7329 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
7330 this function similar to what is done for plline3. The glyph is\n\
7331 specified with a PLplot user string. Note that the user string is not\n\
7332 actually limited to one glyph so it is possible (but not normally\n\
7333 useful) to plot more than one glyph at the specified points with this\n\
7334 function. As with plmtex and plptex, the user string can contain FCI\n\
7335 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7336 else PLplot escapes for Hershey or unicode text to determine the\n\
7339 Redacted form: plstring3(x, y, z, string)\n\
7341 This function is used in example 18. \n\
7347 plstring3(n, x, y, z, string)\n\
7351 n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
7353 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7356 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7359 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7362 string (const char *, input) : PLplot user string corresponding to\n\
7363 the glyph to be plotted at each of the n points. \n\
7366 Switch to text screen \n\
7370 Sets an interactive device to text mode, used in conjunction with\n\
7371 plgra to allow graphics and text to be interspersed. On a device\n\
7372 which supports separate text and graphics windows, this command causes\n\
7373 control to be switched to the text window.\tThis can be useful for\n\
7374 printing diagnostic messages or getting user input, which would\n\
7375 otherwise interfere with the plots. The program must switch back to\n\
7376 the graphics window before issuing plot commands, as the text (or\n\
7377 console) device will probably become quite confused otherwise. If\n\
7378 already in text mode, this command is ignored. It is also ignored on\n\
7379 devices which only support a single window or use a different method\n\
7380 for shifting focus (see also plgra). \n\
7382 Redacted form: pltext()\n\
7384 This function is used in example 1. \n\
7393 Get parameters that define current plot-space window \n\
7397 Get relative minima and maxima that define current plot-space window.\n\
7398 If plsdiplt has not been called the default values pointed to by\n\
7399 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
7401 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7403 This function is used in example 31. \n\
7409 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7413 p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
7415 p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
7417 p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
7419 p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
7422 Get the (current) run level \n\
7426 Get the (current) run level. Valid settings are: 0, uninitialized \n\
7427 \t 1,\tinitialized \n\
7428 \t 2,\tviewport defined \n\
7429 \t 3,\tworld coordinates defined \n\
7432 Redacted form: plglevel(p_level)\n\
7434 This function is used in example 31. \n\
7440 plglevel(p_level)\n\
7444 p_level (PLINT *, output) : Pointer to the run level. \n\
7447 Plot a histogram from binned data \n\
7451 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
7452 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
7453 placed in y[i]. For proper operation, the values in x[i] must form a\n\
7454 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
7455 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
7456 placed midway between the values in the x array. Also see plhist for\n\
7457 drawing histograms from unbinned data. \n\
7459 Redacted form: General: plbin(x, y, opt)\n\
7460 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
7461 \t Python: plbin(nbin, x, y, opt)\n\
7464 This function is not used in any examples. \n\
7470 plbin(nbin, x, y, opt)\n\
7474 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
7477 x (PLFLT *, input) : Pointer to array containing values associated\n\
7478 with bins. These must form a strictly increasing sequence. \n\
7480 y (PLFLT *, input) : Pointer to array containing number of points\n\
7481 in bin. This is a PLFLT (instead of PLINT) array so as to allow\n\
7482 histograms of probabilities, etc. \n\
7484 opt (PLINT, input) : Is a combination of several flags:\n\
7485 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
7486 outer bins are expanded to fill up the entire x-axis and bins of\n\
7487 zero height are simply drawn. \n\
7488 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
7489 between the x values. If the values in x are equally spaced,\n\
7490 the values are the center values of the bins. \n\
7491 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
7492 size as the ones inside. \n\
7493 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
7494 (there is a gap for such bins). \n\
7497 Get family, style and weight of the current font \n\
7501 Gets information about current font. See the PLplot documentation for\n\
7502 more information on font selection. \n\
7504 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7506 This function is used in example 23. \n\
7512 plgfont(p_family, p_style, p_weight)\n\
7516 p_family (PLINT *, output) : Pointer to variable with the current\n\
7517 font family. The available values are given by the PL_FCI_*\n\
7518 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7519 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7520 p_family is NULL then the font family is not returned. \n\
7522 p_style (PLINT *, output) : Pointer to variable with the current\n\
7523 font style. The available values are given by the PL_FCI_*\n\
7524 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7525 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
7526 font style is not returned. \n\
7528 p_weight (PLINT *, output) : Pointer to variable with the current\n\
7529 font weight. The available values are given by the PL_FCI_*\n\
7530 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7531 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7535 Get z axis parameters \n\
7539 Identical to plgxax, except that arguments are flags for z axis. See\n\
7540 the description of plgxax for more detail. \n\
7542 Redacted form: plgzax(digmax, digits)\n\
7544 This function is used in example 31. \n\
7550 plgzax(digmax, digits)\n\
7554 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7555 number of digits for the z axis. If nonzero, the printed label\n\
7556 has been switched to a floating point representation when the\n\
7557 number of digits exceeds digmax. \n\
7559 digits (PLINT *, output) : Pointer to variable with the actual\n\
7560 number of digits for the numeric labels (z axis) from the last\n\
7564 Write text inside the viewport of a 3D plot. \n\
7568 Writes text at a specified position and inclination and with a\n\
7569 specified shear within the viewport. Text is clipped at the viewport\n\
7570 boundaries. The reference point of a string lies along a line passing\n\
7571 through the string at half the height of a capital letter.\tThe\n\
7572 position of the reference point along this line is determined by just,\n\
7573 and the reference point is placed at world coordinates (\n\
7576 z) within the viewport. The inclination and shear of the string is\n\
7577 specified in terms of differences of world coordinates making it easy\n\
7578 to write text parallel to a line in a graph. \n\
7580 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7582 This function is used in example 28. \n\
7588 plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7592 x (PLFLT, input) : x coordinate of reference point of string. \n\
7594 y (PLFLT, input) : y coordinate of reference point of string. \n\
7596 z (PLFLT, input) : z coordinate of reference point of string. \n\
7598 dx (PLFLT, input) : Together with dy and \n\
7599 dz, this specifies the inclination of the string. The baseline of\n\
7600 the string is parallel to a line joining (\n\
7611 dy (PLFLT, input) : Together with dx and \n\
7612 dz, this specifies the inclination of the string. \n\
7614 dz (PLFLT, input) : Together with dx and \n\
7615 dy, this specifies the inclination of the string. \n\
7617 sx (PLFLT, input) : Together with sy and \n\
7618 sz, this specifies the shear of the string. The string is sheared so\n\
7619 that the characters are vertically parallel to a line joining (\n\
7630 sz = 0.) then the text is not sheared. \n\
7632 sy (PLFLT, input) : Together with sx and \n\
7633 sz, this specifies shear of the string. \n\
7635 sz (PLFLT, input) : Together with sx and \n\
7636 sy, this specifies shear of the string. \n\
7638 just (PLFLT, input) : Specifies the position of the string relative\n\
7639 to its reference point. If just=0., the reference point is at the\n\
7640 left and if just=1., it is at the right of the string. Other\n\
7641 values of just give intermediate justifications. \n\
7643 text (const char *, input) : The string to be written out. \n\
7646 Draw a box with axes, etc. with arbitrary origin \n\
7650 Draws a box around the currently defined viewport with arbitrary\n\
7651 world-coordinate origin specified by x0 and y0 and labels it with\n\
7652 world coordinate values appropriate to the window.\tThus plaxes should\n\
7653 only be called after defining both viewport and window. The character\n\
7654 strings xopt and yopt specify how the box should be drawn as described\n\
7655 below. If ticks and/or subticks are to be drawn for a particular\n\
7656 axis, the tick intervals and number of subintervals may be specified\n\
7657 explicitly, or they may be defaulted by setting the appropriate\n\
7658 arguments to zero. \n\
7660 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
7662 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
7666 This function is not used in any examples. \n\
7672 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
7676 x0 (PLFLT, input) : World X coordinate of origin. \n\
7678 y0 (PLFLT, input) : World Y coordinate of origin. \n\
7680 xopt (const char *, input) : Pointer to character string specifying\n\
7681 options for horizontal axis. The string can include any\n\
7682 combination of the following letters (upper or lower case) in any\n\
7683 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
7684 is vertical line (x=0). \n\
7685 b: Draws bottom (X) or left (Y) edge of frame. \n\
7686 c: Draws top (X) or right (Y) edge of frame. \n\
7687 d: Plot labels as date / time. Values are assumed to be\n\
7688 seconds since the epoch (as used by gmtime). \n\
7689 f: Always use fixed point numeric labels. \n\
7690 g: Draws a grid at the major tick interval. \n\
7691 h: Draws a grid at the minor tick interval. \n\
7692 i: Inverts tick marks, so they are drawn outwards, rather than\n\
7694 l: Labels axis logarithmically. This only affects the labels,\n\
7695 not the data, and so it is necessary to compute the logarithms\n\
7696 of data points before passing them to any of the drawing\n\
7698 m: Writes numeric labels at major tick intervals in the\n\
7699 unconventional location (above box for X, right of box for Y). \n\
7700 n: Writes numeric labels at major tick intervals in the\n\
7701 conventional location (below box for X, left of box for Y). \n\
7702 o: Use custom labeling function to generate axis label text. \n\
7703 The custom labeling function can be defined with the\n\
7704 plslabelfuncplslabelfunc; command. \n\
7705 s: Enables subticks between major ticks, only valid if t is\n\
7707 t: Draws major ticks. \n\
7710 xtick (PLFLT, input) : World coordinate interval between major\n\
7711 ticks on the x axis. If it is set to zero, PLplot automatically\n\
7712 generates a suitable tick interval. \n\
7714 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
7715 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7716 generates a suitable minor tick interval. \n\
7718 yopt (const char *, input) : Pointer to character string specifying\n\
7719 options for vertical axis. The string can include any combination\n\
7720 of the letters defined above for xopt, and in addition may\n\
7721 contain: v: Write numeric labels for vertical axis parallel to the\n\
7722 base of the graph, rather than parallel to the axis. \n\
7725 ytick (PLFLT, input) : World coordinate interval between major\n\
7726 ticks on the y axis. If it is set to zero, PLplot automatically\n\
7727 generates a suitable tick interval. \n\
7729 nysub (PLINT, input) : Number of subintervals between major y axis\n\
7730 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7731 generates a suitable minor tick interval. \n\
7734 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
7738 Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
7740 Redacted form: plgcolbg(r, g, b)\n\
7742 This function is used in example 31. \n\
7748 plgcolbg(r, g, b)\n\
7752 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7753 representing the degree of red in the color. \n\
7755 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7756 representing the degree of green in the color. \n\
7758 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7759 representing the degree of blue in the color. \n\
7762 Plot a glyph at the specified 3D points \n\
7766 Plot a glyph at the specified 3D points. (This function is largely\n\
7767 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
7768 Set up the call to this function similar to what is done for plline3.\n\
7769 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7770 and a draw at the same place. Not ideal, since a sufficiently\n\
7771 intelligent output device may optimize it away, or there may be faster\n\
7772 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7773 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7774 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7775 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7776 code <= 127 the corresponding printable ASCII character is plotted. \n\
7778 Redacted form: plpoin3(x, y, z, code)\n\
7780 This function is not used in any example. \n\
7786 plpoin3(n, x, y, z, code)\n\
7790 n (PLINT, input) : Number of points in the x and y arrays. \n\
7792 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7795 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7798 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7801 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7802 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7803 each of the n points. \n\
7806 Draw a polygon in 3 space \n\
7810 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
7811 like plline3, but differs from that function in that plpoly3 attempts\n\
7812 to determine if the polygon is viewable depending on the order of the\n\
7813 points within the arrays and the value of ifcc. If the back of\n\
7814 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
7815 you want, then use plline3 instead. \n\
7817 The points are assumed to be in a plane, and the directionality of the\n\
7818 plane is determined from the first three points. Additional points do\n\
7819 not have to lie on the plane defined by the first three, but if they\n\
7820 do not, then the determination of visibility obviously can\'t be 100%\n\
7821 accurate... So if you\'re 3 space polygons are too far from planar,\n\
7822 consider breaking them into smaller polygons. 3 points define a plane\n\
7825 Bugs: If one of the first two segments is of zero length, or if they\n\
7826 are co-linear, the calculation of visibility has a 50/50 chance of\n\
7827 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
7828 of this problem. (Search for 20.1). \n\
7830 Redacted form: plpoly3(x, y, z, code)\n\
7832 This function is used in example 18. \n\
7838 plpoly3(n, x, y, z, draw, ifcc)\n\
7842 n (PLINT, input) : Number of points defining line. \n\
7844 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
7846 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
7848 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
7850 draw (PLBOOL *, input) : Pointer to array which controls drawing\n\
7851 the segments of the polygon. If draw[i] is true, then the polygon\n\
7852 segment from index [i] to [i+1] is drawn, otherwise, not. \n\
7854 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
7855 polygon is determined by assuming the points are laid out in a\n\
7856 counter-clockwise order. Otherwise, the directionality of the\n\
7857 polygon is determined by assuming the points are laid out in a\n\
7858 clockwise order. \n\
7861 Set the background color by 8-bit RGB value and double alpha value. \n\
7865 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7866 (see the PLplot documentation) and double alpha value. \n\
7868 This function is used in example 31. \n\
7874 plscolbga(r, g, b, a)\n\
7878 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7879 degree of red in the color. \n\
7881 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7882 degree of green in the color. \n\
7884 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7885 degree of blue in the color. \n\
7887 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
7888 value of the color. \n\
7891 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n\
7895 Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
7898 This function is used in example 31. \n\
7904 plgcolbga(r, g, b, a)\n\
7908 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7909 representing the degree of red in the color. \n\
7911 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7912 representing the degree of green in the color. \n\
7914 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7915 representing the degree of blue in the color. \n\
7917 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
7920 Draw x error bar \n\
7924 Draws a set of n horizontal error bars, the i\'th error bar extending\n\
7925 from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
7926 error bar are of length equal to the minor tick length (settable using\n\
7929 Redacted form: General: plerrx(xmin, ymax, y)\n\
7930 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
7933 This function is used in example 29. \n\
7939 plerrx(n, xmin, xmax, y)\n\
7943 n (PLINT, input) : Number of error bars to draw. \n\
7945 xmin (PLFLT *, input) : Pointer to array with x coordinates of\n\
7946 left-hand endpoint of error bars. \n\
7948 xmax (PLFLT *, input) : Pointer to array with x coordinates of\n\
7949 right-hand endpoint of error bars. \n\
7951 y (PLFLT *, input) : Pointer to array with y coordinates of error\n\
7955 Eject current page \n\
7959 Clears the graphics screen of an interactive device, or ejects a page\n\
7960 on a plotter. See plbop for more information. \n\
7962 Redacted form: pleop()\n\
7964 This function is used in example 2,14. \n\
7973 Convert HLS color to RGB \n\
7977 Convert HLS color coordinates to RGB. \n\
7979 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
7980 \t Perl/PDL: Not available? Implemented as plhls? \n\
7983 This function is used in example 2. \n\
7989 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
7993 h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
7995 l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
7996 of the colour cone (0.0-1.0) \n\
7998 s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
7999 radius of the colour cone (0.0-1.0) \n\
8001 p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
8004 p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
8007 p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
8011 Draw y error bar \n\
8015 Draws a set of n vertical error bars, the i\'th error bar extending\n\
8016 from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
8017 error bar are of length equal to the minor tick length (settable using\n\
8020 Redacted form: General: plerry(x, ymin, ymax)\n\
8021 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
8024 This function is used in example 29. \n\
8030 plerry(n, x, ymin, ymax)\n\
8034 n (PLINT, input) : Number of error bars to draw. \n\
8036 x (PLFLT *, input) : Pointer to array with x coordinates of error\n\
8039 ymin (PLFLT *, input) : Pointer to array with y coordinates of\n\
8040 lower endpoint of error bars. \n\
8042 ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n\
8043 endpoint of error bar. \n\
8046 Set FCI (font characterization integer) \n\
8050 Sets font characteristics to be used at the start of the next string\n\
8051 using the FCI approach. See the PLplot documentation for more\n\
8054 Redacted form: General: plsfci(fci)\n\
8055 \t Perl/PDL: Not available? \n\
8058 This function is used in example 23. \n\
8068 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
8072 Select area fill pattern \n\
8076 Select one of eight predefined area fill patterns to use (also see\n\
8077 plpat). Setting the fill style to 0 gives a solid fill. \n\
8079 Redacted form: plpsty(n)\n\
8081 This function is used in examples 12,13,15,16,25. \n\
8091 n (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
8092 horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
8093 consists of lines at 45 degrees angle (upward), and so on. \n\
8100 This sets up the size of all subsequent symbols drawn by plpoin and\n\
8101 plsym. The actual height of a symbol is the product of the default\n\
8102 symbol size and a scaling factor as for the character height. \n\
8104 Redacted form: plssym(def, scale)\n\
8106 This function is used in example 29. \n\
8112 plssym(def, scale)\n\
8116 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
8117 should be set to zero if the default height is to remain\n\
8120 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
8121 actual symbol height. \n\
8128 Alternative to plstar for initializing the plotting package. The\n\
8129 device name keyword for the desired output device must be supplied as\n\
8130 an argument. The device keywords are the same as those printed out by\n\
8131 plstar. If the requested device is not available, or if the input\n\
8132 string is empty or begins with ``?\'\', the prompted startup of plstar\n\
8133 is used. This routine also divides the output device into nx by ny\n\
8134 subpages, each of which may be used independently.\tThe subroutine\n\
8135 pladv is used to advance from one subpage to the next. \n\
8137 Redacted form: General: plstart(device, nx, ny)\n\
8138 \t Perl/PDL: plstart(nx, ny, device)\n\
8141 This function is not used in any examples. \n\
8147 plstart(device, nx, ny)\n\
8151 device (const char *, input) : Device name (keyword) of the\n\
8152 required output device. If NULL or if the first character is a\n\
8153 ``?\'\', the normal (prompted) startup is used. \n\
8155 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8156 horizontal direction. \n\
8158 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8159 vertical direction. \n\
8164 PLINT *arg2 = (PLINT *) 0 ;
8165 char **arg3 = (
char **) 0 ;
8167 octave_value_list _out;
8168 octave_value_list *_outp=&_out;
8179 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
8180 arg2 =
new PLINT[
Alen];
8181 temp1 = args(0).matrix_value();
8185 charMatrix temp_matrix;
8189 size_t max_length, non_blank_length;
8193 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
8195 if ( !args(1).is_empty() )
8197 if (
_dim( args(1), 0 ) != Alen )
8199 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
8201 arg3 =
new char*[
Alen];
8202 ifcell = args(1).is_cell();
8205 temp_cell = args(1).cell_value();
8209 temp_matrix = args(1).char_matrix_value();
8211 max_length =
_dim( args(1), 1 ) + 1;
8214 for ( i = 0; i <
Alen; i++ )
8221 if ( temp_cell.elem( i ).is_string() )
8223 str = temp_cell.elem( i ).string_value();
8225 max_length = str.size() + 1;
8226 tmp_cstring = (
char *) str.c_str();
8236 tmp_cstring = (
char *)
"";
8241 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
8243 arg3[i] =
new char[max_length];
8244 strncpy( arg3[i], tmp_cstring, max_length - 1 );
8245 arg3[i][max_length - 1] =
'\0';
8260 non_blank_length = max_length - 2;
8261 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
8265 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
8269 arg3[i][non_blank_length + 1] =
'\0';
8278 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
8279 _outv = octave_value();
8288 for ( i = 0; i <
Alen; i++ )
8304 for ( i = 0; i <
Alen; i++ )
8311 return octave_value_list();
8316 int *arg1 = (
int *) 0 ;
8317 int *arg2 = (
int *) 0 ;
8318 int *arg3 = (
int *) 0 ;
8319 char *arg4 = (
char *) 0 ;
8320 int *arg5 = (
int *) 0 ;
8321 int *arg6 = (
int *) 0 ;
8322 PLFLT *arg7 = (PLFLT *) 0 ;
8323 PLFLT *arg8 = (PLFLT *) 0 ;
8324 PLFLT *arg9 = (PLFLT *) 0 ;
8325 PLFLT *arg10 = (PLFLT *) 0 ;
8326 int *arg11 = (
int *) 0 ;
8333 octave_value_list retval4 ;
8348 octave_value_list _out;
8349 octave_value_list *_outp=&_out;
8358 # if OCTAVE_API_VERSION_NUMBER < 45
8359 retval4( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
8361 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
8363 arg4 = (
char *) retval4( 0 ).char_matrix_value().data();
8375 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
8443 return octave_value_list();
8448 PLFLT *arg1 = (PLFLT *) 0 ;
8449 PLFLT *arg2 = (PLFLT *) 0 ;
8460 octave_value_list _out;
8461 octave_value_list *_outp=&_out;
8474 arg3 = (
PLFLT)(val3);
8479 arg4 = (
PLFLT)(val4);
8497 return octave_value_list();
8502 PLINT *arg1 = (PLINT *) 0 ;
8503 char *arg2 = (
char *) 0 ;
8504 char *arg3 = (
char *) 0 ;
8516 PLINT *arg15 = (PLINT *) 0 ;
8517 PLINT *arg16 = (PLINT *) 0 ;
8518 char *arg17 = (
char *) 0 ;
8519 char *arg18 = (
char *) 0 ;
8520 char *arg19 = (
char *) 0 ;
8521 char *arg20 = (
char *) 0 ;
8522 char *arg21 = (
char *) 0 ;
8523 char *arg22 = (
char *) 0 ;
8524 char *arg23 = (
char *) 0 ;
8578 octave_value_list _out;
8579 octave_value_list *_outp=&_out;
8590 arg2 = (
char *)(buf2);
8595 arg3 = (
char *)(buf3);
8600 arg4 = (
PLFLT)(val4);
8605 arg5 = (
PLFLT)(val5);
8610 arg6 = (
PLFLT)(val6);
8615 arg7 = (
PLFLT)(val7);
8620 arg8 = (
PLFLT)(val8);
8625 arg9 = (
PLFLT)(val9);
8630 arg10 = (
PLFLT)(val10);
8645 arg13 = (
PLINT)(val13);
8650 arg14 = (
PLINT)(val14);
8652 if (
_n_dims( args(13) ) > 1 )
8657 temp15 = args(13).matrix_value();
8658 arg15 =
new PLINT[
Alen];
8662 if (
_n_dims( args(14) ) > 1 )
8666 if (
_dim( args(14), 0 ) != Alen )
8670 temp16 = args(14).matrix_value();
8671 arg16 =
new PLINT[
Alen];
8678 arg17 = (
char *)(buf17);
8683 arg18 = (
char *)(buf18);
8688 arg19 = (
char *)(buf19);
8693 arg20 = (
char *)(buf20);
8698 arg21 = (
char *)(buf21);
8703 arg22 = (
char *)(buf22);
8708 arg23 = (
char *)(buf23);
8709 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);
8710 _outv = octave_value();
8750 return octave_value_list();
8755 PLFLT *arg1 = (PLFLT *) 0 ;
8762 PLFLT *arg8 = (PLFLT *) 0 ;
8764 PLFLT *arg10 = (PLFLT *) 0 ;
8776 octave_value_list _out;
8777 octave_value_list *_outp=&_out;
8786 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
8788 temp1 = args(0).matrix_value();
8789 arg1 = &temp1( 0, 0 );
8790 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
8797 arg4 = (
PLINT)(val4);
8802 arg5 = (
PLINT)(val5);
8807 arg6 = (
PLINT)(val6);
8812 arg7 = (
PLINT)(val7);
8818 temp8 = args(5).matrix_value();
8819 arg8 = &temp8( 0, 0 );
8820 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
8827 if (
_dim( args(6), 0 ) != 6 )
8831 temp10 = args(6).matrix_value();
8832 arg10 = &temp10( 0, 0 );
8834 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
8835 _outv = octave_value();
8857 return octave_value_list();
8862 PLFLT *arg1 = (PLFLT *) 0 ;
8869 PLFLT *arg8 = (PLFLT *) 0 ;
8881 octave_value_list _out;
8882 octave_value_list *_outp=&_out;
8891 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
8893 temp1 = args(0).matrix_value();
8894 arg1 = &temp1( 0, 0 );
8895 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
8902 arg4 = (
PLINT)(val4);
8907 arg5 = (
PLINT)(val5);
8912 arg6 = (
PLINT)(val6);
8917 arg7 = (
PLINT)(val7);
8923 temp8 = args(5).matrix_value();
8924 arg8 = &temp8( 0, 0 );
8925 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
8927 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
8928 _outv = octave_value();
8944 return octave_value_list();
8949 PLFLT *arg1 = (PLFLT *) 0 ;
8956 PLFLT *arg8 = (PLFLT *) 0 ;
8958 PLFLT *arg10 = (PLFLT *) 0 ;
8959 PLFLT *arg11 = (PLFLT *) 0 ;
8972 octave_value_list _out;
8973 octave_value_list *_outp=&_out;
8982 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
8984 temp1 = args(0).matrix_value();
8985 arg1 = &temp1( 0, 0 );
8986 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
8993 arg4 = (
PLINT)(val4);
8998 arg5 = (
PLINT)(val5);
9003 arg6 = (
PLINT)(val6);
9008 arg7 = (
PLINT)(val7);
9014 temp8 = args(5).matrix_value();
9015 arg8 = &temp8( 0, 0 );
9016 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9023 if (
_dim( args(6), 0 ) != Xlen )
9027 temp10 = args(6).matrix_value();
9028 arg10 = &temp10( 0, 0 );
9039 temp11 = args(7).matrix_value();
9040 arg11 = &temp11( 0, 0 );
9042 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9043 _outv = octave_value();
9071 return octave_value_list();
9076 PLFLT *arg1 = (PLFLT *) 0 ;
9083 PLFLT *arg8 = (PLFLT *) 0 ;
9085 PLFLT *arg10 = (PLFLT *) 0 ;
9086 PLFLT *arg11 = (PLFLT *) 0 ;
9099 octave_value_list _out;
9100 octave_value_list *_outp=&_out;
9109 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9111 temp1 = args(0).matrix_value();
9112 arg1 = &temp1( 0, 0 );
9113 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9120 arg4 = (
PLINT)(val4);
9125 arg5 = (
PLINT)(val5);
9130 arg6 = (
PLINT)(val6);
9135 arg7 = (
PLINT)(val7);
9141 temp8 = args(5).matrix_value();
9142 arg8 = &temp8( 0, 0 );
9143 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9148 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9150 if (
_dim( args(6), 0 ) != Xlen )
9152 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9156 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9158 temp10 = args(6).matrix_value();
9159 arg10 = &temp10( 0, 0 );
9164 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9166 if (
_dim( args(7), 0 ) != Xlen )
9168 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9172 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9174 temp11 = args(7).matrix_value();
9175 arg11 = &temp11( 0, 0 );
9177 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9178 _outv = octave_value();
9206 return octave_value_list();
9211 PLFLT *arg1 = (PLFLT *) 0 ;
9218 PLFLT *arg8 = (PLFLT *) 0 ;
9220 PLFLT *arg10 = (PLFLT *) 0 ;
9221 PLFLT *arg11 = (PLFLT *) 0 ;
9234 octave_value_list _out;
9235 octave_value_list *_outp=&_out;
9244 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9246 temp1 = args(0).matrix_value();
9247 arg1 = &temp1( 0, 0 );
9248 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
9255 arg4 = (
PLINT)(val4);
9260 arg5 = (
PLINT)(val5);
9265 arg6 = (
PLINT)(val6);
9270 arg7 = (
PLINT)(val7);
9276 temp8 = args(5).matrix_value();
9277 arg8 = &temp8( 0, 0 );
9278 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
9283 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9285 if (
_dim( args(6), 0 ) != Xlen )
9287 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9291 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9293 temp10 = args(6).matrix_value();
9294 arg10 = &temp10( 0, 0 );
9299 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9301 if (
_dim( args(7), 0 ) != Xlen )
9303 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9307 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9309 temp11 = args(7).matrix_value();
9310 arg11 = &temp11( 0, 0 );
9312 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
9313 _outv = octave_value();
9341 return octave_value_list();
9346 PLFLT *arg1 = (PLFLT *) 0 ;
9347 PLFLT *arg2 = (PLFLT *) 0 ;
9348 PLFLT *arg3 = (PLFLT *) 0 ;
9350 PLFLT *arg5 = (PLFLT *) 0 ;
9352 PLFLT *arg7 = (PLFLT *) 0 ;
9354 PLFLT *arg9 = (PLFLT *) 0 ;
9362 octave_value_list retval7 ;
9367 octave_value_list _out;
9368 octave_value_list *_outp=&_out;
9380 temp1 = args(0).matrix_value();
9381 arg1 = &temp1( 0, 0 );
9388 if (
_dim( args(1), 0 ) != Alen )
9392 temp2 = args(1).matrix_value();
9393 arg2 = &temp2( 0, 0 );
9400 if (
_dim( args(2), 0 ) != Alen )
9404 temp3 = args(2).matrix_value();
9405 arg3 = &temp3( 0, 0 );
9413 temp5 = args(3).matrix_value();
9414 arg5 = &temp5( 0, 0 );
9415 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
9422 temp7 = args(4).matrix_value();
9423 arg7 = &temp7( 0, 0 );
9425 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
9426 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
9432 arg10 = (
PLINT)(val10);
9437 arg11 = (
PLFLT)(val11);
9438 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
9439 _outv = octave_value();
9476 return octave_value_list();
9481 PLFLT *arg1 = (PLFLT *) 0 ;
9482 PLFLT *arg2 = (PLFLT *) 0 ;
9483 PLFLT *arg3 = (PLFLT *) 0 ;
9492 octave_value_list _out;
9493 octave_value_list *_outp=&_out;
9504 temp1 = args(0).matrix_value();
9505 arg1 = &temp1( 0, 0 );
9513 temp2 = args(1).matrix_value();
9514 arg2 = &temp2( 0, 0 );
9520 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9522 if (
_dim( args(2), 0 ) != Xlen )
9524 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9528 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9530 temp3 = args(2).matrix_value();
9531 arg3 = &temp3( 0, 0 );
9539 arg6 = (
PLINT)(val6);
9540 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
9541 _outv = octave_value();
9563 return octave_value_list();
9568 PLFLT *arg1 = (PLFLT *) 0 ;
9569 PLFLT *arg2 = (PLFLT *) 0 ;
9570 PLFLT *arg3 = (PLFLT *) 0 ;
9574 PLFLT *arg7 = (PLFLT *) 0 ;
9582 octave_value_list _out;
9583 octave_value_list *_outp=&_out;
9594 temp1 = args(0).matrix_value();
9595 arg1 = &temp1( 0, 0 );
9603 temp2 = args(1).matrix_value();
9604 arg2 = &temp2( 0, 0 );
9610 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9612 if (
_dim( args(2), 0 ) != Xlen )
9614 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9618 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9620 temp3 = args(2).matrix_value();
9621 arg3 = &temp3( 0, 0 );
9629 arg6 = (
PLINT)(val6);
9635 temp7 = args(4).matrix_value();
9636 arg7 = &temp7( 0, 0 );
9637 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9639 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9640 _outv = octave_value();
9668 return octave_value_list();
9673 PLFLT *arg1 = (PLFLT *) 0 ;
9674 PLFLT *arg2 = (PLFLT *) 0 ;
9675 PLFLT *arg3 = (PLFLT *) 0 ;
9687 octave_value_list _out;
9688 octave_value_list *_outp=&_out;
9699 temp1 = args(0).matrix_value();
9700 arg1 = &temp1( 0, 0 );
9708 temp2 = args(1).matrix_value();
9709 arg2 = &temp2( 0, 0 );
9715 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9717 if (
_dim( args(2), 0 ) != Xlen )
9719 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9723 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9725 temp3 = args(2).matrix_value();
9726 arg3 = &temp3( 0, 0 );
9734 arg6 = (
PLINT)(val6);
9740 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
9741 _outv = octave_value();
9763 return octave_value_list();
9768 PLFLT *arg1 = (PLFLT *) 0 ;
9769 PLFLT *arg2 = (PLFLT *) 0 ;
9770 PLFLT *arg3 = (PLFLT *) 0 ;
9774 PLFLT *arg7 = (PLFLT *) 0 ;
9782 octave_value_list _out;
9783 octave_value_list *_outp=&_out;
9794 temp1 = args(0).matrix_value();
9795 arg1 = &temp1( 0, 0 );
9803 temp2 = args(1).matrix_value();
9804 arg2 = &temp2( 0, 0 );
9810 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9812 if (
_dim( args(2), 0 ) != Xlen )
9814 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9818 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9820 temp3 = args(2).matrix_value();
9821 arg3 = &temp3( 0, 0 );
9829 arg6 = (
PLINT)(val6);
9835 temp7 = args(4).matrix_value();
9836 arg7 = &temp7( 0, 0 );
9837 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9839 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9840 _outv = octave_value();
9868 return octave_value_list();
9873 PLFLT *arg1 = (PLFLT *) 0 ;
9874 PLFLT *arg2 = (PLFLT *) 0 ;
9875 PLFLT *arg3 = (PLFLT *) 0 ;
9879 PLFLT *arg7 = (PLFLT *) 0 ;
9887 octave_value_list _out;
9888 octave_value_list *_outp=&_out;
9899 temp1 = args(0).matrix_value();
9900 arg1 = &temp1( 0, 0 );
9908 temp2 = args(1).matrix_value();
9909 arg2 = &temp2( 0, 0 );
9915 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
9917 if (
_dim( args(2), 0 ) != Xlen )
9919 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
9923 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
9925 temp3 = args(2).matrix_value();
9926 arg3 = &temp3( 0, 0 );
9934 arg6 = (
PLINT)(val6);
9940 temp7 = args(4).matrix_value();
9941 arg7 = &temp7( 0, 0 );
9942 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
9944 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
9945 _outv = octave_value();
9973 return octave_value_list();
9978 PLFLT *arg1 = (PLFLT *) 0 ;
9981 PLFLT *arg4 = (PLFLT *) 0 ;
9996 PLFLT *arg19 = (PLFLT *) 0 ;
10028 octave_value_list _out;
10029 octave_value_list *_outp=&_out;
10030 octave_value _outv;
10036 if (
_n_dims( args(0) ) > 2 )
10038 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10040 temp1 = args(0).matrix_value();
10041 arg1 = &temp1( 0, 0 );
10042 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10046 if (
_n_dims( args(1) ) > 1 )
10051 temp4 = args(1).matrix_value();
10052 arg4 = &temp4( 0, 0 );
10058 arg5 = (
PLFLT)(val5);
10063 arg6 = (
PLFLT)(val6);
10068 arg7 = (
PLFLT)(val7);
10073 arg8 = (
PLFLT)(val8);
10078 arg9 = (
PLFLT)(val9);
10083 arg10 = (
PLFLT)(val10);
10088 arg11 = (
PLINT)(val11);
10093 arg12 = (
PLFLT)(val12);
10098 arg13 = (
PLINT)(val13);
10103 arg14 = (
PLINT)(val14);
10108 arg15 = (
PLINT)(val15);
10113 arg16 = (
PLINT)(val16);
10118 arg17 = (
PLINT)(val17);
10123 arg18 = (
PLBOOL)(val18);
10125 if (
_n_dims( args(16) ) > 1 )
10129 if (
_dim( args(16), 0 ) != 6 )
10133 temp19 = args(16).matrix_value();
10134 arg19 = &temp19( 0, 0 );
10136 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);
10137 _outv = octave_value();
10159 return octave_value_list();
10164 PLFLT *arg1 = (PLFLT *) 0 ;
10167 char *arg4 = (
char *) 0 ;
10182 PLFLT *arg19 = (PLFLT *) 0 ;
10183 PLFLT *arg20 = (PLFLT *) 0 ;
10218 octave_value_list _out;
10219 octave_value_list *_outp=&_out;
10220 octave_value _outv;
10226 if (
_n_dims( args(0) ) > 2 )
10228 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10230 temp1 = args(0).matrix_value();
10231 arg1 = &temp1( 0, 0 );
10232 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10239 arg4 = (
char *)(buf4);
10244 arg5 = (
PLFLT)(val5);
10249 arg6 = (
PLFLT)(val6);
10254 arg7 = (
PLFLT)(val7);
10259 arg8 = (
PLFLT)(val8);
10264 arg9 = (
PLFLT)(val9);
10269 arg10 = (
PLFLT)(val10);
10274 arg11 = (
PLINT)(val11);
10279 arg12 = (
PLFLT)(val12);
10284 arg13 = (
PLINT)(val13);
10289 arg14 = (
PLINT)(val14);
10294 arg15 = (
PLINT)(val15);
10299 arg16 = (
PLINT)(val16);
10304 arg17 = (
PLINT)(val17);
10309 arg18 = (
PLBOOL)(val18);
10311 if (
_n_dims( args(16) ) > 1 )
10315 if (
_dim( args(16), 0 ) != Xlen )
10319 temp19 = args(16).matrix_value();
10320 arg19 = &temp19( 0, 0 );
10323 if (
_n_dims( args(17) ) > 1 )
10327 if (
_dim( args(17), 0 ) !=
Ylen )
10331 temp20 = args(17).matrix_value();
10332 arg20 = &temp20( 0, 0 );
10334 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);
10335 _outv = octave_value();
10359 return octave_value_list();
10364 PLFLT *arg1 = (PLFLT *) 0 ;
10367 char *arg4 = (
char *) 0 ;
10382 PLFLT *arg19 = (PLFLT *) 0 ;
10383 PLFLT *arg20 = (PLFLT *) 0 ;
10418 octave_value_list _out;
10419 octave_value_list *_outp=&_out;
10420 octave_value _outv;
10426 if (
_n_dims( args(0) ) > 2 )
10428 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10430 temp1 = args(0).matrix_value();
10431 arg1 = &temp1( 0, 0 );
10432 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10439 arg4 = (
char *)(buf4);
10444 arg5 = (
PLFLT)(val5);
10449 arg6 = (
PLFLT)(val6);
10454 arg7 = (
PLFLT)(val7);
10459 arg8 = (
PLFLT)(val8);
10464 arg9 = (
PLFLT)(val9);
10469 arg10 = (
PLFLT)(val10);
10474 arg11 = (
PLINT)(val11);
10479 arg12 = (
PLFLT)(val12);
10484 arg13 = (
PLINT)(val13);
10489 arg14 = (
PLINT)(val14);
10494 arg15 = (
PLINT)(val15);
10499 arg16 = (
PLINT)(val16);
10504 arg17 = (
PLINT)(val17);
10509 arg18 = (
PLBOOL)(val18);
10511 if (
_n_dims( args(16) ) > 2 )
10513 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10515 temp19 = args(16).matrix_value();
10516 arg19 = &temp19( 0, 0 );
10517 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
10521 if (
_n_dims( args(17) ) > 2 )
10523 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10525 temp20 = args(17).matrix_value();
10526 arg20 = &temp20( 0, 0 );
10527 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
10530 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);
10531 _outv = octave_value();
10555 return octave_value_list();
10560 PLFLT *arg1 = (PLFLT *) 0 ;
10567 PLFLT *arg8 = (PLFLT *) 0 ;
10591 octave_value_list _out;
10592 octave_value_list *_outp=&_out;
10593 octave_value _outv;
10599 if (
_n_dims( args(0) ) > 2 )
10601 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10603 temp1 = args(0).matrix_value();
10604 arg1 = &temp1( 0, 0 );
10605 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10612 arg4 = (
PLFLT)(val4);
10617 arg5 = (
PLFLT)(val5);
10622 arg6 = (
PLFLT)(val6);
10627 arg7 = (
PLFLT)(val7);
10629 if (
_n_dims( args(5) ) > 1 )
10633 temp8 = args(5).matrix_value();
10634 arg8 = &temp8( 0, 0 );
10635 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10641 arg10 = (
PLINT)(val10);
10646 arg11 = (
PLINT)(val11);
10651 arg12 = (
PLINT)(val12);
10656 arg13 = (
PLBOOL)(val13);
10657 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
10658 _outv = octave_value();
10674 return octave_value_list();
10679 PLFLT *arg1 = (PLFLT *) 0 ;
10686 PLFLT *arg8 = (PLFLT *) 0 ;
10692 PLFLT *arg14 = (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 ) != 6 )
10787 temp14 = args(10).matrix_value();
10788 arg14 = &temp14( 0, 0 );
10790 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
10791 _outv = octave_value();
10813 return octave_value_list();
10818 PLFLT *arg1 = (PLFLT *) 0 ;
10825 PLFLT *arg8 = (PLFLT *) 0 ;
10831 PLFLT *arg14 = (PLFLT *) 0 ;
10832 PLFLT *arg15 = (PLFLT *) 0 ;
10853 octave_value_list _out;
10854 octave_value_list *_outp=&_out;
10855 octave_value _outv;
10861 if (
_n_dims( args(0) ) > 2 )
10863 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
10865 temp1 = args(0).matrix_value();
10866 arg1 = &temp1( 0, 0 );
10867 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
10874 arg4 = (
PLFLT)(val4);
10879 arg5 = (
PLFLT)(val5);
10884 arg6 = (
PLFLT)(val6);
10889 arg7 = (
PLFLT)(val7);
10891 if (
_n_dims( args(5) ) > 1 )
10895 temp8 = args(5).matrix_value();
10896 arg8 = &temp8( 0, 0 );
10897 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
10903 arg10 = (
PLINT)(val10);
10908 arg11 = (
PLINT)(val11);
10913 arg12 = (
PLINT)(val12);
10918 arg13 = (
PLBOOL)(val13);
10920 if (
_n_dims( args(10) ) > 1 )
10924 if (
_dim( args(10), 0 ) != Xlen )
10928 temp14 = args(10).matrix_value();
10929 arg14 = &temp14( 0, 0 );
10932 if (
_n_dims( args(11) ) > 1 )
10936 if (
_dim( args(11), 0 ) !=
Ylen )
10940 temp15 = args(11).matrix_value();
10941 arg15 = &temp15( 0, 0 );
10943 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);
10944 _outv = octave_value();
10972 return octave_value_list();
10977 PLFLT *arg1 = (PLFLT *) 0 ;
10984 PLFLT *arg8 = (PLFLT *) 0 ;
10990 PLFLT *arg14 = (PLFLT *) 0 ;
10991 PLFLT *arg15 = (PLFLT *) 0 ;
11012 octave_value_list _out;
11013 octave_value_list *_outp=&_out;
11014 octave_value _outv;
11020 if (
_n_dims( args(0) ) > 2 )
11022 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11024 temp1 = args(0).matrix_value();
11025 arg1 = &temp1( 0, 0 );
11026 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11033 arg4 = (
PLFLT)(val4);
11038 arg5 = (
PLFLT)(val5);
11043 arg6 = (
PLFLT)(val6);
11048 arg7 = (
PLFLT)(val7);
11050 if (
_n_dims( args(5) ) > 1 )
11054 temp8 = args(5).matrix_value();
11055 arg8 = &temp8( 0, 0 );
11056 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11062 arg10 = (
PLINT)(val10);
11067 arg11 = (
PLINT)(val11);
11072 arg12 = (
PLINT)(val12);
11077 arg13 = (
PLBOOL)(val13);
11079 if (
_n_dims( args(10) ) > 2 )
11081 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11083 temp14 = args(10).matrix_value();
11084 arg14 = &temp14( 0, 0 );
11085 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
11089 if (
_n_dims( args(11) ) > 2 )
11091 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11093 temp15 = args(11).matrix_value();
11094 arg15 = &temp15( 0, 0 );
11095 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
11098 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);
11099 _outv = octave_value();
11127 return octave_value_list();
11132 PLFLT *arg1 = (PLFLT *) 0 ;
11133 PLFLT *arg2 = (PLFLT *) 0 ;
11137 PLFLT *arg6 = (PLFLT *) 0 ;
11143 octave_value_list _out;
11144 octave_value_list *_outp=&_out;
11145 octave_value _outv;
11151 if (
_n_dims( args(0) ) > 2 )
11153 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11155 temp1 = args(0).matrix_value();
11156 arg1 = &temp1( 0, 0 );
11161 if (
_n_dims( args(1) ) > 2 )
11163 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11165 if (
_dim( args(1), 0 ) != Xlen )
11167 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11171 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11173 temp2 = args(1).matrix_value();
11174 arg2 = &temp2( 0, 0 );
11182 arg5 = (
PLFLT)(val5);
11184 if (
_n_dims( args(3) ) > 1 )
11188 if (
_dim( args(3), 0 ) != 6 )
11192 temp6 = args(3).matrix_value();
11193 arg6 = &temp6( 0, 0 );
11195 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
11196 _outv = octave_value();
11218 return octave_value_list();
11223 PLFLT *arg1 = (PLFLT *) 0 ;
11224 PLFLT *arg2 = (PLFLT *) 0 ;
11228 PLFLT *arg6 = (PLFLT *) 0 ;
11229 PLFLT *arg7 = (PLFLT *) 0 ;
11236 octave_value_list _out;
11237 octave_value_list *_outp=&_out;
11238 octave_value _outv;
11244 if (
_n_dims( args(0) ) > 2 )
11246 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11248 temp1 = args(0).matrix_value();
11249 arg1 = &temp1( 0, 0 );
11254 if (
_n_dims( args(1) ) > 2 )
11256 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11258 if (
_dim( args(1), 0 ) != Xlen )
11260 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11264 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11266 temp2 = args(1).matrix_value();
11267 arg2 = &temp2( 0, 0 );
11275 arg5 = (
PLFLT)(val5);
11277 if (
_n_dims( args(3) ) > 1 )
11281 if (
_dim( args(3), 0 ) != Xlen )
11285 temp6 = args(3).matrix_value();
11286 arg6 = &temp6( 0, 0 );
11289 if (
_n_dims( args(4) ) > 1 )
11297 temp7 = args(4).matrix_value();
11298 arg7 = &temp7( 0, 0 );
11300 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
11301 _outv = octave_value();
11329 return octave_value_list();
11334 PLFLT *arg1 = (PLFLT *) 0 ;
11335 PLFLT *arg2 = (PLFLT *) 0 ;
11339 PLFLT *arg6 = (PLFLT *) 0 ;
11340 PLFLT *arg7 = (PLFLT *) 0 ;
11347 octave_value_list _out;
11348 octave_value_list *_outp=&_out;
11349 octave_value _outv;
11355 if (
_n_dims( args(0) ) > 2 )
11357 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11359 temp1 = args(0).matrix_value();
11360 arg1 = &temp1( 0, 0 );
11365 if (
_n_dims( args(1) ) > 2 )
11367 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11369 if (
_dim( args(1), 0 ) != Xlen )
11371 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11375 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11377 temp2 = args(1).matrix_value();
11378 arg2 = &temp2( 0, 0 );
11386 arg5 = (
PLFLT)(val5);
11388 if (
_n_dims( args(3) ) > 2 )
11390 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11392 temp6 = args(3).matrix_value();
11393 arg6 = &temp6( 0, 0 );
11398 if (
_n_dims( args(4) ) > 2 )
11400 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11402 temp7 = args(4).matrix_value();
11403 arg7 = &temp7( 0, 0 );
11407 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
11408 _outv = octave_value();
11436 return octave_value_list();
11441 PLFLT *arg1 = (PLFLT *) 0 ;
11475 octave_value_list _out;
11476 octave_value_list *_outp=&_out;
11477 octave_value _outv;
11483 if (
_n_dims( args(0) ) > 2 )
11485 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11487 temp1 = args(0).matrix_value();
11488 arg1 = &temp1( 0, 0 );
11489 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11496 arg4 = (
PLFLT)(val4);
11501 arg5 = (
PLFLT)(val5);
11506 arg6 = (
PLFLT)(val6);
11511 arg7 = (
PLFLT)(val7);
11516 arg8 = (
PLFLT)(val8);
11521 arg9 = (
PLFLT)(val9);
11526 arg10 = (
PLFLT)(val10);
11531 arg11 = (
PLFLT)(val11);
11536 arg12 = (
PLFLT)(val12);
11541 arg13 = (
PLFLT)(val13);
11542 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
11543 _outv = octave_value();
11553 return octave_value_list();
11558 PLFLT *arg1 = (PLFLT *) 0 ;
11586 octave_value_list _out;
11587 octave_value_list *_outp=&_out;
11588 octave_value _outv;
11594 if (
_n_dims( args(0) ) > 2 )
11596 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11598 temp1 = args(0).matrix_value();
11599 arg1 = &temp1( 0, 0 );
11600 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11607 arg4 = (
PLFLT)(val4);
11612 arg5 = (
PLFLT)(val5);
11617 arg6 = (
PLFLT)(val6);
11622 arg7 = (
PLFLT)(val7);
11627 arg8 = (
PLFLT)(val8);
11632 arg9 = (
PLFLT)(val9);
11637 arg10 = (
PLFLT)(val10);
11642 arg11 = (
PLFLT)(val11);
11643 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11644 _outv = octave_value();
11654 return octave_value_list();
11659 PLFLT *arg1 = (PLFLT *) 0 ;
11670 PLFLT *arg12 = (PLFLT *) 0 ;
11689 octave_value_list _out;
11690 octave_value_list *_outp=&_out;
11691 octave_value _outv;
11697 if (
_n_dims( args(0) ) > 2 )
11699 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11701 temp1 = args(0).matrix_value();
11702 arg1 = &temp1( 0, 0 );
11703 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11710 arg4 = (
PLFLT)(val4);
11715 arg5 = (
PLFLT)(val5);
11720 arg6 = (
PLFLT)(val6);
11725 arg7 = (
PLFLT)(val7);
11730 arg8 = (
PLFLT)(val8);
11735 arg9 = (
PLFLT)(val9);
11740 arg10 = (
PLFLT)(val10);
11745 arg11 = (
PLFLT)(val11);
11747 if (
_n_dims( args(9) ) > 1 )
11751 if (
_dim( args(9), 0 ) != 6 )
11755 temp12 = args(9).matrix_value();
11756 arg12 = &temp12( 0, 0 );
11758 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
11759 _outv = octave_value();
11775 return octave_value_list();
11780 PLFLT *arg1 = (PLFLT *) 0 ;
11791 PLFLT *arg12 = (PLFLT *) 0 ;
11792 PLFLT *arg13 = (PLFLT *) 0 ;
11812 octave_value_list _out;
11813 octave_value_list *_outp=&_out;
11814 octave_value _outv;
11820 if (
_n_dims( args(0) ) > 2 )
11822 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11824 temp1 = args(0).matrix_value();
11825 arg1 = &temp1( 0, 0 );
11826 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11833 arg4 = (
PLFLT)(val4);
11838 arg5 = (
PLFLT)(val5);
11843 arg6 = (
PLFLT)(val6);
11848 arg7 = (
PLFLT)(val7);
11853 arg8 = (
PLFLT)(val8);
11858 arg9 = (
PLFLT)(val9);
11863 arg10 = (
PLFLT)(val10);
11868 arg11 = (
PLFLT)(val11);
11870 if (
_n_dims( args(9) ) > 1 )
11874 if (
_dim( args(9), 0 ) != Xlen )
11878 temp12 = args(9).matrix_value();
11879 arg12 = &temp12( 0, 0 );
11882 if (
_n_dims( args(10) ) > 1 )
11886 if (
_dim( args(10), 0 ) !=
Ylen )
11890 temp13 = args(10).matrix_value();
11891 arg13 = &temp13( 0, 0 );
11893 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
11894 _outv = octave_value();
11916 return octave_value_list();
11921 PLFLT *arg1 = (PLFLT *) 0 ;
11932 PLFLT *arg12 = (PLFLT *) 0 ;
11933 PLFLT *arg13 = (PLFLT *) 0 ;
11953 octave_value_list _out;
11954 octave_value_list *_outp=&_out;
11955 octave_value _outv;
11961 if (
_n_dims( args(0) ) > 2 )
11963 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11965 temp1 = args(0).matrix_value();
11966 arg1 = &temp1( 0, 0 );
11967 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11974 arg4 = (
PLFLT)(val4);
11979 arg5 = (
PLFLT)(val5);
11984 arg6 = (
PLFLT)(val6);
11989 arg7 = (
PLFLT)(val7);
11994 arg8 = (
PLFLT)(val8);
11999 arg9 = (
PLFLT)(val9);
12004 arg10 = (
PLFLT)(val10);
12009 arg11 = (
PLFLT)(val11);
12011 if (
_n_dims( args(9) ) > 2 )
12013 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12015 temp12 = args(9).matrix_value();
12016 arg12 = &temp12( 0, 0 );
12021 if (
_n_dims( args(10) ) > 2 )
12023 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12025 temp13 = args(10).matrix_value();
12026 arg13 = &temp13( 0, 0 );
12027 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
12030 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
12031 _outv = octave_value();
12053 return octave_value_list();
12058 PLFLT *arg1 = (PLFLT *) 0 ;
12059 PLFLT *arg2 = (PLFLT *) 0 ;
12074 PLINT *arg17 = (PLINT *) 0 ;
12075 char **arg18 = (
char **) 0 ;
12077 char **arg20 = (
char **) 0 ;
12078 PLFLT *arg21 = (PLFLT *) 0 ;
12079 PLINT *arg22 = (PLINT *) 0 ;
12080 PLINT *arg23 = (PLINT *) 0 ;
12081 PLFLT *arg24 = (PLFLT *) 0 ;
12117 octave_value_list _out;
12118 octave_value_list *_outp=&_out;
12119 octave_value _outv;
12130 arg3 = (
PLINT)(val3);
12135 arg4 = (
PLINT)(val4);
12140 arg5 = (
PLFLT)(val5);
12145 arg6 = (
PLFLT)(val6);
12150 arg7 = (
PLFLT)(val7);
12155 arg8 = (
PLFLT)(val8);
12160 arg9 = (
PLINT)(val9);
12165 arg10 = (
PLINT)(val10);
12170 arg11 = (
PLINT)(val11);
12175 arg12 = (
PLFLT)(val12);
12180 arg13 = (
PLFLT)(val13);
12185 arg14 = (
PLINT)(val14);
12190 arg15 = (
PLFLT)(val15);
12192 if (
_n_dims( args(13) ) > 1 )
12196 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
12197 arg17 =
new PLINT[
Alen];
12198 temp16 = args(13).matrix_value();
12202 charMatrix temp_matrix;
12206 size_t max_length, non_blank_length;
12208 if (
_n_dims( args(14) ) > 2 )
12210 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
12212 if ( !args(14).is_empty() )
12214 if (
_dim( args(14), 0 ) != Alen )
12216 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
12218 arg18 =
new char*[
Alen];
12219 ifcell = args(14).is_cell();
12222 temp_cell = args(14).cell_value();
12226 temp_matrix = args(14).char_matrix_value();
12228 max_length =
_dim( args(14), 1 ) + 1;
12231 for ( i = 0; i <
Alen; i++ )
12238 if ( temp_cell.elem( i ).is_string() )
12240 str = temp_cell.elem( i ).string_value();
12242 max_length = str.size() + 1;
12243 tmp_cstring = (
char *) str.c_str();
12253 tmp_cstring = (
char *)
"";
12258 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
12260 arg18[i] =
new char[max_length];
12261 strncpy( arg18[i], tmp_cstring, max_length - 1 );
12262 arg18[i][max_length - 1] =
'\0';
12277 non_blank_length = max_length - 2;
12278 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
12280 non_blank_length--;
12282 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
12284 non_blank_length--;
12286 arg18[i][non_blank_length + 1] =
'\0';
12296 charMatrix temp_matrix;
12300 size_t max_length, non_blank_length;
12302 if (
_n_dims( args(15) ) > 2 )
12304 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
12306 if ( !args(15).is_empty() )
12308 Alen =
_dim( args(15), 0 );
12310 arg20 =
new char*[
Alen];
12311 ifcell = args(15).is_cell();
12314 temp_cell = args(15).cell_value();
12318 temp_matrix = args(15).char_matrix_value();
12320 max_length =
_dim( args(15), 1 ) + 1;
12323 for ( i = 0; i <
Alen; i++ )
12330 if ( temp_cell.elem( i ).is_string() )
12332 str = temp_cell.elem( i ).string_value();
12334 max_length = str.size() + 1;
12335 tmp_cstring = (
char *) str.c_str();
12345 tmp_cstring = (
char *)
"";
12350 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
12352 arg20[i] =
new char[max_length];
12353 strncpy( arg20[i], tmp_cstring, max_length - 1 );
12354 arg20[i][max_length - 1] =
'\0';
12369 non_blank_length = max_length - 2;
12370 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
12372 non_blank_length--;
12374 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
12376 non_blank_length--;
12378 arg20[i][non_blank_length + 1] =
'\0';
12389 if (
_n_dims( args(16) ) > 1 )
12393 if (
_dim( args(16), 0 ) != Alen )
12397 temp21 = args(16).matrix_value();
12398 arg21 = &temp21( 0, 0 );
12401 if (
_n_dims( args(17) ) > 1 )
12405 if (
_dim( args(17), 0 ) != Alen )
12409 temp22 = args(17).matrix_value();
12410 arg22 =
new PLINT[
Alen];
12415 if (
_n_dims( args(18) ) > 1 )
12419 if (
_dim( args(18), 0 ) != Alen )
12424 temp23 = args(18).matrix_value();
12425 arg23 =
new PLINT[
Alen];
12428 for ( i = 0; i <
Xlen; i++ )
12429 if ( arg23[i] >
Ylen )
12433 if (
_n_dims( args(19) ) > 2 )
12435 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12437 if (
_dim( args(19), 0 ) != Xlen )
12439 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12441 if (
_dim( args(19), 1 ) !=
Ylen )
12443 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12445 temp24 = args(19).matrix_value();
12446 arg24 = &temp24( 0, 0 );
12448 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);
12449 _outv = octave_value();
12468 if ( arg18 != NULL )
12470 for ( i = 0; i <
Alen; i++ )
12479 if ( arg20 != NULL )
12481 for ( i = 0; i <
Alen; i++ )
12507 if ( arg18 != NULL )
12509 for ( i = 0; i <
Alen; i++ )
12518 if ( arg20 != NULL )
12520 for ( i = 0; i <
Alen; i++ )
12539 return octave_value_list();
12550 octave_value_list _out;
12551 octave_value_list *_outp=&_out;
12552 octave_value _outv;
12566 arg2 = (int)(val2);
12567 if (arg1) (arg1)->type = arg2;
12568 _outv = octave_value();
12572 return octave_value_list();
12580 octave_value_list _out;
12581 octave_value_list *_outp=&_out;
12582 octave_value _outv;
12593 result = (int) ((arg1)->type);
12598 return octave_value_list();
12604 unsigned int arg2 ;
12607 unsigned int val2 ;
12609 octave_value_list _out;
12610 octave_value_list *_outp=&_out;
12611 octave_value _outv;
12625 arg2 = (
unsigned int)(val2);
12626 if (arg1) (arg1)->state = arg2;
12627 _outv = octave_value();
12631 return octave_value_list();
12639 octave_value_list _out;
12640 octave_value_list *_outp=&_out;
12641 octave_value _outv;
12642 unsigned int result;
12652 result = (
unsigned int) ((arg1)->state);
12657 return octave_value_list();
12663 unsigned int arg2 ;
12666 unsigned int val2 ;
12668 octave_value_list _out;
12669 octave_value_list *_outp=&_out;
12670 octave_value _outv;
12684 arg2 = (
unsigned int)(val2);
12685 if (arg1) (arg1)->keysym = arg2;
12686 _outv = octave_value();
12690 return octave_value_list();
12698 octave_value_list _out;
12699 octave_value_list *_outp=&_out;
12700 octave_value _outv;
12701 unsigned int result;
12711 result = (
unsigned int) ((arg1)->keysym);
12716 return octave_value_list();
12722 unsigned int arg2 ;
12725 unsigned int val2 ;
12727 octave_value_list _out;
12728 octave_value_list *_outp=&_out;
12729 octave_value _outv;
12743 arg2 = (
unsigned int)(val2);
12744 if (arg1) (arg1)->button = arg2;
12745 _outv = octave_value();
12749 return octave_value_list();
12757 octave_value_list _out;
12758 octave_value_list *_outp=&_out;
12759 octave_value _outv;
12760 unsigned int result;
12770 result = (
unsigned int) ((arg1)->button);
12775 return octave_value_list();
12786 octave_value_list _out;
12787 octave_value_list *_outp=&_out;
12788 octave_value _outv;
12802 arg2 = (
PLINT)(val2);
12803 if (arg1) (arg1)->subwindow = arg2;
12804 _outv = octave_value();
12808 return octave_value_list();
12816 octave_value_list _out;
12817 octave_value_list *_outp=&_out;
12818 octave_value _outv;
12829 result = (
PLINT) ((arg1)->subwindow);
12834 return octave_value_list();
12845 octave_value_list _out;
12846 octave_value_list *_outp=&_out;
12847 octave_value _outv;
12861 arg2 = (
char *)(temp2);
12862 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
12863 else memset(arg1->
string,0,16*
sizeof(
char));
12864 _outv = octave_value();
12868 return octave_value_list();
12876 octave_value_list _out;
12877 octave_value_list *_outp=&_out;
12878 octave_value _outv;
12889 result = (
char *)(
char *) ((arg1)->
string);
12893 while (size && (result[size - 1] ==
'\0')) --size;
12900 return octave_value_list();
12911 octave_value_list _out;
12912 octave_value_list *_outp=&_out;
12913 octave_value _outv;
12927 arg2 = (int)(val2);
12928 if (arg1) (arg1)->pX = arg2;
12929 _outv = octave_value();
12933 return octave_value_list();
12941 octave_value_list _out;
12942 octave_value_list *_outp=&_out;
12943 octave_value _outv;
12954 result = (int) ((arg1)->pX);
12959 return octave_value_list();
12970 octave_value_list _out;
12971 octave_value_list *_outp=&_out;
12972 octave_value _outv;
12986 arg2 = (int)(val2);
12987 if (arg1) (arg1)->pY = arg2;
12988 _outv = octave_value();
12992 return octave_value_list();
13000 octave_value_list _out;
13001 octave_value_list *_outp=&_out;
13002 octave_value _outv;
13013 result = (int) ((arg1)->pY);
13018 return octave_value_list();
13029 octave_value_list _out;
13030 octave_value_list *_outp=&_out;
13031 octave_value _outv;
13045 arg2 = (
PLFLT)(val2);
13046 if (arg1) (arg1)->dX = arg2;
13047 _outv = octave_value();
13051 return octave_value_list();
13059 octave_value_list _out;
13060 octave_value_list *_outp=&_out;
13061 octave_value _outv;
13072 result = (
PLFLT) ((arg1)->dX);
13077 return octave_value_list();
13088 octave_value_list _out;
13089 octave_value_list *_outp=&_out;
13090 octave_value _outv;
13104 arg2 = (
PLFLT)(val2);
13105 if (arg1) (arg1)->dY = arg2;
13106 _outv = octave_value();
13110 return octave_value_list();
13118 octave_value_list _out;
13119 octave_value_list *_outp=&_out;
13120 octave_value _outv;
13131 result = (
PLFLT) ((arg1)->dY);
13136 return octave_value_list();
13147 octave_value_list _out;
13148 octave_value_list *_outp=&_out;
13149 octave_value _outv;
13163 arg2 = (
PLFLT)(val2);
13164 if (arg1) (arg1)->wX = arg2;
13165 _outv = octave_value();
13169 return octave_value_list();
13177 octave_value_list _out;
13178 octave_value_list *_outp=&_out;
13179 octave_value _outv;
13190 result = (
PLFLT) ((arg1)->wX);
13195 return octave_value_list();
13206 octave_value_list _out;
13207 octave_value_list *_outp=&_out;
13208 octave_value _outv;
13222 arg2 = (
PLFLT)(val2);
13223 if (arg1) (arg1)->wY = arg2;
13224 _outv = octave_value();
13228 return octave_value_list();
13236 octave_value_list _out;
13237 octave_value_list *_outp=&_out;
13238 octave_value _outv;
13249 result = (
PLFLT) ((arg1)->wY);
13254 return octave_value_list();
13259 octave_value_list _out;
13260 octave_value_list *_outp=&_out;
13261 octave_value _outv;
13272 return octave_value_list();
13280 octave_value_list _out;
13281 octave_value_list *_outp=&_out;
13282 octave_value _outv;
13293 _outv = octave_value();
13297 return octave_value_list();
13327 octave_value_list _out;
13328 octave_value_list *_outp=&_out;
13329 octave_value _outv;
13338 arg1 = (
PLINT)(val1);
13343 arg2 = (
PLINT)(val2);
13345 _outv = octave_value();
13349 return octave_value_list();
13366 octave_value_list _out;
13367 octave_value_list *_outp=&_out;
13368 octave_value _outv;
13377 arg1 = (
PLFLT)(val1);
13382 arg2 = (
PLFLT)(val2);
13387 arg3 = (
PLFLT)(val3);
13392 arg4 = (
PLINT)(val4);
13394 _outv = octave_value();
13398 return octave_value_list();
13406 octave_value_list _out;
13407 octave_value_list *_outp=&_out;
13408 octave_value _outv;
13417 arg1 = (
PLINT)(val1);
13419 _outv = octave_value();
13423 return octave_value_list();
13452 octave_value_list _out;
13453 octave_value_list *_outp=&_out;
13454 octave_value _outv;
13463 arg1 = (
PLFLT)(val1);
13468 arg2 = (
PLFLT)(val2);
13473 arg3 = (
PLFLT)(val3);
13478 arg4 = (
PLFLT)(val4);
13483 arg5 = (
PLFLT)(val5);
13488 arg6 = (
PLFLT)(val6);
13493 arg7 = (
PLFLT)(val7);
13499 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
13500 _outv = octave_value();
13504 return octave_value_list();
13511 char *arg3 = (
char *) 0 ;
13514 char *arg6 = (
char *) 0 ;
13535 octave_value_list _out;
13536 octave_value_list *_outp=&_out;
13537 octave_value _outv;
13546 arg1 = (
PLFLT)(val1);
13551 arg2 = (
PLFLT)(val2);
13556 arg3 = (
char *)(buf3);
13561 arg4 = (
PLFLT)(val4);
13566 arg5 = (
PLINT)(val5);
13571 arg6 = (
char *)(buf6);
13576 arg7 = (
PLFLT)(val7);
13581 arg8 = (
PLINT)(val8);
13582 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
13583 _outv = octave_value();
13591 return octave_value_list();
13597 PLFLT *arg2 = (PLFLT *) 0 ;
13598 PLFLT *arg3 = (PLFLT *) 0 ;
13604 octave_value_list _out;
13605 octave_value_list *_outp=&_out;
13606 octave_value _outv;
13612 if (
_n_dims( args(0) ) > 1 )
13616 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
13617 temp1 = args(0).matrix_value();
13618 arg2 = &temp1( 0, 0 );
13621 if (
_n_dims( args(1) ) > 1 )
13625 if (
_dim( args(1), 0 ) != Alen )
13629 temp3 = args(1).matrix_value();
13630 arg3 = &temp3( 0, 0 );
13636 arg4 = (
PLINT)(val4);
13637 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
13638 _outv = octave_value();
13654 return octave_value_list();
13659 PLINT *arg1 = (PLINT *) 0 ;
13660 PLINT *arg2 = (PLINT *) 0 ;
13661 PLINT *arg3 = (PLINT *) 0 ;
13662 PLINT *arg4 = (PLINT *) 0 ;
13663 PLINT *arg5 = (PLINT *) 0 ;
13664 PLFLT *arg6 = (PLFLT *) 0 ;
13680 octave_value_list _out;
13681 octave_value_list *_outp=&_out;
13682 octave_value _outv;
13697 arg7 = (
PLFLT)(val7);
13698 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13699 _outv = octave_value();
13739 return octave_value_list();
13744 octave_value_list _out;
13745 octave_value_list *_outp=&_out;
13746 octave_value _outv;
13752 _outv = octave_value();
13756 return octave_value_list();
13761 char *arg1 = (
char *) 0 ;
13764 char *arg4 = (
char *) 0 ;
13781 octave_value_list _out;
13782 octave_value_list *_outp=&_out;
13783 octave_value _outv;
13792 arg1 = (
char *)(buf1);
13797 arg2 = (
PLFLT)(val2);
13802 arg3 = (
PLINT)(val3);
13807 arg4 = (
char *)(buf4);
13812 arg5 = (
PLFLT)(val5);
13817 arg6 = (
PLINT)(val6);
13818 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
13819 _outv = octave_value();
13827 return octave_value_list();
13832 char *arg1 = (
char *) 0 ;
13833 char *arg2 = (
char *) 0 ;
13836 char *arg5 = (
char *) 0 ;
13837 char *arg6 = (
char *) 0 ;
13840 char *arg9 = (
char *) 0 ;
13841 char *arg10 = (
char *) 0 ;
13874 octave_value_list _out;
13875 octave_value_list *_outp=&_out;
13876 octave_value _outv;
13885 arg1 = (
char *)(buf1);
13890 arg2 = (
char *)(buf2);
13895 arg3 = (
PLFLT)(val3);
13900 arg4 = (
PLINT)(val4);
13905 arg5 = (
char *)(buf5);
13910 arg6 = (
char *)(buf6);
13915 arg7 = (
PLFLT)(val7);
13920 arg8 = (
PLINT)(val8);
13925 arg9 = (
char *)(buf9);
13930 arg10 = (
char *)(buf10);
13935 arg11 = (
PLFLT)(val11);
13940 arg12 = (
PLINT)(val12);
13941 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);
13942 _outv = octave_value();
13958 return octave_value_list();
13965 PLFLT *arg3 = (PLFLT *) 0 ;
13966 PLFLT *arg4 = (PLFLT *) 0 ;
13967 PLINT *arg5 = (PLINT *) 0 ;
13978 octave_value_list _out;
13979 octave_value_list *_outp=&_out;
13980 octave_value _outv;
13992 arg1 = (
PLFLT)(val1);
13997 arg2 = (
PLFLT)(val2);
13999 _outv = octave_value();
14021 return octave_value_list();
14026 octave_value_list _out;
14027 octave_value_list *_outp=&_out;
14028 octave_value _outv;
14034 _outv = octave_value();
14038 return octave_value_list();
14046 octave_value_list _out;
14047 octave_value_list *_outp=&_out;
14048 octave_value _outv;
14057 arg1 = (
PLINT)(val1);
14059 _outv = octave_value();
14063 return octave_value_list();
14071 octave_value_list _out;
14072 octave_value_list *_outp=&_out;
14073 octave_value _outv;
14082 arg1 = (
PLFLT)(val1);
14084 _outv = octave_value();
14088 return octave_value_list();
14126 octave_value_list _out;
14127 octave_value_list *_outp=&_out;
14128 octave_value _outv;
14137 arg1 = (
PLFLT)(val1);
14142 arg2 = (
PLFLT)(val2);
14147 arg3 = (
PLFLT)(val3);
14152 arg4 = (
PLINT)(val4);
14162 arg6 = (
PLINT)(val6);
14167 arg7 = (
PLINT)(val7);
14172 arg8 = (
PLINT)(val8);
14177 arg9 = (
PLINT)(val9);
14182 arg10 = (
PLINT)(val10);
14187 arg11 = (
PLFLT)(val11);
14188 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14189 _outv = octave_value();
14193 return octave_value_list();
14204 PLFLT *arg7 = (PLFLT *) 0 ;
14219 octave_value_list _out;
14220 octave_value_list *_outp=&_out;
14221 octave_value _outv;
14231 arg1 = (
PLINT)(val1);
14236 arg2 = (
PLINT)(val2);
14241 arg3 = (
PLINT)(val3);
14246 arg4 = (
PLINT)(val4);
14251 arg5 = (
PLINT)(val5);
14256 arg6 = (
PLFLT)(val6);
14257 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14258 _outv = octave_value();
14268 return octave_value_list();
14279 octave_value_list _out;
14280 octave_value_list *_outp=&_out;
14281 octave_value _outv;
14290 arg1 = (
PLINT)(val1);
14297 _outv = octave_value();
14301 return octave_value_list();
14306 octave_value_list _out;
14307 octave_value_list *_outp=&_out;
14308 octave_value _outv;
14314 _outv = octave_value();
14318 return octave_value_list();
14323 octave_value_list _out;
14324 octave_value_list *_outp=&_out;
14325 octave_value _outv;
14331 _outv = octave_value();
14335 return octave_value_list();
14358 octave_value_list _out;
14359 octave_value_list *_outp=&_out;
14360 octave_value _outv;
14369 arg1 = (
PLFLT)(val1);
14374 arg2 = (
PLFLT)(val2);
14379 arg3 = (
PLFLT)(val3);
14384 arg4 = (
PLFLT)(val4);
14389 arg5 = (
PLINT)(val5);
14394 arg6 = (
PLINT)(val6);
14395 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
14396 _outv = octave_value();
14400 return octave_value_list();
14423 octave_value_list _out;
14424 octave_value_list *_outp=&_out;
14425 octave_value _outv;
14434 arg1 = (
PLFLT)(val1);
14439 arg2 = (
PLFLT)(val2);
14444 arg3 = (
PLFLT)(val3);
14449 arg4 = (
PLFLT)(val4);
14454 arg5 = (
PLINT)(val5);
14459 arg6 = (
PLINT)(val6);
14460 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
14461 _outv = octave_value();
14465 return octave_value_list();
14470 octave_value_list _out;
14471 octave_value_list *_outp=&_out;
14472 octave_value _outv;
14478 _outv = octave_value();
14482 return octave_value_list();
14488 PLFLT *arg2 = (PLFLT *) 0 ;
14489 PLFLT *arg3 = (PLFLT *) 0 ;
14490 PLFLT *arg4 = (PLFLT *) 0 ;
14494 octave_value_list _out;
14495 octave_value_list *_outp=&_out;
14496 octave_value _outv;
14502 if (
_n_dims( args(0) ) > 1 )
14506 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14507 temp1 = args(0).matrix_value();
14508 arg2 = &temp1( 0, 0 );
14511 if (
_n_dims( args(1) ) > 1 )
14515 if (
_dim( args(1), 0 ) != Alen )
14519 temp3 = args(1).matrix_value();
14520 arg3 = &temp3( 0, 0 );
14523 if (
_n_dims( args(2) ) > 1 )
14527 if (
_dim( args(2), 0 ) != Alen )
14531 temp4 = args(2).matrix_value();
14532 arg4 = &temp4( 0, 0 );
14534 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14535 _outv = octave_value();
14557 return octave_value_list();
14563 PLFLT *arg2 = (PLFLT *) 0 ;
14564 PLFLT *arg3 = (PLFLT *) 0 ;
14565 PLFLT *arg4 = (PLFLT *) 0 ;
14569 octave_value_list _out;
14570 octave_value_list *_outp=&_out;
14571 octave_value _outv;
14577 if (
_n_dims( args(0) ) > 1 )
14581 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14582 temp1 = args(0).matrix_value();
14583 arg2 = &temp1( 0, 0 );
14586 if (
_n_dims( args(1) ) > 1 )
14590 if (
_dim( args(1), 0 ) != Alen )
14594 temp3 = args(1).matrix_value();
14595 arg3 = &temp3( 0, 0 );
14598 if (
_n_dims( args(2) ) > 1 )
14602 if (
_dim( args(2), 0 ) != Alen )
14606 temp4 = args(2).matrix_value();
14607 arg4 = &temp4( 0, 0 );
14609 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14610 _outv = octave_value();
14632 return octave_value_list();
14637 octave_value_list _out;
14638 octave_value_list *_outp=&_out;
14639 octave_value _outv;
14645 _outv = octave_value();
14649 return octave_value_list();
14655 PLFLT *arg2 = (PLFLT *) 0 ;
14656 PLFLT *arg3 = (PLFLT *) 0 ;
14659 octave_value_list _out;
14660 octave_value_list *_outp=&_out;
14661 octave_value _outv;
14667 if (
_n_dims( args(0) ) > 1 )
14671 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14672 temp1 = args(0).matrix_value();
14673 arg2 = &temp1( 0, 0 );
14676 if (
_n_dims( args(1) ) > 1 )
14680 if (
_dim( args(1), 0 ) != Alen )
14684 temp3 = args(1).matrix_value();
14685 arg3 = &temp3( 0, 0 );
14687 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
14688 _outv = octave_value();
14704 return octave_value_list();
14710 PLFLT *arg2 = (PLFLT *) 0 ;
14711 PLFLT *arg3 = (PLFLT *) 0 ;
14712 PLFLT *arg4 = (PLFLT *) 0 ;
14716 octave_value_list _out;
14717 octave_value_list *_outp=&_out;
14718 octave_value _outv;
14724 if (
_n_dims( args(0) ) > 1 )
14728 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14729 temp1 = args(0).matrix_value();
14730 arg2 = &temp1( 0, 0 );
14733 if (
_n_dims( args(1) ) > 1 )
14737 if (
_dim( args(1), 0 ) != Alen )
14741 temp3 = args(1).matrix_value();
14742 arg3 = &temp3( 0, 0 );
14745 if (
_n_dims( args(2) ) > 1 )
14749 if (
_dim( args(2), 0 ) != Alen )
14753 temp4 = args(2).matrix_value();
14754 arg4 = &temp4( 0, 0 );
14756 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
14757 _outv = octave_value();
14779 return octave_value_list();
14785 PLFLT *arg2 = (PLFLT *) 0 ;
14786 PLFLT *arg3 = (PLFLT *) 0 ;
14792 octave_value_list _out;
14793 octave_value_list *_outp=&_out;
14794 octave_value _outv;
14800 if (
_n_dims( args(0) ) > 1 )
14804 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
14805 temp1 = args(0).matrix_value();
14806 arg2 = &temp1( 0, 0 );
14809 if (
_n_dims( args(1) ) > 1 )
14813 if (
_dim( args(1), 0 ) != Alen )
14817 temp3 = args(1).matrix_value();
14818 arg3 = &temp3( 0, 0 );
14824 arg4 = (
PLFLT)(val4);
14825 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
14826 _outv = octave_value();
14842 return octave_value_list();
14847 octave_value_list _out;
14848 octave_value_list *_outp=&_out;
14849 octave_value _outv;
14855 _outv = octave_value();
14859 return octave_value_list();
14867 octave_value_list _out;
14868 octave_value_list *_outp=&_out;
14869 octave_value _outv;
14878 arg1 = (
PLINT)(val1);
14880 _outv = octave_value();
14884 return octave_value_list();
14892 octave_value_list _out;
14893 octave_value_list *_outp=&_out;
14894 octave_value _outv;
14903 arg1 = (
PLINT)(val1);
14905 _outv = octave_value();
14909 return octave_value_list();
14914 PLFLT *arg1 = (PLFLT *) 0 ;
14915 PLFLT *arg2 = (PLFLT *) 0 ;
14920 octave_value_list _out;
14921 octave_value_list *_outp=&_out;
14922 octave_value _outv;
14930 _outv = octave_value();
14946 return octave_value_list();
14952 PLINT *arg2 = (PLINT *) 0 ;
14953 PLINT *arg3 = (PLINT *) 0 ;
14954 PLINT *arg4 = (PLINT *) 0 ;
14963 octave_value_list _out;
14964 octave_value_list *_outp=&_out;
14965 octave_value _outv;
14977 arg1 = (
PLINT)(val1);
14978 plgcol0(arg1,arg2,arg3,arg4);
14979 _outv = octave_value();
15001 return octave_value_list();
15007 PLINT *arg2 = (PLINT *) 0 ;
15008 PLINT *arg3 = (PLINT *) 0 ;
15009 PLINT *arg4 = (PLINT *) 0 ;
15010 PLFLT *arg5 = (PLFLT *) 0 ;
15021 octave_value_list _out;
15022 octave_value_list *_outp=&_out;
15023 octave_value _outv;
15036 arg1 = (
PLINT)(val1);
15037 plgcol0a(arg1,arg2,arg3,arg4,arg5);
15038 _outv = octave_value();
15066 return octave_value_list();
15071 PLINT *arg1 = (PLINT *) 0 ;
15072 PLINT *arg2 = (PLINT *) 0 ;
15073 PLINT *arg3 = (PLINT *) 0 ;
15080 octave_value_list _out;
15081 octave_value_list *_outp=&_out;
15082 octave_value _outv;
15091 _outv = octave_value();
15113 return octave_value_list();
15118 PLINT *arg1 = (PLINT *) 0 ;
15119 PLINT *arg2 = (PLINT *) 0 ;
15120 PLINT *arg3 = (PLINT *) 0 ;
15121 PLFLT *arg4 = (PLFLT *) 0 ;
15130 octave_value_list _out;
15131 octave_value_list *_outp=&_out;
15132 octave_value _outv;
15142 _outv = octave_value();
15170 return octave_value_list();
15175 PLINT *arg1 = (PLINT *) 0 ;
15178 octave_value_list _out;
15179 octave_value_list *_outp=&_out;
15180 octave_value _outv;
15187 _outv = octave_value();
15197 return octave_value_list();
15202 char *arg1 = (
char *) 0 ;
15203 octave_value_list retval1 ;
15204 octave_value_list _out;
15205 octave_value_list *_outp=&_out;
15206 octave_value _outv;
15210 # if OCTAVE_API_VERSION_NUMBER < 45
15211 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
15213 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15215 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
15221 _outv = octave_value();
15228 return octave_value_list();
15233 PLFLT *arg1 = (PLFLT *) 0 ;
15234 PLFLT *arg2 = (PLFLT *) 0 ;
15235 PLFLT *arg3 = (PLFLT *) 0 ;
15236 PLFLT *arg4 = (PLFLT *) 0 ;
15245 octave_value_list _out;
15246 octave_value_list *_outp=&_out;
15247 octave_value _outv;
15257 _outv = octave_value();
15285 return octave_value_list();
15290 PLFLT *arg1 = (PLFLT *) 0 ;
15293 octave_value_list _out;
15294 octave_value_list *_outp=&_out;
15295 octave_value _outv;
15302 _outv = octave_value();
15312 return octave_value_list();
15317 PLFLT *arg1 = (PLFLT *) 0 ;
15318 PLFLT *arg2 = (PLFLT *) 0 ;
15319 PLFLT *arg3 = (PLFLT *) 0 ;
15320 PLFLT *arg4 = (PLFLT *) 0 ;
15329 octave_value_list _out;
15330 octave_value_list *_outp=&_out;
15331 octave_value _outv;
15341 _outv = octave_value();
15369 return octave_value_list();
15374 PLINT *arg1 = (PLINT *) 0 ;
15375 PLINT *arg2 = (PLINT *) 0 ;
15376 PLINT *arg3 = (PLINT *) 0 ;
15383 octave_value_list _out;
15384 octave_value_list *_outp=&_out;
15385 octave_value _outv;
15394 _outv = octave_value();
15416 return octave_value_list();
15424 octave_value_list _out;
15425 octave_value_list *_outp=&_out;
15426 octave_value _outv;
15433 _outv = octave_value();
15443 return octave_value_list();
15448 char *arg1 = (
char *) 0 ;
15449 octave_value_list retval1 ;
15450 octave_value_list _out;
15451 octave_value_list *_outp=&_out;
15452 octave_value _outv;
15456 # if OCTAVE_API_VERSION_NUMBER < 45
15457 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
15459 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15461 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
15467 _outv = octave_value();
15474 return octave_value_list();
15479 PLINT *arg1 = (PLINT *) 0 ;
15480 PLINT *arg2 = (PLINT *) 0 ;
15481 PLINT *arg3 = (PLINT *) 0 ;
15488 octave_value_list _out;
15489 octave_value_list *_outp=&_out;
15490 octave_value _outv;
15499 _outv = octave_value();
15521 return octave_value_list();
15526 PLINT *arg1 = (PLINT *) 0 ;
15529 octave_value_list _out;
15530 octave_value_list *_outp=&_out;
15531 octave_value _outv;
15538 _outv = octave_value();
15548 return octave_value_list();
15553 PLFLT *arg1 = (PLFLT *) 0 ;
15554 PLFLT *arg2 = (PLFLT *) 0 ;
15555 PLINT *arg3 = (PLINT *) 0 ;
15556 PLINT *arg4 = (PLINT *) 0 ;
15557 PLINT *arg5 = (PLINT *) 0 ;
15558 PLINT *arg6 = (PLINT *) 0 ;
15571 octave_value_list _out;
15572 octave_value_list *_outp=&_out;
15573 octave_value _outv;
15584 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
15585 _outv = octave_value();
15625 return octave_value_list();
15630 octave_value_list _out;
15631 octave_value_list *_outp=&_out;
15632 octave_value _outv;
15638 _outv = octave_value();
15642 return octave_value_list();
15647 PLFLT *arg1 = (PLFLT *) 0 ;
15648 PLFLT *arg2 = (PLFLT *) 0 ;
15649 PLFLT *arg3 = (PLFLT *) 0 ;
15650 PLFLT *arg4 = (PLFLT *) 0 ;
15659 octave_value_list _out;
15660 octave_value_list *_outp=&_out;
15661 octave_value _outv;
15670 plgspa(arg1,arg2,arg3,arg4);
15671 _outv = octave_value();
15699 return octave_value_list();
15704 PLINT *arg1 = (PLINT *) 0 ;
15707 octave_value_list _out;
15708 octave_value_list *_outp=&_out;
15709 octave_value _outv;
15716 _outv = octave_value();
15726 return octave_value_list();
15731 char *arg1 = (
char *) 0 ;
15732 octave_value_list retval1 ;
15733 octave_value_list _out;
15734 octave_value_list *_outp=&_out;
15735 octave_value _outv;
15739 # if OCTAVE_API_VERSION_NUMBER < 45
15740 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
15742 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15744 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
15750 _outv = octave_value();
15757 return octave_value_list();
15762 PLFLT *arg1 = (PLFLT *) 0 ;
15763 PLFLT *arg2 = (PLFLT *) 0 ;
15764 PLFLT *arg3 = (PLFLT *) 0 ;
15765 PLFLT *arg4 = (PLFLT *) 0 ;
15774 octave_value_list _out;
15775 octave_value_list *_outp=&_out;
15776 octave_value _outv;
15785 plgvpd(arg1,arg2,arg3,arg4);
15786 _outv = octave_value();
15814 return octave_value_list();
15819 PLFLT *arg1 = (PLFLT *) 0 ;
15820 PLFLT *arg2 = (PLFLT *) 0 ;
15821 PLFLT *arg3 = (PLFLT *) 0 ;
15822 PLFLT *arg4 = (PLFLT *) 0 ;
15831 octave_value_list _out;
15832 octave_value_list *_outp=&_out;
15833 octave_value _outv;
15842 plgvpw(arg1,arg2,arg3,arg4);
15843 _outv = octave_value();
15871 return octave_value_list();
15876 PLINT *arg1 = (PLINT *) 0 ;
15877 PLINT *arg2 = (PLINT *) 0 ;
15882 octave_value_list _out;
15883 octave_value_list *_outp=&_out;
15884 octave_value _outv;
15892 _outv = octave_value();
15908 return octave_value_list();
15913 PLINT *arg1 = (PLINT *) 0 ;
15914 PLINT *arg2 = (PLINT *) 0 ;
15919 octave_value_list _out;
15920 octave_value_list *_outp=&_out;
15921 octave_value _outv;
15929 _outv = octave_value();
15945 return octave_value_list();
15950 PLINT *arg1 = (PLINT *) 0 ;
15951 PLINT *arg2 = (PLINT *) 0 ;
15956 octave_value_list _out;
15957 octave_value_list *_outp=&_out;
15958 octave_value _outv;
15966 _outv = octave_value();
15982 return octave_value_list();
15988 PLFLT *arg2 = (PLFLT *) 0 ;
16002 octave_value_list _out;
16003 octave_value_list *_outp=&_out;
16004 octave_value _outv;
16010 if (
_n_dims( args(0) ) > 1 )
16014 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16015 temp1 = args(0).matrix_value();
16016 arg2 = &temp1( 0, 0 );
16022 arg3 = (
PLFLT)(val3);
16027 arg4 = (
PLFLT)(val4);
16032 arg5 = (
PLINT)(val5);
16037 arg6 = (
PLINT)(val6);
16038 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
16039 _outv = octave_value();
16049 return octave_value_list();
16057 PLFLT *arg4 = (PLFLT *) 0 ;
16058 PLFLT *arg5 = (PLFLT *) 0 ;
16059 PLFLT *arg6 = (PLFLT *) 0 ;
16072 octave_value_list _out;
16073 octave_value_list *_outp=&_out;
16074 octave_value _outv;
16086 arg1 = (
PLFLT)(val1);
16091 arg2 = (
PLFLT)(val2);
16096 arg3 = (
PLFLT)(val3);
16097 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
16098 _outv = octave_value();
16120 return octave_value_list();
16125 octave_value_list _out;
16126 octave_value_list *_outp=&_out;
16127 octave_value _outv;
16133 _outv = octave_value();
16137 return octave_value_list();
16154 octave_value_list _out;
16155 octave_value_list *_outp=&_out;
16156 octave_value _outv;
16165 arg1 = (
PLFLT)(val1);
16170 arg2 = (
PLFLT)(val2);
16175 arg3 = (
PLFLT)(val3);
16180 arg4 = (
PLFLT)(val4);
16181 pljoin(arg1,arg2,arg3,arg4);
16182 _outv = octave_value();
16186 return octave_value_list();
16191 char *arg1 = (
char *) 0 ;
16192 char *arg2 = (
char *) 0 ;
16193 char *arg3 = (
char *) 0 ;
16203 octave_value_list _out;
16204 octave_value_list *_outp=&_out;
16205 octave_value _outv;
16214 arg1 = (
char *)(buf1);
16219 arg2 = (
char *)(buf2);
16224 arg3 = (
char *)(buf3);
16225 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
16226 _outv = octave_value();
16236 return octave_value_list();
16241 PLFLT *arg1 = (PLFLT *) 0 ;
16242 PLFLT *arg2 = (PLFLT *) 0 ;
16254 PLINT *arg14 = (PLINT *) 0 ;
16259 PLINT *arg19 = (PLINT *) 0 ;
16260 char **arg20 = (
char **) 0 ;
16261 PLINT *arg21 = (PLINT *) 0 ;
16262 PLINT *arg22 = (PLINT *) 0 ;
16263 PLFLT *arg23 = (PLFLT *) 0 ;
16264 PLFLT *arg24 = (PLFLT *) 0 ;
16265 PLINT *arg25 = (PLINT *) 0 ;
16266 PLINT *arg26 = (PLINT *) 0 ;
16267 PLFLT *arg27 = (PLFLT *) 0 ;
16268 PLINT *arg28 = (PLINT *) 0 ;
16269 PLFLT *arg29 = (PLFLT *) 0 ;
16270 PLINT *arg30 = (PLINT *) 0 ;
16271 char **arg31 = (
char **) 0 ;
16316 octave_value_list _out;
16317 octave_value_list *_outp=&_out;
16318 octave_value _outv;
16329 arg3 = (
PLINT)(val3);
16334 arg4 = (
PLINT)(val4);
16339 arg5 = (
PLFLT)(val5);
16344 arg6 = (
PLFLT)(val6);
16349 arg7 = (
PLFLT)(val7);
16354 arg8 = (
PLINT)(val8);
16359 arg9 = (
PLINT)(val9);
16364 arg10 = (
PLINT)(val10);
16369 arg11 = (
PLINT)(val11);
16374 arg12 = (
PLINT)(val12);
16376 if (
_n_dims( args(10) ) > 1 )
16380 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
16381 arg14 =
new PLINT[
Alen];
16382 temp13 = args(10).matrix_value();
16389 arg15 = (
PLFLT)(val15);
16394 arg16 = (
PLFLT)(val16);
16399 arg17 = (
PLFLT)(val17);
16404 arg18 = (
PLFLT)(val18);
16406 if (
_n_dims( args(15) ) > 1 )
16410 if (
_dim( args(15), 0 ) != Alen )
16414 temp19 = args(15).matrix_value();
16415 arg19 =
new PLINT[
Alen];
16419 charMatrix temp_matrix;
16423 size_t max_length, non_blank_length;
16425 if (
_n_dims( args(16) ) > 2 )
16427 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
16429 if ( !args(16).is_empty() )
16431 if (
_dim( args(16), 0 ) != Alen )
16433 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
16435 arg20 =
new char*[
Alen];
16436 ifcell = args(16).is_cell();
16439 temp_cell = args(16).cell_value();
16443 temp_matrix = args(16).char_matrix_value();
16445 max_length =
_dim( args(16), 1 ) + 1;
16448 for ( i = 0; i <
Alen; i++ )
16455 if ( temp_cell.elem( i ).is_string() )
16457 str = temp_cell.elem( i ).string_value();
16459 max_length = str.size() + 1;
16460 tmp_cstring = (
char *) str.c_str();
16470 tmp_cstring = (
char *)
"";
16475 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
16477 arg20[i] =
new char[max_length];
16478 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16479 arg20[i][max_length - 1] =
'\0';
16494 non_blank_length = max_length - 2;
16495 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16497 non_blank_length--;
16499 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16501 non_blank_length--;
16503 arg20[i][non_blank_length + 1] =
'\0';
16513 if (
_n_dims( args(17) ) > 1 )
16517 if ( !args(17).is_empty() )
16519 if (
_dim( args(17), 0 ) != Alen )
16523 temp21 = args(17).matrix_value();
16524 arg21 =
new PLINT[
Alen];
16533 if (
_n_dims( args(18) ) > 1 )
16537 if ( !args(18).is_empty() )
16539 if (
_dim( args(18), 0 ) != Alen )
16543 temp22 = args(18).matrix_value();
16544 arg22 =
new PLINT[
Alen];
16553 if (
_n_dims( args(19) ) > 1 )
16557 if ( !args(19).is_empty() )
16559 if (
_dim( args(19), 0 ) != Alen )
16563 temp23 = args(19).matrix_value();
16564 arg23 = &temp23( 0, 0 );
16572 if (
_n_dims( args(20) ) > 1 )
16576 if ( !args(20).is_empty() )
16578 if (
_dim( args(20), 0 ) != Alen )
16582 temp24 = args(20).matrix_value();
16583 arg24 = &temp24( 0, 0 );
16591 if (
_n_dims( args(21) ) > 1 )
16595 if ( !args(21).is_empty() )
16597 if (
_dim( args(21), 0 ) != Alen )
16601 temp25 = args(21).matrix_value();
16602 arg25 =
new PLINT[
Alen];
16611 if (
_n_dims( args(22) ) > 1 )
16615 if ( !args(22).is_empty() )
16617 if (
_dim( args(22), 0 ) != Alen )
16621 temp26 = args(22).matrix_value();
16622 arg26 =
new PLINT[
Alen];
16631 if (
_n_dims( args(23) ) > 1 )
16635 if ( !args(23).is_empty() )
16637 if (
_dim( args(23), 0 ) != Alen )
16641 temp27 = args(23).matrix_value();
16642 arg27 = &temp27( 0, 0 );
16650 if (
_n_dims( args(24) ) > 1 )
16654 if ( !args(24).is_empty() )
16656 if (
_dim( args(24), 0 ) != Alen )
16660 temp28 = args(24).matrix_value();
16661 arg28 =
new PLINT[
Alen];
16670 if (
_n_dims( args(25) ) > 1 )
16674 if ( !args(25).is_empty() )
16676 if (
_dim( args(25), 0 ) != Alen )
16680 temp29 = args(25).matrix_value();
16681 arg29 = &temp29( 0, 0 );
16689 if (
_n_dims( args(26) ) > 1 )
16693 if ( !args(26).is_empty() )
16695 if (
_dim( args(26), 0 ) != Alen )
16699 temp30 = args(26).matrix_value();
16700 arg30 =
new PLINT[
Alen];
16709 charMatrix temp_matrix;
16713 size_t max_length, non_blank_length;
16715 if (
_n_dims( args(27) ) > 2 )
16717 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
16719 if ( !args(27).is_empty() )
16721 if (
_dim( args(27), 0 ) != Alen )
16723 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
16725 arg31 =
new char*[
Alen];
16726 ifcell = args(27).is_cell();
16729 temp_cell = args(27).cell_value();
16733 temp_matrix = args(27).char_matrix_value();
16735 max_length =
_dim( args(27), 1 ) + 1;
16738 for ( i = 0; i <
Alen; i++ )
16745 if ( temp_cell.elem( i ).is_string() )
16747 str = temp_cell.elem( i ).string_value();
16749 max_length = str.size() + 1;
16750 tmp_cstring = (
char *) str.c_str();
16760 tmp_cstring = (
char *)
"";
16765 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
16767 arg31[i] =
new char[max_length];
16768 strncpy( arg31[i], tmp_cstring, max_length - 1 );
16769 arg31[i][max_length - 1] =
'\0';
16784 non_blank_length = max_length - 2;
16785 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
16787 non_blank_length--;
16789 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
16791 non_blank_length--;
16793 arg31[i][non_blank_length + 1] =
'\0';
16802 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);
16803 _outv = octave_value();
16825 if ( arg20 != NULL )
16827 for ( i = 0; i <
Alen; i++ )
16835 if ( arg21 != NULL )
16839 if ( arg22 != NULL )
16849 if ( arg25 != NULL )
16853 if ( arg26 != NULL )
16860 if ( arg28 != NULL )
16867 if ( arg30 != NULL )
16872 if ( arg31 != NULL )
16874 for ( i = 0; i <
Alen; i++ )
16891 if ( arg20 != NULL )
16893 for ( i = 0; i <
Alen; i++ )
16901 if ( arg21 != NULL )
16905 if ( arg22 != NULL )
16915 if ( arg25 != NULL )
16919 if ( arg26 != NULL )
16926 if ( arg28 != NULL )
16933 if ( arg30 != NULL )
16938 if ( arg31 != NULL )
16940 for ( i = 0; i <
Alen; i++ )
16947 return octave_value_list();
16961 octave_value_list _out;
16962 octave_value_list *_outp=&_out;
16963 octave_value _outv;
16972 arg1 = (
PLFLT)(val1);
16977 arg2 = (
PLFLT)(val2);
16982 arg3 = (
PLFLT)(val3);
16984 _outv = octave_value();
16988 return octave_value_list();
16994 PLFLT *arg2 = (PLFLT *) 0 ;
16995 PLFLT *arg3 = (PLFLT *) 0 ;
16998 octave_value_list _out;
16999 octave_value_list *_outp=&_out;
17000 octave_value _outv;
17006 if (
_n_dims( args(0) ) > 1 )
17010 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17011 temp1 = args(0).matrix_value();
17012 arg2 = &temp1( 0, 0 );
17015 if (
_n_dims( args(1) ) > 1 )
17019 if (
_dim( args(1), 0 ) != Alen )
17023 temp3 = args(1).matrix_value();
17024 arg3 = &temp3( 0, 0 );
17026 plline(arg1,(
double const *)arg2,(
double const *)arg3);
17027 _outv = octave_value();
17043 return octave_value_list();
17049 PLFLT *arg2 = (PLFLT *) 0 ;
17050 PLFLT *arg3 = (PLFLT *) 0 ;
17051 PLFLT *arg4 = (PLFLT *) 0 ;
17055 octave_value_list _out;
17056 octave_value_list *_outp=&_out;
17057 octave_value _outv;
17063 if (
_n_dims( args(0) ) > 1 )
17067 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17068 temp1 = args(0).matrix_value();
17069 arg2 = &temp1( 0, 0 );
17072 if (
_n_dims( args(1) ) > 1 )
17076 if (
_dim( args(1), 0 ) != Alen )
17080 temp3 = args(1).matrix_value();
17081 arg3 = &temp3( 0, 0 );
17084 if (
_n_dims( args(2) ) > 1 )
17088 if (
_dim( args(2), 0 ) != Alen )
17092 temp4 = args(2).matrix_value();
17093 arg4 = &temp4( 0, 0 );
17095 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17096 _outv = octave_value();
17118 return octave_value_list();
17126 octave_value_list _out;
17127 octave_value_list *_outp=&_out;
17128 octave_value _outv;
17137 arg1 = (
PLINT)(val1);
17139 _outv = octave_value();
17143 return octave_value_list();
17148 PLINT *arg1 = (PLINT *) 0 ;
17151 octave_value_list _out;
17152 octave_value_list *_outp=&_out;
17153 octave_value _outv;
17160 _outv = octave_value();
17170 return octave_value_list();
17175 char *arg1 = (
char *) 0 ;
17179 char *arg5 = (
char *) 0 ;
17192 octave_value_list _out;
17193 octave_value_list *_outp=&_out;
17194 octave_value _outv;
17203 arg1 = (
char *)(buf1);
17208 arg2 = (
PLFLT)(val2);
17213 arg3 = (
PLFLT)(val3);
17218 arg4 = (
PLFLT)(val4);
17223 arg5 = (
char *)(buf5);
17224 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
17225 _outv = octave_value();
17233 return octave_value_list();
17238 char *arg1 = (
char *) 0 ;
17242 char *arg5 = (
char *) 0 ;
17255 octave_value_list _out;
17256 octave_value_list *_outp=&_out;
17257 octave_value _outv;
17266 arg1 = (
char *)(buf1);
17271 arg2 = (
PLFLT)(val2);
17276 arg3 = (
PLFLT)(val3);
17281 arg4 = (
PLFLT)(val4);
17286 arg5 = (
char *)(buf5);
17287 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
17288 _outv = octave_value();
17296 return octave_value_list();
17301 int *arg1 = (
int *) 0 ;
17302 char **arg2 = (
char **) 0 ;
17310 octave_value_list _out;
17311 octave_value_list *_outp=&_out;
17312 octave_value _outv;
17322 arg1 = (
int *)(argp1);
17327 arg2 = (
char **)(argp2);
17332 arg3 = (
PLINT)(val3);
17338 return octave_value_list();
17344 PLINT *arg2 = (PLINT *) 0 ;
17345 PLINT *arg3 = (PLINT *) 0 ;
17348 octave_value_list _out;
17349 octave_value_list *_outp=&_out;
17350 octave_value _outv;
17356 if (
_n_dims( args(0) ) > 1 )
17360 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17361 arg2 =
new PLINT[
Alen];
17362 temp1 = args(0).matrix_value();
17366 if (
_n_dims( args(1) ) > 1 )
17370 if (
_dim( args(1), 0 ) != Alen )
17374 temp3 = args(1).matrix_value();
17375 arg3 =
new PLINT[
Alen];
17378 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
17379 _outv = octave_value();
17395 return octave_value_list();
17401 PLFLT *arg2 = (PLFLT *) 0 ;
17402 PLFLT *arg3 = (PLFLT *) 0 ;
17408 octave_value_list _out;
17409 octave_value_list *_outp=&_out;
17410 octave_value _outv;
17416 if (
_n_dims( args(0) ) > 1 )
17420 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17421 temp1 = args(0).matrix_value();
17422 arg2 = &temp1( 0, 0 );
17425 if (
_n_dims( args(1) ) > 1 )
17429 if (
_dim( args(1), 0 ) != Alen )
17433 temp3 = args(1).matrix_value();
17434 arg3 = &temp3( 0, 0 );
17440 arg4 = (
PLINT)(val4);
17441 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17442 _outv = octave_value();
17458 return octave_value_list();
17464 PLFLT *arg2 = (PLFLT *) 0 ;
17465 PLFLT *arg3 = (PLFLT *) 0 ;
17466 PLFLT *arg4 = (PLFLT *) 0 ;
17473 octave_value_list _out;
17474 octave_value_list *_outp=&_out;
17475 octave_value _outv;
17481 if (
_n_dims( args(0) ) > 1 )
17485 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17486 temp1 = args(0).matrix_value();
17487 arg2 = &temp1( 0, 0 );
17490 if (
_n_dims( args(1) ) > 1 )
17494 if (
_dim( args(1), 0 ) != Alen )
17498 temp3 = args(1).matrix_value();
17499 arg3 = &temp3( 0, 0 );
17502 if (
_n_dims( args(2) ) > 1 )
17506 if (
_dim( args(2), 0 ) != Alen )
17510 temp4 = args(2).matrix_value();
17511 arg4 = &temp4( 0, 0 );
17517 arg5 = (
PLINT)(val5);
17518 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
17519 _outv = octave_value();
17541 return octave_value_list();
17547 PLFLT *arg2 = (PLFLT *) 0 ;
17548 PLFLT *arg3 = (PLFLT *) 0 ;
17549 PLFLT *arg4 = (PLFLT *) 0 ;
17558 octave_value_list _out;
17559 octave_value_list *_outp=&_out;
17560 octave_value _outv;
17566 if (
_n_dims( args(0) ) > 1 )
17570 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17571 temp1 = args(0).matrix_value();
17572 arg2 = &temp1( 0, 0 );
17575 if (
_n_dims( args(1) ) > 1 )
17579 if (
_dim( args(1), 0 ) != Alen )
17583 temp3 = args(1).matrix_value();
17584 arg3 = &temp3( 0, 0 );
17587 if (
_n_dims( args(2) ) > 1 )
17591 if (
_dim( args(2), 0 ) != Alen )
17595 temp4 = args(2).matrix_value();
17596 arg4 = &temp4( 0, 0 );
17599 if (
_n_dims( args(3) ) > 1 )
17603 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
17605 error(
"argument vector must be same length or one less" );
SWIG_fail;
17607 temp5 = args(3).matrix_value();
17608 arg5 =
new PLINT[
Alen];
17616 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
17617 _outv = octave_value();
17645 return octave_value_list();
17656 octave_value_list _out;
17657 octave_value_list *_outp=&_out;
17658 octave_value _outv;
17667 arg1 = (
PLINT)(val1);
17672 arg2 = (
PLINT)(val2);
17674 _outv = octave_value();
17678 return octave_value_list();
17686 octave_value_list _out;
17687 octave_value_list *_outp=&_out;
17688 octave_value _outv;
17697 arg1 = (
PLINT)(val1);
17699 _outv = octave_value();
17703 return octave_value_list();
17713 char *arg6 = (
char *) 0 ;
17727 octave_value_list _out;
17728 octave_value_list *_outp=&_out;
17729 octave_value _outv;
17738 arg1 = (
PLFLT)(val1);
17743 arg2 = (
PLFLT)(val2);
17748 arg3 = (
PLFLT)(val3);
17753 arg4 = (
PLFLT)(val4);
17758 arg5 = (
PLFLT)(val5);
17763 arg6 = (
char *)(buf6);
17764 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
17765 _outv = octave_value();
17771 return octave_value_list();
17786 char *arg11 = (
char *) 0 ;
17810 octave_value_list _out;
17811 octave_value_list *_outp=&_out;
17812 octave_value _outv;
17821 arg1 = (
PLFLT)(val1);
17826 arg2 = (
PLFLT)(val2);
17831 arg3 = (
PLFLT)(val3);
17836 arg4 = (
PLFLT)(val4);
17841 arg5 = (
PLFLT)(val5);
17846 arg6 = (
PLFLT)(val6);
17851 arg7 = (
PLFLT)(val7);
17856 arg8 = (
PLFLT)(val8);
17861 arg9 = (
PLFLT)(val9);
17866 arg10 = (
PLFLT)(val10);
17871 arg11 = (
char *)(buf11);
17872 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
17873 _outv = octave_value();
17879 return octave_value_list();
17884 octave_value_list _out;
17885 octave_value_list *_outp=&_out;
17886 octave_value _outv;
17897 return octave_value_list();
17902 octave_value_list _out;
17903 octave_value_list *_outp=&_out;
17904 octave_value _outv;
17910 _outv = octave_value();
17914 return octave_value_list();
17922 PLFLT *arg4 = (PLFLT *) 0 ;
17923 PLFLT *arg5 = (PLFLT *) 0 ;
17924 PLFLT *arg6 = (PLFLT *) 0 ;
17937 octave_value_list _out;
17938 octave_value_list *_outp=&_out;
17939 octave_value _outv;
17951 arg1 = (
PLFLT)(val1);
17956 arg2 = (
PLFLT)(val2);
17961 arg3 = (
PLFLT)(val3);
17962 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
17963 _outv = octave_value();
17985 return octave_value_list();
17996 octave_value_list _out;
17997 octave_value_list *_outp=&_out;
17998 octave_value _outv;
18007 arg1 = (
PLFLT)(val1);
18012 arg2 = (
PLFLT)(val2);
18014 _outv = octave_value();
18018 return octave_value_list();
18023 PLINT *arg1 = (PLINT *) 0 ;
18024 PLINT *arg2 = (PLINT *) 0 ;
18025 PLINT *arg3 = (PLINT *) 0 ;
18030 octave_value_list _out;
18031 octave_value_list *_outp=&_out;
18032 octave_value _outv;
18038 if (
_n_dims( args(0) ) > 1 )
18043 temp1 = args(0).matrix_value();
18044 arg1 =
new PLINT[
Alen];
18048 if (
_n_dims( args(1) ) > 1 )
18052 if (
_dim( args(1), 0 ) != Alen )
18056 temp2 = args(1).matrix_value();
18057 arg2 =
new PLINT[
Alen];
18061 if (
_n_dims( args(2) ) > 1 )
18065 if (
_dim( args(2), 0 ) != Alen )
18069 temp3 = args(2).matrix_value();
18070 arg3 =
new PLINT[
Alen];
18074 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
18075 _outv = octave_value();
18097 return octave_value_list();
18102 PLINT *arg1 = (PLINT *) 0 ;
18103 PLINT *arg2 = (PLINT *) 0 ;
18104 PLINT *arg3 = (PLINT *) 0 ;
18105 PLFLT *arg4 = (PLFLT *) 0 ;
18111 octave_value_list _out;
18112 octave_value_list *_outp=&_out;
18113 octave_value _outv;
18119 if (
_n_dims( args(0) ) > 1 )
18124 temp1 = args(0).matrix_value();
18125 arg1 =
new PLINT[
Alen];
18129 if (
_n_dims( args(1) ) > 1 )
18133 if (
_dim( args(1), 0 ) != Alen )
18137 temp2 = args(1).matrix_value();
18138 arg2 =
new PLINT[
Alen];
18142 if (
_n_dims( args(2) ) > 1 )
18146 if (
_dim( args(2), 0 ) != Alen )
18150 temp3 = args(2).matrix_value();
18151 arg3 =
new PLINT[
Alen];
18155 if (
_n_dims( args(3) ) > 1 )
18159 if (
_dim( args(3), 0 ) != Alen )
18163 temp4 = args(3).matrix_value();
18164 arg4 = &temp4( 0, 0 );
18167 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
18168 _outv = octave_value();
18196 return octave_value_list();
18204 octave_value_list _out;
18205 octave_value_list *_outp=&_out;
18206 octave_value _outv;
18215 arg1 = (
PLINT)(val1);
18217 _outv = octave_value();
18221 return octave_value_list();
18226 PLINT *arg1 = (PLINT *) 0 ;
18227 PLINT *arg2 = (PLINT *) 0 ;
18228 PLINT *arg3 = (PLINT *) 0 ;
18233 octave_value_list _out;
18234 octave_value_list *_outp=&_out;
18235 octave_value _outv;
18241 if (
_n_dims( args(0) ) > 1 )
18246 temp1 = args(0).matrix_value();
18247 arg1 =
new PLINT[
Alen];
18251 if (
_n_dims( args(1) ) > 1 )
18255 if (
_dim( args(1), 0 ) != Alen )
18259 temp2 = args(1).matrix_value();
18260 arg2 =
new PLINT[
Alen];
18264 if (
_n_dims( args(2) ) > 1 )
18268 if (
_dim( args(2), 0 ) != Alen )
18272 temp3 = args(2).matrix_value();
18273 arg3 =
new PLINT[
Alen];
18277 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
18278 _outv = octave_value();
18300 return octave_value_list();
18305 PLINT *arg1 = (PLINT *) 0 ;
18306 PLINT *arg2 = (PLINT *) 0 ;
18307 PLINT *arg3 = (PLINT *) 0 ;
18308 PLFLT *arg4 = (PLFLT *) 0 ;
18314 octave_value_list _out;
18315 octave_value_list *_outp=&_out;
18316 octave_value _outv;
18322 if (
_n_dims( args(0) ) > 1 )
18327 temp1 = args(0).matrix_value();
18328 arg1 =
new PLINT[
Alen];
18332 if (
_n_dims( args(1) ) > 1 )
18336 if (
_dim( args(1), 0 ) != Alen )
18340 temp2 = args(1).matrix_value();
18341 arg2 =
new PLINT[
Alen];
18345 if (
_n_dims( args(2) ) > 1 )
18349 if (
_dim( args(2), 0 ) != Alen )
18353 temp3 = args(2).matrix_value();
18354 arg3 =
new PLINT[
Alen];
18358 if (
_n_dims( args(3) ) > 1 )
18362 if (
_dim( args(3), 0 ) != Alen )
18366 temp4 = args(3).matrix_value();
18367 arg4 = &temp4( 0, 0 );
18370 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
18371 _outv = octave_value();
18399 return octave_value_list();
18406 PLFLT *arg3 = (PLFLT *) 0 ;
18407 PLFLT *arg4 = (PLFLT *) 0 ;
18408 PLFLT *arg5 = (PLFLT *) 0 ;
18409 PLFLT *arg6 = (PLFLT *) 0 ;
18418 octave_value_list _out;
18419 octave_value_list *_outp=&_out;
18420 octave_value _outv;
18431 if (
_n_dims( args(1) ) > 1 )
18435 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
18436 temp2 = args(1).matrix_value();
18437 arg3 = &temp2( 0, 0 );
18440 if (
_n_dims( args(2) ) > 1 )
18444 if (
_dim( args(2), 0 ) != Alen )
18448 temp4 = args(2).matrix_value();
18449 arg4 = &temp4( 0, 0 );
18452 if (
_n_dims( args(3) ) > 1 )
18456 if (
_dim( args(3), 0 ) != Alen )
18460 temp5 = args(3).matrix_value();
18461 arg5 = &temp5( 0, 0 );
18464 if (
_n_dims( args(4) ) > 1 )
18468 if (
_dim( args(4), 0 ) != Alen )
18472 temp6 = args(4).matrix_value();
18473 arg6 = &temp6( 0, 0 );
18476 if (
_n_dims( args(5) ) > 1 )
18480 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
18482 error(
"argument vector must be same length or one less" );
SWIG_fail;
18484 temp7 = args(5).matrix_value();
18485 arg7 =
new PLINT[
Alen];
18488 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
18489 _outv = octave_value();
18523 return octave_value_list();
18530 PLFLT *arg3 = (PLFLT *) 0 ;
18531 PLFLT *arg4 = (PLFLT *) 0 ;
18532 PLFLT *arg5 = (PLFLT *) 0 ;
18533 PLFLT *arg6 = (PLFLT *) 0 ;
18534 PLFLT *arg7 = (PLFLT *) 0 ;
18544 octave_value_list _out;
18545 octave_value_list *_outp=&_out;
18546 octave_value _outv;
18557 if (
_n_dims( args(1) ) > 1 )
18561 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
18562 temp2 = args(1).matrix_value();
18563 arg3 = &temp2( 0, 0 );
18566 if (
_n_dims( args(2) ) > 1 )
18570 if (
_dim( args(2), 0 ) != Alen )
18574 temp4 = args(2).matrix_value();
18575 arg4 = &temp4( 0, 0 );
18578 if (
_n_dims( args(3) ) > 1 )
18582 if (
_dim( args(3), 0 ) != Alen )
18586 temp5 = args(3).matrix_value();
18587 arg5 = &temp5( 0, 0 );
18590 if (
_n_dims( args(4) ) > 1 )
18594 if (
_dim( args(4), 0 ) != Alen )
18598 temp6 = args(4).matrix_value();
18599 arg6 = &temp6( 0, 0 );
18602 if (
_n_dims( args(5) ) > 1 )
18606 if (
_dim( args(5), 0 ) != Alen )
18610 temp7 = args(5).matrix_value();
18611 arg7 = &temp7( 0, 0 );
18614 if (
_n_dims( args(6) ) > 1 )
18618 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
18620 error(
"argument vector must be same length or one less" );
SWIG_fail;
18622 temp8 = args(6).matrix_value();
18623 arg8 =
new PLINT[
Alen];
18626 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
18627 _outv = octave_value();
18667 return octave_value_list();
18675 octave_value_list _out;
18676 octave_value_list *_outp=&_out;
18677 octave_value _outv;
18686 arg1 = (
PLINT)(val1);
18688 _outv = octave_value();
18692 return octave_value_list();
18703 octave_value_list _out;
18704 octave_value_list *_outp=&_out;
18705 octave_value _outv;
18714 arg1 = (
PLFLT)(val1);
18719 arg2 = (
PLFLT)(val2);
18721 _outv = octave_value();
18725 return octave_value_list();
18730 PLFLT *arg1 = (PLFLT *) 0 ;
18731 PLFLT *arg2 = (PLFLT *) 0 ;
18736 octave_value_list _out;
18737 octave_value_list *_outp=&_out;
18738 octave_value _outv;
18746 _outv = octave_value();
18762 return octave_value_list();
18779 octave_value_list _out;
18780 octave_value_list *_outp=&_out;
18781 octave_value _outv;
18790 arg1 = (
PLINT)(val1);
18795 arg2 = (
PLINT)(val2);
18800 arg3 = (
PLINT)(val3);
18805 arg4 = (
PLINT)(val4);
18806 plscol0(arg1,arg2,arg3,arg4);
18807 _outv = octave_value();
18811 return octave_value_list();
18831 octave_value_list _out;
18832 octave_value_list *_outp=&_out;
18833 octave_value _outv;
18842 arg1 = (
PLINT)(val1);
18847 arg2 = (
PLINT)(val2);
18852 arg3 = (
PLINT)(val3);
18857 arg4 = (
PLINT)(val4);
18862 arg5 = (
PLFLT)(val5);
18863 plscol0a(arg1,arg2,arg3,arg4,arg5);
18864 _outv = octave_value();
18868 return octave_value_list();
18882 octave_value_list _out;
18883 octave_value_list *_outp=&_out;
18884 octave_value _outv;
18893 arg1 = (
PLINT)(val1);
18898 arg2 = (
PLINT)(val2);
18903 arg3 = (
PLINT)(val3);
18905 _outv = octave_value();
18909 return octave_value_list();
18926 octave_value_list _out;
18927 octave_value_list *_outp=&_out;
18928 octave_value _outv;
18937 arg1 = (
PLINT)(val1);
18942 arg2 = (
PLINT)(val2);
18947 arg3 = (
PLINT)(val3);
18952 arg4 = (
PLFLT)(val4);
18954 _outv = octave_value();
18958 return octave_value_list();
18966 octave_value_list _out;
18967 octave_value_list *_outp=&_out;
18968 octave_value _outv;
18977 arg1 = (
PLINT)(val1);
18979 _outv = octave_value();
18983 return octave_value_list();
18991 octave_value_list _out;
18992 octave_value_list *_outp=&_out;
18993 octave_value _outv;
19002 arg1 = (
PLINT)(val1);
19004 _outv = octave_value();
19008 return octave_value_list();
19013 char *arg1 = (
char *) 0 ;
19017 octave_value_list _out;
19018 octave_value_list *_outp=&_out;
19019 octave_value _outv;
19028 arg1 = (
char *)(buf1);
19029 plsdev((
char const *)arg1);
19030 _outv = octave_value();
19036 return octave_value_list();
19053 octave_value_list _out;
19054 octave_value_list *_outp=&_out;
19055 octave_value _outv;
19064 arg1 = (
PLFLT)(val1);
19069 arg2 = (
PLFLT)(val2);
19074 arg3 = (
PLFLT)(val3);
19079 arg4 = (
PLFLT)(val4);
19081 _outv = octave_value();
19085 return octave_value_list();
19108 octave_value_list _out;
19109 octave_value_list *_outp=&_out;
19110 octave_value _outv;
19119 arg1 = (
PLINT)(val1);
19124 arg2 = (
PLINT)(val2);
19129 arg3 = (
PLINT)(val3);
19134 arg4 = (
PLINT)(val4);
19139 arg5 = (
PLFLT)(val5);
19144 arg6 = (
PLFLT)(val6);
19145 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
19146 _outv = octave_value();
19150 return octave_value_list();
19158 octave_value_list _out;
19159 octave_value_list *_outp=&_out;
19160 octave_value _outv;
19169 arg1 = (
PLFLT)(val1);
19171 _outv = octave_value();
19175 return octave_value_list();
19192 octave_value_list _out;
19193 octave_value_list *_outp=&_out;
19194 octave_value _outv;
19203 arg1 = (
PLFLT)(val1);
19208 arg2 = (
PLFLT)(val2);
19213 arg3 = (
PLFLT)(val3);
19218 arg4 = (
PLFLT)(val4);
19220 _outv = octave_value();
19224 return octave_value_list();
19241 octave_value_list _out;
19242 octave_value_list *_outp=&_out;
19243 octave_value _outv;
19252 arg1 = (
PLFLT)(val1);
19257 arg2 = (
PLFLT)(val2);
19262 arg3 = (
PLFLT)(val3);
19267 arg4 = (
PLFLT)(val4);
19269 _outv = octave_value();
19273 return octave_value_list();
19278 unsigned int arg1 ;
19279 unsigned int val1 ;
19281 octave_value_list _out;
19282 octave_value_list *_outp=&_out;
19283 octave_value _outv;
19292 arg1 = (
unsigned int)(val1);
19294 _outv = octave_value();
19298 return octave_value_list();
19306 octave_value_list _out;
19307 octave_value_list *_outp=&_out;
19308 octave_value _outv;
19317 arg1 = (char)(val1);
19319 _outv = octave_value();
19323 return octave_value_list();
19328 char *arg1 = (
char *) 0 ;
19329 char *arg2 = (
char *) 0 ;
19336 octave_value_list _out;
19337 octave_value_list *_outp=&_out;
19338 octave_value _outv;
19348 arg1 = (
char *)(buf1);
19353 arg2 = (
char *)(buf2);
19354 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
19363 return octave_value_list();
19377 octave_value_list _out;
19378 octave_value_list *_outp=&_out;
19379 octave_value _outv;
19388 arg1 = (
PLINT)(val1);
19393 arg2 = (
PLINT)(val2);
19398 arg3 = (
PLINT)(val3);
19400 _outv = octave_value();
19404 return octave_value_list();
19410 unsigned int val1 ;
19412 octave_value_list _out;
19413 octave_value_list *_outp=&_out;
19414 octave_value _outv;
19425 _outv = octave_value();
19429 return octave_value_list();
19434 char *arg1 = (
char *) 0 ;
19438 octave_value_list _out;
19439 octave_value_list *_outp=&_out;
19440 octave_value _outv;
19449 arg1 = (
char *)(buf1);
19451 _outv = octave_value();
19457 return octave_value_list();
19471 octave_value_list _out;
19472 octave_value_list *_outp=&_out;
19473 octave_value _outv;
19482 arg1 = (
PLINT)(val1);
19487 arg2 = (
PLINT)(val2);
19492 arg3 = (
PLINT)(val3);
19494 _outv = octave_value();
19498 return octave_value_list();
19506 octave_value_list _out;
19507 octave_value_list *_outp=&_out;
19508 octave_value _outv;
19514 octave_value obj = args(0);
19515 if ( !obj.is_empty() )
19517 if ( obj.is_function_handle() || obj.is_inline_function() )
19519 fcnLabelFunc = obj.function_value();
19521 else if ( obj.is_string() )
19523 nameLabelFunc = obj.string_value();
19524 fcnLabelFunc = NULL;
19538 _outv = octave_value();
19542 return octave_value_list();
19553 octave_value_list _out;
19554 octave_value_list *_outp=&_out;
19555 octave_value _outv;
19564 arg1 = (
PLFLT)(val1);
19569 arg2 = (
PLFLT)(val2);
19571 _outv = octave_value();
19575 return octave_value_list();
19586 octave_value_list _out;
19587 octave_value_list *_outp=&_out;
19588 octave_value _outv;
19597 arg1 = (
PLFLT)(val1);
19602 arg2 = (
PLFLT)(val2);
19604 _outv = octave_value();
19608 return octave_value_list();
19616 octave_value_list _out;
19617 octave_value_list *_outp=&_out;
19618 octave_value _outv;
19627 arg1 = (
PLINT)(val1);
19629 _outv = octave_value();
19633 return octave_value_list();
19656 octave_value_list _out;
19657 octave_value_list *_outp=&_out;
19658 octave_value _outv;
19667 arg1 = (
PLFLT)(val1);
19672 arg2 = (
PLFLT)(val2);
19677 arg3 = (
PLINT)(val3);
19682 arg4 = (
PLINT)(val4);
19687 arg5 = (
PLINT)(val5);
19692 arg6 = (
PLINT)(val6);
19693 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
19694 _outv = octave_value();
19698 return octave_value_list();
19703 char *arg1 = (
char *) 0 ;
19707 octave_value_list _out;
19708 octave_value_list *_outp=&_out;
19709 octave_value _outv;
19718 arg1 = (
char *)(buf1);
19720 _outv = octave_value();
19726 return octave_value_list();
19731 char *arg1 = (
char *) 0 ;
19738 octave_value_list _out;
19739 octave_value_list *_outp=&_out;
19740 octave_value _outv;
19749 arg1 = (
char *)(buf1);
19755 plspal1((
char const *)arg1,arg2);
19756 _outv = octave_value();
19762 return octave_value_list();
19770 octave_value_list _out;
19771 octave_value_list *_outp=&_out;
19772 octave_value _outv;
19783 _outv = octave_value();
19787 return octave_value_list();
19795 octave_value_list _out;
19796 octave_value_list *_outp=&_out;
19797 octave_value _outv;
19806 arg1 = (
PLINT)(val1);
19808 _outv = octave_value();
19812 return octave_value_list();
19823 octave_value_list _out;
19824 octave_value_list *_outp=&_out;
19825 octave_value _outv;
19834 arg1 = (
PLINT)(val1);
19839 arg2 = (
PLINT)(val2);
19841 _outv = octave_value();
19845 return octave_value_list();
19856 octave_value_list _out;
19857 octave_value_list *_outp=&_out;
19858 octave_value _outv;
19867 arg1 = (
PLFLT)(val1);
19872 arg2 = (
PLFLT)(val2);
19874 _outv = octave_value();
19878 return octave_value_list();
19889 octave_value_list _out;
19890 octave_value_list *_outp=&_out;
19891 octave_value _outv;
19900 arg1 = (
PLINT)(val1);
19905 arg2 = (
PLINT)(val2);
19907 _outv = octave_value();
19911 return octave_value_list();
19916 char *arg1 = (
char *) 0 ;
19926 octave_value_list _out;
19927 octave_value_list *_outp=&_out;
19928 octave_value _outv;
19937 arg1 = (
char *)(buf1);
19942 arg2 = (
PLINT)(val2);
19947 arg3 = (
PLINT)(val3);
19948 plstart((
char const *)arg1,arg2,arg3);
19949 _outv = octave_value();
19955 return octave_value_list();
19963 octave_value_list _out;
19964 octave_value_list *_outp=&_out;
19965 octave_value _outv;
19971 octave_value obj = args(0);
19972 if ( !obj.is_empty() )
19974 if ( obj.is_function_handle() || obj.is_inline_function() )
19976 fcnCoordTrans = obj.function_value();
19978 else if ( obj.is_string() )
19980 nameCoordTrans = obj.string_value();
19981 fcnCoordTrans = NULL;
19995 _outv = octave_value();
19999 return octave_value_list();
20005 PLFLT *arg2 = (PLFLT *) 0 ;
20006 PLFLT *arg3 = (PLFLT *) 0 ;
20007 char *arg4 = (
char *) 0 ;
20013 octave_value_list _out;
20014 octave_value_list *_outp=&_out;
20015 octave_value _outv;
20021 if (
_n_dims( args(0) ) > 1 )
20025 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20026 temp1 = args(0).matrix_value();
20027 arg2 = &temp1( 0, 0 );
20030 if (
_n_dims( args(1) ) > 1 )
20034 if (
_dim( args(1), 0 ) != Alen )
20038 temp3 = args(1).matrix_value();
20039 arg3 = &temp3( 0, 0 );
20045 arg4 = (
char *)(buf4);
20046 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
20047 _outv = octave_value();
20065 return octave_value_list();
20071 PLFLT *arg2 = (PLFLT *) 0 ;
20072 PLFLT *arg3 = (PLFLT *) 0 ;
20073 PLFLT *arg4 = (PLFLT *) 0 ;
20074 char *arg5 = (
char *) 0 ;
20081 octave_value_list _out;
20082 octave_value_list *_outp=&_out;
20083 octave_value _outv;
20089 if (
_n_dims( args(0) ) > 1 )
20093 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20094 temp1 = args(0).matrix_value();
20095 arg2 = &temp1( 0, 0 );
20098 if (
_n_dims( args(1) ) > 1 )
20102 if (
_dim( args(1), 0 ) != Alen )
20106 temp3 = args(1).matrix_value();
20107 arg3 = &temp3( 0, 0 );
20110 if (
_n_dims( args(2) ) > 1 )
20114 if (
_dim( args(2), 0 ) != Alen )
20118 temp4 = args(2).matrix_value();
20119 arg4 = &temp4( 0, 0 );
20125 arg5 = (
char *)(buf5);
20126 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
20127 _outv = octave_value();
20151 return octave_value_list();
20168 octave_value_list _out;
20169 octave_value_list *_outp=&_out;
20170 octave_value _outv;
20179 arg1 = (
PLINT)(val1);
20184 arg2 = (
PLINT)(val2);
20189 arg3 = (
PLFLT)(val3);
20194 arg4 = (
PLFLT)(val4);
20196 _outv = octave_value();
20200 return octave_value_list();
20208 octave_value_list _out;
20209 octave_value_list *_outp=&_out;
20210 octave_value _outv;
20219 arg1 = (
PLINT)(val1);
20221 _outv = octave_value();
20225 return octave_value_list();
20231 PLINT *arg2 = (PLINT *) 0 ;
20232 PLINT *arg3 = (PLINT *) 0 ;
20235 octave_value_list _out;
20236 octave_value_list *_outp=&_out;
20237 octave_value _outv;
20243 if (
_n_dims( args(0) ) > 1 )
20247 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20248 arg2 =
new PLINT[
Alen];
20249 temp1 = args(0).matrix_value();
20253 if (
_n_dims( args(1) ) > 1 )
20257 if (
_dim( args(1), 0 ) != Alen )
20261 temp3 = args(1).matrix_value();
20262 arg3 =
new PLINT[
Alen];
20265 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
20266 _outv = octave_value();
20282 return octave_value_list();
20287 PLFLT *arg1 = (PLFLT *) 0 ;
20288 PLFLT *arg2 = (PLFLT *) 0 ;
20295 octave_value_list _out;
20296 octave_value_list *_outp=&_out;
20297 octave_value _outv;
20303 if (
_n_dims( args(0) ) > 1 )
20308 temp1 = args(0).matrix_value();
20309 arg1 = &temp1( 0, 0 );
20312 if (
_n_dims( args(1) ) > 1 )
20316 if (
_dim( args(1), 0 ) != Alen )
20320 temp2 = args(1).matrix_value();
20321 arg2 = &temp2( 0, 0 );
20329 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
20330 _outv = octave_value();
20346 return octave_value_list();
20363 octave_value_list _out;
20364 octave_value_list *_outp=&_out;
20365 octave_value _outv;
20374 arg1 = (
PLFLT)(val1);
20379 arg2 = (
PLFLT)(val2);
20384 arg3 = (
PLFLT)(val3);
20389 arg4 = (
PLFLT)(val4);
20390 plsvpa(arg1,arg2,arg3,arg4);
20391 _outv = octave_value();
20395 return octave_value_list();
20406 octave_value_list _out;
20407 octave_value_list *_outp=&_out;
20408 octave_value _outv;
20417 arg1 = (
PLINT)(val1);
20422 arg2 = (
PLINT)(val2);
20424 _outv = octave_value();
20428 return octave_value_list();
20439 octave_value_list _out;
20440 octave_value_list *_outp=&_out;
20441 octave_value _outv;
20450 arg1 = (
PLINT)(val1);
20455 arg2 = (
PLINT)(val2);
20457 _outv = octave_value();
20461 return octave_value_list();
20467 PLFLT *arg2 = (PLFLT *) 0 ;
20468 PLFLT *arg3 = (PLFLT *) 0 ;
20474 octave_value_list _out;
20475 octave_value_list *_outp=&_out;
20476 octave_value _outv;
20482 if (
_n_dims( args(0) ) > 1 )
20486 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20487 temp1 = args(0).matrix_value();
20488 arg2 = &temp1( 0, 0 );
20491 if (
_n_dims( args(1) ) > 1 )
20495 if (
_dim( args(1), 0 ) != Alen )
20499 temp3 = args(1).matrix_value();
20500 arg3 = &temp3( 0, 0 );
20506 arg4 = (
PLINT)(val4);
20507 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
20508 _outv = octave_value();
20524 return octave_value_list();
20535 octave_value_list _out;
20536 octave_value_list *_outp=&_out;
20537 octave_value _outv;
20546 arg1 = (
PLINT)(val1);
20551 arg2 = (
PLINT)(val2);
20553 _outv = octave_value();
20557 return octave_value_list();
20562 octave_value_list _out;
20563 octave_value_list *_outp=&_out;
20564 octave_value _outv;
20570 _outv = octave_value();
20574 return octave_value_list();
20579 char *arg1 = (
char *) 0 ;
20583 octave_value_list _out;
20584 octave_value_list *_outp=&_out;
20585 octave_value _outv;
20594 arg1 = (
char *)(buf1);
20596 _outv = octave_value();
20602 return octave_value_list();
20610 octave_value_list _out;
20611 octave_value_list *_outp=&_out;
20612 octave_value _outv;
20621 arg1 = (
PLFLT)(val1);
20623 _outv = octave_value();
20627 return octave_value_list();
20647 octave_value_list _out;
20648 octave_value_list *_outp=&_out;
20649 octave_value _outv;
20658 arg1 = (
PLFLT)(val1);
20663 arg2 = (
PLFLT)(val2);
20668 arg3 = (
PLFLT)(val3);
20673 arg4 = (
PLFLT)(val4);
20678 arg5 = (
PLFLT)(val5);
20679 plvpas(arg1,arg2,arg3,arg4,arg5);
20680 _outv = octave_value();
20684 return octave_value_list();
20701 octave_value_list _out;
20702 octave_value_list *_outp=&_out;
20703 octave_value _outv;
20712 arg1 = (
PLFLT)(val1);
20717 arg2 = (
PLFLT)(val2);
20722 arg3 = (
PLFLT)(val3);
20727 arg4 = (
PLFLT)(val4);
20728 plvpor(arg1,arg2,arg3,arg4);
20729 _outv = octave_value();
20733 return octave_value_list();
20738 octave_value_list _out;
20739 octave_value_list *_outp=&_out;
20740 octave_value _outv;
20746 _outv = octave_value();
20750 return octave_value_list();
20788 octave_value_list _out;
20789 octave_value_list *_outp=&_out;
20790 octave_value _outv;
20799 arg1 = (
PLFLT)(val1);
20804 arg2 = (
PLFLT)(val2);
20809 arg3 = (
PLFLT)(val3);
20814 arg4 = (
PLFLT)(val4);
20819 arg5 = (
PLFLT)(val5);
20824 arg6 = (
PLFLT)(val6);
20829 arg7 = (
PLFLT)(val7);
20834 arg8 = (
PLFLT)(val8);
20839 arg9 = (
PLFLT)(val9);
20844 arg10 = (
PLFLT)(val10);
20849 arg11 = (
PLFLT)(val11);
20850 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
20851 _outv = octave_value();
20855 return octave_value_list();
20863 octave_value_list _out;
20864 octave_value_list *_outp=&_out;
20865 octave_value _outv;
20874 arg1 = (
PLINT)(val1);
20876 _outv = octave_value();
20880 return octave_value_list();
20897 octave_value_list _out;
20898 octave_value_list *_outp=&_out;
20899 octave_value _outv;
20908 arg1 = (
PLFLT)(val1);
20913 arg2 = (
PLFLT)(val2);
20918 arg3 = (
PLFLT)(val3);
20923 arg4 = (
PLFLT)(val4);
20924 plwind(arg1,arg2,arg3,arg4);
20925 _outv = octave_value();
20929 return octave_value_list();
20940 octave_value_list _out;
20941 octave_value_list *_outp=&_out;
20942 octave_value _outv;
20954 _outv = octave_value();
20964 return octave_value_list();
20970 char *arg2 = (
char *) 0 ;
20986 octave_value_list _out;
20987 octave_value_list *_outp=&_out;
20988 octave_value _outv;
20994 octave_value obj = args(0);
20995 if ( !obj.is_empty() )
20997 if ( obj.is_function_handle() || obj.is_inline_function() )
20999 fcnMapForm = obj.function_value();
21001 else if ( obj.is_string() )
21003 nameMapForm = obj.string_value();
21017 arg2 = (
char *)(buf2);
21022 arg3 = (
PLFLT)(val3);
21027 arg4 = (
PLFLT)(val4);
21032 arg5 = (
PLFLT)(val5);
21037 arg6 = (
PLFLT)(val6);
21038 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
21039 _outv = octave_value();
21045 return octave_value_list();
21069 octave_value_list _out;
21070 octave_value_list *_outp=&_out;
21071 octave_value _outv;
21077 octave_value obj = args(0);
21078 if ( !obj.is_empty() )
21080 if ( obj.is_function_handle() || obj.is_inline_function() )
21082 fcnMapForm = obj.function_value();
21084 else if ( obj.is_string() )
21086 nameMapForm = obj.string_value();
21100 arg2 = (
PLFLT)(val2);
21105 arg3 = (
PLFLT)(val3);
21110 arg4 = (
PLFLT)(val4);
21115 arg5 = (
PLFLT)(val5);
21120 arg6 = (
PLFLT)(val6);
21125 arg7 = (
PLFLT)(val7);
21127 _outv = octave_value();
21131 return octave_value_list();
21136 octave_value_list _out;
21137 octave_value_list *_outp=&_out;
21138 octave_value _outv;
21144 _outv = octave_value();
21148 return octave_value_list();
21153 octave_value_list _out;
21154 octave_value_list *_outp=&_out;
21155 octave_value _outv;
21161 _outv = octave_value();
21165 return octave_value_list();
21170 char *arg1 = (
char *) 0 ;
21171 char *arg2 = (
char *) 0 ;
21178 octave_value_list _out;
21179 octave_value_list *_outp=&_out;
21180 octave_value _outv;
21189 arg1 = (
char *)(buf1);
21194 arg2 = (
char *)(buf2);
21195 plSetUsage((
char const *)arg1,(
char const *)arg2);
21196 _outv = octave_value();
21204 return octave_value_list();
21209 octave_value_list _out;
21210 octave_value_list *_outp=&_out;
21211 octave_value _outv;
21217 _outv = octave_value();
21221 return octave_value_list();
21227 {
"testppchar",_wrap_testppchar,0,0,2,0},
21229 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
21232 {
"plcont0",_wrap_plcont0,0,0,2,0},
21233 {
"plcont1",_wrap_plcont1,0,0,2,0},
21234 {
"plcont2",_wrap_plcont2,0,0,2,0},
21235 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
21243 {
"plshade1",_wrap_plshade1,0,0,2,0},
21244 {
"plshade2",_wrap_plshade2,0,0,2,0},
21246 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
21247 {
"plshades1",_wrap_plshades1,0,0,2,0},
21248 {
"plshades2",_wrap_plshades2,0,0,2,0},
21250 {
"plvect1",_wrap_plvect1,0,0,2,0},
21251 {
"plvect2",_wrap_plvect2,0,0,2,0},
21252 {
"pplimage",_wrap_pplimage,0,0,2,0},
21254 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
21255 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
21256 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
21390 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
21537 #define SWIGRUNTIME_DEBUG
21548 if (swig_module.
next==0) {
21560 if (!module_head) {
21570 if (iter==&swig_module) {
21575 }
while (iter!= module_head);
21580 swig_module.
next = module_head->
next;
21588 if (init == 0)
return;
21591 #ifdef SWIGRUNTIME_DEBUG
21592 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
21594 for (i = 0; i < swig_module.
size; ++i) {
21599 #ifdef SWIGRUNTIME_DEBUG
21600 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
21604 if (swig_module.
next != &swig_module) {
21609 #ifdef SWIGRUNTIME_DEBUG
21610 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
21614 #ifdef SWIGRUNTIME_DEBUG
21615 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
21624 while (cast->
type) {
21628 #ifdef SWIGRUNTIME_DEBUG
21629 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
21631 if (swig_module.
next != &swig_module) {
21633 #ifdef SWIGRUNTIME_DEBUG
21634 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
21639 #ifdef SWIGRUNTIME_DEBUG
21640 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
21647 #ifdef SWIGRUNTIME_DEBUG
21648 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
21650 if (!ocast) ret = 0;
21655 #ifdef SWIGRUNTIME_DEBUG
21656 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
21667 swig_module.
types[i] = type;
21669 swig_module.
types[i] = 0;
21671 #ifdef SWIGRUNTIME_DEBUG
21672 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21673 for (i = 0; i < swig_module.
size; ++i) {
21676 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
21677 while (cast->
type) {
21678 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
21682 printf(
"---- Total casts: %d\n",j);
21684 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
21697 static int init_run = 0;
21699 if (init_run)
return;
21702 for (i = 0; i < swig_module.
size; i++) {
21710 equiv = equiv->
next;
21730 #if OCTAVE_API_VERSION_NUMBER < 38
21731 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
21732 unwind_protect_int(error_state);
21733 unwind_protect_int(warning_state);
21734 unwind_protect_bool(discard_error_messages);
21735 unwind_protect_bool(discard_warning_messages);
21737 unwind_protect frame;
21738 frame.protect_var(error_state);
21739 frame.protect_var(warning_state);
21740 frame.protect_var(discard_error_messages);
21741 frame.protect_var(discard_warning_messages);
21745 discard_error_messages =
true;
21746 discard_warning_messages =
true;
21747 feval(name, octave_value_list(), 0);
21748 retn = (error_state == 0);
21749 #if OCTAVE_API_VERSION_NUMBER < 38
21750 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
21762 #if OCTAVE_API_VERSION_NUMBER < 38
21763 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
21764 unwind_protect_int(error_state);
21765 unwind_protect_int(warning_state);
21766 unwind_protect_bool(discard_error_messages);
21767 unwind_protect_bool(discard_warning_messages);
21769 unwind_protect frame;
21770 frame.protect_var(error_state);
21771 frame.protect_var(warning_state);
21772 frame.protect_var(discard_error_messages);
21773 frame.protect_var(discard_warning_messages);
21777 discard_error_messages =
true;
21778 discard_warning_messages =
true;
21779 octave_value_list args;
21781 args.append(octloadfcn->fcn_file_name());
21783 feval(
"autoload", args, 0);
21784 retn = (error_state == 0);
21785 #if OCTAVE_API_VERSION_NUMBER < 38
21786 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
21796 @deftypefn {Loadable Function} {} subclass()\n\
21797 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
21798 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
21800 See the SWIG manual for usage examples.\n\
21805 for (
int j = 0; j < args.length(); ++j) {
21806 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
21809 if (!ost->is_owned()) {
21810 error(
"subclass: cannot subclass object not constructed on octave side");
21811 return octave_value_list();
21814 }
else if (args(j).is_function_handle()) {
21815 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
21816 }
else if (args(j).is_string()) {
21817 if (j + 1 >= args.length()) {
21818 error(
"subclass: member assignments must be of string,value form");
21819 return octave_value_list();
21821 top->
assign(args(j).string_value(), args(j + 1));
21824 error(
"subclass: invalid arguments to subclass()");
21825 return octave_value_list();
21832 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
21833 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
21837 if (args.length() != 1) {
21838 error(
"swig_type: must be called with only a single object");
21839 return octave_value_list();
21843 error(
"swig_type: object is not a swig_ref");
21844 return octave_value_list();
21850 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
21851 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
21852 otherwise return `<unknown>'.\n\
21855 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
21856 if (args.length() != 1 || !args(0).is_string()) {
21857 error(
"swig_typequery: must be called with single string argument");
21858 return octave_value_list();
21863 return octave_value(
"<unknown>");
21864 return octave_value(type->
name);
21868 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
21869 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
21873 if (args.length() != 1) {
21874 error(
"swig_this: must be called with only a single object");
21875 return octave_value_list();
21877 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
21878 return octave_value(octave_uint64(0));
21881 error(
"swig_this: object is not a swig_ref");
21882 return octave_value_list();
21884 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
21888 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
21889 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
21900 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
21901 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
21902 octave_exit = ::_Exit;
21907 if (args.length() != 0 || nargout != 0) {
21909 return octave_value_list();
21917 #if OCTAVE_API_VERSION_NUMBER > 36
21918 octave_value_list eval_args;
21919 eval_args.append(
"base");
21920 eval_args.append(
"function __swig_atexit__; "
21927 "__swig_atexit__; "
21928 "atexit(\"__swig_atexit__\", false); "
21929 "atexit(\"__swig_atexit__\")");
21930 feval(
"evalin", eval_args, 0);
21933 octave_swig_ref::register_type();
21934 octave_swig_packed::register_type();
21938 octave_function *me = octave_call_stack::current();
21941 return octave_value_list();
21944 return octave_value_list();
21947 return octave_value_list();
21950 return octave_value_list();
21956 for (
int j=0;swig_globals[j].
name;++j)
21958 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21966 for (
int j=0;swig_globals[j].
name;++j)
21968 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21970 for (
int j=0;swig_globals[j].
name;++j)
21971 if (swig_globals[j].
method)
21972 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
21977 for (
int j=0;swig_types[j];++j)
21978 if (swig_types[j]->clientdata) {
21988 return octave_value_list();
21995 if (mb->second.first && mb->second.first->method) {
21997 return octave_value_list();
22002 #if OCTAVE_API_VERSION_NUMBER < 37
22012 if (mb->second.second.is_defined()) {
22021 return octave_value_list();
static const char * _wrap_pljoin_texinfo
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const swig_type_info * swig_PLGraphicsIn_base[]
static swig_cast_info _swigc__p_int[]
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
static const char * _wrap_pladv_texinfo
void merge(octave_swig_type &rhs)
#define swigreg_binary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
octave_swig_type(const octave_swig_type &x)
static const char * _wrap_plcol0_texinfo
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swig_binary_op(name)
static const char * _wrap_pl_setcontlabelformat_texinfo
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
static bool SWIG_init_user(octave_swig_type *module_ns)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsmin_texinfo
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_function * fcnLabelFunc
static const char * _wrap_plsyax_texinfo
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * swig_PLGraphicsIn_base_names[]
static const char *const swig_typequery_usage
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const subclass_usage
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const * label
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plschr_texinfo
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plszax_texinfo
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
static const char * _wrap_plscolbga_texinfo
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
static const char * _wrap_plSetOpt_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT nx
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plstripa_texinfo
octave_base_value * empty_clone() const
subroutine plmtex3(side, disp, pos, xjust, text)
virtual bool is_object() const
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
#define SWIG_RUNTIME_VERSION
static const char * _wrap_plsori_texinfo
static const char * _wrap_plstransform_texinfo
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_map() const
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
std::string swig_type_name() const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT bb_color
static const char * _wrap_plscmap1a_texinfo
virtual bool save_ascii(std::ostream &os)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
static const char * _wrap_plgcol0a_texinfo
#define SWIGTYPE_p_PLGraphicsIn
void PLFLT PLINT PLINT position
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT const PLINT * n_values
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
std::string nameLabelFunc
static const char * _wrap_plstripd_texinfo
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
subroutine plstring3(x, y, z, string)
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static const char * _wrap_plmeridians_texinfo
virtual Octave_map map_value() const
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static const char * _wrap_plmtex3_texinfo
void plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, int npts, PLFLT *xg, int nptsx, PLFLT *yg, int nptsy, PLFLT **zg, int type, PLFLT data)
static const char * _wrap_plpoin_texinfo
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plshades(const PLFLT *const *a, PLINT nx, PLINT ny, PLINT(*defined)(PLFLT, PLFLT), PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, const PLFLT *clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, void(*fill)(PLINT, const PLFLT *, const PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpoin3_texinfo
void plimage(PLFLT **data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
subroutine plmtex(side, disp, pos, xjust, text)
void c_plvect(const PLFLT *const *u, const PLFLT *const *v, PLINT nx, PLINT ny, PLFLT scale, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
#define pl_setcontlabelparam
#define SWIGTYPE_p_p_char
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_double
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
struct swig_cast_info * cast
static const char * _wrap_plsstrm_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
static const char * _wrap_plgspa_texinfo
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
subroutine plstring(x, y, string)
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static const char * _wrap_plenv0_texinfo
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpsty_texinfo
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
std::map< std::string, member_value_pair > member_map
void PLFLT PLINT PLINT PLFLT x
virtual std::string string_value(bool force=false) const
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void load_members(const swig_octave_class *c, member_map &out) const
static const char * _wrap_plgfont_texinfo
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
octave_swig_type * get_ptr() const
static swig_type_info _swigt__p_p_char
for(i=0;i< nx;i++) if(n_values[i]< ny) ny
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
member_map::const_iterator swig_member_const_iterator
static const char * _wrap_plstring_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
dim_vector dims(void) const
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbox3_texinfo
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
octave_base_value * clone() const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT const PLINT const PLFLT * a
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plshade1(PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, void(*fill)(PLINT, PLFLT *, PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdidev_texinfo
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _n_dims(const octave_value &o_obj)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const * axis_opts
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
void c_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static const char *const SWIG_name_usage
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
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)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plarc_texinfo
static const char * _wrap_plwind_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT low_cap_color
static const char * _wrap_plgdiori_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
static const char * _wrap_plstring3_texinfo
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsfont_texinfo
static swig_cast_info _swigc__p_double[]
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plgcompression_texinfo
void c_plimagefr(const PLFLT *const *idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
static const char * _wrap_plgyax_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual string_vector map_keys() const
static const char * _wrap_plgstrm_texinfo
static swig_type_info _swigt__p_char
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plstyl_texinfo
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pleop_texinfo
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcol0_texinfo
static const char * _wrap_plgchr_texinfo
static const char * _wrap_plbox_texinfo
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_plgfci_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_function * fcnMapForm
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_pllightsource_texinfo
static octave_value make_value_hack(const octave_base_value &x)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgver_texinfo
int plTranslateCursor(PLGraphicsIn *plg)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plgra_texinfo
static const char * _wrap_plsvect_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
static const char * _wrap_plsfnam_texinfo
void * cast(swig_type_info *type, int *_own, int flags)
static const char * _wrap_plgfam_texinfo
octave_function * fcnCoordTrans
const char * help_text() const
virtual bool load_ascii(std::istream &is)
virtual bool is_object() const
swig_member_const_iterator swig_members_begin()
static const char * _wrap_plspage_texinfo
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
void assign(const std::string &name, const swig_octave_member *m)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void assign(const std::string &name, const octave_value &ov)
static const char * _wrap_plreplot_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
octave_swig_ref(octave_swig_type *_ptr=0)
static const char *const swig_type_usage
static const char * _wrap_plsmaj_texinfo
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_exception_fail(code, msg)
struct swig_module_info * next
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SetModule(clientdata, pointer)
static const char * _wrap_plvasp_texinfo
static const char * _wrap_plvsta_texinfo
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscompression_texinfo
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
octave_value operator*() const
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT y
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
swig_converter_func converter
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plsfam_texinfo
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
octave_base_value * clone() const
static const char * _wrap_plsdidev_texinfo
#define SWIGTYPE_p_unsigned_int
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
#define SWIG_as_voidptr(a)
int plSetOpt(const char *opt, const char *opt_arg)
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plgradient_texinfo
#define SWIG_DelNewMask(r)
void load_members(member_map &out) const
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plend1_texinfo
virtual bool is_map() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static const char * _wrap_plspal0_texinfo
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plscmap1_texinfo
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssub_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plpat_texinfo
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
subroutine plspal0(filename)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
static const char * _wrap_plgvpd_texinfo
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
std::string nameCoordTrans
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgvpw_texinfo
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plvpor_texinfo
bool dispatch_unary_op(const std::string &symbol, octave_value &ret)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
static const char * _wrap_plflush_texinfo
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plfill3_texinfo
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT high_cap_color
static const char * _wrap_plprec_texinfo
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plstar_texinfo
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
static const char * _wrap_plseed_texinfo
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_string() const
virtual bool save_ascii(std::ostream &os)
virtual bool save_ascii(std::ostream &os)
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plptex_texinfo
octave_swig_type & operator=(const octave_swig_type &rhs)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static const char * _wrap_plscmap0n_texinfo
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscolbg_texinfo
void c_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
void c_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
subroutine plsetopt(opt, optarg)
static const char * _wrap_plsdev_texinfo
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
const char * constructor_doc
const swig_type_info ** base
static swig_type_info * swig_types[10]
subroutine plptex(x, y, dx, dy, xjust, text)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plgzax_texinfo
static const char * _wrap_plenv_texinfo
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT cont_color
static const char * _wrap_plscmap1l_texinfo
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
void my_plshadesx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, PLFLT *tr)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLGraphicsIn
subroutine pllab(xlab, ylab, title)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plerry_texinfo
static const char * _wrap_plline3_texinfo
static const char * _wrap_plscmap1n_texinfo
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static PLFLT value(double n1, double n2, double hue)
static swig_octave_class _wrap_class_PLGraphicsIn
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGRUNTIMEINLINE
static swig_cast_info _swigc__p_unsigned_int[]
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_plgcolbg_texinfo
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plrandd_texinfo
void c_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
static const char * _wrap_plspal1_texinfo
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
static const char * _wrap_plmtex_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plfont_texinfo
static const char *const swig_this_usage
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
#define SWIG_AttributeError
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
static const char * _wrap_plline_texinfo
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT x_length
static const char * _wrap_plbop_texinfo
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plcont2(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_pltext_texinfo
static const char * _wrap_plxormod_texinfo
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plerrx_texinfo
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static const char * _wrap_plsdiplt_texinfo
static const char * _wrap_plfill_texinfo
static const char * _wrap_plpoly3_texinfo
static const char * _wrap_plscolor_texinfo
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscol0a_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plsym_texinfo
static const char * _wrap_plbin_texinfo
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swigreg_unary_op(name)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT cont_width
swig_member_const_iterator swig_members_end()
static const char * _wrap_plsesc_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
struct swig_cast_info * next
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plw3d_texinfo
void PLFLT * p_colorbar_height
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
static const char * _wrap_plglevel_texinfo
subroutine plspal1(filename, interpolate)
const swig_octave_member * members
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT bb_style
#define SWIG_RuntimeError
SWIGRUNTIME void SWIG_InstallOps(int tid)
virtual std::string string_value(bool force=false) const
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static int _arraylen(const octave_value &o_obj)
static swig_cast_info * swig_cast_initial[]
swig_module_info * module
static const char * _wrap_plstart_texinfo
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plstart(devname, nx, ny)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pllab_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref,"swig_ref","swig_ref")
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static const char * _wrap_plgpage_texinfo
struct swig_cast_info swig_cast_info
static const struct swig_octave_member swig_globals[]
static const char * _wrap_plsdiplz_texinfo
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
std::pair< const swig_octave_member *, octave_value > member_value_pair
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_ref(const octave_value_list &_ovl, int _j)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_DISOWN
static const char * _wrap_plcalc_world_texinfo
struct swig_cast_info * prev
static const char * _wrap_plcol1_texinfo
static const char * _wrap_plslabelfunc_texinfo
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
swig_cast_info ** cast_initial
octave_value_list(* octave_func)(const octave_value_list &, int)
void c_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline[], const char *labx, const char *laby, const char *labtop)
static const char * _wrap_plmkstrm_texinfo
static swig_type_info * swig_type_initial[]
#define SWIG_DEFUN(cname, wname, doc)
static const char * _wrap_plrgbhls_texinfo
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbga_texinfo
#define swig_unary_op(name)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT bg_color
static const char * _wrap_plgfnam_texinfo
#define SWIG_DivisionByZero
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plcpstrm_texinfo
virtual Octave_map map_value() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT * label_opts
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmap_texinfo
const swig_type_info * construct_type
static const char * _wrap_pllsty_texinfo
virtual bool is_string() const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT * sub_ticks
static const char * _wrap_pllegend_texinfo
static const char * _wrap_plptex3_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
void my_plshade1(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
static const char * _wrap_plclear_texinfo
static const char * _wrap_plaxes_texinfo
const octave_value_list & ovl
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsdiori_texinfo
swig_type_info ** type_initial
static const char * _wrap_plend_texinfo
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plscol0_texinfo
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT * ticks
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plshade(const PLFLT *const *a, PLINT nx, PLINT ny, PLINT(*defined)(PLFLT, PLFLT), PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void(*fill)(PLINT, const PLFLT *, const PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plcont(const PLFLT *const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssym_texinfo
static int _dim(const octave_value &o_obj, int dim_idx)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info swig_type_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
static swig_octave_member swig_PLGraphicsIn_members[]
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plfamadv_texinfo
subroutine pltimefmt(fmt)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
static const char * _wrap_plgxax_texinfo
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *label, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values) void my_plcolorbar(PLFLT *p_colorbar_width
static const char * _wrap_plspause_texinfo
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *labels, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsvpa_texinfo
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
dim_vector dims(void) const
static swig_cast_info _swigc__p_PLGraphicsIn[]
static const char * _wrap_plvpas_texinfo
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT y_length
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
static const char * _wrap_plscmap0_texinfo
#define SWIG_NewPointerObj(ptr, type, flags)
std::vector< type_ptr_pair > types
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT n_labels
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plhist_texinfo
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)