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>
758 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
759 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + OCTAVE_PATCH_VERSION >= ((major)<<16) + ((minor)<<8) + (patch) )
762 #if !defined(OCTAVE_MAJOR_VERSION)
764 # if !defined(OCTAVE_API_VERSION_NUMBER)
768 # include <octave/ov.h>
769 # if defined(octave_ov_h)
770 # define OCTAVE_MAJOR_VERSION 3
771 # define OCTAVE_MINOR_VERSION 8
772 # define OCTAVE_PATCH_VERSION 0
776 # define ComplexLU __ignore
777 # include <octave/CmplxLU.h>
779 # if defined(octave_Complex_LU_h)
782 # define OCTAVE_MAJOR_VERSION 3
783 # define OCTAVE_MINOR_VERSION 1
784 # define OCTAVE_PATCH_VERSION 99
789 # define OCTAVE_MAJOR_VERSION 3
790 # define OCTAVE_MINOR_VERSION 2
791 # define OCTAVE_PATCH_VERSION 0
793 # endif // defined(octave_Complex_LU_h)
795 # endif // defined(octave_ov_h)
799 # elif OCTAVE_API_VERSION_NUMBER >= 48
800 # define OCTAVE_MAJOR_VERSION 3
801 # define OCTAVE_MINOR_VERSION 6
802 # define OCTAVE_PATCH_VERSION 0
804 # elif OCTAVE_API_VERSION_NUMBER >= 45
805 # define OCTAVE_MAJOR_VERSION 3
806 # define OCTAVE_MINOR_VERSION 4
807 # define OCTAVE_PATCH_VERSION 1
809 # elif OCTAVE_API_VERSION_NUMBER >= 42
810 # define OCTAVE_MAJOR_VERSION 3
811 # define OCTAVE_MINOR_VERSION 3
812 # define OCTAVE_PATCH_VERSION 54
814 # elif OCTAVE_API_VERSION_NUMBER >= 41
815 # define OCTAVE_MAJOR_VERSION 3
816 # define OCTAVE_MINOR_VERSION 3
817 # define OCTAVE_PATCH_VERSION 53
819 # elif OCTAVE_API_VERSION_NUMBER >= 40
820 # define OCTAVE_MAJOR_VERSION 3
821 # define OCTAVE_MINOR_VERSION 3
822 # define OCTAVE_PATCH_VERSION 52
824 # elif OCTAVE_API_VERSION_NUMBER >= 39
825 # define OCTAVE_MAJOR_VERSION 3
826 # define OCTAVE_MINOR_VERSION 3
827 # define OCTAVE_PATCH_VERSION 51
829 # else // OCTAVE_API_VERSION_NUMBER == 38
830 # define OCTAVE_MAJOR_VERSION 3
831 # define OCTAVE_MINOR_VERSION 3
832 # define OCTAVE_PATCH_VERSION 50
834 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
836 #endif // !defined(OCTAVE_MAJOR_VERSION)
838 #if !SWIG_OCTAVE_PREREQ(3,2,0)
839 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
841 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
845 if (num_args > max_args && !varargs)
846 error(
"function %s takes at most %i arguments", func_name, max_args);
847 else if (num_args < min_args)
848 error(
"function %s requires at least %i arguments", func_name, min_args);
862 return "SWIG_MemoryError";
864 return "SWIG_IOError";
866 return "SWIG_RuntimeError";
868 return "SWIG_IndexError";
870 return "SWIG_TypeError";
872 return "SWIG_DivisionByZero";
874 return "SWIG_OverflowError";
876 return "SWIG_SyntaxError";
878 return "SWIG_ValueError";
880 return "SWIG_SystemError";
882 return "SWIG_AttributeError";
884 return "SWIG unknown error";
890 r +=
" (" + type.string_value() +
")";
892 return octave_value(r);
895 #define SWIG_fail goto fail
897 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
898 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
899 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
900 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
901 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
902 #define swig_owntype int
904 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
905 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
907 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
908 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
910 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
911 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
913 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
914 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
915 #define SWIG_MODULE_CLIENTDATA_TYPE void*
917 #define Octave_Error_Occurred() 0
918 #define SWIG_Octave_AddErrorMsg(msg) {;}
924 #define SWIG_POINTER_EXCEPTION 0
925 #define SWIG_arg_fail(arg) 0
933 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
938 #ifdef SWIG_DIRECTORS
942 typedef std::map < void *, Director * > rtdir_map;
959 #ifdef SWIG_DIRECTORS
960 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
961 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
962 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1023 if (m->name == name)
1041 member_map::iterator it = members.find(name);
1042 if (it != members.end())
1045 for (
unsigned int j = 0; j < types.size(); ++j)
1047 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1048 if (!insert_if_not_found)
1050 return &members[
name];
1055 for (
unsigned int j = 0; j < types.size(); ++j) {
1056 assert(types[j].first->clientdata);
1058 if (cj->
name == name)
1059 return types[j].first;
1076 if (cj->
name == name)
1084 if (out.find(m->name) == out.end())
1085 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1105 for (
unsigned int j = 0; j < types.size(); ++j)
1106 if (types[j].first->clientdata)
1110 octave_value_list
member_invoke(member_value_pair *m,
const octave_value_list &args,
int nargout) {
1111 if (m->second.is_defined())
1112 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1113 else if (m->first && m->first->method)
1114 return m->first->method(args, nargout);
1115 error(
"member not defined or not invocable");
1116 return octave_value_list();
1120 member_value_pair *m =
find_member(symbol,
false);
1121 if (!m || m->first->is_static() || m->first->is_global())
1123 octave_value_list args;
1126 if (argout.length() < 1)
1133 member_value_pair *m =
find_member(symbol,
false);
1134 if (!m || m->first->is_static() || m->first->is_global())
1136 octave_value_list args;
1140 if (argout.length() < 1)
1147 member_value_pair *m =
find_member(symbol,
false);
1148 if (!m || m->first->is_static() || m->first->is_global())
1150 octave_value_list args;
1154 if (argout.length() >= 1)
1159 octave_value_list
member_deref(member_value_pair *m,
const octave_value_list &args) {
1160 if (m->second.is_defined())
1162 else if (m->first) {
1163 if (m->first->get_method)
1164 return m->first->get_method(args, 1);
1165 else if (m->first->method)
1166 return octave_value(
new octave_builtin(m->first->method));
1168 error(
"undefined member");
1169 return octave_value_list();
1174 return octave_value((octave_base_value *) &x);
1182 bool _always_static =
false)
1183 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1184 always_static(_always_static) {
1186 types.push_back(std::make_pair(_type, _ptr));
1187 #ifdef SWIG_DIRECTORS
1189 Swig::Director *d = Swig::get_rtdir(_ptr);
1191 Swig::swig_director_set_self(d,
this);
1199 for (
unsigned int j = 0; j < types.size(); ++j) {
1200 if (!types[j].first || !types[j].first->clientdata)
1203 if (c->
destructor && !types[j].second.destroyed && types[j].second.ptr) {
1208 #ifdef SWIG_DIRECTORS
1209 for (
unsigned int j = 0; j < types.size(); ++j)
1210 Swig::erase_rtdir(types[j].second.ptr);
1218 member_value_pair *m = nc_this->
find_member(
"__dims__",
false);
1220 if (!m)
return dim_vector(1,1);
1223 octave_value_list inarg;
1225 octave_value_list outarg = nc_this->
member_invoke(m, inarg, 1);
1228 if (outarg.length() < 1)
return dim_vector(1,1);
1230 octave_value & out = outarg(0);
1233 if (out.is_cell()) {
1234 const Cell & c=out.cell_value();
1235 int ndim = c.rows();
1236 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1239 d.resize(ndim < 2 ? 2 : ndim);
1243 for (
int k=0;k<ndim;k++) {
1244 const octave_value& obj = c(k);
1245 d.elem(k) = obj.int_value();
1248 if (error_state)
return dim_vector(1,1);
1251 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1252 if (out.rows()==1 || out.columns()==1) {
1253 Array<int> a = out.int_vector_value();
1254 if (error_state)
return dim_vector(1,1);
1256 d.resize(a.numel() < 2 ? 2 : a.numel());
1258 for (
int k=0;k<a.numel();k++) {
1263 return dim_vector(1,1);
1266 return dim_vector(1,1);
1287 return (
long) types[0].second.ptr;
1292 if (!types[0].first->clientdata)
1302 for (
unsigned int j = 0; j < types.size(); ++j) {
1305 if (types[j].first->clientdata) {
1309 ret += types[j].first->name;
1316 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1317 assert(!rhs.
types[j].second.destroyed);
1318 #ifdef SWIG_DIRECTORS
1319 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1321 Swig::swig_director_set_self(d,
this);
1324 types.insert(types.end(), rhs.
types.begin(), rhs.
types.end());
1339 if (!type && types.size())
1340 return types[0].second.ptr;
1341 for (
unsigned int j = 0; j < types.size(); ++j)
1342 if (type == types[j].first)
1343 return types[j].second.ptr;
1344 for (
unsigned int j = 0; j < types.size(); ++j) {
1349 void *vptr =
SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1360 #ifdef SWIG_DIRECTORS
1361 void director_destroyed(Swig::Director *d) {
1363 for (
unsigned int j = 0; j < types.size(); ++j) {
1364 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1366 types[j].second.destroyed =
true;
1379 members[
name] = std::make_pair(m, octave_value());
1403 octave_value_list ovl =
subsref(ops, idx, 1);
1404 return ovl.length()? ovl(0) : octave_value();
1407 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1408 assert(ops.size() > 0);
1409 assert(ops.size() == idx.size());
1411 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1413 octave_value_list sub_ovl;
1416 if (ops[skip] ==
'(' && construct_type) {
1420 error(
"cannot create instance");
1421 return octave_value_list();
1423 octave_value_list args;
1426 args.append(*idx_it++);
1431 else if (ops[skip] ==
'.') {
1435 octave_value_list subname_ovl(*idx_it++);
1437 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1438 subname = subname_ovl(0).string_value();
1441 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1446 member_value_pair tmp, *m = &tmp;
1447 if (!base || !(m->first =
find_member(base, subname)))
1450 error(
"member not found");
1451 return octave_value_list();
1454 octave_value_list args;
1455 if (!always_static &&
1456 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1458 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1459 ((m->first && m->first->method) || m->second.is_function() ||
1460 m->second.is_function_handle())) {
1461 args.append(*idx_it++);
1470 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1471 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1472 octave_value_list args;
1473 args.append(*idx_it++);
1476 error(
"error evaluating index operator");
1477 return octave_value_list();
1480 error(
"unsupported subsref");
1481 return octave_value_list();
1485 if (skip >= (
int) ops.size())
1487 if (sub_ovl.length() < 1) {
1488 error(
"bad subs ref");
1489 return octave_value_list();
1491 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1494 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1495 assert(ops.size() > 0);
1496 assert(ops.size() == idx.size());
1498 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1501 if (ops.size() > 1) {
1502 std::list < octave_value_list >::const_iterator last = idx.end();
1504 std::list < octave_value_list > next_idx(idx.begin(), last);
1505 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1506 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1509 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1510 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1511 member_value_pair *m =
find_member(op_name,
false);
1513 octave_value_list args;
1515 args.append(*idx_it);
1519 error(
"%s member not found", op_name);
1522 else if (ops[skip] ==
'.') {
1523 octave_value_list subname_ovl(*idx_it++);
1525 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1526 std::string subname = subname_ovl(0).string_value();
1528 member_value_pair *m =
find_member(subname,
true);
1529 if (!m->first || !m->first->set_method) {
1532 }
else if (m->first->set_method) {
1533 octave_value_list args;
1534 if (!m->first->is_static() && !m->first->is_global())
1537 m->first->set_method(args, 1);
1539 error(
"member not assignable");
1541 error(
"unsupported subsasgn");
1557 member_value_pair *m = nc_this->
find_member(
"__str__",
false);
1559 error(
"__str__ method not defined");
1563 if (outarg.length() < 1 || !outarg(0).is_string()) {
1564 error(
"__str__ method did not return a string");
1567 return outarg(0).string_value();
1570 #if SWIG_OCTAVE_PREREQ(3,3,52)
1572 return octave_map();
1576 return Octave_map();
1584 string_vector keys(tmp.size());
1586 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1587 keys(k++) = it->first;
1605 oct_mach_info::float_format fmt) {
1609 #if defined (HAVE_HDF5)
1611 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1616 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1621 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1633 octave_function *fcn = is_valid_function(symbol,
std::string(),
false);
1636 ret = fcn->do_multi_index_op(1, args)(0);
1648 octave_value_list args;
1653 error(
"could not dispatch unary operator");
1654 return octave_value();
1657 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1665 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1676 octave_value_list args;
1707 error(
"could not dispatch binary operator");
1708 return octave_value();
1711 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1721 os <<
"{"; newline(os);
1722 increment_indent_level();
1723 for (
unsigned int j = 0; j < types.size(); ++j) {
1725 if (types[j].first->clientdata) {
1727 os << c->
name <<
", ptr = " << types[j].second.ptr; newline(os);
1729 os << types[j].first->name <<
", ptr = " << types[j].second.ptr; newline(os);
1732 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1734 if (it->second.first) {
1735 const char *objtype = it->second.first->method ?
"method" :
"variable";
1736 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1737 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1738 assert(it->second.first->name == it->first);
1740 os << it->first; newline(os);
1743 decrement_indent_level();
1745 os <<
"}"; newline(os);
1768 {
if (ptr) ptr->
decref(); }
1780 {
return ptr->
dims(); }
1786 {
return ptr->
is_map(); }
1789 {
return ptr->
subsref(ops, idx); }
1791 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1792 {
return ptr->
subsref(ops, idx, nargout); }
1794 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1795 {
return ptr->
subsasgn(ops, idx, rhs); }
1806 #if SWIG_OCTAVE_PREREQ(3,3,52)
1827 oct_mach_info::float_format fmt)
1830 #if defined (HAVE_HDF5)
1832 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
1833 {
return ptr->save_hdf5(loc_id, name, save_as_floats); }
1836 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug)
1837 {
return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1840 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
1846 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const
1847 {
return ptr->
print(os, pr_as_read_syntax); }
1862 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1866 if (outtype && outtype != type)
1868 assert(sz <= buf.size());
1869 std::copy(buf.begin(), buf.begin()+sz, (
char*)ptr);
1885 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
const {
1887 os <<
"swig packed type: name = " << (type ? type->
name :
std::string()) <<
", len = " << buf.size(); newline(os);
1904 oct_mach_info::float_format fmt) {
1908 #if defined (HAVE_HDF5)
1910 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats) {
1915 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug) {
1928 error(
"attempt to set immutable member variable");
1929 return octave_value_list();
1937 :ovl(_ovl), j(_j) { }
1939 operator octave_value()
const {
1956 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1957 ov = ov.cell_value()(0);
1962 if (ov.type_id() != octave_swig_ref::static_type_id())
1971 #define swig_unary_op(name) \
1972 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1973 return octave_swig_type::dispatch_unary_op(x,#name); \
1975 #define swig_binary_op(name) \
1976 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1977 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1979 #define swigreg_unary_op(name) \
1980 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1981 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1982 #define swigreg_binary_op(name) \
1983 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1984 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2053 for (
int j = 0; j < tid; ++j) {
2062 #ifdef SWIG_DIRECTORS
2063 Swig::Director *d = Swig::get_rtdir(ptr);
2064 if (d && Swig::swig_director_get_self(d))
2065 return Swig::swig_director_get_self(d)->as_value();
2071 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2072 ov = ov.cell_value()(0);
2073 if (!ov.is_defined() ||
2074 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2079 if (ov.type_id() != octave_swig_ref::static_type_id())
2083 void *vptr = ost->
cast(type, own, flags);
2096 if (!ov.is_defined())
2098 if (ov.type_id() != octave_swig_packed::static_type_id())
2105 module_ns->
assign(name, ov);
2109 return get_global_value(name,
true);
2113 set_global_value(name, value);
2117 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2118 link_to_global_variable(curr_sym_tab->lookup(name,
true));
2120 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2121 symbol_table::varref(name);
2123 symbol_table::mark_global(name);
2129 if (!ov.is_defined() ||
2130 ov.type_id() != octave_swig_packed::static_type_id())
2146 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2148 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2154 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2155 #define SWIGTYPE_p_char swig_types[1]
2156 #define SWIGTYPE_p_double swig_types[2]
2157 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2158 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2159 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2160 #define SWIGTYPE_p_int swig_types[6]
2161 #define SWIGTYPE_p_p_char swig_types[7]
2162 #define SWIGTYPE_p_unsigned_int swig_types[8]
2165 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2166 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2171 #define SWIGVERSION 0x020012
2172 #define SWIG_VERSION SWIGVERSION
2175 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2176 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2179 #include <stdexcept>
2189 #ifdef OCTAVE_EXPORT
2190 #if defined ( __GNUC__ ) && __GNUC__ > 3
2191 #undef OCTAVE_EXPORT
2192 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2210 inline int max(
int a,
int b )
2212 return a >= b ? a : b;
2214 inline int min(
int a,
int b )
2216 return a >= b ? a : b;
2230 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2242 if (
max( o_obj.columns(), 1 ) > 1 )
2247 else if (
max( o_obj.rows(), 1 ) > 1 )
2257 _dim(
const octave_value &o_obj,
int dim_idx )
2260 return max( o_obj.rows(), 0 );
2264 else if ( dim_idx == 1 )
2265 return max( o_obj.columns(), 0 );
2278 template <
class FLOAT>
2282 while ( n_el-- > 0 )
2283 *out_arr++ = (FLOAT) ( *in_arr++ );
2289 template void _cvt_double_to(
unsigned long *,
double *,
unsigned );
2291 template void _cvt_double_to(
unsigned short *,
double *,
unsigned );
2302 template <
class FLOAT>
2306 while ( n_el-- > 0 )
2307 *d_arr++ = double(*arr++);
2313 template void _cvt_to_double(
unsigned long *,
double *,
unsigned );
2315 template void _cvt_to_double(
unsigned short *,
double *,
unsigned );
2338 octave_value_list functionArguments;
2339 octave_value_list retval;
2346 for ( i = 0; i < n; i++ )
2352 functionArguments( 0 ) = xin;
2353 functionArguments( 1 ) = yin;
2355 if ( fcnMapForm != NULL )
2356 retval = feval( fcnMapForm, functionArguments, 1 );
2358 retval = feval( nameMapForm, functionArguments, 1 );
2361 if ( retval.length() >= 2 )
2363 xout = retval( 0 ).matrix_value();
2364 yout = retval( 1 ).matrix_value();
2366 for ( i = 0; i < n; i++ )
2368 x[i] = xout( i, 0 );
2369 y[i] = yout( i, 0 );
2381 octave_value_list functionArguments;
2382 octave_value_list retval;
2384 Matrix inAxis( 1, 1 );
2385 Matrix inValue( 1, 1 );
2386 inAxis( 0, 0 ) = axis;
2387 inValue( 0, 0 ) =
value;
2389 functionArguments( 0 ) = inAxis;
2390 functionArguments( 1 ) = inValue;
2392 if ( fcnLabelFunc != NULL )
2393 retval = feval( fcnLabelFunc, functionArguments, 1 );
2395 retval = feval( nameLabelFunc, functionArguments, 1 );
2397 strncpy( label, retval( 0 ).string_value().c_str(), length );
2407 octave_value_list functionArguments;
2408 octave_value_list retval;
2418 functionArguments( 0 ) = xin;
2419 functionArguments( 1 ) = yin;
2421 if ( fcnCoordTrans != NULL )
2422 retval = feval( fcnCoordTrans, functionArguments, 1 );
2424 retval = feval( nameCoordTrans, functionArguments, 1 );
2427 if ( retval.length() >= 2 )
2429 xout = retval( 0 ).matrix_value();
2430 yout = retval( 1 ).matrix_value();
2438 void testppchar( PLINT nlegend,
const PLINT *opt_array,
const char ** text )
2441 printf(
"nlegend =%d\n", nlegend );
2442 for ( i = 0; i < nlegend; i++ )
2444 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2445 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen( text[i] ) );
2446 printf(
"text[%d] =%s\n", i, text[i] );
2452 #if !defined(SWIG_NO_LLONG_MAX)
2453 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2454 # define LLONG_MAX __LONG_LONG_MAX__
2455 # define LLONG_MIN (-LLONG_MAX - 1LL)
2456 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2463 if (!ov.is_scalar_type())
2465 if (ov.is_complex_scalar())
2467 if (ov.is_double_type()||ov.is_single_type()) {
2468 double v=ov.double_value();
2473 *val = ov.long_value();
2484 if ((v < INT_MIN || v > INT_MAX)) {
2487 if (val) *val = (int)(v);
2494 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 )
2502 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2510 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2511 ov = ov.cell_value()(0);
2512 if (!ov.is_string())
2516 size_t len=str.size();
2517 char* cstr=(
char*)str.c_str();
2519 *cptr = (
char*)(memcpy((
new char[len + 1]), cstr,
sizeof(
char)*(len + 1)));
2534 return octave_value(value);
2547 return octave_value(value);
2556 gin.
dX = x_in; gin.
dY = y_in;
2558 *x = gin.
wX; *y = gin.
wY;
2565 if (!ov.is_scalar_type())
2567 if (ov.is_complex_scalar())
2570 *val = ov.double_value();
2578 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2579 PLFLT xlpos, PLFLT ylpos,
2581 PLINT colbox, PLINT collab,
2582 const PLINT *colline,
const PLINT *styline,
2583 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2584 const char *labx,
const char *laby,
const char *labtop )
2586 const char *legline[4];
2587 legline[0] = legline1; legline[1] = legline2;
2588 legline[2] = legline3; legline[3] = legline4;
2589 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2590 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2591 labx, laby, labtop );
2609 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2610 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2615 #define f2c( f, ff, nx, ny ) \
2617 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2618 for ( int i = 0; i < nx; i++ ) { \
2619 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2620 for ( int j = 0; j < ny; j++ ) \
2621 *( ff[i] + j ) = *( f + nx * j + i );}
2625 void my_plcont(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2626 PLINT ly,
const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2628 f2c( f, ff, nx, ny );
2629 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2634 void my_plcont0(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2635 PLINT ly,
const PLFLT *clevel, PLINT nlevel )
2637 f2c( f, ff, nx, ny );
2638 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2643 void my_plcont1(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2644 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2647 grid1.
nx = nx; grid1.
ny = ny;
2648 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2649 f2c( f, ff, nx, ny );
2650 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2654 void my_plcont2(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2655 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2658 f2c( xg, xgg, nx, ny );
2659 f2c( yg, ygg, nx, ny );
2660 grid2.
nx = nx; grid2.
ny = ny;
2661 grid2.
xg = xgg; grid2.
yg = ygg;
2662 f2c( f, ff, nx, ny );
2663 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2668 void my_plcont2p(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2669 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2672 f2c( xg, xgg, nx, ny );
2673 f2c( yg, ygg, nx, ny );
2674 grid2.
nx = nx; grid2.
ny = ny;
2675 grid2.
xg = xgg; grid2.
yg = ygg;
2676 f2c( f, ff, nx, ny );
2677 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2682 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
2683 PLFLT *zg,
int type, PLFLT data )
2685 f2c( zg, zgg, nptsx, nptsy );
2686 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2687 for (
int i = 0; i < nptsx; i++ )
2688 for (
int j = 0; j < nptsy; j++ )
2689 *( zg + nptsx * j + i ) = zgg[i][j];
2695 void my_plmesh(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2697 f2c( z, zz, nx, ny );
2698 c_plmesh( x, y, (
const PLFLT **) zz, nx, ny, opt );
2703 void my_plmeshc(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
2705 f2c( z, zz, nx, ny );
2706 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2711 void my_plot3d(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z,
2712 PLINT nx, PLINT ny, PLINT opt, PLINT side )
2714 f2c( z, zz, nx, ny );
2715 c_plot3d( x, y, (
const PLFLT **) zz, nx, ny, opt, side );
2720 PLINT nx, PLINT ny, PLINT opt,
2721 const PLFLT *clevel, PLINT nlevel )
2723 f2c( z, zz, nx, ny );
2724 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2729 PLINT nx, PLINT ny, PLINT opt,
2730 const PLFLT * clevel, PLINT nlevel,
2731 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
2733 f2c( z, zz, nx, ny );
2734 c_plot3dcl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2735 indexxmin, indexxmax, indexymin, indexymax );
2740 PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
2742 f2c( z, zz, nx, ny );
2743 c_plsurf3d( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2747 PLINT nx, PLINT ny, PLINT opt,
const PLFLT * clevel, PLINT nlevel,
2748 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
2750 f2c( z, zz, nx, ny );
2751 c_plsurf3dl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2752 indexxmin, indexxmax, indexymin, indexymax );
2762 void my_plshade(
const PLFLT *a, PLINT nx, PLINT ny,
const PLFLT *defined,
2763 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2764 PLFLT shade_min, PLFLT shade_max,
2765 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2766 PLINT min_color, PLINT min_width,
2767 PLINT max_color, PLINT max_width,
2768 PLINT rectangular, PLFLT *tr )
2770 f2c( a, aa, nx, ny );
2771 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2772 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2773 min_color, min_width, max_color, max_width,
2778 void my_plshade1(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
2779 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2780 PLFLT shade_min, PLFLT shade_max,
2781 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2782 PLINT min_color, PLINT min_width,
2783 PLINT max_color, PLINT max_width,
2784 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
2787 grid1.
nx = nx; grid1.
ny = ny;
2788 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2789 f2c( a, aa, nx, ny );
2790 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2791 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2792 min_color, min_width, max_color, max_width,
2797 void my_plshade2(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
2798 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2799 PLFLT shade_min, PLFLT shade_max,
2800 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2801 PLINT min_color, PLINT min_width,
2802 PLINT max_color, PLINT max_width,
2803 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
2806 f2c( xg, xgg, nx, ny );
2807 f2c( yg, ygg, nx, ny );
2808 grid2.
nx = nx; grid2.
ny = ny;
2809 grid2.
xg = xgg; grid2.
yg = ygg;
2810 f2c( a, aa, nx, ny );
2811 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2812 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2813 min_color, min_width, max_color, max_width,
2820 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2821 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2822 PLINT cont_color, PLINT cont_width,
2825 f2c( a, aa, nx, ny );
2826 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2827 clevel, nlevel, fill_width, cont_color, cont_width,
2828 plfill, rectangular, NULL, NULL );
2832 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2833 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2834 PLINT cont_color, PLINT cont_width,
2835 PLINT rectangular, PLFLT *tr )
2837 f2c( a, aa, nx, ny );
2838 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2839 clevel, nlevel, fill_width, cont_color, cont_width,
2844 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2845 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2846 PLINT cont_color, PLINT cont_width,
2847 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
2850 grid1.
nx = nx; grid1.
ny = ny;
2851 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2853 f2c( a, aa, nx, ny );
2854 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2855 clevel, nlevel, fill_width, cont_color, cont_width,
2860 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2861 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2862 PLINT cont_color, PLINT cont_width,
2863 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
2866 f2c( xg, xgg, nx, ny );
2867 f2c( yg, ygg, nx, ny );
2868 grid2.
nx = nx; grid2.
ny = ny;
2869 grid2.
xg = xgg; grid2.
yg = ygg;
2870 f2c( a, aa, nx, ny );
2871 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2872 clevel, nlevel, fill_width, cont_color, cont_width,
2880 void my_plvect(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2882 f2c( u, uu, nx, ny );
2883 f2c( v, vv, nx, ny );
2884 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
xform, tr );
2888 void my_plvect1(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *xg,
const PLFLT *yg )
2891 grid1.
nx = nx; grid1.
ny = ny;
2892 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2893 f2c( u, uu, nx, ny );
2894 f2c( v, vv, nx, ny );
2895 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr1, &grid1 );
2899 void my_plvect2(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *xg,
const PLFLT *yg )
2902 f2c( xg, xgg, nx, ny );
2903 f2c( yg, ygg, nx, ny );
2904 grid2.
nx = nx; grid2.
ny = ny;
2905 grid2.
xg = xgg; grid2.
yg = ygg;
2906 f2c( u, uu, nx, ny );
2907 f2c( v, vv, nx, ny );
2908 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr2, &grid2 );
2914 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2915 PLFLT zmin, PLFLT zmax,
2916 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2918 f2c( a, aa, nx, ny );
2919 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2925 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2926 PLFLT zmin, PLFLT zmax,
2927 PLFLT valuemin, PLFLT valuemax )
2929 f2c( a, aa, nx, ny );
2930 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2934 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2935 PLFLT zmin, PLFLT zmax,
2936 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2938 f2c( a, aa, nx, ny );
2939 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
2944 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2945 PLFLT zmin, PLFLT zmax,
2946 PLFLT valuemin, PLFLT valuemax,
const PLFLT *xg,
const PLFLT *yg )
2949 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
2950 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2951 f2c( a, aa, nx, ny );
2952 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
2957 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2958 PLFLT zmin, PLFLT zmax,
2959 PLFLT valuemin, PLFLT valuemax,
const PLFLT *xg,
const PLFLT *yg )
2962 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
2963 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2964 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
2965 grid2.
xg = xgg; grid2.
yg = ygg;
2966 f2c( a, aa, nx, ny );
2967 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
2973 PLINT opt, PLINT position, PLFLT x, PLFLT y,
2974 PLFLT x_length, PLFLT y_length,
2975 PLINT bg_color, PLINT bb_color, PLINT bb_style,
2976 PLFLT low_cap_color, PLFLT high_cap_color,
2977 PLINT cont_color, PLFLT cont_width,
2978 PLINT n_labels,
const PLINT *label_opts,
const char **label,
2979 PLINT n_axes,
const char ** axis_opts,
2980 const PLFLT *ticks,
const PLINT *sub_ticks,
2981 const PLINT *n_values,
const PLFLT *a )
2986 for ( i = 0; i < nx; i++ )
2987 if ( n_values[i] > ny )
2989 f2c( a, aa, nx, ny );
2991 opt, position, x, y,
2993 bg_color, bb_color, bb_style,
2994 low_cap_color, high_cap_color,
2995 cont_color, cont_width,
2996 n_labels, label_opts, label,
3006 if (!ov.is_scalar_type())
3008 if (ov.is_complex_scalar())
3010 if (ov.is_double_type()||ov.is_single_type()) {
3011 double v=ov.double_value();
3017 if (ov.is_int8_type()||ov.is_int16_type()||
3018 ov.is_int32_type()) {
3019 long v=ov.long_value();
3023 if (ov.is_int64_type()) {
3024 long long v=ov.int64_scalar_value().value();
3029 *val = ov.ulong_value();
3040 if ((v > UINT_MAX)) {
3043 if (val) *val = (
unsigned int)(v);
3052 return octave_value(value);
3066 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3069 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3070 if (csize <= size) {
3072 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3073 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3090 static int init = 0;
3115 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3116 if (val) *val = (char)(v);
3126 Specify viewport in absolute coordinates\n\
3130 Alternate routine to plvpor for setting up the viewport. This routine\n\
3131 should be used only if the viewport is required to have a definite\n\
3132 size in millimeters. The routine plgspa is useful for finding out the\n\
3133 size of the current subpage.\n\
3135 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3137 This function is used in example 10.\n\
3143 plsvpa(xmin, xmax, ymin, ymax)\n\
3147 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3148 viewport from the left-hand edge of the subpage in millimeters.\n\
3150 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3151 viewport from the left-hand edge of the subpage in millimeters.\n\
3153 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3154 viewport from the bottom edge of the subpage in millimeters.\n\
3156 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3157 from the bottom edge of the subpage in millimeters.\n\
3160 Write text relative to viewport boundaries in 3D plots\n\
3164 Writes text at a specified position relative to the viewport\n\
3165 boundaries. Text may be written inside or outside the viewport, but\n\
3166 is clipped at the subpage boundaries. The reference point of a string\n\
3167 lies along a line passing through the string at half the height of a\n\
3168 capital letter. The position of the reference point along this line\n\
3169 is determined by just, and the position of the reference point\n\
3170 relative to the viewport is set by disp and pos.\n\
3172 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3174 This function is used in example 28.\n\
3180 plmtex3(side, disp, pos, just, text)\n\
3184 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3185 the side of the viewport along which the text is to be written.\n\
3186 The string should contain one or more of the following characters:\n\
3187 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3188 only label the X axis, not both the X and Y axes. x: Label the X\n\
3190 y: Label the Y axis.\n\
3191 z: Label the Z axis.\n\
3192 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3193 For X it is the axis that starts at y-min. For Y it is the\n\
3194 axis that starts at x-min.\n\
3195 s: Label the secondary axis.\n\
3196 v: Draw the text perpendicular to the axis.\n\
3199 disp (PLFLT, input) : Position of the reference point of string,\n\
3200 measured outwards from the specified viewport edge in units of the\n\
3201 current character height. Use negative disp to write within the\n\
3204 pos (PLFLT, input) : Position of the reference point of string\n\
3205 along the specified edge, expressed as a fraction of the length of\n\
3208 just (PLFLT, input) : Specifies the position of the string relative\n\
3209 to its reference point. If just=0. , the reference point is at\n\
3210 the left and if just=1. , it is at the right of the string. Other\n\
3211 values of just give intermediate justifications.\n\
3213 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3217 Set semitransparent cmap1 RGBA colors.\n\
3221 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3222 RGBA vector values. This function also sets the number of cmap1\n\
3223 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3224 floating-point index in the range from 0.0-1.0 which is linearly\n\
3225 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3226 vectors in the range from 0 to\n\
3227 ncol1-1. So in order for this continuous color model to work\n\
3228 properly, it is the responsibility of the user of plscmap1 to insure\n\
3229 that these RGBA vectors are continuous functions of their integer\n\
3232 Redacted form: plscmap1a(r, g, b, alpha)\n\
3234 This function is used in example 31.\n\
3240 plscmap1a(r, g, b, alpha, ncol1)\n\
3244 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3245 8-bit integers in the range from 0-255) the degree of red in the\n\
3246 color as a continuous function of the integer index of the vector.\n\
3248 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3249 8-bit integers in the range from 0-255) the degree of green in the\n\
3250 color as a continuous function of the integer index of the vector.\n\
3252 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3253 8-bit integers in the range from 0-255) the degree of blue in the\n\
3254 color as a continuous function of the integer index of the vector.\n\
3256 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3257 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3258 completely transparent and 1.0 corresponds to completely opaque)\n\
3259 the alpha transparency of the color as a continuous function of\n\
3260 the integer index of the vector.\n\
3262 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3266 Select standard viewport\n\
3270 Selects the largest viewport within the subpage that leaves a standard\n\
3271 margin (left-hand margin of eight character heights, and a margin\n\
3272 around the other three sides of five character heights).\n\
3274 Redacted form: plvsta()\n\
3276 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3285 Switch to graphics screen\n\
3289 Sets an interactive device to graphics mode, used in conjunction with\n\
3290 pltext to allow graphics and text to be interspersed. On a device\n\
3291 which supports separate text and graphics windows, this command causes\n\
3292 control to be switched to the graphics window. If already in graphics\n\
3293 mode, this command is ignored. It is also ignored on devices which\n\
3294 only support a single window or use a different method for shifting\n\
3295 focus. See also pltext.\n\
3297 Redacted form: plgra()\n\
3299 This function is used in example 1.\n\
3308 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3312 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3313 (see the PLplot documentation) index. Overwrites the previous color\n\
3314 value for the given index and, thus, does not result in any additional\n\
3315 allocation of space for colors.\n\
3317 This function is used in example 30.\n\
3323 plscol0a(icol0, r, g, b, alpha)\n\
3327 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3328 number of colors (which is set by default, by plscmap0n, or even\n\
3331 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3332 degree of red in the color.\n\
3334 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3335 degree of green in the color.\n\
3337 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3338 degree of blue in the color.\n\
3340 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3344 Set y axis parameters\n\
3348 Identical to plsxax, except that arguments are flags for y axis. See\n\
3349 the description of plsxax for more detail.\n\
3351 Redacted form: plsyax(digmax, digits)\n\
3353 This function is used in examples 1, 14, and 31.\n\
3359 plsyax(digmax, digits)\n\
3363 digmax (PLINT, input) : Variable to set the maximum number of\n\
3364 digits for the y axis. If nonzero, the printed label will be\n\
3365 switched to a floating-point representation when the number of\n\
3366 digits exceeds digmax.\n\
3368 digits (PLINT, input) : Field digits value. Currently, changing\n\
3369 its value here has no effect since it is set only by plbox or\n\
3370 plbox3. However, the user may obtain its value after a call to\n\
3371 either of these functions by calling plgyax.\n\
3374 Returns 8-bit RGB values for given color index from cmap0\n\
3378 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3379 PLplot documentation). Values are negative if an invalid color id is\n\
3382 Redacted form: plgcol0(icol0, r, g, b)\n\
3384 This function is used in example 2.\n\
3390 plgcol0(icol0, r, g, b)\n\
3394 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3396 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3399 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3402 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3406 Set seed for internal random number generator.\n\
3410 Set the seed for the internal random number generator. See plrandd for\n\
3413 Redacted form: plseed(seed)\n\
3415 This function is used in example 21.\n\
3425 seed (unsigned int, input) : Seed for random number generator.\n\
3428 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3432 When the implementation is completed this variant of plot3dc (see that\n\
3433 function\'s documentation for more details) should be suitable for the\n\
3434 case where the area of the x, y coordinate grid where z is defined can\n\
3435 be non-rectangular. The implementation is incomplete so the last 4\n\
3436 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3437 indexymax; are currently ignored and the functionality is otherwise\n\
3438 identical to that of plot3dc.\n\
3440 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3441 indexymin, indexymax)\n\
3442 \t Perl/PDL: Not available?\n\
3445 This function is not used in any example.\n\
3451 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3455 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3456 which the function is evaluated.\n\
3458 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3459 which the function is evaluated.\n\
3461 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3462 plot. Should have dimensions of\n\
3466 nx (PLINT, input) : Number of x values at which the function is\n\
3469 ny (PLINT, input) : Number of y values at which the function is\n\
3472 opt (PLINT, input) : Determines the way in which the surface is\n\
3473 represented. To specify more than one option just add the options,\n\
3474 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3475 showing z as a function of x for each value of y[j] .\n\
3476 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3477 for each value of x[i] .\n\
3478 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3479 at which function is defined.\n\
3480 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3481 the z value being plotted. The color is used from the current\n\
3483 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3487 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3488 the borders of the plotted function.\n\
3491 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3494 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3496 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3497 corresponds to the first x index where z is defined.\n\
3499 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3500 which corresponds (by convention) to one more than the last x\n\
3501 index value where z is defined.\n\
3503 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3504 values which all must be ≥ 0. These values are the first y index\n\
3505 where z is defined for a particular x index in the range from\n\
3506 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3509 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3510 values which all must be ≤ ny. These values correspond (by\n\
3511 convention) to one more than the last y index where z is defined\n\
3512 for a particular x index in the range from indexxmin to indexxmax\n\
3513 - 1. The dimension of indexymax is indexxmax.\n\
3516 Get output file name\n\
3520 Gets the current output file name, if applicable.\n\
3522 Redacted form: plgfnam(fnam)\n\
3524 This function is used in example 31.\n\
3534 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3535 (with preallocated length of 80 characters or more) containing the\n\
3543 Specify the window, i.e., the world coordinates of the edges of the\n\
3546 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3548 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3555 plwind(xmin, xmax, ymin, ymax)\n\
3559 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3562 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3565 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3568 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3572 Set cmap1 colors using a piece-wise linear relationship\n\
3576 Set cmap1 colors using a piece-wise linear relationship between the\n\
3577 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3578 (see the PLplot documentation). May be called at any time.\n\
3580 The idea here is to specify a number of control points that define the\n\
3581 mapping between input cmap1 intensity indices and HLS (or RGB).\n\
3582 Between these points, linear interpolation is used which gives a\n\
3583 smooth variation of color with intensity index. Any number of control\n\
3584 points may be specified, located at arbitrary positions, although\n\
3585 typically 2 - 4 are enough. Another way of stating this is that we are\n\
3586 traversing a given number of lines through HLS (or RGB) space as we\n\
3587 move through cmap1 intensity indices. The control points at the\n\
3588 minimum and maximum position (0 and 1) must always be specified. By\n\
3589 adding more control points you can get more variation. One good\n\
3590 technique for plotting functions that vary about some expected average\n\
3591 is to use an additional 2 control points in the center (position ~=\n\
3592 0.5) that are the same lightness as the background (typically white\n\
3593 for paper output, black for crt), and same hue as the boundary control\n\
3594 points. This allows the highs and lows to be very easily\n\
3597 Each control point must specify the cmap1 intensity index and the\n\
3598 associated three coordinates in HLS or RGB space. The first point\n\
3599 must correspond to position = 0, and the last to position = 1.\n\
3601 The default behaviour is for the hue to be linearly interpolated\n\
3602 between the control points. Since the hue lies in the range [0, 360]\n\
3603 this corresponds to interpolation around the \"front\" of the color\n\
3604 wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3605 alternative interpolation is used between control points i and i+1. If\n\
3606 hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n\
3607 - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n\
3608 this as interpolation around the \"back\" or \"reverse\" of the color\n\
3609 wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3610 alt_hue_path[] = false for every control point.\n\
3612 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3613 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3614 240]truegreen-yellow-red-magenta-blue[240\n\
3615 120]trueblue-magenta-red-yellow-green\n\
3617 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3618 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3619 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3621 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3624 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3630 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3634 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3636 npts (PLINT, input) : number of control points\n\
3638 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3639 intensity index (0.0-1.0) in ascending order for each control\n\
3642 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3643 coordinate (H or R) for each control point.\n\
3645 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3646 coordinate (L or G) for each control point.\n\
3648 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3649 coordinate (S or B) for each control point.\n\
3651 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3652 npts - 1 elements) containing the alternative interpolation method\n\
3653 Boolean value for each control point interval. (alt_hue_path[i]\n\
3654 refers to the interpolation interval between the i and i + 1\n\
3658 Set the pause (on end-of-page) status\n\
3662 Set the pause (on end-of-page) status.\n\
3664 Redacted form: plspause(pause)\n\
3666 This function is in examples 14,20.\n\
3676 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3677 end-of-page for those drivers which support this. Otherwise there\n\
3681 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
3685 Routine for creating a discrete plot legend with a plotted filled box,\n\
3686 line, and/or line of symbols for each annotated legend entry. (See\n\
3687 plcolorbar for similar functionality for creating continuous color\n\
3688 bars.) The arguments of pllegend provide control over the location\n\
3689 and size of the legend as well as the location and characteristics of\n\
3690 the elements (most of which are optional) within that legend. The\n\
3691 resulting legend is clipped at the boundaries of the current subpage.\n\
3692 (N.B. the adopted coordinate system used for some of the parameters is\n\
3693 defined in the documentation of the position parameter.)\n\
3695 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3696 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3697 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3698 test_justification, text_colors, text, box_colors, box_patterns,\n\
3699 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3700 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3702 This function is used in examples 4, 26, and 33.\n\
3708 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\
3712 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
3713 legend width in adopted coordinates. This quantity is calculated\n\
3714 from plot_width, text_offset, ncolumn (possibly modified inside\n\
3715 the routine depending on nlegend and nrow), and the length\n\
3716 (calculated internally) of the longest text string.\n\
3718 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
3719 legend height in adopted coordinates. This quantity is calculated\n\
3720 from text_scale, text_spacing, and nrow (possibly modified inside\n\
3721 the routine depending on nlegend and nrow).\n\
3723 opt (PLINT, input) : opt contains bits controlling the overall\n\
3724 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3725 on the left of the legend and the plotted area on the right.\n\
3726 Otherwise, put the text area on the right of the legend and the\n\
3727 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3728 plot a (semitransparent) background for the legend. If the\n\
3729 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3730 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3731 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3732 plot the resulting array of legend entries in row-major order.\n\
3733 Otherwise, plot the legend entries in column-major order.\n\
3735 position (PLINT, input) : position contains bits which control the\n\
3736 overall position of the legend and the definition of the adopted\n\
3737 coordinates used for positions just like what is done for the\n\
3738 position argument for plcolorbar. However, note that the defaults\n\
3739 for the position bits (see below) are different than the\n\
3740 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3741 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3742 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3743 the 16 possible standard positions (the 4 corners and centers of\n\
3744 the 4 sides for both the inside and outside cases) of the legend\n\
3745 relative to the adopted coordinate system. The corner positions\n\
3746 are specified by the appropriate combination of two of the\n\
3747 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3748 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3749 value of one of those bits. The adopted coordinates are\n\
3750 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3751 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3752 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3753 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3754 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3755 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3756 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3757 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
3759 x (PLFLT, input) : X offset of the legend position in adopted\n\
3760 coordinates from the specified standard position of the legend.\n\
3761 For positive x, the direction of motion away from the standard\n\
3762 position is inward/outward from the standard corner positions or\n\
3763 standard left or right positions if the\n\
3764 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
3765 For the standard top or bottom positions, the direction of motion\n\
3766 is toward positive X.\n\
3768 y (PLFLT, input) : Y offset of the legend position in adopted\n\
3769 coordinates from the specified standard position of the legend.\n\
3770 For positive y, the direction of motion away from the standard\n\
3771 position is inward/outward from the standard corner positions or\n\
3772 standard top or bottom positions if the\n\
3773 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
3774 the standard left or right positions, the direction of motion is\n\
3775 toward positive Y.\n\
3777 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3778 of the plot area (where the colored boxes, lines, and/or lines of\n\
3779 symbols are drawn) of the legend.\n\
3781 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3782 legend (PL_LEGEND_BACKGROUND).\n\
3784 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3785 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
3787 bb_style (PLINT, input) : The pllsty style number for the\n\
3788 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
3790 nrow (PLINT, input) : The cmap0 index of the background color for\n\
3791 the legend (PL_LEGEND_BACKGROUND).\n\
3793 ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3794 for the legend (PL_LEGEND_BACKGROUND).\n\
3796 nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3797 vertical height of the legend in adopted coordinates is calculated\n\
3798 internally from nlegend, text_scale (see below), and text_spacing\n\
3801 opt_array (PLINT_VECTOR, input) : A vector of\n\
3802 nlegend values of options to control each individual plotted area\n\
3803 corresponding to a legend entry. If the\n\
3804 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3806 PL_LEGEND_COLOR_BOX,\n\
3807 PL_LEGEND_LINE, and/or\n\
3808 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3809 entry is plotted with a colored box; a line; and/or a line of\n\
3812 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3813 area in units of character width. N.B. The total horizontal\n\
3814 width of the legend in adopted coordinates is calculated\n\
3816 plot_width (see above),\n\
3817 text_offset, and length (calculated internally) of the longest text\n\
3820 text_scale (PLFLT, input) : Character height scale for text\n\
3821 annotations. N.B. The total vertical height of the legend in\n\
3822 adopted coordinates is calculated internally from\n\
3823 nlegend (see above),\n\
3825 text_spacing (see below).\n\
3827 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3828 character height from one legend entry to the next. N.B. The\n\
3829 total vertical height of the legend in adopted coordinates is\n\
3830 calculated internally from\n\
3831 nlegend (see above),\n\
3832 text_scale (see above), and\n\
3835 text_justification (PLFLT, input) : Justification parameter used\n\
3836 for text justification. The most common values of\n\
3837 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3838 is left justified, centred, or right justified within the text\n\
3839 area, but other values are allowed as well.\n\
3841 text_colors (PLINT_VECTOR, input) : A vector containing\n\
3842 nlegend cmap0 text colors.\n\
3844 text (PLCHAR_MATRIX, input) : A vector of\n\
3845 nlegend UTF-8 character strings containing the legend annotations.\n\
3847 box_colors (PLINT_VECTOR, input) : A vector containing\n\
3848 nlegend cmap0 colors for the discrete colored boxes (\n\
3849 PL_LEGEND_COLOR_BOX).\n\
3851 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
3852 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
3853 PL_LEGEND_COLOR_BOX).\n\
3855 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
3856 nlegend scales (units of fraction of character height) for the height\n\
3857 of the discrete colored boxes (\n\
3858 PL_LEGEND_COLOR_BOX).\n\
3860 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
3861 nlegend line widths for the patterns specified by box_patterns (\n\
3862 PL_LEGEND_COLOR_BOX).\n\
3864 line_colors (PLINT_VECTOR, input) : A vector containing\n\
3865 nlegend cmap0 line colors (\n\
3868 line_styles (PLINT_VECTOR, input) : A vector containing\n\
3869 nlegend line styles (plsty indices) (\n\
3872 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
3873 nlegend line widths (\n\
3876 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
3877 nlegend cmap0 symbol colors (\n\
3878 PL_LEGEND_SYMBOL).\n\
3880 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
3881 nlegend scale values for the symbol height (\n\
3882 PL_LEGEND_SYMBOL).\n\
3884 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
3885 nlegend numbers of symbols to be drawn across the width of the plotted\n\
3887 PL_LEGEND_SYMBOL).\n\
3889 symbols (PLCHAR_MATRIX, input) : A vector of\n\
3890 nlegend UTF-8 character strings containing the legend symbols. (\n\
3891 PL_LEGEND_SYMBOL).\n\
3894 Set number of colors in cmap1\n\
3898 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
3899 values if this is the first allocation (see the PLplot documentation).\n\
3901 Redacted form: plscmap1n(ncol1)\n\
3903 This function is used in examples 8, 11, 20, and 21.\n\
3913 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3914 the cmap1 palette. If this number is zero or less, then the value\n\
3915 from the previous call to plscmap1n is used and if there is no\n\
3916 previous call, then a default value is used.\n\
3919 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
3923 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
3924 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
3925 Values are negative if an invalid color id is given.\n\
3927 Redacted form: plgcola(r, g, b)\n\
3929 This function is used in example 30.\n\
3935 plgcol0a(icol0, r, g, b, alpha)\n\
3939 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3941 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
3942 in the range from 0 to 255.\n\
3944 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
3945 in the range from 0 to 255.\n\
3947 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
3948 in the range from 0 to 255.\n\
3950 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
3951 transparency in the range from (0.0-1.0).\n\
3954 Replays contents of plot buffer to current device/file\n\
3958 Replays contents of plot buffer to current device/file.\n\
3960 Redacted form: plreplot()\n\
3962 This function is used in example 1,20.\n\
3971 Simple routine to write labels\n\
3975 Routine for writing simple labels. Use plmtex for more complex labels.\n\
3977 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3979 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
3985 pllab(xlabel, ylabel, tlabel)\n\
3989 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3990 the label for the x axis.\n\
3992 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3993 the label for the y axis.\n\
3995 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3996 the title of the plot.\n\
3999 Set parameters that define current device-space window\n\
4003 Set relative margin width, aspect ratio, and relative justification\n\
4004 that define current device-space window. If you want to just use the\n\
4005 previous value for any of these, just pass in the magic value\n\
4006 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4007 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4008 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4009 to a device-specific value.\n\
4011 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4013 This function is used in example 31.\n\
4019 plsdidev(mar, aspect, jx, jy)\n\
4023 mar (PLFLT, input) : Relative margin width.\n\
4025 aspect (PLFLT, input) : Aspect ratio.\n\
4027 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4028 the range -0.5 to 0.5.\n\
4030 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4031 the range -0.5 to 0.5.\n\
4038 Begins a new page.\tFor a file driver, the output file is opened if\n\
4039 necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
4040 page break is desired at a particular point when plotting to subpages.\n\
4041 Another use for pleop and plbop is when plotting pages to different\n\
4042 files, since you can manually set the file name by calling plsfnam\n\
4043 after the call to pleop. (In fact some drivers may only support a\n\
4044 single page per file, making this a necessity.) One way to handle\n\
4045 this case automatically is to page advance via pladv, but enable\n\
4046 familying (see plsfam) with a small limit on the file size so that a\n\
4047 new family member file will be created on each page break.\n\
4049 Redacted form: plbop()\n\
4051 This function is used in examples 2 and 20.\n\
4060 Set cmap0 colors by 8-bit RGB values\n\
4064 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4065 documentation). This sets the entire color map -- only as many colors\n\
4066 as specified will be allocated.\n\
4068 Redacted form: plscmap0(r, g, b)\n\
4070 This function is used in examples 2 and 24.\n\
4076 plscmap0(r, g, b, ncol0)\n\
4080 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4081 integers (0-255) representing the degree of red in the color.\n\
4083 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4084 integers (0-255) representing the degree of green in the color.\n\
4086 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4087 integers (0-255) representing the degree of blue in the color.\n\
4089 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4092 Set the number of subpages in x and y\n\
4096 Set the number of subpages in x and y.\n\
4098 Redacted form: plssub(nx, ny)\n\
4100 This function is examples 1,2,14,21,25,27.\n\
4110 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4111 of window columns).\n\
4113 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4117 Set a global coordinate transform function\n\
4121 This function can be used to define a coordinate transformation which\n\
4122 affects all elements drawn within the current plot window.\tThe\n\
4123 coordinate_transform callback function is similar to that provided for\n\
4124 the plmap and plmeridians functions. The coordinate_transform_data\n\
4125 parameter may be used to pass extra data to coordinate_transform.\n\
4127 Redacted form: General: plstransform(coordinate_transform,\n\
4128 coordinate_transform_data)\n\
4131 This function is used in examples 19 and 22.\n\
4137 plstransform(coordinate_transform, coordinate_transform_data)\n\
4141 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4142 function that defines the transformation from the input (x, y)\n\
4143 world coordinates to new PLplot world coordinates. If\n\
4144 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4145 case), then no transform is applied.\n\
4147 coordinate_transform_data (PL_GENERIC_POINTER, input) : Optional\n\
4149 coordinate_transform.\n\
4152 Set opaque RGB cmap1 colors values\n\
4156 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4157 vector values. This function also sets the number of cmap1 colors.\n\
4158 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4159 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4160 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4162 ncol1-1. So in order for this continuous color model to work\n\
4163 properly, it is the responsibility of the user of plscmap1 to insure\n\
4164 that these RGB vectors are continuous functions of their integer\n\
4167 Redacted form: plscmap1(r, g, b)\n\
4169 This function is used in example 31.\n\
4175 plscmap1(r, g, b, ncol1)\n\
4179 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4180 8-bit integers in the range from 0-255) the degree of red in the\n\
4181 color as a continuous function of the integer index of the vector.\n\
4183 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4184 8-bit integers in the range from 0-255) the degree of green in the\n\
4185 color as a continuous function of the integer index of the vector.\n\
4187 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4188 8-bit integers in the range from 0-255) the degree of blue in the\n\
4189 color as a continuous function of the integer index of the vector.\n\
4191 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4194 Configure the transformation between continuous and broken-down time for the current stream\n\
4198 Configure the transformation between continuous and broken-down time\n\
4199 for the current stream. This transformation is used by both plbtime\n\
4202 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4203 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4204 \t Perl/PDL: Not available?\n\
4207 This function is used in example 29.\n\
4213 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4217 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4218 As a special case, if\n\
4219 scale is 0., then all other arguments are ignored, and the result (the\n\
4220 default used by PLplot) is the equivalent of a call to\n\
4221 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4222 That is, for this special case broken-down time is calculated with\n\
4223 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4224 and the continuous time is defined as the number of seconds since\n\
4225 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4227 offset1 (PLFLT, input) : If\n\
4228 ifbtime_offset is true, the parameters\n\
4230 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4231 (with units in days) specify the epoch of the continuous time\n\
4232 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4233 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4234 are used to specify the origin to allow users (by specifying\n\
4235 offset1 as an integer that can be exactly represented by a\n\
4236 floating-point variable and specifying\n\
4237 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4238 the numerical errors of the continuous time representation.\n\
4240 offset2 (PLFLT, input) : See documentation of\n\
4243 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4244 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4245 calendar is used for broken-down time rather than the proleptic\n\
4246 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4247 have been historically used to define UTC are inserted into the\n\
4248 broken-down time. Other possibilities for additional control bits\n\
4249 for ccontrol exist such as making the historical time corrections\n\
4250 in the broken-down time corresponding to ET (ephemeris time) or\n\
4251 making the (slightly non-constant) corrections from international\n\
4252 atomic time (TAI) to what astronomers define as terrestrial time\n\
4253 (TT). But those additional possibilities have not been\n\
4254 implemented yet in the qsastime library (one of the PLplot utility\n\
4257 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4258 epoch of the continuous time scale is specified by the user. If\n\
4259 ifbtime_offset is false, then\n\
4261 offset2 are used to specify the epoch, and the following broken-down\n\
4262 time parameters are completely ignored. If\n\
4263 ifbtime_offset is true, then\n\
4265 offset2 are completely ignored, and the following broken-down time\n\
4266 parameters are used to specify the epoch.\n\
4268 year (PLINT, input) : Year of epoch.\n\
4270 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4273 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4275 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4277 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4279 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4282 Set length of minor ticks\n\
4286 This sets up the length of the minor ticks and the length of the\n\
4287 terminals on error bars. The actual length is the product of the\n\
4288 default length and a scaling factor as for character height.\n\
4290 Redacted form: plsmin(def, scale)\n\
4292 This function is used in example 29.\n\
4298 plsmin(def, scale)\n\
4302 def (PLFLT, input) : The default length of a minor tick in\n\
4303 millimeters, should be set to zero if the default length is to\n\
4304 remain unchanged.\n\
4306 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4307 actual tick length.\n\
4310 Set character size\n\
4314 This sets up the size of all subsequent characters drawn. The actual\n\
4315 height of a character is the product of the default character size and\n\
4316 a scaling factor.\n\
4318 Redacted form: plschr(def, scale)\n\
4320 This function is used in examples 2, 13, 23, and 24.\n\
4326 plschr(def, scale)\n\
4330 def (PLFLT, input) : The default height of a character in\n\
4331 millimeters, should be set to zero if the default height is to\n\
4332 remain unchanged. For rasterized drivers the dx and dy values\n\
4333 specified in plspage are used to convert from mm to pixels (note\n\
4334 the different unit systems used). This dpi aware scaling is not\n\
4335 implemented for all drivers yet.\n\
4337 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4338 actual character height.\n\
4341 Initialize PLplot\n\
4345 Initializing the plotting package.\tThe program prompts for the device\n\
4346 keyword or number of the desired output device. Hitting a RETURN in\n\
4347 response to the prompt is the same as selecting the first device.\n\
4348 plinit will issue no prompt if either the device was specified\n\
4349 previously (via command line flag, the plsetopt function, or the\n\
4350 plsdev function), or if only one device is enabled when PLplot is\n\
4351 installed.\tIf subpages have been specified, the output device is\n\
4352 divided into nx by ny subpages, each of which may be used\n\
4353 independently. If plinit is called again during a program, the\n\
4354 previously opened file will be closed. The subroutine pladv is used\n\
4355 to advance from one subpage to the next.\n\
4357 Redacted form: plinit()\n\
4359 This function is used in all of the examples.\n\
4368 Draw a box with axes, etc\n\
4372 Draws a box around the currently defined viewport, and labels it with\n\
4373 world coordinate values appropriate to the window.\tThus plbox should\n\
4374 only be called after defining both viewport and window. The ascii\n\
4375 character strings xopt and yopt specify how the box should be drawn as\n\
4376 described below. If ticks and/or subticks are to be drawn for a\n\
4377 particular axis, the tick intervals and number of subintervals may be\n\
4378 specified explicitly, or they may be defaulted by setting the\n\
4379 appropriate arguments to zero.\n\
4381 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4382 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4385 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4392 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4396 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4397 options for the x axis. The string can include any combination of\n\
4398 the following letters (upper or lower case) in any order: a: Draws\n\
4399 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4401 b: Draws bottom (X) or left (Y) edge of frame.\n\
4402 c: Draws top (X) or right (Y) edge of frame.\n\
4403 d: Plot labels as date / time. Values are assumed to be\n\
4404 seconds since the epoch (as used by gmtime).\n\
4405 f: Always use fixed point numeric labels.\n\
4406 g: Draws a grid at the major tick interval.\n\
4407 h: Draws a grid at the minor tick interval.\n\
4408 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4410 l: Labels axis logarithmically. This only affects the labels,\n\
4411 not the data, and so it is necessary to compute the logarithms\n\
4412 of data points before passing them to any of the drawing\n\
4414 m: Writes numeric labels at major tick intervals in the\n\
4415 unconventional location (above box for X, right of box for Y).\n\
4416 n: Writes numeric labels at major tick intervals in the\n\
4417 conventional location (below box for X, left of box for Y).\n\
4418 o: Use custom labelling function to generate axis label text.\n\
4419 The custom labelling function can be defined with the\n\
4420 plslabelfunc command.\n\
4421 s: Enables subticks between major ticks, only valid if t is\n\
4423 t: Draws major ticks.\n\
4424 u: Exactly like \"b\" except don\'t draw edge line.\n\
4425 w: Exactly like \"c\" except don\'t draw edge line.\n\
4426 x: Exactly like \"t\" (including the side effect of the\n\
4427 numerical labels for the major ticks) except exclude drawing\n\
4428 the major and minor tick marks.\n\
4431 xtick (PLFLT, input) : World coordinate interval between major\n\
4432 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4433 generates a suitable tick interval.\n\
4435 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4436 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4437 generates a suitable minor tick interval.\n\
4439 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4440 options for the y axis. The string can include any combination of\n\
4441 the letters defined above for xopt, and in addition may contain:\n\
4442 v: Write numeric labels for the y axis parallel to the base of the\n\
4443 graph, rather than parallel to the axis.\n\
4446 ytick (PLFLT, input) : World coordinate interval between major\n\
4447 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4448 generates a suitable tick interval.\n\
4450 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4451 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4452 generates a suitable minor tick interval.\n\
4455 Get parameters that define current device-space window\n\
4459 Get relative margin width, aspect ratio, and relative justification\n\
4460 that define current device-space window. If plsdidev has not been\n\
4461 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4462 p_jy will all be 0.\n\
4464 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4466 This function is used in example 31.\n\
4472 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4476 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4479 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4482 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4483 justification in x.\n\
4485 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4486 justification in y.\n\
4489 Plot a glyph at the specified points\n\
4493 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4494 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4495 is specified with a PLplot user string. Note that the user string is\n\
4496 not actually limited to one glyph so it is possible (but not normally\n\
4497 useful) to plot more than one glyph at the specified points with this\n\
4498 function. As with plmtex and plptex, the user string can contain FCI\n\
4499 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4500 else PLplot escapes for Hershey or unicode text to determine the\n\
4503 Redacted form: plstring(x, y, string)\n\
4505 This function is used in examples 4, 21 and 26.\n\
4511 plstring(n, x, y, string)\n\
4515 n (PLINT, input) : Number of points in the x and y vectors.\n\
4517 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4520 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4523 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4524 the glyph(s) to be plotted at each of the n points.\n\
4527 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4531 As per plmapline, however the items are plotted as strings or points\n\
4532 in the same way as plstring.\n\
4534 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4535 maxy, plotentries)\n\
4537 This function is not used in any examples.\n\
4543 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4547 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4548 transform the coordinates given in the shapefile into a plot\n\
4549 coordinate system. By using this transform, we can change from a\n\
4550 longitude, latitude coordinate to a polar stereographic project,\n\
4551 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4552 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4553 mapform(), x[] and y[] should be replaced by the corresponding\n\
4554 plot coordinates. If no transform is desired, mapform can be\n\
4555 replaced by NULL.\n\
4557 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4558 the file name of a set of Shapefile files without the file\n\
4561 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4564 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4565 be in the same units as used by the Shapefile. You could use a\n\
4566 very large negative number to plot everything, but you can improve\n\
4567 performance by limiting the area drawn. The units must match those\n\
4568 of the Shapefile projection, which may be for example longitude or\n\
4569 distance. The value of minx must be less than the value of maxx.\n\
4571 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4572 use a very large number to plot everything, but you can improve\n\
4573 performance by limiting the area drawn.\n\
4575 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4576 be in the same units as used by the Shapefile. You could use a\n\
4577 very large negative number to plot everything, but you can improve\n\
4578 performance by limiting the area drawn. The units must match those\n\
4579 of the Shapefile projection, which may be for example latitude or\n\
4580 distance. The value of miny must be less than the value of maxy.\n\
4582 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4583 use a very large number to plot everything, but you can improve\n\
4584 performance by limiting the area drawn.\n\
4586 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4587 zero-based indices of the Shapefile elements which will be drawn.\n\
4589 plotentries to NULL will plot all elements of the Shapefile.\n\
4591 nplotentries (PLINT, input) : The number of items in\n\
4592 plotentries. Ignored if\n\
4593 plotentries is NULL.\n\
4596 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4600 Sets up plotter environment for simple graphs by calling pladv and\n\
4601 setting up viewport and window to sensible default values. plenv0\n\
4602 leaves a standard margin (left-hand margin of eight character heights,\n\
4603 and a margin around the other three sides of five character heights)\n\
4604 around most graphs for axis labels and a title. When these defaults\n\
4605 are not suitable, use the individual routines plvpas, plvpor, or\n\
4606 plvasp for setting up the viewport, plwind for defining the window,\n\
4607 and plbox for drawing the box.\n\
4609 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4611 This function is used in example 21.\n\
4617 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4621 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4622 world coordinates).\n\
4624 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4625 world coordinates).\n\
4627 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4630 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4633 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4634 scales will not be set, the user must set up the scale before\n\
4635 calling plenv0 using plsvpa, plvasp or other.\n\
4636 0: the x and y axes are scaled independently to use as much of\n\
4637 the screen as possible.\n\
4638 1: the scales of the x and y axes are made equal.\n\
4639 2: the axis of the x and y axes are made equal, and the plot\n\
4640 box will be square.\n\
4643 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4644 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4645 -1: draw box only.\n\
4646 0: draw box, ticks, and numeric tick labels.\n\
4647 1: also draw coordinate axes at x=0 and y=0.\n\
4648 2: also draw a grid at major tick positions in both\n\
4650 3: also draw a grid at minor tick positions in both\n\
4652 10: same as 0 except logarithmic x tick marks. (The x data\n\
4653 have to be converted to logarithms separately.)\n\
4654 11: same as 1 except logarithmic x tick marks. (The x data\n\
4655 have to be converted to logarithms separately.)\n\
4656 12: same as 2 except logarithmic x tick marks. (The x data\n\
4657 have to be converted to logarithms separately.)\n\
4658 13: same as 3 except logarithmic x tick marks. (The x data\n\
4659 have to be converted to logarithms separately.)\n\
4660 20: same as 0 except logarithmic y tick marks. (The y data\n\
4661 have to be converted to logarithms separately.)\n\
4662 21: same as 1 except logarithmic y tick marks. (The y data\n\
4663 have to be converted to logarithms separately.)\n\
4664 22: same as 2 except logarithmic y tick marks. (The y data\n\
4665 have to be converted to logarithms separately.)\n\
4666 23: same as 3 except logarithmic y tick marks. (The y data\n\
4667 have to be converted to logarithms separately.)\n\
4668 30: same as 0 except logarithmic x and y tick marks. (The x\n\
4669 and y data have to be converted to logarithms separately.)\n\
4670 31: same as 1 except logarithmic x and y tick marks. (The x\n\
4671 and y data have to be converted to logarithms separately.)\n\
4672 32: same as 2 except logarithmic x and y tick marks. (The x\n\
4673 and y data have to be converted to logarithms separately.)\n\
4674 33: same as 3 except logarithmic x and y tick marks. (The x\n\
4675 and y data have to be converted to logarithms separately.)\n\
4676 40: same as 0 except date / time x labels.\n\
4677 41: same as 1 except date / time x labels.\n\
4678 42: same as 2 except date / time x labels.\n\
4679 43: same as 3 except date / time x labels.\n\
4680 50: same as 0 except date / time y labels.\n\
4681 51: same as 1 except date / time y labels.\n\
4682 52: same as 2 except date / time y labels.\n\
4683 53: same as 3 except date / time y labels.\n\
4684 60: same as 0 except date / time x and y labels.\n\
4685 61: same as 1 except date / time x and y labels.\n\
4686 62: same as 2 except date / time x and y labels.\n\
4687 63: same as 3 except date / time x and y labels.\n\
4688 70: same as 0 except custom x and y labels.\n\
4689 71: same as 1 except custom x and y labels.\n\
4690 72: same as 2 except custom x and y labels.\n\
4691 73: same as 3 except custom x and y labels.\n\
4694 Configure the transformations required for projecting a 3D surface on a 2D window\n\
4698 Configure the transformations required for projecting a 3D surface on\n\
4699 an existing 2D window. Those transformations (see the PLplot\n\
4700 documentation) are done to a rectangular cuboid enclosing the 3D\n\
4701 surface which has its limits expressed in 3D world coordinates and\n\
4702 also normalized 3D coordinates (used for interpreting the altitude and\n\
4703 azimuth of the viewing angle). The transformations consist of the\n\
4704 linear transform from 3D world coordinates to normalized 3D\n\
4705 coordinates, and the 3D rotation of normalized coordinates required to\n\
4706 align the pole of the new 3D coordinate system with the viewing\n\
4707 direction specified by altitude and azimuth so that x and y of the\n\
4708 surface elements in that transformed coordinate system are the\n\
4709 projection of the 3D surface with given viewing direction on the 2D\n\
4712 The enclosing rectangular cuboid for the surface plot is defined by\n\
4713 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
4714 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
4715 sizes of basex by basey by height so that xmin maps to -\n\
4716 basex/2, xmax maps to basex/2, ymin maps to -\n\
4717 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4718 The resulting rectangular cuboid in normalized coordinates is then\n\
4719 viewed by an observer at altitude alt and azimuth az. This routine\n\
4720 must be called before plbox3 or any of the 3D surface plotting\n\
4721 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
4722 plsurf3dl or plfill3.\n\
4724 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4725 zmin, zmax, alt, az)\n\
4727 This function is examples 8, 11, 18, and 21.\n\
4733 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4737 basex (PLFLT, input) : The normalized x coordinate size of the\n\
4738 rectangular cuboid.\n\
4740 basey (PLFLT, input) : The normalized y coordinate size of the\n\
4741 rectangular cuboid.\n\
4743 height (PLFLT, input) : The normalized z coordinate size of the\n\
4744 rectangular cuboid.\n\
4746 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
4747 rectangular cuboid.\n\
4749 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
4750 rectangular cuboid.\n\
4752 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
4753 rectangular cuboid.\n\
4755 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
4756 rectangular cuboid.\n\
4758 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
4759 rectangular cuboid.\n\
4761 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
4762 rectangular cuboid.\n\
4764 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
4765 plane of the rectangular cuboid in normalized coordinates.\n\
4767 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
4768 rectangular cuboid in normalized coordinates. When az=0, the\n\
4769 observer is looking face onto the zx plane of the rectangular\n\
4770 cuboid in normalized coordinates, and as az is increased, the\n\
4771 observer moves clockwise around that cuboid when viewed from above\n\
4775 Draw filled polygon\n\
4779 Fills the polygon defined by the n points (\n\
4781 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4782 style is a solid fill. The routine will automatically close the\n\
4783 polygon between the last and first vertices. If multiple closed\n\
4784 polygons are passed in x and y then plfill will fill in between them.\n\
4786 Redacted form: plfill(x,y)\n\
4788 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4798 n (PLINT, input) : Number of vertices in polygon.\n\
4800 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4803 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4807 Magnitude colored plot surface with contour\n\
4811 Aside from dropping the\n\
4812 side functionality this is a more powerful form of plot3d: the surface\n\
4813 mesh can be colored accordingly to the current z value being plotted,\n\
4814 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
4815 drawn between the plotted function border and the base XY plane. The\n\
4816 arguments are identical to those of plmeshc. The only difference\n\
4817 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
4818 the surface, while plot3dc only draws the surface as viewed from the\n\
4821 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
4822 \t Perl/PDL: Not available?\n\
4825 This function is used in example 21.\n\
4831 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4835 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4836 which the function is evaluated.\n\
4838 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4839 which the function is evaluated.\n\
4841 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4842 plot. Should have dimensions of\n\
4846 nx (PLINT, input) : Number of x values at which function is\n\
4849 ny (PLINT, input) : Number of y values at which function is\n\
4852 opt (PLINT, input) : Determines the way in which the surface is\n\
4853 represented. To specify more than one option just add the options,\n\
4854 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
4855 showing z as a function of x for each value of y[j] .\n\
4856 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4857 for each value of x[i] .\n\
4858 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4859 at which function is defined.\n\
4860 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
4861 the z value being plotted. The color is used from the current\n\
4863 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4867 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4868 the borders of the plotted function.\n\
4871 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4874 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4877 Write text relative to viewport boundaries\n\
4881 Writes text at a specified position relative to the viewport\n\
4882 boundaries. Text may be written inside or outside the viewport, but\n\
4883 is clipped at the subpage boundaries. The reference point of a string\n\
4884 lies along a line passing through the string at half the height of a\n\
4885 capital letter. The position of the reference point along this line\n\
4886 is determined by just, and the position of the reference point\n\
4887 relative to the viewport is set by disp and pos.\n\
4889 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4890 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4893 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
4900 plmtex(side, disp, pos, just, text)\n\
4904 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4905 the side of the viewport along which the text is to be written.\n\
4906 The string must be one of: b: Bottom of viewport, text written\n\
4907 parallel to edge.\n\
4908 bv: Bottom of viewport, text written at right angles to edge.\n\
4909 l: Left of viewport, text written parallel to edge.\n\
4910 lv: Left of viewport, text written at right angles to edge.\n\
4911 r: Right of viewport, text written parallel to edge.\n\
4912 rv: Right of viewport, text written at right angles to edge.\n\
4913 t: Top of viewport, text written parallel to edge.\n\
4914 tv: Top of viewport, text written at right angles to edge.\n\
4917 disp (PLFLT, input) : Position of the reference point of string,\n\
4918 measured outwards from the specified viewport edge in units of the\n\
4919 current character height. Use negative disp to write within the\n\
4922 pos (PLFLT, input) : Position of the reference point of string\n\
4923 along the specified edge, expressed as a fraction of the length of\n\
4926 just (PLFLT, input) : Specifies the position of the string relative\n\
4927 to its reference point. If just=0. , the reference point is at\n\
4928 the left and if just=1. , it is at the right of the string. Other\n\
4929 values of just give intermediate justifications.\n\
4931 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4935 Set arrow style for vector plots\n\
4939 Set the style for the arrow used by plvect to plot vectors.\n\
4941 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4943 This function is used in example 22.\n\
4949 plsvect(arrowx, arrowy, npts, fill)\n\
4953 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4954 the x and y points which make up the arrow. The arrow is plotted\n\
4955 by joining these points to form a polygon. The scaling assumes\n\
4956 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4957 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4958 will be reset to its default.\n\
4960 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4963 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4964 fill is false then the arrow is open.\n\
4967 Get family file parameters\n\
4971 Gets information about current family file, if familying is enabled.\n\
4972 See the PLplot documentation for more information.\n\
4974 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
4976 This function is used in examples 14 and 31.\n\
4982 plgfam(p_fam, p_num, p_bmax)\n\
4986 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
4987 family flag value. If nonzero, familying is enabled for the\n\
4990 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
4991 family file number.\n\
4993 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4994 file size (in bytes) for a family file.\n\
4997 Random number generator returning a real random number in the range [0,1]\n\
5001 Random number generator returning a real random number in the range\n\
5002 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5003 / compilers provide their own random number generator, and so this is\n\
5004 provided purely for convenience and to give a consistent random number\n\
5005 generator across all languages supported by PLplot. This is\n\
5006 particularly useful for comparing results from the test suite of\n\
5009 Redacted form: plrandd()\n\
5011 This function is used in examples 17 and 21.\n\
5024 Draws a contour plot of the data in f[\n\
5026 ny], using the nlevel contour levels specified by clevel. Only the\n\
5027 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5028 where all these index ranges are interpreted as one-based for\n\
5029 historical reasons. A transformation routine pointed to by pltr with\n\
5030 a generic pointer pltr_data for additional data required by the\n\
5031 transformation routine is used to map indices within the matrix to the\n\
5032 world coordinates.\n\
5034 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5035 where (see above discussion) the pltr, pltr_data callback arguments\n\
5036 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5037 vectors; or xg and yg matrices.\n\
5039 This function is used in examples 9, 14, 16, and 22.\n\
5045 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5049 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5051 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5053 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5054 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5055 zero-based for historical backwards-compatibility reasons.\n\
5057 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5058 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5059 zero-based for historical backwards-compatibility reasons.\n\
5061 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5062 which to draw contours.\n\
5064 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5066 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5067 defines the transformation between the zero-based indices of the\n\
5068 matrix f and the world coordinates.For the C case, transformation\n\
5069 functions are provided in the PLplot library: pltr0 for the\n\
5070 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5071 respectively defined by vectors and matrices. In addition, C\n\
5072 callback routines for the transformation can be supplied by the\n\
5073 user such as the mypltr function in examples/c/x09c.c which\n\
5074 provides a general linear transformation between index coordinates\n\
5075 and world coordinates.For languages other than C you should\n\
5076 consult the PLplot documentation for the details concerning how\n\
5077 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5078 general, a particular pattern of callback-associated arguments\n\
5079 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5080 yg matrices are respectively interfaced to a linear-transformation\n\
5081 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5082 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5083 the PLplot documentation) support native language callbacks for\n\
5084 handling index to world-coordinate transformations. Examples of\n\
5085 these various approaches are given in examples/<language>x09*,\n\
5086 examples/<language>x16*, examples/<language>x20*,\n\
5087 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5088 supported languages.\n\
5090 pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
5091 pass information to pltr0, pltr1, pltr2, or whatever callback\n\
5092 routine that is externally supplied.\n\
5099 This sets up the line style for all lines subsequently drawn. A line\n\
5100 consists of segments in which the pen is alternately down and up. The\n\
5101 lengths of these segments are passed in the vectors mark and space\n\
5102 respectively. The number of mark-space pairs is specified by nms.\tIn\n\
5103 order to return the line style to the default continuous line, plstyl\n\
5104 should be called with nms =0 .(see also pllsty)\n\
5106 Redacted form: plstyl(mark, space)\n\
5108 This function is used in examples 1, 9, and 14.\n\
5114 plstyl(nms, mark, space)\n\
5118 nms (PLINT, input) : The number of mark and space elements in a\n\
5119 line. Thus a simple broken line can be obtained by setting nms=1\n\
5120 . A continuous line is specified by setting nms=0 .\n\
5122 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5123 segments during which the pen is down, measured in micrometers.\n\
5125 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5126 the segments during which the pen is up, measured in micrometers.\n\
5129 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5133 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5135 Redacted form: plspal0(filename)\n\
5137 This function is in example 16.\n\
5143 plspal0(filename)\n\
5147 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5148 containing the name of the cmap0*.pal file. If this string is\n\
5149 empty, use the default cmap0*.pal file.\n\
5152 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5156 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5158 Redacted form: plspal1(filename, interpolate)\n\
5160 This function is used in example 16.\n\
5166 plspal1(filename, interpolate)\n\
5170 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5171 containing the name of the cmap1*.pal file. If this string is\n\
5172 empty, use the default cmap1*.pal file.\n\
5174 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5175 columns containing the intensity index, r, g, b, alpha and\n\
5176 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5177 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5178 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5179 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5180 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5181 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5182 are used instead to set the cmap1 palette directly with a call to\n\
5186 Set current output stream\n\
5190 Sets the number of the current output stream. The stream number\n\
5191 defaults to 0 unless changed by this routine. The first use of this\n\
5192 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5194 Redacted form: plsstrm(strm)\n\
5196 This function is examples 1,14,20.\n\
5206 strm (PLINT, input) : The current stream number.\n\
5209 Specify viewport using normalized subpage coordinates\n\
5213 Device-independent routine for setting up the viewport. This defines\n\
5214 the viewport in terms of normalized subpage coordinates which run from\n\
5215 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5216 current subpage. Use the alternate routine plsvpa in order to create\n\
5217 a viewport of a definite size.\n\
5219 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5221 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5222 24, 26, 27, and 31.\n\
5228 plvpor(xmin, xmax, ymin, ymax)\n\
5232 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5233 left-hand edge of the viewport.\n\
5235 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5236 right-hand edge of the viewport.\n\
5238 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5239 bottom edge of the viewport.\n\
5241 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5242 edge of the viewport.\n\
5245 Write text inside the viewport\n\
5249 Writes text at a specified position and inclination within the\n\
5250 viewport. Text is clipped at the viewport boundaries. The reference\n\
5251 point of a string lies along a line passing through the string at half\n\
5252 the height of a capital letter. The position of the reference point\n\
5253 along this line is determined by just, the reference point is placed\n\
5254 at world coordinates (\n\
5256 y)\twithin the viewport. The inclination of the string is specified\n\
5257 in terms of differences of world coordinates making it easy to write\n\
5258 text parallel to a line in a graph.\n\
5260 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5262 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5268 plptex(x, y, dx, dy, just, text)\n\
5272 x (PLFLT, input) : x coordinate of reference point of string.\n\
5274 y (PLFLT, input) : y coordinate of reference point of string.\n\
5276 dx (PLFLT, input) : Together with dy, this specifies the\n\
5277 inclination of the string. The baseline of the string is parallel\n\
5278 to a line joining (\n\
5286 dy (PLFLT, input) : Together with dx, this specifies the\n\
5287 inclination of the string.\n\
5289 just (PLFLT, input) : Specifies the position of the string relative\n\
5290 to its reference point. If just=0. , the reference point is at\n\
5291 the left and if just=1. , it is at the right of the string. Other\n\
5292 values of just give intermediate justifications.\n\
5294 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5298 Set z axis parameters\n\
5302 Identical to plsxax, except that arguments are flags for z axis. See\n\
5303 the description of plsxax for more detail.\n\
5305 Redacted form: plszax(digmax, digits)\n\
5307 This function is used in example 31.\n\
5313 plszax(digmax, digits)\n\
5317 digmax (PLINT, input) : Variable to set the maximum number of\n\
5318 digits for the z axis. If nonzero, the printed label will be\n\
5319 switched to a floating-point representation when the number of\n\
5320 digits exceeds digmax.\n\
5322 digits (PLINT, input) : Field digits value. Currently, changing\n\
5323 its value here has no effect since it is set only by plbox or\n\
5324 plbox3. However, the user may obtain its value after a call to\n\
5325 either of these functions by calling plgzax.\n\
5328 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5332 This variant of plsurf3d (see that function\'s documentation for more\n\
5333 details) should be suitable for the case where the area of the x, y\n\
5334 coordinate grid where z is defined can be non-rectangular.\tThe limits\n\
5335 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5336 indexymin, and indexymax.\n\
5338 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5341 This function is used in example 8.\n\
5347 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5351 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5352 which the function is evaluated.\n\
5354 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5355 which the function is evaluated.\n\
5357 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5358 plot. Should have dimensions of\n\
5362 nx (PLINT, input) : Number of x values at which function is\n\
5365 ny (PLINT, input) : Number of y values at which function is\n\
5368 opt (PLINT, input) : Determines the way in which the surface is\n\
5369 represented. To specify more than one option just add the options,\n\
5370 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5371 connecting points at which function is defined.\n\
5372 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5376 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5380 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5381 the borders of the plotted function.\n\
5382 opt=MAG_COLOR : the surface is colored according to the value\n\
5383 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5384 according to the intensity of the reflected light in the\n\
5385 surface from a light source whose position is set using\n\
5389 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5392 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5394 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5395 corresponds to the first x index where z is defined.\n\
5397 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5398 which corresponds (by convention) to one more than the last x\n\
5399 index value where z is defined.\n\
5401 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5402 values which all must be ≥ 0. These values are the first y index\n\
5403 where z is defined for a particular x index in the range from\n\
5404 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5407 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5408 values which all must be ≤ ny. These values correspond (by\n\
5409 convention) to one more than the last y index where z is defined\n\
5410 for a particular x index in the range from indexxmin to indexxmax\n\
5411 - 1. The dimension of indexymax is indexxmax.\n\
5418 Sets the font used for subsequent text and symbols. For devices that\n\
5419 still use Hershey fonts this routine has no effect unless the Hershey\n\
5420 fonts with extended character set are loaded (see plfontld). For\n\
5421 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5422 this routine calls the plsfci routine with argument set up\n\
5423 appropriately for the various cases below.\tHowever, this method of\n\
5424 specifying the font for unicode-aware devices is deprecated, and the\n\
5425 much more flexible method of calling plsfont directly is recommended\n\
5426 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5428 Redacted form: plfont(ifont)\n\
5430 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5440 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5441 (simplest and fastest)\n\
5447 Get the cmap1 argument range for continuous color plots\n\
5451 Get the cmap1 argument range for continuous color plots. (Use\n\
5452 plscmap1_range to set the cmap1 argument range.)\n\
5454 Redacted form: plgcmap1_range(min_color, max_color)\n\
5456 This function is currently not used in any example.\n\
5462 plgcmap1_range(min_color, max_color)\n\
5466 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5467 minimum cmap1 argument.\n\
5469 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5470 maximum cmap1 argument.\n\
5473 Set the cmap1 argument range for continuous color plots\n\
5477 Set the cmap1 argument range for continuous color plots that\n\
5478 corresponds to the range of data values. The maximum range\n\
5479 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5480 the cmap1 argument range that is specified with this routine, the\n\
5481 smaller the subset of the cmap1 color palette that is used to\n\
5482 represent the continuous data being plotted. If\n\
5483 min_color is greater than\n\
5485 max_color is greater than 1.0 or\n\
5486 min_color is less than 0.0 then no change is made to the cmap1\n\
5487 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5489 Redacted form: plscmap1_range(min_color, max_color)\n\
5491 This function is currently used in example 33.\n\
5497 plscmap1_range(min_color, max_color)\n\
5501 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5502 than 0.0, then 0.0 is used instead.\n\
5504 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5505 than 1.0, then 1.0 is used instead.\n\
5508 Draw a circular or elliptical arc\n\
5512 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5513 semiminor axis b, starting at angle1 and ending at angle2.\n\
5515 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5519 This function is used in examples 3 and 27.\n\
5525 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5529 x (PLFLT, input) : X coordinate of arc center.\n\
5531 y (PLFLT, input) : Y coordinate of arc center.\n\
5533 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5535 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5537 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5540 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5543 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5546 fill (PLBOOL, input) : Draw a filled arc.\n\
5549 Plot 3-d surface plot\n\
5553 Plots a three-dimensional surface plot within the environment set up\n\
5554 by plw3d. The surface is defined by the matrix z[\n\
5556 ny] , the point z[i][j] being the value of the function at (\n\
5558 y[j]). Note that the points in vectors x and y do not need to be\n\
5559 equally spaced, but must be stored in ascending order. The parameter\n\
5560 opt controls the way in which the surface is displayed. For further\n\
5561 details see the PLplot documentation. The only difference between\n\
5562 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5563 while plot3d only draws the surface as viewed from the top.\n\
5565 Redacted form: plot3d(x, y, z, opt, side)\n\
5567 This function is used in examples 11 and 21.\n\
5573 plot3d(x, y, z, nx, ny, opt, side)\n\
5577 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5578 which the function is evaluated.\n\
5580 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5581 which the function is evaluated.\n\
5583 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5584 plot. Should have dimensions of\n\
5588 nx (PLINT, input) : Number of x values at which function is\n\
5591 ny (PLINT, input) : Number of y values at which function is\n\
5594 opt (PLINT, input) : Determines the way in which the surface is\n\
5595 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5596 function of x for each value of y[j] .\n\
5597 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5598 for each value of x[i] .\n\
5599 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5600 at which function is defined.\n\
5603 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5604 should be draw on the figure. If side is true sides are drawn,\n\
5605 otherwise no sides are drawn.\n\
5608 Set area line fill pattern\n\
5612 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5613 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5614 inclinations and spacings.\tThe arguments to this routine are the\n\
5615 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5616 elements) specifying the inclinations in tenths of a degree and the\n\
5617 spacing in micrometers. (See also plpsty)\n\
5619 Redacted form: General: plpat(inc, del)\n\
5620 \t Perl/PDL: plpat(nlin, inc, del)\n\
5623 This function is used in example 15.\n\
5629 plpat(nlin, inc, del)\n\
5633 nlin (PLINT, input) : Number of sets of lines making up the\n\
5634 pattern, either 1 or 2.\n\
5636 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5637 inclination in tenths of a degree. (Should be between -900 and\n\
5640 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5641 spacing in micrometers between the lines making up the pattern.\n\
5644 Get x axis parameters\n\
5648 Returns current values of the p_digmax and p_digits flags for the x\n\
5649 axis. p_digits is updated after the plot is drawn, so this routine\n\
5650 should only be called after the call to plbox (or plbox3) is complete.\n\
5651 See the PLplot documentation for more information.\n\
5653 Redacted form: plgxax(p_digmax, p_digits)\n\
5655 This function is used in example 31.\n\
5661 plgxax(p_digmax, p_digits)\n\
5665 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5666 number of digits for the x axis. If nonzero, the printed label\n\
5667 has been switched to a floating-point representation when the\n\
5668 number of digits exceeds this value.\n\
5670 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5671 number of digits for the numeric labels (x axis) from the last\n\
5675 Draw filled polygon in 3D\n\
5679 Fills the 3D polygon defined by the n points in the x, y, and z\n\
5680 vectors using the pattern defined by plpsty or plpat. The routine\n\
5681 will automatically close the polygon between the last and first\n\
5682 vertices. If multiple closed polygons are passed in x, y, and z then\n\
5683 plfill3 will fill in between them.\n\
5685 Redacted form: General: plfill3(x, y, z)\n\
5686 \t Perl/PDL: plfill3(n, x, y, z)\n\
5689 This function is used in example 15.\n\
5695 plfill3(n, x, y, z)\n\
5699 n (PLINT, input) : Number of vertices in polygon.\n\
5701 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5704 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5707 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5715 Sets the color index for cmap0 (see the PLplot documentation).\n\
5717 Redacted form: plcol0(icol0)\n\
5719 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
5729 icol0 (PLINT, input) : Integer representing the color. The\n\
5730 defaults at present are (these may change):\n\
5731 0 black (default background)\n\
5732 1 red (default foreground)\n\
5748 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
5749 change an individual color in the cmap0 color palette.\n\
5752 Draw text at points defined by Shapefile data in world coordinates\n\
5756 As per plmapline, however the items are plotted as text in the same\n\
5759 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
5760 miny, maxy, plotentry)\n\
5762 This function is used in example 19.\n\
5768 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
5772 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5773 transform the coordinates given in the shapefile into a plot\n\
5774 coordinate system. By using this transform, we can change from a\n\
5775 longitude, latitude coordinate to a polar stereographic project,\n\
5776 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5777 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5778 mapform(), x[] and y[] should be replaced by the corresponding\n\
5779 plot coordinates. If no transform is desired, mapform can be\n\
5780 replaced by NULL.\n\
5782 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5783 the file name of a set of Shapefile files without the file\n\
5786 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
5789 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
5792 just (PLFLT, input) : Set the justification of the text. The value\n\
5793 given will be the fraction of the distance along the string that\n\
5794 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
5795 centralized text and 1.0 gives right aligned text.\n\
5797 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
5799 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5800 be in the same units as used by the Shapefile. You could use a\n\
5801 very large negative number to plot everything, but you can improve\n\
5802 performance by limiting the area drawn. The units must match those\n\
5803 of the Shapefile projection, which may be for example longitude or\n\
5804 distance. The value of minx must be less than the value of maxx.\n\
5806 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5807 use a very large number to plot everything, but you can improve\n\
5808 performance by limiting the area drawn.\n\
5810 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5811 be in the same units as used by the Shapefile. You could use a\n\
5812 very large negative number to plot everything, but you can improve\n\
5813 performance by limiting the area drawn. The units must match those\n\
5814 of the Shapefile projection, which may be for example latitude or\n\
5815 distance. The value of miny must be less than the value of maxy.\n\
5817 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5818 use a very large number to plot everything, but you can improve\n\
5819 performance by limiting the area drawn.\n\
5821 plotentry (PLINT, input) : An integer indicating which text string\n\
5822 of the Shapefile (zero indexed) will be drawn.\n\
5825 Draw a line between two points\n\
5829 Joins the point (\n\
5835 Redacted form: pljoin(x1,y1,x2,y2)\n\
5837 This function is used in examples 3 and 14.\n\
5843 pljoin(x1, y1, x2, y2)\n\
5847 x1 (PLFLT, input) : x coordinate of first point.\n\
5849 y1 (PLFLT, input) : y coordinate of first point.\n\
5851 x2 (PLFLT, input) : x coordinate of second point.\n\
5853 y2 (PLFLT, input) : y coordinate of second point.\n\
5860 Sets the color for cmap1 (see the PLplot documentation).\n\
5862 Redacted form: plcol1(col1)\n\
5864 This function is used in examples 12 and 21.\n\
5874 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
5875 is mapped to color using the continuous cmap1 palette which by\n\
5876 default ranges from blue to the background color to red. The\n\
5877 cmap1 palette can also be straightforwardly changed by the user\n\
5878 with plscmap1 or plscmap1l.\n\
5885 Set integer plot orientation parameter. This function is identical to\n\
5886 plsdiori except for the type of the argument, and should be used in\n\
5887 the same way. See the documentation of plsdiori for details.\n\
5889 Redacted form: plsori(ori)\n\
5891 This function is used in example 3.\n\
5901 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5902 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5906 Calculate continuous time from broken-down time for the current stream\n\
5910 Calculate continuous time, ctime, from broken-down time for the\n\
5911 current stream. The broken-down\n\
5912 time is specified by the following parameters: year, month, day, hour,\n\
5913 min, and sec. This function is the inverse of plbtime.\n\
5915 The PLplot definition of broken-down time is a calendar time that\n\
5916 completely ignores all time zone offsets, i.e., it is the user\'s\n\
5917 responsibility to apply those offsets (if so desired) before using the\n\
5918 PLplot time API. By default broken-down time is defined using the\n\
5919 proleptic Gregorian calendar without the insertion of leap seconds and\n\
5920 continuous time is defined as the number of seconds since the Unix\n\
5921 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
5922 broken-down and continuous time are possible, see plconfigtime which\n\
5923 specifies that transformation for the current stream.\n\
5925 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
5927 \t Perl/PDL: Not available?\n\
5930 This function is used in example 29.\n\
5936 plctime(year, month, day, hour, min, sec, ctime)\n\
5940 year (PLINT, input) : Input year.\n\
5942 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
5945 day (PLINT, input) : Input day in range from 1 to 31.\n\
5947 hour (PLINT, input) : Input hour in range from 0 to 23\n\
5949 min (PLINT, input) : Input minute in range from 0 to 59.\n\
5951 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
5953 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continous\n\
5954 time calculated from the broken-down time specified by the\n\
5955 previous parameters.\n\
5958 Plot continental outline or shapefile data in world coordinates\n\
5962 Plots continental outlines or shapefile data in world coordinates. A\n\
5963 demonstration of how to use this function to create different\n\
5964 projections can be found in examples/c/x19c. PLplot is provided with\n\
5965 basic coastal outlines and USA state borders. These can be used\n\
5966 irrespective of whether Shapefile support is built into PLplot. With\n\
5967 Shapefile support this function can also be used with user Shapefiles,\n\
5968 in which case it will plot the entire contents of a Shapefile joining\n\
5969 each point of each Shapefile element with a line. Shapefiles have\n\
5970 become a popular standard for geographical data and data in this\n\
5971 format can be easily found from a number of online sources. Shapefile\n\
5972 data is actually provided as three or more files with the same\n\
5973 filename, but different extensions. The .shp and .shx files are\n\
5974 required for plotting Shapefile data with PLplot.\n\
5976 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5978 This function is used in example 19.\n\
5984 plmap(mapform, name, minx, maxx, miny, maxy)\n\
5988 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5989 transform the original map data coordinates to a new coordinate\n\
5990 system. The PLplot-supplied map data is provided as latitudes and\n\
5991 longitudes; other Shapefile data may be provided in other\n\
5992 coordinate systems as can be found in their .prj plain text files.\n\
5993 For example, by using this transform we can change from a\n\
5994 longitude, latitude coordinate to a polar stereographic\n\
5995 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5996 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5997 corresponding y coordinates (latitudes for the PLplot supplied\n\
5998 data). After the call to mapform(), x[] and y[] should be\n\
5999 replaced by the corresponding plot coordinates. If no transform is\n\
6000 desired, mapform can be replaced by NULL.\n\
6002 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6003 the type of map plotted. This is either one of the PLplot built-in\n\
6004 maps or the file name of a set of Shapefile files without the file\n\
6005 extensions. For the PLplot built-in maps the possible values are:\n\
6006 \"globe\" -- continental outlines\n\
6007 \"usa\" -- USA and state boundaries\n\
6008 \"cglobe\" -- continental outlines and countries\n\
6009 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6012 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6013 drawn. For the built in maps this is a measure of longitude. For\n\
6014 Shapefiles the units must match the projection. The value of minx\n\
6015 must be less than the value of maxx. Specifying a useful limit for\n\
6016 these limits provides a useful optimization for complex or\n\
6019 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6022 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6023 drawn. For the built in maps this is a measure of latitude. For\n\
6024 Shapefiles the units must match the projection. The value of miny\n\
6025 must be less than the value of maxy.\n\
6027 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6031 Calculate broken-down time from continuous time for the current stream\n\
6035 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6036 continuous time, ctime for the current stream. This function is the\n\
6037 inverse of plctime.\n\
6039 The PLplot definition of broken-down time is a calendar time that\n\
6040 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6041 responsibility to apply those offsets (if so desired) before using the\n\
6042 PLplot time API. By default broken-down time is defined using the\n\
6043 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6044 continuous time is defined as the number of seconds since the Unix\n\
6045 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6046 broken-down and continuous time are possible, see plconfigtime.\n\
6048 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6050 \t Perl/PDL: Not available?\n\
6053 This function is used in example 29.\n\
6059 plbtime(year, month, day, hour, min, sec, ctime)\n\
6063 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6064 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6065 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6068 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6069 the year in the range from 0 (January) to 11 (December).\n\
6071 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6072 month in the range from 1 to 31.\n\
6074 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6075 day in the range from 0 to 23.\n\
6077 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6078 hour in the range from 0 to 59\n\
6080 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6081 minute in range from 0. to 60.\n\
6083 ctime (PLFLT, input) : Continous time from which the broken-down\n\
6084 time is calculated.\n\
6087 Get current stream number\n\
6091 Gets the number of the current output stream. See also plsstrm.\n\
6093 Redacted form: plgstrm(p_strm)\n\
6095 This function is used in example 1,20.\n\
6105 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6109 Draw a line in 3 space\n\
6113 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6114 first set up the viewport, the 2d viewing window (in world\n\
6115 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6118 Redacted form: plline3(x, y, z)\n\
6120 This function is used in example 18.\n\
6126 plline3(n, x, y, z)\n\
6130 n (PLINT, input) : Number of points defining line.\n\
6132 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6135 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6138 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6142 Load Hershey fonts\n\
6146 Loads the Hershey fonts used for text and symbols.\tThis routine may\n\
6147 be called before or after initializing PLplot. If not explicitly\n\
6148 called before PLplot initialization, then by default that\n\
6149 initialization loads Hershey fonts with the extended character set.\n\
6150 This routine only has a practical effect for devices that still use\n\
6151 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6152 system fonts instead of Hershey fonts).\n\
6154 Redacted form: plfontld(fnt)\n\
6156 This function is used in examples 1 and 7.\n\
6166 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6167 A zero value specifies Hershey fonts with the standard character\n\
6168 set and a non-zero value (the default assumed if plfontld is never\n\
6169 called) specifies Hershey fonts with the extended character set.\n\
6172 Set any command-line option\n\
6176 Set any command-line option internally from a program before it\n\
6177 invokes plinit. opt is the name of the command-line option and optarg\n\
6178 is the corresponding command-line option argument.\n\
6180 This function returns 0 on success.\n\
6182 Redacted form: plsetopt(opt, optarg)\n\
6184 This function is used in example 14.\n\
6190 PLINT plsetopt(opt, optarg)\n\
6194 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6195 the command-line option.\n\
6197 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6198 containing the argument of the command-line option.\n\
6201 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6205 Plot all or a subset of Shapefile data using lines in world\n\
6206 coordinates. Our 19th standard example demonstrates how to use this\n\
6207 function. This function plots data from a Shapefile using lines as in\n\
6208 plmap, however it also has the option of also only drawing specified\n\
6209 elements from the Shapefile. The vector of indices of the required\n\
6210 elements are passed as a function argument. The Shapefile data should\n\
6211 include a metadata file (extension.dbf) listing all items within the\n\
6212 Shapefile. This file can be opened by most popular spreadsheet\n\
6213 programs and can be used to decide which indices to pass to this\n\
6216 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6219 This function is used in example 19.\n\
6225 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6229 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6230 transform the coordinates given in the shapefile into a plot\n\
6231 coordinate system. By using this transform, we can change from a\n\
6232 longitude, latitude coordinate to a polar stereographic project,\n\
6233 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6234 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6235 mapform(), x[] and y[] should be replaced by the corresponding\n\
6236 plot coordinates. If no transform is desired, mapform can be\n\
6237 replaced by NULL.\n\
6239 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6240 the file name of a set of Shapefile files without the file\n\
6243 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6244 be in the same units as used by the Shapefile. You could use a\n\
6245 very large negative number to plot everything, but you can improve\n\
6246 performance by limiting the area drawn. The units must match those\n\
6247 of the Shapefile projection, which may be for example longitude or\n\
6248 distance. The value of minx must be less than the value of maxx.\n\
6250 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6251 use a very large number to plot everything, but you can improve\n\
6252 performance by limiting the area drawn.\n\
6254 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6255 be in the same units as used by the Shapefile. You could use a\n\
6256 very large negative number to plot everything, but you can improve\n\
6257 performance by limiting the area drawn. The units must match those\n\
6258 of the Shapefile projection, which may be for example latitude or\n\
6259 distance. The value of miny must be less than the value of maxy.\n\
6261 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6262 use a very large number to plot everything, but you can improve\n\
6263 performance by limiting the area drawn.\n\
6265 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6266 zero-based indices of the Shapefile elements which will be drawn.\n\
6268 plotentries to NULL will plot all elements of the Shapefile.\n\
6270 nplotentries (PLINT, input) : The number of items in\n\
6271 plotentries. Ignored if\n\
6272 plotentries is NULL.\n\
6275 Used to globally turn color output on/off\n\
6279 Used to globally turn color output on/off for those drivers/devices\n\
6282 Redacted form: plscolor(color)\n\
6284 This function is used in example 31.\n\
6294 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6295 turned off. If non-zero, color is turned on.\n\
6298 Wait for graphics input event and translate to world coordinates.\n\
6302 Wait for graphics input event and translate to world coordinates.\n\
6303 Returns 0 if no translation to world coordinates is possible.\n\
6305 This function returns 1 on success and 0 if no translation to world\n\
6306 coordinates is possible.\n\
6308 Redacted form: plGetCursor(gin)\n\
6310 This function is used in examples 1 and 20.\n\
6316 PLINT plGetCursor(gin)\n\
6320 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6321 which will contain the output. The structure is not allocated by\n\
6322 the routine and must exist before the function is called.\n\
6325 Get the current device (keyword) name\n\
6329 Get the current device (keyword) name. Note: you must have allocated\n\
6330 space for this (80 characters is safe).\n\
6332 Redacted form: plgdev(p_dev)\n\
6334 This function is used in example 14.\n\
6344 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6345 (with preallocated length of 80 characters or more) containing the\n\
6346 device (keyword) name.\n\
6349 Add a point to a strip chart\n\
6353 Add a point to a given pen of a given strip chart. There is no need\n\
6354 for all pens to have the same number of points or to be equally\n\
6355 sampled in the x coordinate. Allocates memory and rescales as\n\
6358 Redacted form: plstripa(id, pen, x, y)\n\
6360 This function is used in example 17.\n\
6366 plstripa(id, pen, x, y)\n\
6370 id (PLINT, input) : Identification number of the strip chart (set\n\
6373 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6375 x (PLFLT, input) : X coordinate of point to plot.\n\
6377 y (PLFLT, input) : Y coordinate of point to plot.\n\
6380 Create a 4-pen strip chart\n\
6384 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6386 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6387 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6388 styline, legline, labx, laby, labz)\n\
6389 \t Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n\
6390 ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n\
6391 ypsec, legline, labx, laby, labtop)\n\
6394 This function is used in example 17.\n\
6400 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6404 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6405 number of the strip chart to use on plstripa and plstripd.\n\
6407 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6408 the x-axis specification as in plbox.\n\
6410 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6411 the y-axis specification as in plbox.\n\
6413 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6414 change as data are added.\n\
6416 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6417 change as data are added.\n\
6419 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6420 is multiplied by the factor (1 +\n\
6423 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6424 change as data are added.\n\
6426 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6427 change as data are added.\n\
6429 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6431 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6433 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6434 true, otherwise not.\n\
6436 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6437 otherwise slide display.\n\
6439 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6441 collab (PLINT, input) : Legend color index (cmap0).\n\
6443 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6444 indices for the 4 pens.\n\
6446 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6447 indices for the 4 pens.\n\
6449 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6450 strings containing legends for the 4 pens.\n\
6452 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6453 the label for the x axis.\n\
6455 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6456 the label for the y axis.\n\
6458 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6462 Deletes and releases memory used by a strip chart\n\
6466 Deletes and releases memory used by a strip chart.\n\
6468 Redacted form: plstripd(id)\n\
6470 This function is used in example 17.\n\
6480 id (PLINT, input) : Identification number of strip chart to delete.\n\
6483 Specify viewport using coordinates and aspect ratio\n\
6487 Device-independent routine for setting up the viewport. The viewport\n\
6488 is chosen to be the largest with the given aspect ratio that fits\n\
6489 within the specified region (in terms of normalized subpage\n\
6490 coordinates). This routine is functionally equivalent to plvpor when\n\
6491 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6492 routine reserves no extra space at the edges for labels.\n\
6494 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6496 This function is used in example 9.\n\
6502 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6506 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6507 left-hand edge of the viewport.\n\
6509 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6510 right-hand edge of the viewport.\n\
6512 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6513 bottom edge of the viewport.\n\
6515 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6516 edge of the viewport.\n\
6518 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6522 Assign a function to use for generating custom axis labels\n\
6526 This function allows a user to provide their own function to provide\n\
6527 axis label text. The user function is given the numeric value for a\n\
6528 point on an axis and returns a string label to correspond with that\n\
6529 value. Custom axis labels can be enabled by passing appropriate\n\
6530 arguments to plenv, plbox, plbox3 and similar functions.\n\
6532 This function is used in example 19.\n\
6538 plslabelfunc(label_func, label_data)\n\
6542 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6543 label function. In order to reset to the default labelling, set\n\
6544 this to NULL. The labelling function parameters are, in order:\n\
6545 axis: This indicates which axis a label is being requested for.\n\
6546 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6548 value: This is the value along the axis which is being labelled.\n\
6550 label_text: The string representation of the label value.\n\
6552 length: The maximum length in characters allowed for label_text.\n\
6555 label_data (PL_GENERIC_POINTER, input) : This parameter may be used\n\
6556 to pass data to the label_func function.\n\
6559 Set length of major ticks\n\
6563 This sets up the length of the major ticks. The actual length is the\n\
6564 product of the default length and a scaling factor as for character\n\
6567 Redacted form: plsmaj(def, scale)\n\
6569 This function is used in example 29.\n\
6575 plsmaj(def, scale)\n\
6579 def (PLFLT, input) : The default length of a major tick in\n\
6580 millimeters, should be set to zero if the default length is to\n\
6581 remain unchanged.\n\
6583 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6584 actual tick length.\n\
6587 Get the current library version number\n\
6591 Get the current library version number. Note: you must have allocated\n\
6592 space for this (80 characters is safe).\n\
6594 Redacted form: plgver(p_ver)\n\
6596 This function is used in example 1.\n\
6606 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6607 (with preallocated length of 80 characters or more) containing the\n\
6608 PLplot version number.\n\
6611 Set format of numerical label for contours\n\
6615 Set format of numerical label for contours.\n\
6617 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6619 This function is used example 9.\n\
6625 pl_setcontlabelformat(lexp, sigdig)\n\
6629 lexp (PLINT, input) : If the contour numerical label is greater\n\
6630 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6631 format is used. Default value of lexp is 4.\n\
6633 sigdig (PLINT, input) : Number of significant digits. Default\n\
6637 Parse command-line arguments\n\
6641 Parse command-line arguments.\n\
6643 plparseopts removes all recognized flags (decreasing argc\n\
6644 accordingly), so that invalid input may be readily detected. It can\n\
6645 also be used to process user command line flags. The user can merge\n\
6646 an option table of type PLOptionTable into the internal option table\n\
6647 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6648 the external table(s) be parsed by calling plClearOpts before\n\
6651 The default action taken by plparseopts is as follows:\n\
6652 Returns with an error if an unrecognized option or badly formed\n\
6653 option-value pair are encountered.\t\n\
6654 Returns immediately (return code 0) when the first non-option command\n\
6655 line argument is found.\n\
6656 Returns with the return code of the option handler, if one was called.\n\
6658 Deletes command line arguments from argv list as they are found, and\n\
6659 decrements argc accordingly.\n\
6660 Does not show \"invisible\" options in usage or help messages.\n\
6661 Assumes the program name is contained in argv[0].\n\
6663 These behaviors may be controlled through the\n\
6666 Redacted form: General: plparseopts(argv, mode)\n\
6667 \t Perl/PDL: Not available?\n\
6670 This function is used in all of the examples.\n\
6676 PLINT plparseopts(p_argc, argv, mode)\n\
6680 p_argc (int *, input/output) : Number of arguments.\n\
6682 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6683 strings containing *p_argc command-line arguments.\n\
6685 mode (PLINT, input) : Parsing mode with the following\n\
6686 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6687 and all error messages enabled, including program exit when an\n\
6688 error occurs. Anything on the command line that isn\'t recognized\n\
6689 as a valid option or option argument is flagged as an error.\n\
6690 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6692 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6694 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6695 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6696 pointer to the program name.\n\
6697 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6698 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6699 unrecognized arguments.\n\
6706 Initializing the plotting package.\tThe program prompts for the device\n\
6707 keyword or number of the desired output device. Hitting a RETURN in\n\
6708 response to the prompt is the same as selecting the first device. If\n\
6709 only one device is enabled when PLplot is installed, plstar will issue\n\
6710 no prompt.\tThe output device is divided into nx by ny subpages, each\n\
6711 of which may be used independently. The subroutine pladv is used to\n\
6712 advance from one subpage to the next.\n\
6714 Redacted form: plstar(nx, ny)\n\
6716 This function is used in example 1.\n\
6726 nx (PLINT, input) : Number of subpages to divide output page in the\n\
6729 ny (PLINT, input) : Number of subpages to divide output page in the\n\
6733 Get FCI (font characterization integer)\n\
6737 Gets information about the current font using the FCI approach. See\n\
6738 the PLplot documentation for more information.\n\
6740 Redacted form: plgfci(p_fci)\n\
6742 This function is used in example 23.\n\
6752 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
6756 Set family file parameters\n\
6760 Sets variables dealing with output file familying.\tDoes nothing if\n\
6761 familying not supported by the driver. This routine, if used, must be\n\
6762 called before initializing PLplot.\tSee the PLplot documentation for\n\
6763 more information.\n\
6765 Redacted form: plsfam(fam, num, bmax)\n\
6767 This function is used in examples 14 and 31.\n\
6773 plsfam(fam, num, bmax)\n\
6777 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
6780 num (PLINT, input) : Current family file number.\n\
6782 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
6786 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
6790 This is a variant of plscmap1l that supports alpha channel\n\
6791 transparency. It sets cmap1 colors using a piece-wise linear\n\
6792 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
6793 HLS or RGB color space (see the PLplot documentation) with alpha\n\
6794 transparency value (0.0-1.0). It may be called at any time.\n\
6796 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
6797 alpha, alt_hue_path)\n\
6799 This function is used in example 30.\n\
6805 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
6809 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
6811 npts (PLINT, input) : number of control points.\n\
6813 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
6814 intensity index (0.0-1.0) in ascending order for each control\n\
6817 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
6818 coordinate (H or R) for each control point.\n\
6820 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
6821 coordinate (L or G) for each control point.\n\
6823 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
6824 coordinate (S or B) for each control point.\n\
6826 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
6827 transparency value (0.0-1.0) for each control point.\n\
6829 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
6830 npts - 1 elements) containing the alternative interpolation method\n\
6831 Boolean value for each control point interval. (alt_hue_path[i]\n\
6832 refers to the interpolation interval between the i and i + 1\n\
6836 Set page parameters\n\
6840 Sets the page configuration (optional). If an individual parameter is\n\
6841 zero then that parameter value is not updated. Not all parameters are\n\
6842 recognized by all drivers and the interpretation is device-dependent.\n\
6843 The X-window driver uses the length and offset parameters to determine\n\
6844 the window size and location. The length and offset values are\n\
6845 expressed in units that are specific to the current driver. For\n\
6846 instance: screen drivers will usually interpret them as number of\n\
6847 pixels, whereas printer drivers will usually use mm.\n\
6849 This routine, if used, must be called before initializing PLplot. It\n\
6850 may be called at later times for interactive drivers to change only\n\
6851 the dpi for subsequent redraws which you can force via a call to\n\
6852 plreplot. If this function is not called then the page size defaults\n\
6853 to landscape A4 for drivers which use real world page sizes and 744\n\
6854 pixels wide by 538 pixels high for raster drivers. The default value\n\
6855 for dx and dy is 90 pixels per inch for raster drivers.\n\
6859 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6861 This function is used in examples 14 and 31.\n\
6867 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6871 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
6872 by raster drivers, ignored by drivers which use \"real world\" units\n\
6875 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
6876 by raster drivers, ignored by drivers which use \"real world\" units\n\
6879 xleng (PLINT, input) : Page length, x.\n\
6881 yleng (PLINT, input) : Page length, y.\n\
6883 xoff (PLINT, input) : Page offset, x.\n\
6885 yoff (PLINT, input) : Page offset, y.\n\
6888 Set precision in numeric labels\n\
6892 Sets the number of places after the decimal point in numeric labels.\n\
6894 Redacted form: plprec(setp, prec)\n\
6896 This function is used in example 29.\n\
6902 plprec(setp, prec)\n\
6906 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
6907 automatically determines the number of places to use after the\n\
6908 decimal point in numeric labels (like those used to label axes).\n\
6909 If setp is 1 then prec sets the number of places.\n\
6911 prec (PLINT, input) : The number of characters to draw after the\n\
6912 decimal point in numeric labels.\n\
6915 Copy state parameters from the reference stream to the current stream\n\
6919 Copies state parameters from the reference stream to the current\n\
6920 stream. Tell driver interface to map device coordinates unless flags\n\
6923 This function is used for making save files of selected plots (e.g.\n\
6924 from the TK driver). After initializing, you can get a copy of the\n\
6925 current plot to the specified device by switching to this stream and\n\
6926 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
6927 appropriate. The plot buffer must have previously been enabled (done\n\
6928 automatically by some display drivers, such as X).\n\
6930 Redacted form: plcpstrm(iplsr, flags)\n\
6932 This function is used in example 1,20.\n\
6938 plcpstrm(iplsr, flags)\n\
6942 iplsr (PLINT, input) : Number of reference stream.\n\
6944 flags (PLBOOL, input) : If flags is set to true the device\n\
6945 coordinates are not copied from the reference to current stream.\n\
6948 Plot a glyph at the specified points\n\
6952 Plot a glyph at the specified points. (This function is largely\n\
6953 superseded by plstring which gives access to many[!] more glyphs.)\n\
6954 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6955 and a draw at the same place. Not ideal, since a sufficiently\n\
6956 intelligent output device may optimize it away, or there may be faster\n\
6957 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6958 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6959 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6960 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6961 code <= 127 the corresponding printable ASCII character is plotted.\n\
6963 Redacted form: plpoin(x, y, code)\n\
6965 This function is used in examples 1, 6, 14, and 29.\n\
6971 plpoin(n, x, y, code)\n\
6975 n (PLINT, input) : Number of points in the x and y vectors.\n\
6977 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6980 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6983 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6984 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6985 each of the n points.\n\
6988 Enter or leave xor mode\n\
6992 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
6993 those drivers (e.g., the xwin driver) that support it. Enables\n\
6994 erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
6995 is not capable of xor operation it returns a status of false.\n\
6997 Redacted form: plxormod(mode, status)\n\
6999 This function is used in examples 1 and 20.\n\
7005 plxormod(mode, status)\n\
7009 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7010 is false means leave xor mode.\n\
7012 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7013 modestatus of true (false) means driver is capable (incapable) of\n\
7017 Get viewport limits in normalized device coordinates\n\
7021 Get viewport limits in normalized device coordinates.\n\
7023 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7024 \t Perl/PDL: Not available?\n\
7027 This function is used in example 31.\n\
7033 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7037 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7038 viewport limit of the normalized device coordinate in x.\n\
7040 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7041 viewport limit of the normalized device coordinate in x.\n\
7043 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7044 viewport limit of the normalized device coordinate in y.\n\
7046 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7047 viewport limit of the normalized device coordinate in y.\n\
7050 Plot surface mesh\n\
7054 Plots a surface mesh within the environment set up by plw3d. The\n\
7055 surface is defined by the matrix z[\n\
7057 ny] , the point z[i][j] being the value of the function at (\n\
7059 y[j]). Note that the points in vectors x and y do not need to be\n\
7060 equally spaced, but must be stored in ascending order. The parameter\n\
7061 opt controls the way in which the surface is displayed. For further\n\
7062 details see the PLplot documentation.\n\
7064 Redacted form: plmesh(x, y, z, opt)\n\
7066 This function is used in example 11.\n\
7072 plmesh(x, y, z, nx, ny, opt)\n\
7076 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7077 which the function is evaluated.\n\
7079 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7080 which the function is evaluated.\n\
7082 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7083 plot. Should have dimensions of\n\
7087 nx (PLINT, input) : Number of x values at which function has been\n\
7090 ny (PLINT, input) : Number of y values at which function has been\n\
7093 opt (PLINT, input) : Determines the way in which the surface is\n\
7094 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7095 function of x for each value of y[j] .\n\
7096 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7097 for each value of x[i] .\n\
7098 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7099 at which function is defined.\n\
7102 Magnitude colored plot surface mesh with contour\n\
7106 A more powerful form of plmesh: the surface mesh can be colored\n\
7107 accordingly to the current z value being plotted, a contour plot can\n\
7108 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7109 plotted function border and the base XY plane.\n\
7111 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7113 This function is used in example 11.\n\
7119 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7123 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7124 which the function is evaluated.\n\
7126 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7127 which the function is evaluated.\n\
7129 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7130 plot. Should have dimensions of\n\
7134 nx (PLINT, input) : Number of x values at which function is\n\
7137 ny (PLINT, input) : Number of y values at which function is\n\
7140 opt (PLINT, input) : Determines the way in which the surface is\n\
7141 represented. To specify more than one option just add the options,\n\
7142 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7143 showing z as a function of x for each value of y[j] .\n\
7144 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7145 for each value of x[i] .\n\
7146 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7147 at which function is defined.\n\
7148 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7149 the z value being plotted. The color is used from the current\n\
7151 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7155 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7156 the borders of the plotted function.\n\
7159 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7162 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7165 End plotting session for current stream\n\
7169 Ends a plotting session for the current output stream only. See\n\
7170 plsstrm for more info.\n\
7172 Redacted form: plend1()\n\
7174 This function is used in examples 1 and 20.\n\
7183 Get y axis parameters\n\
7187 Identical to plgxax, except that arguments are flags for y axis. See\n\
7188 the description of plgxax for more detail.\n\
7190 Redacted form: plgyax(p_digmax, p_digits)\n\
7192 This function is used in example 31.\n\
7198 plgyax(p_digmax, p_digits)\n\
7202 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7203 number of digits for the y axis. If nonzero, the printed label\n\
7204 has been switched to a floating-point representation when the\n\
7205 number of digits exceeds this value.\n\
7207 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7208 number of digits for the numeric labels (y axis) from the last\n\
7212 Set plot orientation\n\
7216 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7217 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7218 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7219 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7220 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7221 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7222 not called the default value of rot is 0.\n\
7224 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7225 probably want to change the aspect ratio to a value suitable for the\n\
7226 plot orientation using a call to plsdidev or the command-line options\n\
7227 -a or -freeaspect.\tFor more documentation of those options see the\n\
7228 PLplot documentation. Such command-line options can be set internally\n\
7229 using plsetopt or set directly using the command line and parsed using\n\
7230 a call to plparseopts.\n\
7232 Redacted form: plsdiori(rot)\n\
7234 This function is not used in any examples.\n\
7244 rot (PLFLT, input) : Plot orientation parameter.\n\
7247 Plot a histogram from unbinned data\n\
7251 Plots a histogram from n data points stored in the data vector. This\n\
7252 routine bins the data into nbin bins equally spaced between datmin and\n\
7253 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7254 opt allows, among other things, the histogram either to be plotted in\n\
7255 an existing window or causes plhist to call plenv with suitable limits\n\
7256 before plotting the histogram.\n\
7258 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7260 This function is used in example 5.\n\
7266 plhist(n, data, datmin, datmax, nbin, opt)\n\
7270 n (PLINT, input) : Number of data points.\n\
7272 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7275 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7277 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7279 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7280 divide the interval xmin to xmax.\n\
7282 opt (PLINT, input) : Is a combination of several flags:\n\
7283 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7284 the histogram data, the outer bins are expanded to fill up the\n\
7285 entire x-axis, data outside the given extremes are assigned to the\n\
7286 outer bins and bins of zero height are simply drawn.\n\
7287 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7288 to fit the histogram data, without this flag, plenv is called\n\
7289 to set the world coordinates.\n\
7290 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7291 extremes are not taken into account. This option should\n\
7292 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7293 properly present the data.\n\
7294 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7295 size as the ones inside.\n\
7296 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7297 (there is a gap for such bins).\n\
7300 End plotting session\n\
7304 Ends a plotting session, tidies up all the output files, switches\n\
7305 interactive devices back into text mode and frees up any memory that\n\
7306 was allocated. Must be called before end of program.\n\
7308 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7309 wait state after a call to plend or other functions which trigger the\n\
7310 end of a plot page. To avoid this, use the plspause function.\n\
7312 Redacted form: plend()\n\
7314 This function is used in all of the examples.\n\
7323 Plot shaded 3-d surface plot\n\
7327 Plots a three-dimensional shaded surface plot within the environment\n\
7328 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7331 ny], the point z[i][j] being the value of the function at (\n\
7333 y[j]). Note that the points in vectors x and y do not need to be\n\
7334 equally spaced, but must be stored in ascending order. For further\n\
7335 details see the PLplot documentation.\n\
7337 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7339 This function is not used in any examples.\n\
7345 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7349 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7350 which the function is evaluated.\n\
7352 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7353 which the function is evaluated.\n\
7355 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7356 plot. Should have dimensions of\n\
7360 nx (PLINT, input) : Number of x values at which function is\n\
7363 ny (PLINT, input) : Number of y values at which function is\n\
7366 opt (PLINT, input) : Determines the way in which the surface is\n\
7367 represented. To specify more than one option just add the options,\n\
7368 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7369 connecting points at which function is defined.\n\
7370 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7374 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7378 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7379 the borders of the plotted function.\n\
7380 opt=MAG_COLOR : the surface is colored according to the value\n\
7381 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7382 according to the intensity of the reflected light in the\n\
7383 surface from a light source whose position is set using\n\
7387 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7390 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7393 Set device-compression level\n\
7397 Set device-compression level. Only used for drivers that provide\n\
7398 compression. This function, if used, should be invoked before a call\n\
7401 Redacted form: plscompression(compression)\n\
7403 This function is used in example 31.\n\
7409 plscompression(compression)\n\
7413 compression (PLINT, input) : The desired compression level. This is\n\
7414 a device-dependent value. Currently only the jpeg and png devices\n\
7415 use these values. For jpeg value is the jpeg quality which should\n\
7416 normally be in the range 0-95. Higher values denote higher quality\n\
7417 and hence larger image sizes. For png values are in the range -1\n\
7418 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7419 A value of -1 denotes the default zlib compression level. Values\n\
7420 in the range 10-99 are divided by 10 and then used as the zlib\n\
7421 compression level. Higher compression levels correspond to greater\n\
7422 compression and small file sizes at the expense of more\n\
7426 Get the current device-compression setting\n\
7430 Get the current device-compression setting. This parameter is only\n\
7431 used for drivers that provide compression.\n\
7433 Redacted form: plgcompression(compression)\n\
7435 This function is used in example 31.\n\
7441 plgcompression(compression)\n\
7445 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7446 compression setting for the current device.\n\
7449 Advance the (sub-)page\n\
7453 Advances to the next subpage if sub=0, performing a page advance if\n\
7454 there are no remaining subpages on the current page. If subpages\n\
7455 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7456 PLplot switches to the specified subpage. Note that this allows you\n\
7457 to overwrite a plot on the specified subpage; if this is not what you\n\
7458 intended, use pleop followed by plbop to first advance the page. This\n\
7459 routine is called automatically (with page=0) by plenv, but if plenv\n\
7460 is not used, pladv must be called after initializing PLplot but before\n\
7461 defining the viewport.\n\
7463 Redacted form: pladv(page)\n\
7465 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7476 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7477 in the top left corner and increasing along the rows) to which to\n\
7478 advance. Set to zero to advance to the next subpage (or to the\n\
7479 next page if subpages are not being used).\n\
7482 Set parameters of contour labelling other than format of numerical label\n\
7486 Set parameters of contour labelling other than those handled by\n\
7487 pl_setcontlabelformat.\n\
7489 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7491 This function is used in example 9.\n\
7497 pl_setcontlabelparam(offset, size, spacing, active)\n\
7501 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7502 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7504 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7505 Default value is 0.3.\n\
7507 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7508 Default value is 0.1.\n\
7510 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7511 contour labels on. Default is off (0).\n\
7514 Set family, style and weight of the current font\n\
7518 Sets the current font. See the PLplot documentation for more\n\
7519 information on font selection.\n\
7521 Redacted form: plsfont(family, style, weight)\n\
7523 This function is used in example 23.\n\
7529 plsfont(family, style, weight)\n\
7533 family (PLINT, input) : Font family to select for the current font.\n\
7534 The available values are given by the PL_FCI_* constants in\n\
7535 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7536 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7537 signifies that the font family should not be altered.\n\
7539 style (PLINT, input) : Font style to select for the current font.\n\
7540 The available values are given by the PL_FCI_* constants in\n\
7541 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7542 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7543 should not be altered.\n\
7545 weight (PLINT, input) : Font weight to select for the current font.\n\
7546 The available values are given by the PL_FCI_* constants in\n\
7547 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7548 negative value signifies that the font weight should not be\n\
7552 Sets the 3D position of the light source\n\
7556 Sets the 3D position of the light source for use with plsurf3d and\n\
7559 Redacted form: pllightsource(x, y, z)\n\
7561 This function is used in example 8.\n\
7567 pllightsource(x, y, z)\n\
7571 x (PLFLT, input) : X-coordinate of the light source.\n\
7573 y (PLFLT, input) : Y-coordinate of the light source.\n\
7575 z (PLFLT, input) : Z-coordinate of the light source.\n\
7582 Draws line defined by n points in x and y.\n\
7584 Redacted form: plline(x, y)\n\
7586 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7597 n (PLINT, input) : Number of points defining line.\n\
7599 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7602 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7610 Sets the pen width.\n\
7612 Redacted form: plwidth(width)\n\
7614 This function is used in examples 1 and 2.\n\
7624 width (PLFLT, input) : The desired pen width. If width is negative\n\
7625 or the same as the previous value no action is taken. width = 0.\n\
7626 should be interpreted as as the minimum valid pen width for the\n\
7627 device. The interpretation of positive width values is also\n\
7628 device dependent.\n\
7631 Draw linear gradient inside polygon\n\
7635 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7638 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7639 polygon coordinates and the gradient angle are all expressed in world\n\
7640 coordinates. The angle from the x axis for both the rotated\n\
7641 coordinate system and the gradient vector is specified by angle. The\n\
7642 magnitude of the gradient vector is the difference between the maximum\n\
7643 and minimum values of x for the vertices in the rotated coordinate\n\
7644 system. The origin of the gradient vector can be interpreted as being\n\
7645 anywhere on the line corresponding to the minimum x value for the\n\
7646 vertices in the rotated coordinate system.\tThe distance along the\n\
7647 gradient vector is linearly transformed to the independent variable of\n\
7648 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7649 1. at the head of the gradient vector. What is drawn is the RGBA\n\
7650 color corresponding to the independent variable of cmap1. For more\n\
7651 information about cmap1 (see the PLplot documentation).\n\
7653 Redacted form: plgradient(x,y,angle)\n\
7655 This function is used in examples 25 and 30.\n\
7661 plgradient(n, x, y, angle)\n\
7665 n (PLINT, input) : Number of vertices in polygon.\n\
7667 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7670 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7673 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
7677 Flushes the output stream\n\
7681 Flushes the output stream. Use sparingly, if at all.\n\
7683 Redacted form: plflush()\n\
7685 This function is used in examples 1 and 14.\n\
7694 Get plot orientation\n\
7698 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7699 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7700 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7701 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7702 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7703 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7704 not been called the default value pointed to by p_rot will be 0.\n\
7706 Redacted form: plgdiori(p_rot)\n\
7708 This function is not used in any examples.\n\
7718 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7722 Set x axis parameters\n\
7726 Sets values of the digmax and digits flags for the x axis.\tSee the\n\
7727 PLplot documentation for more information.\n\
7729 Redacted form: plsxax(digmax, digits)\n\
7731 This function is used in example 31.\n\
7737 plsxax(digmax, digits)\n\
7741 digmax (PLINT, input) : Variable to set the maximum number of\n\
7742 digits for the x axis. If nonzero, the printed label will be\n\
7743 switched to a floating-point representation when the number of\n\
7744 digits exceeds digmax.\n\
7746 digits (PLINT, input) : Field digits value. Currently, changing\n\
7747 its value here has no effect since it is set only by plbox or\n\
7748 plbox3. However, the user may obtain its value after a call to\n\
7749 either of these functions by calling plgxax.\n\
7752 Get viewport limits in world coordinates\n\
7756 Get viewport limits in world coordinates.\n\
7758 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7759 \t Perl/PDL: Not available?\n\
7762 This function is used in example 31.\n\
7768 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7772 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7773 viewport limit of the world coordinate in x.\n\
7775 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7776 viewport limit of the world coordinate in x.\n\
7778 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7779 viewport limit of the world coordinate in y.\n\
7781 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7782 viewport limit of the world coordinate in y.\n\
7785 Shade regions on the basis of value\n\
7789 Shade regions on the basis of value. This is the high-level routine\n\
7790 for making continuous color shaded plots with cmap1 while plshade\n\
7791 should be used to plot individual shaded regions using either cmap0 or\n\
7792 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
7793 our supported languages.\n\
7795 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
7796 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
7798 \t Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n\
7799 fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n\
7803 This function is used in examples 16, 21, and 22.\n\
7809 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
7813 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7814 plot. Should have dimensions of\n\
7818 nx (PLINT, input) : First dimension of matrix \"a\".\n\
7820 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
7822 defined (PLDEFINED_callback, input) : Callback function specifying\n\
7823 the region that should be plotted in the shade plot. This\n\
7824 function accepts x and y coordinates as input arguments and must\n\
7825 return 1 if the point is to be included in the shade plot and 0\n\
7826 otherwise. If you want to plot the entire shade plot (the usual\n\
7827 case), this argument should be set to NULL.\n\
7829 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
7830 pltr below for how these arguments are used (only for the special case\n\
7831 when the callback function\n\
7832 pltr is not supplied).\n\
7834 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
7835 corresponding to the edges of each shaded region that will be\n\
7836 plotted by this function. To work properly the levels should be\n\
7839 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
7840 of shade edge values in clevel).\n\
7842 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
7845 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
7846 contours defining edges of shaded regions. The pen color is only\n\
7847 temporary set for the contour drawing. Set this value to zero or\n\
7848 less if no shade edge contours are wanted.\n\
7850 cont_width (PLFLT, input) : Defines line width used for contours\n\
7851 defining edges of shaded regions. This value may not be honored\n\
7852 by all drivers. The pen width is only temporary set for the\n\
7853 contour drawing. Set this value to zero or less if no shade edge\n\
7854 contours are wanted.\n\
7856 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
7857 region. Use plfill for this purpose.\n\
7859 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
7860 map to rectangles after coordinate transformation with pltrl.\n\
7861 Otherwise, set rectangular to false. If rectangular is set to\n\
7862 true, plshade tries to save time by filling large rectangles.\n\
7863 This optimization fails if the coordinate transformation distorts\n\
7864 the shape of rectangles. For example a plot in polar coordinates\n\
7865 has to have rectangular set to false.\n\
7867 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
7868 defines the transformation between the zero-based indices of the\n\
7869 matrix a and world coordinates. If\n\
7870 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
7871 indices of a are mapped to the range\n\
7873 xmax and the y indices of a are mapped to the range\n\
7875 ymax.For the C case, transformation functions are provided in the\n\
7876 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
7877 pltr2 for arbitrary mappings respectively defined by vectors and\n\
7878 matrices. In addition, C callback routines for the transformation\n\
7879 can be supplied by the user such as the mypltr function in\n\
7880 examples/c/x09c.c which provides a general linear transformation\n\
7881 between index coordinates and world coordinates.For languages\n\
7882 other than C you should consult the PLplot documentation for the\n\
7883 details concerning how PLTRANSFORM_callback arguments are\n\
7884 interfaced. However, in general, a particular pattern of\n\
7885 callback-associated arguments such as a tr vector with 6 elements;\n\
7886 xg and yg vectors; or xg and yg matrices are respectively\n\
7887 interfaced to a linear-transformation routine similar to the above\n\
7888 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
7889 sophisticated bindings (see, e.g., the PLplot documentation)\n\
7890 support native language callbacks for handling index to\n\
7891 world-coordinate transformations. Examples of these various\n\
7892 approaches are given in examples/<language>x09*,\n\
7893 examples/<language>x16*, examples/<language>x20*,\n\
7894 examples/<language>x21*, and examples/<language>x22*, for all our\n\
7895 supported languages.\n\
7897 pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
7898 pass information to pltr0, pltr1, pltr2, or whatever routine that\n\
7899 is externally supplied.\n\
7902 Plot color bar for image, shade or gradient plots\n\
7906 Routine for creating a continuous color bar for image, shade, or\n\
7907 gradient plots. (See pllegend for similar functionality for creating\n\
7908 legends with discrete elements). The arguments of plcolorbar provide\n\
7909 control over the location and size of the color bar as well as the\n\
7910 location and characteristics of the elements (most of which are\n\
7911 optional) within that color bar. The resulting color bar is clipped\n\
7912 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
7913 system used for some of the parameters is defined in the documentation\n\
7914 of the position parameter.)\n\
7916 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
7917 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
7918 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
7919 labels, axis_opts, ticks, sub_ticks, values)\n\
7921 This function is used in examples 16 and 33.\n\
7927 plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n\
7931 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
7932 labelled and decorated color bar width in adopted coordinates.\n\
7934 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
7935 labelled and decorated color bar height in adopted coordinates.\n\
7937 opt (PLINT, input) : opt contains bits controlling the overall\n\
7938 color bar. The orientation (direction of the maximum value) of\n\
7939 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
7940 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
7941 specified, the default orientation is toward the top if the\n\
7942 colorbar is placed on the left or right of the viewport or toward\n\
7943 the right if the colorbar is placed on the top or bottom of the\n\
7944 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
7945 (semitransparent) background for the color bar. If the\n\
7946 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
7947 color bar. The type of color bar must be specified with one of\n\
7948 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
7949 more than one of those bits is set only the first one in the above\n\
7950 list is honored. The position of the (optional) label/title can be\n\
7951 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
7952 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
7953 will be drawn. If more than one of this list of bits is specified,\n\
7954 only the first one on the list is honored. End-caps for the color\n\
7955 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
7956 If a particular color bar cap option is not specified then no cap\n\
7957 will be drawn for that end. As a special case for\n\
7958 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
7959 specified. If this option is provided then any tick marks and tick\n\
7960 labels will be placed at the breaks between shaded segments. TODO:\n\
7961 This should be expanded to support custom placement of tick marks\n\
7962 and tick labels at custom value locations for any color bar type.\n\
7964 position (PLINT, input) : position contains bits which control the\n\
7965 overall position of the color bar and the definition of the\n\
7966 adopted coordinates used for positions just like what is done for\n\
7967 the position argument for pllegend. However, note that the\n\
7968 defaults for the position bits (see below) are different than the\n\
7969 pllegend case. The combination of the PL_POSITION_LEFT,\n\
7970 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
7971 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
7972 the 16 possible standard positions (the 4 corners and centers of\n\
7973 the 4 sides for both the inside and outside cases) of the color\n\
7974 bar relative to the adopted coordinate system. The corner\n\
7975 positions are specified by the appropriate combination of two of\n\
7976 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
7977 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
7978 value of one of those bits. The adopted coordinates are\n\
7979 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
7980 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
7981 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
7982 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
7983 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
7984 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
7985 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
7986 PL_POSITION_VIEWPORT.\n\
7988 x (PLFLT, input) : X offset of the color bar position in adopted\n\
7989 coordinates from the specified standard position of the color bar.\n\
7990 For positive x, the direction of motion away from the standard\n\
7991 position is inward/outward from the standard corner positions or\n\
7992 standard left or right positions if the\n\
7993 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
7994 For the standard top or bottom positions, the direction of motion\n\
7995 is toward positive X.\n\
7997 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
7998 coordinates from the specified standard position of the color bar.\n\
7999 For positive y, the direction of motion away from the standard\n\
8000 position is inward/outward from the standard corner positions or\n\
8001 standard top or bottom positions if the\n\
8002 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8003 For the standard left or right positions, the direction of motion\n\
8004 is toward positive Y.\n\
8006 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8007 the X direction in adopted coordinates.\n\
8009 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8010 the Y direction in adopted coordinates.\n\
8012 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8013 color bar (PL_COLORBAR_BACKGROUND).\n\
8015 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8016 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8018 bb_style (PLINT, input) : The pllsty style number for the\n\
8019 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8021 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8022 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8024 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8025 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8027 cont_color (PLINT, input) : The cmap0 contour color for\n\
8028 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8029 it will be interpreted according to the design of plshades.\n\
8031 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8032 plots. This is passed directly to plshades, so it will be\n\
8033 interpreted according to the design of plshades.\n\
8035 n_labels (PLINT, input) : Number of labels to place around the\n\
8038 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8041 labels (PLCHAR_MATRIX, input) : A vector of\n\
8042 n_labels UTF-8 character strings containing the labels for the color\n\
8043 bar. Ignored if no label position is specified with one of the\n\
8044 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8045 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8046 corresponding label_opts field.\n\
8048 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8049 value must be greater than 0. It is typically 1 (numerical axis\n\
8050 labels are provided for one of the long edges of the color bar),\n\
8051 but it can be larger if multiple numerical axis labels for the\n\
8052 long edges of the color bar are desired.\n\
8054 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8055 n_axes ascii character strings containing options (interpreted as for\n\
8056 plbox) for the color bar\'s axis definitions.\n\
8058 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8059 spacing of the major tick marks (interpreted as for plbox) for the\n\
8060 color bar\'s axis definitions.\n\
8062 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8063 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8064 axis definitions.\n\
8066 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8067 elements in each of the n_axes rows of the values matrix.\n\
8069 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8070 values for the data range represented by the color bar. For a row\n\
8071 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8072 elements in the row is specified by n_values[i_axis]. For\n\
8073 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8074 is 2, and the corresponding row elements of the values matrix are\n\
8075 the minimum and maximum value represented by the colorbar. For\n\
8076 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8077 of the values matrix is interpreted the same as the nlevel and\n\
8078 clevel arguments of plshades.\n\
8081 Get current subpage parameters\n\
8085 Gets the size of the current subpage in millimeters measured from the\n\
8086 bottom left hand corner of the output device page or screen. Can be\n\
8087 used in conjunction with plsvpa for setting the size of a viewport in\n\
8088 absolute coordinates (millimeters).\n\
8090 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8092 This function is used in example 23.\n\
8098 plgspa(xmin, xmax, ymin, ymax)\n\
8102 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8103 the left hand edge of the subpage in millimeters.\n\
8105 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8106 the right hand edge of the subpage in millimeters.\n\
8108 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8109 the bottom edge of the subpage in millimeters.\n\
8111 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8112 the top edge of the subpage in millimeters.\n\
8115 Shade individual region on the basis of value\n\
8119 Shade individual region on the basis of value. Use plshades if you\n\
8120 want to shade a number of contiguous regions using continuous colors.\n\
8121 In particular the edge contours are treated properly in plshades. If\n\
8122 you attempt to do contiguous regions with plshade the contours at the\n\
8123 edge of the shade are partially obliterated by subsequent plots of\n\
8124 contiguous shaded regions.\n\
8126 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8127 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8128 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8131 This function is used in example 15.\n\
8137 plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8141 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8142 plot. Should have dimensions of\n\
8146 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8148 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8150 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8151 the region that should be plotted in the shade plot. This\n\
8152 function accepts x and y coordinates as input arguments and must\n\
8153 return 1 if the point is to be included in the shade plot and 0\n\
8154 otherwise. If you want to plot the entire shade plot (the usual\n\
8155 case), this argument should be set to NULL.\n\
8157 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8158 pltr below for how these arguments are used (only for the special case\n\
8159 when the callback function\n\
8160 pltr is not supplied).\n\
8162 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8163 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8165 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8166 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8168 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8169 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8170 then sh_color is interpreted as a cmap1 argument in the range\n\
8173 sh_color (PLFLT, input) : Defines color map index with integer\n\
8174 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8176 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8178 min_color (PLINT, input) : Defines pen color, width used by the\n\
8179 boundary of shaded region. The min values are used for the\n\
8180 shade_min boundary, and the max values are used on the shade_max\n\
8181 boundary. Set color and width to zero for no plotted boundaries.\n\
8183 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8184 boundary of shaded region. The min values are used for the\n\
8185 shade_min boundary, and the max values are used on the shade_max\n\
8186 boundary. Set color and width to zero for no plotted boundaries.\n\
8188 max_color (PLINT, input) : Defines pen color, width used by the\n\
8189 boundary of shaded region. The min values are used for the\n\
8190 shade_min boundary, and the max values are used on the shade_max\n\
8191 boundary. Set color and width to zero for no plotted boundaries.\n\
8193 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8194 boundary of shaded region. The min values are used for the\n\
8195 shade_min boundary, and the max values are used on the shade_max\n\
8196 boundary. Set color and width to zero for no plotted boundaries.\n\
8198 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8199 Use plfill. Future version of PLplot may have other fill\n\
8202 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8203 map to rectangles after coordinate transformation with pltrl.\n\
8204 Otherwise, set rectangular to false. If rectangular is set to\n\
8205 true, plshade tries to save time by filling large rectangles.\n\
8206 This optimization fails if the coordinate transformation distorts\n\
8207 the shape of rectangles. For example a plot in polar coordinates\n\
8208 has to have rectangular set to false.\n\
8210 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8211 defines the transformation between the zero-based indices of the\n\
8212 matrix a and world coordinates. If\n\
8213 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8214 indices of a are mapped to the range\n\
8216 xmax and the y indices of a are mapped to the range\n\
8218 ymax.For the C case, transformation functions are provided in the\n\
8219 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8220 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8221 matrices. In addition, C callback routines for the transformation\n\
8222 can be supplied by the user such as the mypltr function in\n\
8223 examples/c/x09c.c which provides a general linear transformation\n\
8224 between index coordinates and world coordinates.For languages\n\
8225 other than C you should consult the PLplot documentation for the\n\
8226 details concerning how PLTRANSFORM_callback arguments are\n\
8227 interfaced. However, in general, a particular pattern of\n\
8228 callback-associated arguments such as a tr vector with 6 elements;\n\
8229 xg and yg vectors; or xg and yg matrices are respectively\n\
8230 interfaced to a linear-transformation routine similar to the above\n\
8231 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8232 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8233 support native language callbacks for handling index to\n\
8234 world-coordinate transformations. Examples of these various\n\
8235 approaches are given in examples/<language>x09*,\n\
8236 examples/<language>x16*, examples/<language>x20*,\n\
8237 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8238 supported languages.\n\
8240 pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
8241 pass information to pltr0, pltr1, pltr2, or whatever routine that\n\
8242 is externally supplied.\n\
8245 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8249 Calculate world coordinates, wx and wy, and corresponding window index\n\
8250 from relative device coordinates, rx and ry.\n\
8252 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8253 \t Perl/PDL: Not available?\n\
8256 This function is used in example 31.\n\
8262 plcalc_world(rx, ry, wx, wy, window)\n\
8266 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8267 the x coordinate.\n\
8269 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8270 the y coordinate.\n\
8272 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8273 coordinate corresponding to the relative device coordinates rx and\n\
8276 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8277 coordinate corresponding to the relative device coordinates rx and\n\
8280 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8281 defined window index that corresponds to the input relative device\n\
8282 coordinates (and the returned world coordinates). To give some\n\
8283 background on the window index, for each page the initial window\n\
8284 index is set to zero, and each time plwind is called within the\n\
8285 page, world and device coordinates are stored for the window and\n\
8286 the window index is incremented. Thus, for a simple page layout\n\
8287 with non-overlapping viewports and one window per viewport, window\n\
8288 corresponds to the viewport index (in the order which the\n\
8289 viewport/windows were created) of the only viewport/window\n\
8290 corresponding to rx and ry. However, for more complicated layouts\n\
8291 with potentially overlapping viewports and possibly more than one\n\
8292 window (set of world coordinates) per viewport, window and the\n\
8293 corresponding output world coordinates corresponds to the last\n\
8294 window created that fulfills the criterion that the relative\n\
8295 device coordinates are inside it. Finally, in all cases where the\n\
8296 input relative device coordinates are not inside any\n\
8297 viewport/window, then the returned value of the last defined\n\
8298 window index is set to -1.\n\
8301 Draw a box with axes, etc, in 3-d\n\
8305 Draws axes, numeric and text labels for a three-dimensional surface\n\
8306 plot. For a more complete description of three-dimensional plotting\n\
8307 see the PLplot documentation.\n\
8309 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8310 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8311 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
8312 xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
8315 This function is used in examples 8, 11, 18, and 21.\n\
8321 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8325 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8326 options for the x axis. The string can include any combination of\n\
8327 the following letters (upper or lower case) in any order: b: Draws\n\
8328 axis at base, at height z=\n\
8329 zmin where zmin is defined by call to plw3d. This character must be\n\
8330 specified in order to use any of the other options.\n\
8331 d: Plot labels as date / time. Values are assumed to be\n\
8332 seconds since the epoch (as used by gmtime).\n\
8333 f: Always use fixed point numeric labels.\n\
8334 i: Inverts tick marks, so they are drawn downwards, rather\n\
8336 l: Labels axis logarithmically. This only affects the labels,\n\
8337 not the data, and so it is necessary to compute the logarithms\n\
8338 of data points before passing them to any of the drawing\n\
8340 n: Writes numeric labels at major tick intervals.\n\
8341 o: Use custom labelling function to generate axis label text.\n\
8342 The custom labelling function can be defined with the\n\
8343 plslabelfunc command.\n\
8344 s: Enables subticks between major ticks, only valid if t is\n\
8346 t: Draws major ticks.\n\
8347 u: If this is specified, the text label for the axis is\n\
8348 written under the axis.\n\
8351 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8352 the text label for the x axis. It is only drawn if u is in the\n\
8355 xtick (PLFLT, input) : World coordinate interval between major\n\
8356 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8357 generates a suitable tick interval.\n\
8359 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8360 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8361 generates a suitable minor tick interval.\n\
8363 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8364 options for the y axis. The string is interpreted in the same way\n\
8367 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8368 the text label for the y axis. It is only drawn if u is in the\n\
8371 ytick (PLFLT, input) : World coordinate interval between major\n\
8372 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8373 generates a suitable tick interval.\n\
8375 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8376 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8377 generates a suitable minor tick interval.\n\
8379 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8380 options for the z axis. The string can include any combination of\n\
8381 the following letters (upper or lower case) in any order: b: Draws\n\
8382 z axis to the left of the surface plot.\n\
8383 c: Draws z axis to the right of the surface plot.\n\
8384 d: Draws grid lines parallel to the x-y plane behind the\n\
8385 figure. These lines are not drawn until after plot3d or\n\
8386 plmesh are called because of the need for hidden line removal.\n\
8387 e: Plot labels as date / time. Values are assumed to be\n\
8388 seconds since the epoch (as used by gmtime). Note this\n\
8389 suboption is interpreted the same as the d suboption for xopt\n\
8390 and yopt, but it has to be identified as e for zopt since d\n\
8391 has already been used for the different purpose above.\n\
8392 f: Always use fixed point numeric labels.\n\
8393 i: Inverts tick marks, so they are drawn away from the center.\n\
8394 l: Labels axis logarithmically. This only affects the labels,\n\
8395 not the data, and so it is necessary to compute the logarithms\n\
8396 of data points before passing them to any of the drawing\n\
8398 m: Writes numeric labels at major tick intervals on the\n\
8399 right-hand z axis.\n\
8400 n: Writes numeric labels at major tick intervals on the\n\
8401 left-hand z axis.\n\
8402 o: Use custom labelling function to generate axis label text.\n\
8403 The custom labelling function can be defined with the\n\
8404 plslabelfunc command.\n\
8405 s: Enables subticks between major ticks, only valid if t is\n\
8407 t: Draws major ticks.\n\
8408 u: If this is specified, the text label is written beside the\n\
8410 v: If this is specified, the text label is written beside the\n\
8414 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8415 the text label for the z axis. It is only drawn if u or v are in\n\
8418 ztick (PLFLT, input) : World coordinate interval between major\n\
8419 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8420 generates a suitable tick interval.\n\
8422 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8423 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8424 generates a suitable minor tick interval.\n\
8427 Get character default height and current (scaled) height\n\
8431 Get character default height and current (scaled) height.\n\
8433 Redacted form: plgchr(p_def, p_ht)\n\
8435 This function is used in example 23.\n\
8441 plgchr(p_def, p_ht)\n\
8445 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8446 character height (mm).\n\
8448 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8449 character height (mm).\n\
8452 Set the escape character for text strings\n\
8456 Set the escape character for text strings.\tFrom C (in contrast to\n\
8457 Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8458 selected characters are allowed to prevent the user from shooting\n\
8459 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8460 with C\'s use of backslash as a character escape). Here are the\n\
8461 allowed escape characters and their corresponding decimal ASCII\n\
8462 values: !, ASCII 33\n\
8473 Redacted form: General: plsesc(esc)\n\
8474 \t Perl/PDL: Not available?\n\
8477 This function is used in example 29.\n\
8487 esc (char, input) : Escape character.\n\
8490 Draw a line between two points, accounting for coordinate transforms\n\
8494 Joins the point (\n\
8498 y2) . If a global coordinate transform is defined then the line is\n\
8499 broken in to n segments to approximate the path. If no transform is\n\
8500 defined then this simply acts like a call to pljoin.\n\
8502 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8504 This function is used in example 22.\n\
8510 plpath(n, x1, y1, x2, y2)\n\
8514 n (PLINT, input) : number of points to use to approximate the path.\n\
8516 x1 (PLFLT, input) : x coordinate of first point.\n\
8518 y1 (PLFLT, input) : y coordinate of first point.\n\
8520 x2 (PLFLT, input) : x coordinate of second point.\n\
8522 y2 (PLFLT, input) : y coordinate of second point.\n\
8525 Set up standard window and draw box\n\
8529 Sets up plotter environment for simple graphs by calling pladv and\n\
8530 setting up viewport and window to sensible default values. plenv\n\
8531 leaves a standard margin (left-hand margin of eight character heights,\n\
8532 and a margin around the other three sides of five character heights)\n\
8533 around most graphs for axis labels and a title. When these defaults\n\
8534 are not suitable, use the individual routines plvpas, plvpor, or\n\
8535 plvasp for setting up the viewport, plwind for defining the window,\n\
8536 and plbox for drawing the box.\n\
8538 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8540 This function is used in example 1,3,9,13,14,19-22,29.\n\
8546 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8550 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8551 world coordinates).\n\
8553 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8554 world coordinates).\n\
8556 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8559 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8562 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8563 scales will not be set, the user must set up the scale before\n\
8564 calling plenv using plsvpa, plvasp or other.\n\
8565 0: the x and y axes are scaled independently to use as much of\n\
8566 the screen as possible.\n\
8567 1: the scales of the x and y axes are made equal.\n\
8568 2: the axis of the x and y axes are made equal, and the plot\n\
8569 box will be square.\n\
8572 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8573 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8574 -1: draw box only.\n\
8575 0: draw box, ticks, and numeric tick labels.\n\
8576 1: also draw coordinate axes at x=0 and y=0.\n\
8577 2: also draw a grid at major tick positions in both\n\
8579 3: also draw a grid at minor tick positions in both\n\
8581 10: same as 0 except logarithmic x tick marks. (The x data\n\
8582 have to be converted to logarithms separately.)\n\
8583 11: same as 1 except logarithmic x tick marks. (The x data\n\
8584 have to be converted to logarithms separately.)\n\
8585 12: same as 2 except logarithmic x tick marks. (The x data\n\
8586 have to be converted to logarithms separately.)\n\
8587 13: same as 3 except logarithmic x tick marks. (The x data\n\
8588 have to be converted to logarithms separately.)\n\
8589 20: same as 0 except logarithmic y tick marks. (The y data\n\
8590 have to be converted to logarithms separately.)\n\
8591 21: same as 1 except logarithmic y tick marks. (The y data\n\
8592 have to be converted to logarithms separately.)\n\
8593 22: same as 2 except logarithmic y tick marks. (The y data\n\
8594 have to be converted to logarithms separately.)\n\
8595 23: same as 3 except logarithmic y tick marks. (The y data\n\
8596 have to be converted to logarithms separately.)\n\
8597 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8598 and y data have to be converted to logarithms separately.)\n\
8599 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8600 and y data have to be converted to logarithms separately.)\n\
8601 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8602 and y data have to be converted to logarithms separately.)\n\
8603 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8604 and y data have to be converted to logarithms separately.)\n\
8605 40: same as 0 except date / time x labels.\n\
8606 41: same as 1 except date / time x labels.\n\
8607 42: same as 2 except date / time x labels.\n\
8608 43: same as 3 except date / time x labels.\n\
8609 50: same as 0 except date / time y labels.\n\
8610 51: same as 1 except date / time y labels.\n\
8611 52: same as 2 except date / time y labels.\n\
8612 53: same as 3 except date / time y labels.\n\
8613 60: same as 0 except date / time x and y labels.\n\
8614 61: same as 1 except date / time x and y labels.\n\
8615 62: same as 2 except date / time x and y labels.\n\
8616 63: same as 3 except date / time x and y labels.\n\
8617 70: same as 0 except custom x and y labels.\n\
8618 71: same as 1 except custom x and y labels.\n\
8619 72: same as 2 except custom x and y labels.\n\
8620 73: same as 3 except custom x and y labels.\n\
8623 Grid data from irregularly sampled data\n\
8627 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8628 require data organized as a grid, i.e., with x sample point values\n\
8629 independent of y coordinate and vice versa. This function takes\n\
8630 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8631 vectors; reads the desired grid location from the input vectors\n\
8632 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8633 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8634 interpolate the data to the grid is specified with the argument type\n\
8635 which can have one parameter specified in argument data.\n\
8637 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8638 \t Perl/PDL: Not available?\n\
8639 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8642 This function is used in example 21.\n\
8648 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8652 x (PLFLT_VECTOR, input) : The input x vector.\n\
8654 y (PLFLT_VECTOR, input) : The input y vector.\n\
8656 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8657 y[i], z[i] represents one data sample coordinate.\n\
8659 npts (PLINT, input) : The number of data samples in the x, y and z\n\
8662 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8663 in the x direction. Usually xg has nptsx equally spaced values\n\
8664 from the minimum to the maximum values of the x input vector.\n\
8666 nptsx (PLINT, input) : The number of points in the xg vector.\n\
8668 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8669 in the y direction. Similar to the xg parameter.\n\
8671 nptsy (PLINT, input) : The number of points in the yg vector.\n\
8673 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8674 where data lies in the grid specified by xg and yg. Therefore the\n\
8675 zg matrix must be dimensioned\n\
8679 type (PLINT, input) : The type of grid interpolation algorithm to\n\
8680 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
8681 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
8682 GRID_NNI: Natural Neighbors Interpolation\n\
8683 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
8684 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
8685 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8687 For details of the algorithms read the source file plgridd.c.\n\
8689 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8690 which can be specified through this argument. Currently, for\n\
8691 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8692 use, the lower the value, the noisier (more local) the\n\
8693 approximation is.\n\
8694 GRID_NNLI, data specifies what a thin triangle is, in the\n\
8695 range [1. .. 2.]. High values enable the usage of very thin\n\
8696 triangles for interpolation, possibly resulting in error in\n\
8697 the approximation.\n\
8698 GRID_NNI, only weights greater than data will be accepted. If\n\
8699 0, all weights will be accepted.\n\
8702 Clear current (sub)page\n\
8706 Clears the current page, effectively erasing everything that have been\n\
8707 drawn. This command only works with interactive drivers; if the\n\
8708 driver does not support this, the page is filled with the background\n\
8709 color in use. If the current page is divided into subpages, only the\n\
8710 current subpage is erased.\tThe nth subpage can be selected with\n\
8713 Redacted form: General: plclear()\n\
8714 \t Perl/PDL: Not available?\n\
8717 This function is not used in any examples.\n\
8726 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8730 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8731 and PLFLT alpha transparency value. This sets the entire color map --\n\
8732 only as many colors as specified will be allocated.\n\
8734 Redacted form: plscmap0a(r, g, b, alpha)\n\
8736 This function is used in examples 30.\n\
8742 plscmap0a(r, g, b, alpha, ncol0)\n\
8746 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8747 integers (0-255) representing the degree of red in the color.\n\
8749 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8750 integers (0-255) representing the degree of green in the color.\n\
8752 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8753 integers (0-255) representing the degree of blue in the color.\n\
8755 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8756 representing the alpha transparency of the color.\n\
8758 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8762 Set 8-bit RGB values for given cmap0 color index\n\
8766 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8767 index. Overwrites the previous color value for the given index and,\n\
8768 thus, does not result in any additional allocation of space for\n\
8771 Redacted form: plscol0(icol0, r, g, b)\n\
8773 This function is used in any example 31.\n\
8779 plscol0(icol0, r, g, b)\n\
8783 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8784 number of colors (which is set by default, by plscmap0n, or even\n\
8787 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8788 degree of red in the color.\n\
8790 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8791 degree of green in the color.\n\
8793 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8794 degree of blue in the color.\n\
8797 Set up transformation from metafile coordinates\n\
8801 Set up transformation from metafile coordinates. The size of the plot\n\
8802 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8803 general-purpose facility just yet (not sure why the user would need\n\
8806 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8809 This function is not used in any examples.\n\
8815 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8819 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
8821 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
8823 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
8825 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
8827 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
8829 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
8832 Creates a new stream and makes it the default\n\
8836 Creates a new stream and makes it the default. Differs from using\n\
8837 plsstrm, in that a free stream number is found, and returned.\n\
8838 Unfortunately, I have to start at stream 1 and work upward, since\n\
8839 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8840 that no initial, library-opening call is required.\tSo stream 0 must\n\
8841 be preallocated, and there is no simple way of determining whether it\n\
8842 is already in use or not.\n\
8844 Redacted form: plmkstrm(p_strm)\n\
8846 This function is used in examples 1 and 20.\n\
8856 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
8857 number of the created stream.\n\
8860 Get page parameters\n\
8864 Gets the current page configuration. The length and offset values are\n\
8865 expressed in units that are specific to the current driver. For\n\
8866 instance: screen drivers will usually interpret them as number of\n\
8867 pixels, whereas printer drivers will usually use mm.\n\
8869 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8871 This function is used in examples 14 and 31.\n\
8877 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8881 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
8882 pixels/inch (DPI) in x.\n\
8884 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
8885 pixels/inch (DPI) in y.\n\
8887 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
8890 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
8893 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
8896 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
8900 Set format for date / time labels\n\
8904 Sets the format for date / time labels. To enable date / time format\n\
8905 labels see the options to plbox, plbox3, and plenv.\n\
8907 Redacted form: pltimefmt(fmt)\n\
8909 This function is used in example 29.\n\
8919 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
8920 interpreted similarly to the format specifier of typical system\n\
8921 strftime routines except that PLplot ignores locale and also\n\
8922 supplies some useful extensions in the context of plotting. All\n\
8923 text in the string is printed as-is other than conversion\n\
8924 specifications which take the form of a \'%\' character followed by\n\
8925 further conversion specification character. The conversion\n\
8926 specifications which are similar to those provided by system\n\
8927 strftime routines are the following: %a: The abbreviated (English)\n\
8929 %A: The full (English) weekday name.\n\
8930 %b: The abbreviated (English) month name.\n\
8931 %B: The full (English) month name.\n\
8932 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
8933 %C: The century number (year/100) as a 2-digit integer.\n\
8934 %d: The day of the month as a decimal number (range 01 to 31).\n\
8935 %D: Equivalent to %m/%d/%y (non-ISO).\n\
8936 %e: Like %d, but a leading zero is replaced by a space.\n\
8937 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
8938 %h: Equivalent to %b.\n\
8939 %H: The hour as a decimal number using a 24-hour clock (range\n\
8941 %I: The hour as a decimal number using a 12-hour clock (range\n\
8943 %j: The day of the year as a decimal number (range 001 to\n\
8945 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
8946 23); single digits are preceded by a blank. (See also %H.)\n\
8947 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
8948 12); single digits are preceded by a blank. (See also %I.)\n\
8949 %m: The month as a decimal number (range 01 to 12).\n\
8950 %M: The minute as a decimal number (range 00 to 59).\n\
8951 %n: A newline character.\n\
8952 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
8953 Noon is treated as \"PM\" and midnight as \"AM\".\n\
8954 %r: Equivalent to %I:%M:%S %p.\n\
8955 %R: The time in 24-hour notation (%H:%M). For a version\n\
8956 including the seconds, see %T below.\n\
8957 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
8959 %S: The second as a decimal number (range 00 to 60). (The\n\
8960 range is up to 60 to allow for occasional leap seconds.)\n\
8961 %t: A tab character.\n\
8962 %T: The time in 24-hour notation (%H:%M:%S).\n\
8963 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
8964 being 1. See also %w.\n\
8965 %U: The week number of the current year as a decimal number,\n\
8966 range 00 to 53, starting with the first Sunday as the first\n\
8967 day of week 01. See also %V and %W.\n\
8968 %v: Equivalent to %e-%b-%Y.\n\
8969 %V: The ISO 8601 week number of the current year as a decimal\n\
8970 number, range 01 to 53, where week 1 is the first week that\n\
8971 has at least 4 days in the new year. See also %U and %W.\n\
8972 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
8973 being 0. See also %u.\n\
8974 %W: The week number of the current year as a decimal number,\n\
8975 range 00 to 53, starting with the first Monday as the first\n\
8977 %x: Equivalent to %a %b %d %Y.\n\
8978 %X: Equivalent to %T.\n\
8979 %y: The year as a decimal number without a century (range 00\n\
8981 %Y: The year as a decimal number including a century.\n\
8982 %z: The UTC time-zone string = \"+0000\".\n\
8983 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
8984 %+: The UTC date and time in default format of the Unix date\n\
8985 command which is equivalent to %a %b %d %T %Z %Y.\n\
8986 %%: A literal \"%\" character.\n\
8987 The conversion specifications which are extensions to those normally\n\
8988 provided by system strftime routines are the following: %(0-9):\n\
8989 The fractional part of the seconds field (including leading\n\
8990 decimal point) to the specified accuracy. Thus %S%3 would give\n\
8991 seconds to millisecond accuracy (00.000).\n\
8992 %.: The fractional part of the seconds field (including\n\
8993 leading decimal point) to the maximum available accuracy. Thus\n\
8994 %S%. would give seconds with fractional part up to 9 decimal\n\
8995 places if available.\n\
8998 Specify viewport using aspect ratio only\n\
9002 Selects the largest viewport with the given aspect ratio within the\n\
9003 subpage that leaves a standard margin (left-hand margin of eight\n\
9004 character heights, and a margin around the other three sides of five\n\
9005 character heights).\n\
9007 Redacted form: plvasp(aspect)\n\
9009 This function is used in example 13.\n\
9019 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9020 axis of resulting viewport.\n\
9023 Set output file name\n\
9027 Sets the current output file name, if applicable. If the file name\n\
9028 has not been specified and is required by the driver, the user will be\n\
9029 prompted for it. If using the X-windows output driver, this sets the\n\
9030 display name. This routine, if used, must be called before\n\
9031 initializing PLplot.\n\
9033 Redacted form: plsfnam(fnam)\n\
9035 This function is used in examples 1 and 20.\n\
9045 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9053 Draws a plot of vector data contained in the matrices (\n\
9059 ny]) . The scaling factor for the vectors is given by scale. A\n\
9060 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9061 additional data required by the transformation routine to map indices\n\
9062 within the matrices to the world coordinates. The style of the vector\n\
9063 arrow may be set using plsvect.\n\
9065 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9066 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9067 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9068 with either one or two dimensions.\n\
9070 This function is used in example 22.\n\
9076 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9080 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9081 and y components of the vector data to be plotted.\n\
9083 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9085 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9086 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9087 automatically calculated for the data. If scale < 0 then the\n\
9088 scaling factor is automatically calculated for the data and then\n\
9090 scale. If scale > 0 then the scaling factor is set to scale.\n\
9092 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9093 defines the transformation between the zero-based indices of the\n\
9094 matrices u and v and world coordinates.For the C case,\n\
9095 transformation functions are provided in the PLplot library: pltr0\n\
9096 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9097 mappings respectively defined by vectors and matrices. In\n\
9098 addition, C callback routines for the transformation can be\n\
9099 supplied by the user such as the mypltr function in\n\
9100 examples/c/x09c.c which provides a general linear transformation\n\
9101 between index coordinates and world coordinates.For languages\n\
9102 other than C you should consult the PLplot documentation for the\n\
9103 details concerning how PLTRANSFORM_callback arguments are\n\
9104 interfaced. However, in general, a particular pattern of\n\
9105 callback-associated arguments such as a tr vector with 6 elements;\n\
9106 xg and yg vectors; or xg and yg matrices are respectively\n\
9107 interfaced to a linear-transformation routine similar to the above\n\
9108 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9109 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9110 support native language callbacks for handling index to\n\
9111 world-coordinate transformations. Examples of these various\n\
9112 approaches are given in examples/<language>x09*,\n\
9113 examples/<language>x16*, examples/<language>x20*,\n\
9114 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9115 supported languages.\n\
9117 pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
9118 pass information to pltr0, pltr1, pltr2, or whatever callback\n\
9119 routine that is externally supplied.\n\
9122 Set parameters that define current plot-space window\n\
9126 Set relative minima and maxima that define the current plot-space\n\
9127 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9128 xmax, and ymax are 0., 0., 1., and 1.\n\
9130 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9132 This function is used in example 31.\n\
9138 plsdiplt(xmin, ymin, xmax, ymax)\n\
9142 xmin (PLFLT, input) : Relative minimum in x.\n\
9144 ymin (PLFLT, input) : Relative minimum in y.\n\
9146 xmax (PLFLT, input) : Relative maximum in x.\n\
9148 ymax (PLFLT, input) : Relative maximum in y.\n\
9151 Select line style\n\
9155 This sets the line style according to one of eight predefined patterns\n\
9156 (also see plstyl).\n\
9158 Redacted form: pllsty(lin)\n\
9160 This function is used in examples 9, 12, 22, and 25.\n\
9170 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9171 a continuous line, line style 2 is a line with short dashes and\n\
9172 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9173 4 has long dashes and short gaps and so on.\n\
9176 Plot a glyph at the specified points\n\
9180 Plot a glyph at the specified points. (This function is largely\n\
9181 superseded by plstring which gives access to many[!] more glyphs.)\n\
9183 Redacted form: plsym(x, y, code)\n\
9185 This function is used in example 7.\n\
9191 plsym(n, x, y, code)\n\
9195 n (PLINT, input) : Number of points in the x and y vectors.\n\
9197 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9200 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9203 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9204 to be plotted at each of the n points.\n\
9207 Set the device (keyword) name\n\
9211 Set the device (keyword) name.\n\
9213 Redacted form: plsdev(devname)\n\
9215 This function is used in examples 1, 14, and 20.\n\
9225 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9226 containing the device name keyword of the required output device.\n\
9228 devname is NULL or if the first character of the string is a ``?\'\',\n\
9229 the normal (prompted) start up is used.\n\
9232 Set the background color by 8-bit RGB value\n\
9236 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9237 the PLplot documentation).\n\
9239 Redacted form: plscolbg(r, g, b)\n\
9241 This function is used in examples 15 and 31.\n\
9247 plscolbg(r, g, b)\n\
9251 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9252 degree of red in the color.\n\
9254 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9255 degree of green in the color.\n\
9257 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9258 degree of blue in the color.\n\
9261 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9265 Set relative minima and maxima incrementally (zoom mode) that define\n\
9266 the current plot-space window. This function has the same effect as\n\
9267 plsdiplt if that function has not been previously called. Otherwise,\n\
9268 this function implements zoom mode using the transformation min_used =\n\
9269 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9270 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9271 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9273 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9275 This function is used in example 31.\n\
9281 plsdiplz(xmin, ymin, xmax, ymax)\n\
9285 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9287 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9289 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9291 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9294 Advance to the next family file on the next new page\n\
9298 Advance to the next family file on the next new page.\n\
9300 Redacted form: plfamadv()\n\
9302 This function is not used in any examples.\n\
9311 Set number of colors in cmap0\n\
9315 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9316 (or reallocate) cmap0, and fill with default values for those colors\n\
9317 not previously allocated. The first 16 default colors are given in\n\
9318 the plcol0 documentation. For larger indices the default color is\n\
9321 The drivers are not guaranteed to support more than 16 colors.\n\
9323 Redacted form: plscmap0n(ncol0)\n\
9325 This function is used in examples 15, 16, and 24.\n\
9335 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9336 the cmap0 palette. If this number is zero or less, then the value\n\
9337 from the previous call to plscmap0n is used and if there is no\n\
9338 previous call, then a default value is used.\n\
9341 Plot latitude and longitude lines\n\
9345 Displays latitude and longitude on the current plot. The lines are\n\
9346 plotted in the current color and line style.\n\
9348 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9351 This function is used in example 19.\n\
9357 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9361 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9362 transform the coordinate longitudes and latitudes to a plot\n\
9363 coordinate system. By using this transform, we can change from a\n\
9364 longitude, latitude coordinate to a polar stereographic project,\n\
9365 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9366 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9367 mapform(), x[] and y[] should be replaced by the corresponding\n\
9368 plot coordinates. If no transform is desired, mapform can be\n\
9369 replaced by NULL.\n\
9371 dlong (PLFLT, input) : The interval in degrees at which the\n\
9372 longitude lines are to be plotted.\n\
9374 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9375 lines are to be plotted.\n\
9377 minlong (PLFLT, input) : The value of the longitude on the left\n\
9378 side of the plot. The value of minlong must be less than the value\n\
9379 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9382 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9383 side of the plot.\n\
9385 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9386 background. One can always use -90.0 as the boundary outside the\n\
9387 plot window will be automatically eliminated. However, the\n\
9388 program will be faster if one can reduce the size of the\n\
9389 background plotted.\n\
9391 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9392 background. One can always use 90.0 as the boundary outside the\n\
9393 plot window will be automatically eliminated.\n\
9396 Convert RGB color to HLS\n\
9400 Convert RGB color coordinates to HLS\n\
9402 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9403 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1?\n\
9406 This function is used in example 2.\n\
9412 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9416 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9418 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9420 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9422 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9423 degrees (0.0-360.0) on the color cylinder.\n\
9425 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9426 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9429 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9430 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9434 Plot a glyph at the specified 3D points\n\
9438 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9439 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9440 this function similar to what is done for plline3. The glyph is\n\
9441 specified with a PLplot user string. Note that the user string is not\n\
9442 actually limited to one glyph so it is possible (but not normally\n\
9443 useful) to plot more than one glyph at the specified points with this\n\
9444 function. As with plmtex and plptex, the user string can contain FCI\n\
9445 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9446 else PLplot escapes for Hershey or unicode text to determine the\n\
9449 Redacted form: plstring3(x, y, z, string)\n\
9451 This function is used in example 18.\n\
9457 plstring3(n, x, y, z, string)\n\
9461 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9463 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9466 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9469 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9472 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9473 the glyph(s) to be plotted at each of the n points. points.\n\
9476 Switch to text screen\n\
9480 Sets an interactive device to text mode, used in conjunction with\n\
9481 plgra to allow graphics and text to be interspersed. On a device\n\
9482 which supports separate text and graphics windows, this command causes\n\
9483 control to be switched to the text window.\tThis can be useful for\n\
9484 printing diagnostic messages or getting user input, which would\n\
9485 otherwise interfere with the plots. The program must switch back to\n\
9486 the graphics window before issuing plot commands, as the text (or\n\
9487 console) device will probably become quite confused otherwise. If\n\
9488 already in text mode, this command is ignored. It is also ignored on\n\
9489 devices which only support a single window or use a different method\n\
9490 for shifting focus (see also plgra).\n\
9492 Redacted form: pltext()\n\
9494 This function is used in example 1.\n\
9503 Get parameters that define current plot-space window\n\
9507 Get relative minima and maxima that define current plot-space window.\n\
9508 If plsdiplt has not been called the default values pointed to by\n\
9509 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9511 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9513 This function is used in example 31.\n\
9519 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9523 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9526 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9529 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9532 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9536 Get the (current) run level\n\
9540 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9541 \t 1,\tinitialized\n\
9542 \t 2,\tviewport defined\n\
9543 \t 3,\tworld coordinates defined\n\
9546 Redacted form: plglevel(p_level)\n\
9548 This function is used in example 31.\n\
9554 plglevel(p_level)\n\
9558 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9562 Plot a histogram from binned data\n\
9566 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9567 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9568 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9569 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9570 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9571 placed midway between the values in the x vector. Also see plhist for\n\
9572 drawing histograms from unbinned data.\n\
9574 Redacted form: General: plbin(x, y, opt)\n\
9575 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9576 \t Python: plbin(nbin, x, y, opt)\n\
9579 This function is not used in any examples.\n\
9585 plbin(nbin, x, y, opt)\n\
9589 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9592 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9593 with bins. These must form a strictly increasing sequence.\n\
9595 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9596 proportional to the number of points in each bin. This is a PLFLT\n\
9597 (instead of PLINT) vector so as to allow histograms of\n\
9598 probabilities, etc.\n\
9600 opt (PLINT, input) : Is a combination of several flags:\n\
9601 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9602 outer bins are expanded to fill up the entire x-axis and bins of\n\
9603 zero height are simply drawn.\n\
9604 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9605 between the x values. If the values in x are equally spaced,\n\
9606 the values are the center values of the bins.\n\
9607 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9608 size as the ones inside.\n\
9609 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9610 (there is a gap for such bins).\n\
9613 Plot a 2D matrix using cmap1\n\
9617 Plot a 2D matrix using cmap1.\n\
9619 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9620 zmax, valuemin, valuemax, pltr, pltr_data)\n\
9623 This function is used in example 20.\n\
9629 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9633 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9634 plot. Should have dimensions of\n\
9638 nx, ny (PLINT, input) : Dimensions of idata\n\
9640 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9641 pltr below for how these arguments are used (only for the special case\n\
9642 when the callback function\n\
9643 pltr is not supplied).\n\
9645 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9646 (inclusive) will be plotted.\n\
9648 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9649 values to use for value to color mappings. A datum equal to or\n\
9650 less than valuemin will be plotted with color 0.0, while a datum\n\
9651 equal to or greater than valuemax will be plotted with color 1.0.\n\
9652 Data between valuemin and valuemax map linearly to colors in the\n\
9655 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9656 defines the transformation between the zero-based indices of the\n\
9657 matrix idata and world coordinates. If\n\
9658 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9659 indices of idata are mapped to the range\n\
9661 xmax and the y indices of idata are mapped to the range\n\
9663 ymax.For the C case, transformation functions are provided in the\n\
9664 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9665 pltr2 for arbitrary mappings respectively defined by vectors and\n\
9666 matrices. In addition, C callback routines for the transformation\n\
9667 can be supplied by the user such as the mypltr function in\n\
9668 examples/c/x09c.c which provides a general linear transformation\n\
9669 between index coordinates and world coordinates.For languages\n\
9670 other than C you should consult the PLplot documentation for the\n\
9671 details concerning how PLTRANSFORM_callback arguments are\n\
9672 interfaced. However, in general, a particular pattern of\n\
9673 callback-associated arguments such as a tr vector with 6 elements;\n\
9674 xg and yg vectors; or xg and yg matrices are respectively\n\
9675 interfaced to a linear-transformation routine similar to the above\n\
9676 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9677 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9678 support native language callbacks for handling index to\n\
9679 world-coordinate transformations. Examples of these various\n\
9680 approaches are given in examples/<language>x09*,\n\
9681 examples/<language>x16*, examples/<language>x20*,\n\
9682 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9683 supported languages.\n\
9685 pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
9686 pass information to pltr0, pltr1, pltr2, or whatever routine is\n\
9687 externally supplied.\n\
9690 Get family, style and weight of the current font\n\
9694 Gets information about current font. See the PLplot documentation for\n\
9695 more information on font selection.\n\
9697 Redacted form: plgfont(p_family, p_style, p_weight)\n\
9699 This function is used in example 23.\n\
9705 plgfont(p_family, p_style, p_weight)\n\
9709 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9710 font family. The available values are given by the PL_FCI_*\n\
9711 constants in plplot.h. Current options are PL_FCI_SANS,\n\
9712 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9713 p_family is NULL then the font family is not returned.\n\
9715 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9716 font style. The available values are given by the PL_FCI_*\n\
9717 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9718 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
9719 style is not returned.\n\
9721 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9722 font weight. The available values are given by the PL_FCI_*\n\
9723 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9724 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9728 Get z axis parameters\n\
9732 Identical to plgxax, except that arguments are flags for z axis. See\n\
9733 the description of plgxax for more detail.\n\
9735 Redacted form: plgzax(p_digmax, p_digits)\n\
9737 This function is used in example 31.\n\
9743 plgzax(p_digmax, p_digits)\n\
9747 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
9748 number of digits for the z axis. If nonzero, the printed label\n\
9749 has been switched to a floating-point representation when the\n\
9750 number of digits exceeds this value.\n\
9752 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
9753 number of digits for the numeric labels (z axis) from the last\n\
9757 Write text inside the viewport of a 3D plot\n\
9761 Writes text at a specified position and inclination and with a\n\
9762 specified shear within the viewport. Text is clipped at the viewport\n\
9763 boundaries. The reference point of a string lies along a line passing\n\
9764 through the string at half the height of a capital letter.\tThe\n\
9765 position of the reference point along this line is determined by just,\n\
9766 and the reference point is placed at world coordinates (\n\
9769 wz) within the viewport. The inclination and shear of the string is\n\
9770 specified in terms of differences of world coordinates making it easy\n\
9771 to write text parallel to a line in a graph.\n\
9773 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
9775 This function is used in example 28.\n\
9781 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9785 wx (PLFLT, input) : x world coordinate of reference point of\n\
9788 wy (PLFLT, input) : y world coordinate of reference point of\n\
9791 wz (PLFLT, input) : z world coordinate of reference point of\n\
9794 dx (PLFLT, input) : Together with dy and\n\
9795 dz , this specifies the inclination of the string. The baseline of\n\
9796 the string is parallel to a line joining (\n\
9807 dy (PLFLT, input) : Together with dx and\n\
9808 dz, this specifies the inclination of the string.\n\
9810 dz (PLFLT, input) : Together with dx and\n\
9811 dy, this specifies the inclination of the string.\n\
9813 sx (PLFLT, input) : Together with sy and\n\
9814 sz , this specifies the shear of the string. The string is sheared so\n\
9815 that the characters are vertically parallel to a line joining (\n\
9826 sz = 0.) then the text is not sheared.\n\
9828 sy (PLFLT, input) : Together with sx and\n\
9829 sz, this specifies shear of the string.\n\
9831 sz (PLFLT, input) : Together with sx and\n\
9832 sy, this specifies shear of the string.\n\
9834 just (PLFLT, input) : Specifies the position of the string relative\n\
9835 to its reference point. If just=0. , the reference point is at\n\
9836 the left and if just=1. , it is at the right of the string. Other\n\
9837 values of just give intermediate justifications.\n\
9839 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
9843 Draw a box with axes, etc. with arbitrary origin\n\
9847 Draws a box around the currently defined viewport with arbitrary\n\
9848 world-coordinate origin specified by x0 and y0 and labels it with\n\
9849 world coordinate values appropriate to the window.\tThus plaxes should\n\
9850 only be called after defining both viewport and window. The ascii\n\
9851 character strings xopt and yopt specify how the box should be drawn as\n\
9852 described below. If ticks and/or subticks are to be drawn for a\n\
9853 particular axis, the tick intervals and number of subintervals may be\n\
9854 specified explicitly, or they may be defaulted by setting the\n\
9855 appropriate arguments to zero.\n\
9857 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9859 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9863 This function is not used in any examples.\n\
9869 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9873 x0 (PLFLT, input) : World X coordinate of origin.\n\
9875 y0 (PLFLT, input) : World Y coordinate of origin.\n\
9877 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
9878 options for the x axis. The string can include any combination of\n\
9879 the following letters (upper or lower case) in any order: a: Draws\n\
9880 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
9882 b: Draws bottom (X) or left (Y) edge of frame.\n\
9883 c: Draws top (X) or right (Y) edge of frame.\n\
9884 d: Plot labels as date / time. Values are assumed to be\n\
9885 seconds since the epoch (as used by gmtime).\n\
9886 f: Always use fixed point numeric labels.\n\
9887 g: Draws a grid at the major tick interval.\n\
9888 h: Draws a grid at the minor tick interval.\n\
9889 i: Inverts tick marks, so they are drawn outwards, rather than\n\
9891 l: Labels axis logarithmically. This only affects the labels,\n\
9892 not the data, and so it is necessary to compute the logarithms\n\
9893 of data points before passing them to any of the drawing\n\
9895 m: Writes numeric labels at major tick intervals in the\n\
9896 unconventional location (above box for X, right of box for Y).\n\
9897 n: Writes numeric labels at major tick intervals in the\n\
9898 conventional location (below box for X, left of box for Y).\n\
9899 o: Use custom labelling function to generate axis label text.\n\
9900 The custom labelling function can be defined with the\n\
9901 plslabelfunc command.\n\
9902 s: Enables subticks between major ticks, only valid if t is\n\
9904 t: Draws major ticks.\n\
9905 u: Exactly like \"b\" except don\'t draw edge line.\n\
9906 w: Exactly like \"c\" except don\'t draw edge line.\n\
9907 x: Exactly like \"t\" (including the side effect of the\n\
9908 numerical labels for the major ticks) except exclude drawing\n\
9909 the major and minor tick marks.\n\
9912 xtick (PLFLT, input) : World coordinate interval between major\n\
9913 ticks on the x axis. If it is set to zero, PLplot automatically\n\
9914 generates a suitable tick interval.\n\
9916 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9917 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9918 generates a suitable minor tick interval.\n\
9920 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
9921 options for the y axis. The string can include any combination of\n\
9922 the letters defined above for xopt, and in addition may contain:\n\
9923 v: Write numeric labels for the y axis parallel to the base of the\n\
9924 graph, rather than parallel to the axis.\n\
9927 ytick (PLFLT, input) : World coordinate interval between major\n\
9928 ticks on the y axis. If it is set to zero, PLplot automatically\n\
9929 generates a suitable tick interval.\n\
9931 nysub (PLINT, input) : Number of subintervals between major y axis\n\
9932 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9933 generates a suitable minor tick interval.\n\
9936 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
9940 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
9942 Redacted form: plgcolbg(r, g, b)\n\
9944 This function is used in example 31.\n\
9950 plgcolbg(r, g, b)\n\
9954 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
9955 in the range from 0 to 255.\n\
9957 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
9958 in the range from 0 to 255.\n\
9960 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
9961 in the range from 0 to 255.\n\
9964 Plot a glyph at the specified 3D points\n\
9968 Plot a glyph at the specified 3D points. (This function is largely\n\
9969 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9970 Set up the call to this function similar to what is done for plline3.\n\
9971 code=-1 means try to just draw a point. Right now it\'s just a move\n\
9972 and a draw at the same place. Not ideal, since a sufficiently\n\
9973 intelligent output device may optimize it away, or there may be faster\n\
9974 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9975 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9976 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9977 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9978 code <= 127 the corresponding printable ASCII character is plotted.\n\
9980 Redacted form: plpoin3(x, y, z, code)\n\
9982 This function is not used in any example.\n\
9988 plpoin3(n, x, y, z, code)\n\
9992 n (PLINT, input) : Number of points in the x and y vectors.\n\
9994 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9997 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10000 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10003 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10004 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10005 each of the n points.\n\
10008 Draw a polygon in 3 space\n\
10012 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10013 like plline3, but differs from that function in that plpoly3 attempts\n\
10014 to determine if the polygon is viewable depending on the order of the\n\
10015 points within the vector and the value of ifcc. If the back of\n\
10016 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
10017 you want, then use plline3 instead.\n\
10019 The points are assumed to be in a plane, and the directionality of the\n\
10020 plane is determined from the first three points. Additional points do\n\
10021 not have to lie on the plane defined by the first three, but if they\n\
10022 do not, then the determination of visibility obviously can\'t be 100%\n\
10023 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10024 consider breaking them into smaller polygons. 3 points define a plane\n\
10027 Bugs: If one of the first two segments is of zero length, or if they\n\
10028 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10029 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
10030 of this problem. (Search for 20.1).\n\
10032 Redacted form: plpoly3(x, y, z, code)\n\
10034 This function is used in example 18.\n\
10040 plpoly3(n, x, y, z, draw, ifcc)\n\
10044 n (PLINT, input) : Number of points defining line.\n\
10046 x (PLFLT_VECTOR, input) : A vector containing\n\
10047 n x coordinates of points.\n\
10049 y (PLFLT_VECTOR, input) : A vector containing\n\
10050 n y coordinates of points.\n\
10052 z (PLFLT_VECTOR, input) : A vector containing\n\
10053 n z coordinates of points.\n\
10055 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10056 n-1 Boolean values which control drawing the segments of the polygon.\n\
10057 If draw[i] is true, then the polygon segment from index [i] to\n\
10058 [i+1] is drawn, otherwise, not.\n\
10060 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10061 polygon is determined by assuming the points are laid out in a\n\
10062 counter-clockwise order. Otherwise, the directionality of the\n\
10063 polygon is determined by assuming the points are laid out in a\n\
10064 clockwise order.\n\
10067 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10071 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10072 PLFLT alpha transparency value (see the PLplot documentation).\n\
10074 This function is used in example 31.\n\
10080 plscolbga(r, g, b, alpha)\n\
10084 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10085 degree of red in the color.\n\
10087 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10088 degree of green in the color.\n\
10090 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10091 degree of blue in the color.\n\
10093 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10097 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10101 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10102 alpha transparency value.\n\
10104 This function is used in example 31.\n\
10110 plgcolbga(r, g, b, alpha)\n\
10114 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10115 in the range from 0 to 255.\n\
10117 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10118 in the range from 0 to 255.\n\
10120 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10121 in the range from 0 to 255.\n\
10123 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10124 transparency in the range (0.0-1.0).\n\
10127 Draw error bars in x direction\n\
10131 Draws a set of n error bars in x direction, the i\'th error bar\n\
10132 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10133 of the error bars are of length equal to the minor tick length\n\
10134 (settable using plsmin).\n\
10136 Redacted form: General: plerrx(xmin, ymax, y)\n\
10137 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
10140 This function is used in example 29.\n\
10146 plerrx(n, xmin, xmax, y)\n\
10150 n (PLINT, input) : Number of error bars to draw.\n\
10152 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10153 of the left-hand endpoints of the error bars.\n\
10155 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10156 of the right-hand endpoints of the error bars.\n\
10158 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10162 Eject current page\n\
10166 Clears the graphics screen of an interactive device, or ejects a page\n\
10167 on a plotter. See plbop for more information.\n\
10169 Redacted form: pleop()\n\
10171 This function is used in example 2,14.\n\
10180 Convert HLS color to RGB\n\
10184 Convert HLS color coordinates to RGB.\n\
10186 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10187 \t Perl/PDL: Not available? Implemented as plhls?\n\
10190 This function is used in example 2.\n\
10196 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10200 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10203 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10204 the axis of the color cylinder.\n\
10206 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10207 the radius of the color cylinder.\n\
10209 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10210 (0.0-1.0) of the color.\n\
10212 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10213 intensity (0.0-1.0) of the color.\n\
10215 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10216 intensity (0.0-1.0) of the color.\n\
10219 Plot all or a subset of Shapefile data, filling the polygons\n\
10223 As per plmapline, however the items are filled in the same way as\n\
10226 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10229 This function is used in example 19.\n\
10235 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10239 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10240 transform the coordinates given in the shapefile into a plot\n\
10241 coordinate system. By using this transform, we can change from a\n\
10242 longitude, latitude coordinate to a polar stereographic project,\n\
10243 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10244 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10245 mapform(), x[] and y[] should be replaced by the corresponding\n\
10246 plot coordinates. If no transform is desired, mapform can be\n\
10247 replaced by NULL.\n\
10249 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10250 the file name of a set of Shapefile files without the file\n\
10253 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10254 be in the same units as used by the Shapefile. You could use a\n\
10255 very large negative number to plot everything, but you can improve\n\
10256 performance by limiting the area drawn. The units must match those\n\
10257 of the Shapefile projection, which may be for example longitude or\n\
10258 distance. The value of minx must be less than the value of maxx.\n\
10260 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10261 use a very large number to plot everything, but you can improve\n\
10262 performance by limiting the area drawn.\n\
10264 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10265 be in the same units as used by the Shapefile. You could use a\n\
10266 very large negative number to plot everything, but you can improve\n\
10267 performance by limiting the area drawn. The units must match those\n\
10268 of the Shapefile projection, which may be for example latitude or\n\
10269 distance. The value of miny must be less than the value of maxy.\n\
10271 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10272 use a very large number to plot everything, but you can improve\n\
10273 performance by limiting the area drawn.\n\
10275 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10276 zero-based indices of the Shapefile elements which will be drawn.\n\
10278 plotentries to NULL will plot all elements of the Shapefile.\n\
10280 nplotentries (PLINT, input) : The number of items in\n\
10281 plotentries. Ignored if\n\
10282 plotentries is NULL.\n\
10285 Draw error bars in the y direction\n\
10289 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10290 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10291 of the error bars are of length equal to the minor tick length\n\
10292 (settable using plsmin).\n\
10294 Redacted form: General: plerry(x, ymin, ymax)\n\
10295 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
10298 This function is used in example 29.\n\
10304 plerry(n, x, ymin, ymax)\n\
10308 n (PLINT, input) : Number of error bars to draw.\n\
10310 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10313 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10314 of the lower endpoints of the error bars.\n\
10316 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10317 of the upper endpoints of the error bars.\n\
10320 Set FCI (font characterization integer)\n\
10324 Sets font characteristics to be used at the start of the next string\n\
10325 using the FCI approach. See the PLplot documentation for more\n\
10326 information. Note, plsfont (which calls plsfci internally) provides a\n\
10327 more user-friendly API for setting the font characterisitics.\n\
10329 Redacted form: General: plsfci(fci)\n\
10330 \t Perl/PDL: Not available?\n\
10333 This function is used in example 23.\n\
10343 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10347 Select area fill pattern\n\
10352 patt is zero or less use either a hardware solid fill if the drivers\n\
10353 have that capability (virtually all do) or fall back to a software\n\
10354 emulation of a solid fill using the eighth area line fill pattern.\tIf\n\
10356 patt <= 8, then select one of eight predefined area line fill patterns\n\
10357 to use (see plpat if you desire other patterns).\n\
10359 Redacted form: plpsty(patt)\n\
10361 This function is used in examples 12, 13, 15, 16, and 25.\n\
10371 patt (PLINT, input) : The desired pattern index. If\n\
10372 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10373 above) used. For\n\
10374 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10375 line fill capability itself (most deliberately do not so that line\n\
10376 fill patterns look identical for those drivers), the patterns\n\
10377 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10378 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10379 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10380 (8) lines at both 45 degrees and -45 degrees.\n\
10387 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10388 plsym. The actual height of a symbol is the product of the default\n\
10389 symbol size and a scaling factor as for the character height.\n\
10391 Redacted form: plssym(def, scale)\n\
10393 This function is used in example 29.\n\
10399 plssym(def, scale)\n\
10403 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10404 should be set to zero if the default height is to remain\n\
10407 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10408 actual symbol height.\n\
10415 Alternative to plstar for initializing the plotting package. The\n\
10416 device name keyword for the desired output device must be supplied as\n\
10417 an argument. These keywords are the same as those printed out by\n\
10418 plstar. If the requested device is not available, or if the input\n\
10419 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10420 is used. This routine also divides the output device page into nx by\n\
10421 ny subpages, each of which may be used independently. The subroutine\n\
10422 pladv is used to advance from one subpage to the next.\n\
10424 Redacted form: General: plstart(devname, nx, ny)\n\
10425 \t Perl/PDL: plstart(nx, ny, devname)\n\
10428 This function is not used in any examples.\n\
10434 plstart(devname, nx, ny)\n\
10438 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10439 containing the device name keyword of the required output device.\n\
10441 devname is NULL or if the first character of the string is a ``?\'\',\n\
10442 the normal (prompted) start up is used.\n\
10444 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10447 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10453 PLINT *arg2 = (PLINT *) 0 ;
10454 char **arg3 = (
char **) 0 ;
10456 octave_value_list _out;
10457 octave_value_list *_outp=&_out;
10458 octave_value _outv;
10464 if (
_n_dims( args(0) ) > 1 )
10468 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
10469 arg2 =
new PLINT[
Alen];
10470 temp1 = args(0).matrix_value();
10474 charMatrix temp_matrix;
10478 size_t max_length = 0, non_blank_length;
10480 if (
_n_dims( args(1) ) > 2 )
10482 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10484 if ( !args(1).is_empty() )
10486 if (
_dim( args(1), 0 ) != Alen )
10488 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10490 arg3 =
new char*[
Alen];
10491 ifcell = args(1).is_cell();
10494 temp_cell = args(1).cell_value();
10498 temp_matrix = args(1).char_matrix_value();
10500 max_length =
_dim( args(1), 1 ) + 1;
10503 for ( i = 0; i <
Alen; i++ )
10510 if ( temp_cell.elem( i ).is_string() )
10512 str = temp_cell.elem( i ).string_value();
10514 max_length = str.size() + 1;
10515 tmp_cstring = (
char *) str.c_str();
10525 tmp_cstring = (
char *)
"";
10530 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
10532 arg3[i] =
new char[max_length];
10533 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10534 arg3[i][max_length - 1] =
'\0';
10549 non_blank_length = max_length - 2;
10550 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10552 non_blank_length--;
10554 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10556 non_blank_length--;
10558 arg3[i][non_blank_length + 1] =
'\0';
10567 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10568 _outv = octave_value();
10575 if ( arg3 != NULL )
10577 for ( i = 0; i <
Alen; i++ )
10591 if ( arg3 != NULL )
10593 for ( i = 0; i <
Alen; i++ )
10600 return octave_value_list();
10605 int *arg1 = (
int *) 0 ;
10606 int *arg2 = (
int *) 0 ;
10607 int *arg3 = (
int *) 0 ;
10608 char *arg4 = (
char *) 0 ;
10609 int *arg5 = (
int *) 0 ;
10610 int *arg6 = (
int *) 0 ;
10611 PLFLT *arg7 = (PLFLT *) 0 ;
10612 PLFLT *arg8 = (PLFLT *) 0 ;
10613 PLFLT *arg9 = (PLFLT *) 0 ;
10614 PLFLT *arg10 = (PLFLT *) 0 ;
10615 int *arg11 = (
int *) 0 ;
10622 octave_value_list retval4 ;
10637 octave_value_list _out;
10638 octave_value_list *_outp=&_out;
10639 octave_value _outv;
10647 # if OCTAVE_API_VERSION_NUMBER < 45
10648 retval4( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
10650 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10652 arg4 = (
char *) retval4( 0 ).char_matrix_value().data();
10664 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10732 return octave_value_list();
10737 PLFLT *arg1 = (PLFLT *) 0 ;
10738 PLFLT *arg2 = (PLFLT *) 0 ;
10749 octave_value_list _out;
10750 octave_value_list *_outp=&_out;
10751 octave_value _outv;
10763 arg3 = (
PLFLT)(val3);
10768 arg4 = (
PLFLT)(val4);
10786 return octave_value_list();
10791 PLINT *arg1 = (PLINT *) 0 ;
10792 char *arg2 = (
char *) 0 ;
10793 char *arg3 = (
char *) 0 ;
10805 PLINT *arg15 = (PLINT *) 0 ;
10806 PLINT *arg16 = (PLINT *) 0 ;
10807 char *arg17 = (
char *) 0 ;
10808 char *arg18 = (
char *) 0 ;
10809 char *arg19 = (
char *) 0 ;
10810 char *arg20 = (
char *) 0 ;
10811 char *arg21 = (
char *) 0 ;
10812 char *arg22 = (
char *) 0 ;
10813 char *arg23 = (
char *) 0 ;
10867 octave_value_list _out;
10868 octave_value_list *_outp=&_out;
10869 octave_value _outv;
10879 arg2 = (
char *)(buf2);
10884 arg3 = (
char *)(buf3);
10889 arg4 = (
PLFLT)(val4);
10894 arg5 = (
PLFLT)(val5);
10899 arg6 = (
PLFLT)(val6);
10904 arg7 = (
PLFLT)(val7);
10909 arg8 = (
PLFLT)(val8);
10914 arg9 = (
PLFLT)(val9);
10919 arg10 = (
PLFLT)(val10);
10924 arg11 = (
PLBOOL)(val11);
10929 arg12 = (
PLBOOL)(val12);
10934 arg13 = (
PLINT)(val13);
10939 arg14 = (
PLINT)(val14);
10941 if (
_n_dims( args(13) ) > 1 )
10945 Alen = (
PLINT) (
_dim( args(13), 0 ) );
10946 temp15 = args(13).matrix_value();
10947 arg15 =
new PLINT[
Alen];
10951 if (
_n_dims( args(14) ) > 1 )
10955 if (
_dim( args(14), 0 ) != Alen )
10959 temp16 = args(14).matrix_value();
10960 arg16 =
new PLINT[
Alen];
10967 arg17 = (
char *)(buf17);
10972 arg18 = (
char *)(buf18);
10977 arg19 = (
char *)(buf19);
10982 arg20 = (
char *)(buf20);
10987 arg21 = (
char *)(buf21);
10992 arg22 = (
char *)(buf22);
10997 arg23 = (
char *)(buf23);
10998 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);
10999 _outv = octave_value();
11039 return octave_value_list();
11044 PLFLT *arg1 = (PLFLT *) 0 ;
11051 PLFLT *arg8 = (PLFLT *) 0 ;
11053 PLFLT *arg10 = (PLFLT *) 0 ;
11065 octave_value_list _out;
11066 octave_value_list *_outp=&_out;
11067 octave_value _outv;
11073 if (
_n_dims( args(0) ) > 2 )
11075 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11077 temp1 = args(0).matrix_value();
11078 arg1 = &temp1( 0, 0 );
11079 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11086 arg4 = (
PLINT)(val4);
11091 arg5 = (
PLINT)(val5);
11096 arg6 = (
PLINT)(val6);
11101 arg7 = (
PLINT)(val7);
11103 if (
_n_dims( args(5) ) > 1 )
11107 temp8 = args(5).matrix_value();
11108 arg8 = &temp8( 0, 0 );
11109 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11112 if (
_n_dims( args(6) ) > 1 )
11116 if (
_dim( args(6), 0 ) != 6 )
11120 temp10 = args(6).matrix_value();
11121 arg10 = &temp10( 0, 0 );
11123 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11124 _outv = octave_value();
11146 return octave_value_list();
11151 PLFLT *arg1 = (PLFLT *) 0 ;
11158 PLFLT *arg8 = (PLFLT *) 0 ;
11170 octave_value_list _out;
11171 octave_value_list *_outp=&_out;
11172 octave_value _outv;
11178 if (
_n_dims( args(0) ) > 2 )
11180 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11182 temp1 = args(0).matrix_value();
11183 arg1 = &temp1( 0, 0 );
11184 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11191 arg4 = (
PLINT)(val4);
11196 arg5 = (
PLINT)(val5);
11201 arg6 = (
PLINT)(val6);
11206 arg7 = (
PLINT)(val7);
11208 if (
_n_dims( args(5) ) > 1 )
11212 temp8 = args(5).matrix_value();
11213 arg8 = &temp8( 0, 0 );
11214 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11216 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11217 _outv = octave_value();
11233 return octave_value_list();
11238 PLFLT *arg1 = (PLFLT *) 0 ;
11245 PLFLT *arg8 = (PLFLT *) 0 ;
11247 PLFLT *arg10 = (PLFLT *) 0 ;
11248 PLFLT *arg11 = (PLFLT *) 0 ;
11261 octave_value_list _out;
11262 octave_value_list *_outp=&_out;
11263 octave_value _outv;
11269 if (
_n_dims( args(0) ) > 2 )
11271 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11273 temp1 = args(0).matrix_value();
11274 arg1 = &temp1( 0, 0 );
11275 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11282 arg4 = (
PLINT)(val4);
11287 arg5 = (
PLINT)(val5);
11292 arg6 = (
PLINT)(val6);
11297 arg7 = (
PLINT)(val7);
11299 if (
_n_dims( args(5) ) > 1 )
11303 temp8 = args(5).matrix_value();
11304 arg8 = &temp8( 0, 0 );
11305 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11308 if (
_n_dims( args(6) ) > 1 )
11312 if (
_dim( args(6), 0 ) != Xlen )
11316 temp10 = args(6).matrix_value();
11317 arg10 = &temp10( 0, 0 );
11320 if (
_n_dims( args(7) ) > 1 )
11328 temp11 = args(7).matrix_value();
11329 arg11 = &temp11( 0, 0 );
11331 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11332 _outv = octave_value();
11360 return octave_value_list();
11365 PLFLT *arg1 = (PLFLT *) 0 ;
11372 PLFLT *arg8 = (PLFLT *) 0 ;
11374 PLFLT *arg10 = (PLFLT *) 0 ;
11375 PLFLT *arg11 = (PLFLT *) 0 ;
11388 octave_value_list _out;
11389 octave_value_list *_outp=&_out;
11390 octave_value _outv;
11396 if (
_n_dims( args(0) ) > 2 )
11398 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11400 temp1 = args(0).matrix_value();
11401 arg1 = &temp1( 0, 0 );
11402 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11409 arg4 = (
PLINT)(val4);
11414 arg5 = (
PLINT)(val5);
11419 arg6 = (
PLINT)(val6);
11424 arg7 = (
PLINT)(val7);
11426 if (
_n_dims( args(5) ) > 1 )
11430 temp8 = args(5).matrix_value();
11431 arg8 = &temp8( 0, 0 );
11432 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11435 if (
_n_dims( args(6) ) > 2 )
11437 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11439 if (
_dim( args(6), 0 ) != Xlen )
11441 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11445 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11447 temp10 = args(6).matrix_value();
11448 arg10 = &temp10( 0, 0 );
11451 if (
_n_dims( args(7) ) > 2 )
11453 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11455 if (
_dim( args(7), 0 ) != Xlen )
11457 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11461 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11463 temp11 = args(7).matrix_value();
11464 arg11 = &temp11( 0, 0 );
11466 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11467 _outv = octave_value();
11495 return octave_value_list();
11500 PLFLT *arg1 = (PLFLT *) 0 ;
11507 PLFLT *arg8 = (PLFLT *) 0 ;
11509 PLFLT *arg10 = (PLFLT *) 0 ;
11510 PLFLT *arg11 = (PLFLT *) 0 ;
11523 octave_value_list _out;
11524 octave_value_list *_outp=&_out;
11525 octave_value _outv;
11531 if (
_n_dims( args(0) ) > 2 )
11533 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11535 temp1 = args(0).matrix_value();
11536 arg1 = &temp1( 0, 0 );
11537 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11544 arg4 = (
PLINT)(val4);
11549 arg5 = (
PLINT)(val5);
11554 arg6 = (
PLINT)(val6);
11559 arg7 = (
PLINT)(val7);
11561 if (
_n_dims( args(5) ) > 1 )
11565 temp8 = args(5).matrix_value();
11566 arg8 = &temp8( 0, 0 );
11567 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11570 if (
_n_dims( args(6) ) > 2 )
11572 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11574 if (
_dim( args(6), 0 ) != Xlen )
11576 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11580 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11582 temp10 = args(6).matrix_value();
11583 arg10 = &temp10( 0, 0 );
11586 if (
_n_dims( args(7) ) > 2 )
11588 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11590 if (
_dim( args(7), 0 ) != Xlen )
11592 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11596 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11598 temp11 = args(7).matrix_value();
11599 arg11 = &temp11( 0, 0 );
11601 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11602 _outv = octave_value();
11630 return octave_value_list();
11635 PLFLT *arg1 = (PLFLT *) 0 ;
11636 PLFLT *arg2 = (PLFLT *) 0 ;
11637 PLFLT *arg3 = (PLFLT *) 0 ;
11639 PLFLT *arg5 = (PLFLT *) 0 ;
11641 PLFLT *arg7 = (PLFLT *) 0 ;
11643 PLFLT *arg9 = (PLFLT *) 0 ;
11651 octave_value_list retval7 ;
11656 octave_value_list _out;
11657 octave_value_list *_outp=&_out;
11658 octave_value _outv;
11664 if (
_n_dims( args(0) ) > 1 )
11669 temp1 = args(0).matrix_value();
11670 arg1 = &temp1( 0, 0 );
11673 if (
_n_dims( args(1) ) > 1 )
11677 if (
_dim( args(1), 0 ) != Alen )
11681 temp2 = args(1).matrix_value();
11682 arg2 = &temp2( 0, 0 );
11685 if (
_n_dims( args(2) ) > 1 )
11689 if (
_dim( args(2), 0 ) != Alen )
11693 temp3 = args(2).matrix_value();
11694 arg3 = &temp3( 0, 0 );
11698 if (
_n_dims( args(3) ) > 1 )
11702 temp5 = args(3).matrix_value();
11703 arg5 = &temp5( 0, 0 );
11704 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
11707 if (
_n_dims( args(4) ) > 1 )
11711 temp7 = args(4).matrix_value();
11712 arg7 = &temp7( 0, 0 );
11714 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
11715 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11721 arg10 = (
PLINT)(val10);
11726 arg11 = (
PLFLT)(val11);
11727 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
11728 _outv = octave_value();
11765 return octave_value_list();
11770 PLFLT *arg1 = (PLFLT *) 0 ;
11771 PLFLT *arg2 = (PLFLT *) 0 ;
11772 PLFLT *arg3 = (PLFLT *) 0 ;
11781 octave_value_list _out;
11782 octave_value_list *_outp=&_out;
11783 octave_value _outv;
11789 if (
_n_dims( args(0) ) > 1 )
11793 temp1 = args(0).matrix_value();
11794 arg1 = &temp1( 0, 0 );
11798 if (
_n_dims( args(1) ) > 1 )
11802 temp2 = args(1).matrix_value();
11803 arg2 = &temp2( 0, 0 );
11807 if (
_n_dims( args(2) ) > 2 )
11809 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11811 if (
_dim( args(2), 0 ) != Xlen )
11813 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11817 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11819 temp3 = args(2).matrix_value();
11820 arg3 = &temp3( 0, 0 );
11828 arg6 = (
PLINT)(val6);
11829 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
11830 _outv = octave_value();
11852 return octave_value_list();
11857 PLFLT *arg1 = (PLFLT *) 0 ;
11858 PLFLT *arg2 = (PLFLT *) 0 ;
11859 PLFLT *arg3 = (PLFLT *) 0 ;
11863 PLFLT *arg7 = (PLFLT *) 0 ;
11871 octave_value_list _out;
11872 octave_value_list *_outp=&_out;
11873 octave_value _outv;
11879 if (
_n_dims( args(0) ) > 1 )
11883 temp1 = args(0).matrix_value();
11884 arg1 = &temp1( 0, 0 );
11888 if (
_n_dims( args(1) ) > 1 )
11892 temp2 = args(1).matrix_value();
11893 arg2 = &temp2( 0, 0 );
11897 if (
_n_dims( args(2) ) > 2 )
11899 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11901 if (
_dim( args(2), 0 ) != Xlen )
11903 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11907 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11909 temp3 = args(2).matrix_value();
11910 arg3 = &temp3( 0, 0 );
11918 arg6 = (
PLINT)(val6);
11920 if (
_n_dims( args(4) ) > 1 )
11924 temp7 = args(4).matrix_value();
11925 arg7 = &temp7( 0, 0 );
11926 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
11928 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
11929 _outv = octave_value();
11957 return octave_value_list();
11962 PLFLT *arg1 = (PLFLT *) 0 ;
11963 PLFLT *arg2 = (PLFLT *) 0 ;
11964 PLFLT *arg3 = (PLFLT *) 0 ;
11976 octave_value_list _out;
11977 octave_value_list *_outp=&_out;
11978 octave_value _outv;
11984 if (
_n_dims( args(0) ) > 1 )
11988 temp1 = args(0).matrix_value();
11989 arg1 = &temp1( 0, 0 );
11993 if (
_n_dims( args(1) ) > 1 )
11997 temp2 = args(1).matrix_value();
11998 arg2 = &temp2( 0, 0 );
12002 if (
_n_dims( args(2) ) > 2 )
12004 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12006 if (
_dim( args(2), 0 ) != Xlen )
12008 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12012 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12014 temp3 = args(2).matrix_value();
12015 arg3 = &temp3( 0, 0 );
12023 arg6 = (
PLINT)(val6);
12029 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12030 _outv = octave_value();
12052 return octave_value_list();
12057 PLFLT *arg1 = (PLFLT *) 0 ;
12058 PLFLT *arg2 = (PLFLT *) 0 ;
12059 PLFLT *arg3 = (PLFLT *) 0 ;
12063 PLFLT *arg7 = (PLFLT *) 0 ;
12071 octave_value_list _out;
12072 octave_value_list *_outp=&_out;
12073 octave_value _outv;
12079 if (
_n_dims( args(0) ) > 1 )
12083 temp1 = args(0).matrix_value();
12084 arg1 = &temp1( 0, 0 );
12088 if (
_n_dims( args(1) ) > 1 )
12092 temp2 = args(1).matrix_value();
12093 arg2 = &temp2( 0, 0 );
12097 if (
_n_dims( args(2) ) > 2 )
12099 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12101 if (
_dim( args(2), 0 ) != Xlen )
12103 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12107 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12109 temp3 = args(2).matrix_value();
12110 arg3 = &temp3( 0, 0 );
12118 arg6 = (
PLINT)(val6);
12120 if (
_n_dims( args(4) ) > 1 )
12124 temp7 = args(4).matrix_value();
12125 arg7 = &temp7( 0, 0 );
12126 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12128 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12129 _outv = octave_value();
12157 return octave_value_list();
12162 PLFLT *arg1 = (PLFLT *) 0 ;
12163 PLFLT *arg2 = (PLFLT *) 0 ;
12164 PLFLT *arg3 = (PLFLT *) 0 ;
12168 PLFLT *arg7 = (PLFLT *) 0 ;
12172 PLINT *arg11 = (PLINT *) 0 ;
12173 PLINT *arg12 = (PLINT *) 0 ;
12184 octave_value_list _out;
12185 octave_value_list *_outp=&_out;
12186 octave_value _outv;
12192 if (
_n_dims( args(0) ) > 1 )
12196 temp1 = args(0).matrix_value();
12197 arg1 = &temp1( 0, 0 );
12201 if (
_n_dims( args(1) ) > 1 )
12205 temp2 = args(1).matrix_value();
12206 arg2 = &temp2( 0, 0 );
12210 if (
_n_dims( args(2) ) > 2 )
12212 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12214 if (
_dim( args(2), 0 ) != Xlen )
12216 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12220 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12222 temp3 = args(2).matrix_value();
12223 arg3 = &temp3( 0, 0 );
12231 arg6 = (
PLINT)(val6);
12233 if (
_n_dims( args(4) ) > 1 )
12237 temp7 = args(4).matrix_value();
12238 arg7 = &temp7( 0, 0 );
12239 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12245 arg9 = (
PLINT)(val9);
12247 if (
_n_dims( args(6) ) > 1 )
12251 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12252 arg11 =
new PLINT[
Alen];
12253 temp10 = args(6).matrix_value();
12257 if (
_n_dims( args(7) ) > 1 )
12261 if (
_dim( args(7), 0 ) != Alen )
12265 temp12 = args(7).matrix_value();
12266 arg12 =
new PLINT[
Alen];
12269 my_plot3dcl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
12270 _outv = octave_value();
12310 return octave_value_list();
12315 PLFLT *arg1 = (PLFLT *) 0 ;
12316 PLFLT *arg2 = (PLFLT *) 0 ;
12317 PLFLT *arg3 = (PLFLT *) 0 ;
12321 PLFLT *arg7 = (PLFLT *) 0 ;
12329 octave_value_list _out;
12330 octave_value_list *_outp=&_out;
12331 octave_value _outv;
12337 if (
_n_dims( args(0) ) > 1 )
12341 temp1 = args(0).matrix_value();
12342 arg1 = &temp1( 0, 0 );
12346 if (
_n_dims( args(1) ) > 1 )
12350 temp2 = args(1).matrix_value();
12351 arg2 = &temp2( 0, 0 );
12355 if (
_n_dims( args(2) ) > 2 )
12357 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12359 if (
_dim( args(2), 0 ) != Xlen )
12361 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12365 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12367 temp3 = args(2).matrix_value();
12368 arg3 = &temp3( 0, 0 );
12376 arg6 = (
PLINT)(val6);
12378 if (
_n_dims( args(4) ) > 1 )
12382 temp7 = args(4).matrix_value();
12383 arg7 = &temp7( 0, 0 );
12384 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12386 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12387 _outv = octave_value();
12415 return octave_value_list();
12420 PLFLT *arg1 = (PLFLT *) 0 ;
12421 PLFLT *arg2 = (PLFLT *) 0 ;
12422 PLFLT *arg3 = (PLFLT *) 0 ;
12426 PLFLT *arg7 = (PLFLT *) 0 ;
12430 PLINT *arg11 = (PLINT *) 0 ;
12431 PLINT *arg12 = (PLINT *) 0 ;
12442 octave_value_list _out;
12443 octave_value_list *_outp=&_out;
12444 octave_value _outv;
12450 if (
_n_dims( args(0) ) > 1 )
12454 temp1 = args(0).matrix_value();
12455 arg1 = &temp1( 0, 0 );
12459 if (
_n_dims( args(1) ) > 1 )
12463 temp2 = args(1).matrix_value();
12464 arg2 = &temp2( 0, 0 );
12468 if (
_n_dims( args(2) ) > 2 )
12470 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12472 if (
_dim( args(2), 0 ) != Xlen )
12474 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12478 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12480 temp3 = args(2).matrix_value();
12481 arg3 = &temp3( 0, 0 );
12489 arg6 = (
PLINT)(val6);
12491 if (
_n_dims( args(4) ) > 1 )
12495 temp7 = args(4).matrix_value();
12496 arg7 = &temp7( 0, 0 );
12497 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12503 arg9 = (
PLINT)(val9);
12505 if (
_n_dims( args(6) ) > 1 )
12509 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12510 arg11 =
new PLINT[
Alen];
12511 temp10 = args(6).matrix_value();
12515 if (
_n_dims( args(7) ) > 1 )
12519 if (
_dim( args(7), 0 ) != Alen )
12523 temp12 = args(7).matrix_value();
12524 arg12 =
new PLINT[
Alen];
12527 my_plsurf3dl((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,(
int const *)arg11,(
int const *)arg12);
12528 _outv = octave_value();
12568 return octave_value_list();
12573 PLFLT *arg1 = (PLFLT *) 0 ;
12576 PLFLT *arg4 = (PLFLT *) 0 ;
12591 PLFLT *arg19 = (PLFLT *) 0 ;
12623 octave_value_list _out;
12624 octave_value_list *_outp=&_out;
12625 octave_value _outv;
12631 if (
_n_dims( args(0) ) > 2 )
12633 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12635 temp1 = args(0).matrix_value();
12636 arg1 = &temp1( 0, 0 );
12637 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12641 if (
_n_dims( args(1) ) > 1 )
12646 temp4 = args(1).matrix_value();
12647 arg4 = &temp4( 0, 0 );
12653 arg5 = (
PLFLT)(val5);
12658 arg6 = (
PLFLT)(val6);
12663 arg7 = (
PLFLT)(val7);
12668 arg8 = (
PLFLT)(val8);
12673 arg9 = (
PLFLT)(val9);
12678 arg10 = (
PLFLT)(val10);
12683 arg11 = (
PLINT)(val11);
12688 arg12 = (
PLFLT)(val12);
12693 arg13 = (
PLINT)(val13);
12698 arg14 = (
PLINT)(val14);
12703 arg15 = (
PLINT)(val15);
12708 arg16 = (
PLINT)(val16);
12713 arg17 = (
PLINT)(val17);
12718 arg18 = (
PLBOOL)(val18);
12720 if (
_n_dims( args(16) ) > 1 )
12724 if (
_dim( args(16), 0 ) != 6 )
12728 temp19 = args(16).matrix_value();
12729 arg19 = &temp19( 0, 0 );
12731 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);
12732 _outv = octave_value();
12754 return octave_value_list();
12759 PLFLT *arg1 = (PLFLT *) 0 ;
12762 char *arg4 = (
char *) 0 ;
12777 PLFLT *arg19 = (PLFLT *) 0 ;
12778 PLFLT *arg20 = (PLFLT *) 0 ;
12813 octave_value_list _out;
12814 octave_value_list *_outp=&_out;
12815 octave_value _outv;
12821 if (
_n_dims( args(0) ) > 2 )
12823 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12825 temp1 = args(0).matrix_value();
12826 arg1 = &temp1( 0, 0 );
12827 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12834 arg4 = (
char *)(buf4);
12839 arg5 = (
PLFLT)(val5);
12844 arg6 = (
PLFLT)(val6);
12849 arg7 = (
PLFLT)(val7);
12854 arg8 = (
PLFLT)(val8);
12859 arg9 = (
PLFLT)(val9);
12864 arg10 = (
PLFLT)(val10);
12869 arg11 = (
PLINT)(val11);
12874 arg12 = (
PLFLT)(val12);
12879 arg13 = (
PLINT)(val13);
12884 arg14 = (
PLINT)(val14);
12889 arg15 = (
PLINT)(val15);
12894 arg16 = (
PLINT)(val16);
12899 arg17 = (
PLINT)(val17);
12904 arg18 = (
PLBOOL)(val18);
12906 if (
_n_dims( args(16) ) > 1 )
12910 if (
_dim( args(16), 0 ) != Xlen )
12914 temp19 = args(16).matrix_value();
12915 arg19 = &temp19( 0, 0 );
12918 if (
_n_dims( args(17) ) > 1 )
12922 if (
_dim( args(17), 0 ) !=
Ylen )
12926 temp20 = args(17).matrix_value();
12927 arg20 = &temp20( 0, 0 );
12929 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);
12930 _outv = octave_value();
12954 return octave_value_list();
12959 PLFLT *arg1 = (PLFLT *) 0 ;
12962 char *arg4 = (
char *) 0 ;
12977 PLFLT *arg19 = (PLFLT *) 0 ;
12978 PLFLT *arg20 = (PLFLT *) 0 ;
13013 octave_value_list _out;
13014 octave_value_list *_outp=&_out;
13015 octave_value _outv;
13021 if (
_n_dims( args(0) ) > 2 )
13023 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13025 temp1 = args(0).matrix_value();
13026 arg1 = &temp1( 0, 0 );
13027 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13034 arg4 = (
char *)(buf4);
13039 arg5 = (
PLFLT)(val5);
13044 arg6 = (
PLFLT)(val6);
13049 arg7 = (
PLFLT)(val7);
13054 arg8 = (
PLFLT)(val8);
13059 arg9 = (
PLFLT)(val9);
13064 arg10 = (
PLFLT)(val10);
13069 arg11 = (
PLINT)(val11);
13074 arg12 = (
PLFLT)(val12);
13079 arg13 = (
PLINT)(val13);
13084 arg14 = (
PLINT)(val14);
13089 arg15 = (
PLINT)(val15);
13094 arg16 = (
PLINT)(val16);
13099 arg17 = (
PLINT)(val17);
13104 arg18 = (
PLBOOL)(val18);
13106 if (
_n_dims( args(16) ) > 2 )
13108 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13110 temp19 = args(16).matrix_value();
13111 arg19 = &temp19( 0, 0 );
13112 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
13116 if (
_n_dims( args(17) ) > 2 )
13118 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13120 temp20 = args(17).matrix_value();
13121 arg20 = &temp20( 0, 0 );
13122 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
13125 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);
13126 _outv = octave_value();
13150 return octave_value_list();
13155 PLFLT *arg1 = (PLFLT *) 0 ;
13162 PLFLT *arg8 = (PLFLT *) 0 ;
13186 octave_value_list _out;
13187 octave_value_list *_outp=&_out;
13188 octave_value _outv;
13194 if (
_n_dims( args(0) ) > 2 )
13196 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13198 temp1 = args(0).matrix_value();
13199 arg1 = &temp1( 0, 0 );
13200 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13207 arg4 = (
PLFLT)(val4);
13212 arg5 = (
PLFLT)(val5);
13217 arg6 = (
PLFLT)(val6);
13222 arg7 = (
PLFLT)(val7);
13224 if (
_n_dims( args(5) ) > 1 )
13228 temp8 = args(5).matrix_value();
13229 arg8 = &temp8( 0, 0 );
13230 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13236 arg10 = (
PLINT)(val10);
13241 arg11 = (
PLINT)(val11);
13246 arg12 = (
PLINT)(val12);
13251 arg13 = (
PLBOOL)(val13);
13252 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13253 _outv = octave_value();
13269 return octave_value_list();
13274 PLFLT *arg1 = (PLFLT *) 0 ;
13281 PLFLT *arg8 = (PLFLT *) 0 ;
13287 PLFLT *arg14 = (PLFLT *) 0 ;
13307 octave_value_list _out;
13308 octave_value_list *_outp=&_out;
13309 octave_value _outv;
13315 if (
_n_dims( args(0) ) > 2 )
13317 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13319 temp1 = args(0).matrix_value();
13320 arg1 = &temp1( 0, 0 );
13321 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13328 arg4 = (
PLFLT)(val4);
13333 arg5 = (
PLFLT)(val5);
13338 arg6 = (
PLFLT)(val6);
13343 arg7 = (
PLFLT)(val7);
13345 if (
_n_dims( args(5) ) > 1 )
13349 temp8 = args(5).matrix_value();
13350 arg8 = &temp8( 0, 0 );
13351 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13357 arg10 = (
PLINT)(val10);
13362 arg11 = (
PLINT)(val11);
13367 arg12 = (
PLINT)(val12);
13372 arg13 = (
PLBOOL)(val13);
13374 if (
_n_dims( args(10) ) > 1 )
13378 if (
_dim( args(10), 0 ) != 6 )
13382 temp14 = args(10).matrix_value();
13383 arg14 = &temp14( 0, 0 );
13385 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13386 _outv = octave_value();
13408 return octave_value_list();
13413 PLFLT *arg1 = (PLFLT *) 0 ;
13420 PLFLT *arg8 = (PLFLT *) 0 ;
13426 PLFLT *arg14 = (PLFLT *) 0 ;
13427 PLFLT *arg15 = (PLFLT *) 0 ;
13448 octave_value_list _out;
13449 octave_value_list *_outp=&_out;
13450 octave_value _outv;
13456 if (
_n_dims( args(0) ) > 2 )
13458 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13460 temp1 = args(0).matrix_value();
13461 arg1 = &temp1( 0, 0 );
13462 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13469 arg4 = (
PLFLT)(val4);
13474 arg5 = (
PLFLT)(val5);
13479 arg6 = (
PLFLT)(val6);
13484 arg7 = (
PLFLT)(val7);
13486 if (
_n_dims( args(5) ) > 1 )
13490 temp8 = args(5).matrix_value();
13491 arg8 = &temp8( 0, 0 );
13492 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13498 arg10 = (
PLINT)(val10);
13503 arg11 = (
PLINT)(val11);
13508 arg12 = (
PLINT)(val12);
13513 arg13 = (
PLBOOL)(val13);
13515 if (
_n_dims( args(10) ) > 1 )
13519 if (
_dim( args(10), 0 ) != Xlen )
13523 temp14 = args(10).matrix_value();
13524 arg14 = &temp14( 0, 0 );
13527 if (
_n_dims( args(11) ) > 1 )
13531 if (
_dim( args(11), 0 ) !=
Ylen )
13535 temp15 = args(11).matrix_value();
13536 arg15 = &temp15( 0, 0 );
13538 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);
13539 _outv = octave_value();
13567 return octave_value_list();
13572 PLFLT *arg1 = (PLFLT *) 0 ;
13579 PLFLT *arg8 = (PLFLT *) 0 ;
13585 PLFLT *arg14 = (PLFLT *) 0 ;
13586 PLFLT *arg15 = (PLFLT *) 0 ;
13607 octave_value_list _out;
13608 octave_value_list *_outp=&_out;
13609 octave_value _outv;
13615 if (
_n_dims( args(0) ) > 2 )
13617 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13619 temp1 = args(0).matrix_value();
13620 arg1 = &temp1( 0, 0 );
13621 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13628 arg4 = (
PLFLT)(val4);
13633 arg5 = (
PLFLT)(val5);
13638 arg6 = (
PLFLT)(val6);
13643 arg7 = (
PLFLT)(val7);
13645 if (
_n_dims( args(5) ) > 1 )
13649 temp8 = args(5).matrix_value();
13650 arg8 = &temp8( 0, 0 );
13651 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13657 arg10 = (
PLINT)(val10);
13662 arg11 = (
PLINT)(val11);
13667 arg12 = (
PLINT)(val12);
13672 arg13 = (
PLBOOL)(val13);
13674 if (
_n_dims( args(10) ) > 2 )
13676 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13678 temp14 = args(10).matrix_value();
13679 arg14 = &temp14( 0, 0 );
13680 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
13684 if (
_n_dims( args(11) ) > 2 )
13686 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13688 temp15 = args(11).matrix_value();
13689 arg15 = &temp15( 0, 0 );
13690 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
13693 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);
13694 _outv = octave_value();
13722 return octave_value_list();
13727 PLFLT *arg1 = (PLFLT *) 0 ;
13728 PLFLT *arg2 = (PLFLT *) 0 ;
13732 PLFLT *arg6 = (PLFLT *) 0 ;
13738 octave_value_list _out;
13739 octave_value_list *_outp=&_out;
13740 octave_value _outv;
13746 if (
_n_dims( args(0) ) > 2 )
13748 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13750 temp1 = args(0).matrix_value();
13751 arg1 = &temp1( 0, 0 );
13756 if (
_n_dims( args(1) ) > 2 )
13758 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13760 if (
_dim( args(1), 0 ) != Xlen )
13762 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13766 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13768 temp2 = args(1).matrix_value();
13769 arg2 = &temp2( 0, 0 );
13777 arg5 = (
PLFLT)(val5);
13779 if (
_n_dims( args(3) ) > 1 )
13783 if (
_dim( args(3), 0 ) != 6 )
13787 temp6 = args(3).matrix_value();
13788 arg6 = &temp6( 0, 0 );
13790 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
13791 _outv = octave_value();
13813 return octave_value_list();
13818 PLFLT *arg1 = (PLFLT *) 0 ;
13819 PLFLT *arg2 = (PLFLT *) 0 ;
13823 PLFLT *arg6 = (PLFLT *) 0 ;
13824 PLFLT *arg7 = (PLFLT *) 0 ;
13831 octave_value_list _out;
13832 octave_value_list *_outp=&_out;
13833 octave_value _outv;
13839 if (
_n_dims( args(0) ) > 2 )
13841 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13843 temp1 = args(0).matrix_value();
13844 arg1 = &temp1( 0, 0 );
13849 if (
_n_dims( args(1) ) > 2 )
13851 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13853 if (
_dim( args(1), 0 ) != Xlen )
13855 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13859 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13861 temp2 = args(1).matrix_value();
13862 arg2 = &temp2( 0, 0 );
13870 arg5 = (
PLFLT)(val5);
13872 if (
_n_dims( args(3) ) > 1 )
13876 if (
_dim( args(3), 0 ) != Xlen )
13880 temp6 = args(3).matrix_value();
13881 arg6 = &temp6( 0, 0 );
13884 if (
_n_dims( args(4) ) > 1 )
13892 temp7 = args(4).matrix_value();
13893 arg7 = &temp7( 0, 0 );
13895 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
13896 _outv = octave_value();
13924 return octave_value_list();
13929 PLFLT *arg1 = (PLFLT *) 0 ;
13930 PLFLT *arg2 = (PLFLT *) 0 ;
13934 PLFLT *arg6 = (PLFLT *) 0 ;
13935 PLFLT *arg7 = (PLFLT *) 0 ;
13942 octave_value_list _out;
13943 octave_value_list *_outp=&_out;
13944 octave_value _outv;
13950 if (
_n_dims( args(0) ) > 2 )
13952 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13954 temp1 = args(0).matrix_value();
13955 arg1 = &temp1( 0, 0 );
13960 if (
_n_dims( args(1) ) > 2 )
13962 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13964 if (
_dim( args(1), 0 ) != Xlen )
13966 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13970 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13972 temp2 = args(1).matrix_value();
13973 arg2 = &temp2( 0, 0 );
13981 arg5 = (
PLFLT)(val5);
13983 if (
_n_dims( args(3) ) > 2 )
13985 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13987 temp6 = args(3).matrix_value();
13988 arg6 = &temp6( 0, 0 );
13993 if (
_n_dims( args(4) ) > 2 )
13995 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13997 temp7 = args(4).matrix_value();
13998 arg7 = &temp7( 0, 0 );
14002 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14003 _outv = octave_value();
14031 return octave_value_list();
14036 PLFLT *arg1 = (PLFLT *) 0 ;
14070 octave_value_list _out;
14071 octave_value_list *_outp=&_out;
14072 octave_value _outv;
14078 if (
_n_dims( args(0) ) > 2 )
14080 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14082 temp1 = args(0).matrix_value();
14083 arg1 = &temp1( 0, 0 );
14084 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14091 arg4 = (
PLFLT)(val4);
14096 arg5 = (
PLFLT)(val5);
14101 arg6 = (
PLFLT)(val6);
14106 arg7 = (
PLFLT)(val7);
14111 arg8 = (
PLFLT)(val8);
14116 arg9 = (
PLFLT)(val9);
14121 arg10 = (
PLFLT)(val10);
14126 arg11 = (
PLFLT)(val11);
14131 arg12 = (
PLFLT)(val12);
14136 arg13 = (
PLFLT)(val13);
14137 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14138 _outv = octave_value();
14148 return octave_value_list();
14153 PLFLT *arg1 = (PLFLT *) 0 ;
14181 octave_value_list _out;
14182 octave_value_list *_outp=&_out;
14183 octave_value _outv;
14189 if (
_n_dims( args(0) ) > 2 )
14191 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14193 temp1 = args(0).matrix_value();
14194 arg1 = &temp1( 0, 0 );
14195 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14202 arg4 = (
PLFLT)(val4);
14207 arg5 = (
PLFLT)(val5);
14212 arg6 = (
PLFLT)(val6);
14217 arg7 = (
PLFLT)(val7);
14222 arg8 = (
PLFLT)(val8);
14227 arg9 = (
PLFLT)(val9);
14232 arg10 = (
PLFLT)(val10);
14237 arg11 = (
PLFLT)(val11);
14238 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14239 _outv = octave_value();
14249 return octave_value_list();
14254 PLFLT *arg1 = (PLFLT *) 0 ;
14265 PLFLT *arg12 = (PLFLT *) 0 ;
14284 octave_value_list _out;
14285 octave_value_list *_outp=&_out;
14286 octave_value _outv;
14292 if (
_n_dims( args(0) ) > 2 )
14294 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14296 temp1 = args(0).matrix_value();
14297 arg1 = &temp1( 0, 0 );
14298 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14305 arg4 = (
PLFLT)(val4);
14310 arg5 = (
PLFLT)(val5);
14315 arg6 = (
PLFLT)(val6);
14320 arg7 = (
PLFLT)(val7);
14325 arg8 = (
PLFLT)(val8);
14330 arg9 = (
PLFLT)(val9);
14335 arg10 = (
PLFLT)(val10);
14340 arg11 = (
PLFLT)(val11);
14342 if (
_n_dims( args(9) ) > 1 )
14346 if (
_dim( args(9), 0 ) != 6 )
14350 temp12 = args(9).matrix_value();
14351 arg12 = &temp12( 0, 0 );
14353 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14354 _outv = octave_value();
14370 return octave_value_list();
14375 PLFLT *arg1 = (PLFLT *) 0 ;
14386 PLFLT *arg12 = (PLFLT *) 0 ;
14387 PLFLT *arg13 = (PLFLT *) 0 ;
14407 octave_value_list _out;
14408 octave_value_list *_outp=&_out;
14409 octave_value _outv;
14415 if (
_n_dims( args(0) ) > 2 )
14417 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14419 temp1 = args(0).matrix_value();
14420 arg1 = &temp1( 0, 0 );
14421 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14428 arg4 = (
PLFLT)(val4);
14433 arg5 = (
PLFLT)(val5);
14438 arg6 = (
PLFLT)(val6);
14443 arg7 = (
PLFLT)(val7);
14448 arg8 = (
PLFLT)(val8);
14453 arg9 = (
PLFLT)(val9);
14458 arg10 = (
PLFLT)(val10);
14463 arg11 = (
PLFLT)(val11);
14465 if (
_n_dims( args(9) ) > 1 )
14469 if (
_dim( args(9), 0 ) != Xlen )
14473 temp12 = args(9).matrix_value();
14474 arg12 = &temp12( 0, 0 );
14477 if (
_n_dims( args(10) ) > 1 )
14481 if (
_dim( args(10), 0 ) !=
Ylen )
14485 temp13 = args(10).matrix_value();
14486 arg13 = &temp13( 0, 0 );
14488 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14489 _outv = octave_value();
14511 return octave_value_list();
14516 PLFLT *arg1 = (PLFLT *) 0 ;
14527 PLFLT *arg12 = (PLFLT *) 0 ;
14528 PLFLT *arg13 = (PLFLT *) 0 ;
14548 octave_value_list _out;
14549 octave_value_list *_outp=&_out;
14550 octave_value _outv;
14556 if (
_n_dims( args(0) ) > 2 )
14558 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14560 temp1 = args(0).matrix_value();
14561 arg1 = &temp1( 0, 0 );
14562 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14569 arg4 = (
PLFLT)(val4);
14574 arg5 = (
PLFLT)(val5);
14579 arg6 = (
PLFLT)(val6);
14584 arg7 = (
PLFLT)(val7);
14589 arg8 = (
PLFLT)(val8);
14594 arg9 = (
PLFLT)(val9);
14599 arg10 = (
PLFLT)(val10);
14604 arg11 = (
PLFLT)(val11);
14606 if (
_n_dims( args(9) ) > 2 )
14608 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14610 temp12 = args(9).matrix_value();
14611 arg12 = &temp12( 0, 0 );
14616 if (
_n_dims( args(10) ) > 2 )
14618 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14620 temp13 = args(10).matrix_value();
14621 arg13 = &temp13( 0, 0 );
14622 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
14625 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14626 _outv = octave_value();
14648 return octave_value_list();
14653 PLFLT *arg1 = (PLFLT *) 0 ;
14654 PLFLT *arg2 = (PLFLT *) 0 ;
14669 PLINT *arg17 = (PLINT *) 0 ;
14670 char **arg18 = (
char **) 0 ;
14672 char **arg20 = (
char **) 0 ;
14673 PLFLT *arg21 = (PLFLT *) 0 ;
14674 PLINT *arg22 = (PLINT *) 0 ;
14675 PLINT *arg23 = (PLINT *) 0 ;
14676 PLFLT *arg24 = (PLFLT *) 0 ;
14712 octave_value_list _out;
14713 octave_value_list *_outp=&_out;
14714 octave_value _outv;
14725 arg3 = (
PLINT)(val3);
14730 arg4 = (
PLINT)(val4);
14735 arg5 = (
PLFLT)(val5);
14740 arg6 = (
PLFLT)(val6);
14745 arg7 = (
PLFLT)(val7);
14750 arg8 = (
PLFLT)(val8);
14755 arg9 = (
PLINT)(val9);
14760 arg10 = (
PLINT)(val10);
14765 arg11 = (
PLINT)(val11);
14770 arg12 = (
PLFLT)(val12);
14775 arg13 = (
PLFLT)(val13);
14780 arg14 = (
PLINT)(val14);
14785 arg15 = (
PLFLT)(val15);
14787 if (
_n_dims( args(13) ) > 1 )
14791 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
14792 arg17 =
new PLINT[
Alen];
14793 temp16 = args(13).matrix_value();
14797 charMatrix temp_matrix;
14801 size_t max_length = 0, non_blank_length;
14803 if (
_n_dims( args(14) ) > 2 )
14805 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14807 if ( !args(14).is_empty() )
14809 if (
_dim( args(14), 0 ) != Alen )
14811 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
14813 arg18 =
new char*[
Alen];
14814 ifcell = args(14).is_cell();
14817 temp_cell = args(14).cell_value();
14821 temp_matrix = args(14).char_matrix_value();
14823 max_length =
_dim( args(14), 1 ) + 1;
14826 for ( i = 0; i <
Alen; i++ )
14833 if ( temp_cell.elem( i ).is_string() )
14835 str = temp_cell.elem( i ).string_value();
14837 max_length = str.size() + 1;
14838 tmp_cstring = (
char *) str.c_str();
14848 tmp_cstring = (
char *)
"";
14853 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14855 arg18[i] =
new char[max_length];
14856 strncpy( arg18[i], tmp_cstring, max_length - 1 );
14857 arg18[i][max_length - 1] =
'\0';
14872 non_blank_length = max_length - 2;
14873 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
14875 non_blank_length--;
14877 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
14879 non_blank_length--;
14881 arg18[i][non_blank_length + 1] =
'\0';
14891 charMatrix temp_matrix;
14895 size_t max_length = 0, non_blank_length;
14897 if (
_n_dims( args(15) ) > 2 )
14899 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
14901 if ( !args(15).is_empty() )
14903 Alen =
_dim( args(15), 0 );
14905 arg20 =
new char*[
Alen];
14906 ifcell = args(15).is_cell();
14909 temp_cell = args(15).cell_value();
14913 temp_matrix = args(15).char_matrix_value();
14915 max_length =
_dim( args(15), 1 ) + 1;
14918 for ( i = 0; i <
Alen; i++ )
14925 if ( temp_cell.elem( i ).is_string() )
14927 str = temp_cell.elem( i ).string_value();
14929 max_length = str.size() + 1;
14930 tmp_cstring = (
char *) str.c_str();
14940 tmp_cstring = (
char *)
"";
14945 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
14947 arg20[i] =
new char[max_length];
14948 strncpy( arg20[i], tmp_cstring, max_length - 1 );
14949 arg20[i][max_length - 1] =
'\0';
14964 non_blank_length = max_length - 2;
14965 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
14967 non_blank_length--;
14969 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
14971 non_blank_length--;
14973 arg20[i][non_blank_length + 1] =
'\0';
14984 if (
_n_dims( args(16) ) > 1 )
14988 if (
_dim( args(16), 0 ) != Alen )
14992 temp21 = args(16).matrix_value();
14993 arg21 = &temp21( 0, 0 );
14996 if (
_n_dims( args(17) ) > 1 )
15000 if (
_dim( args(17), 0 ) != Alen )
15004 temp22 = args(17).matrix_value();
15005 arg22 =
new PLINT[
Alen];
15010 if (
_n_dims( args(18) ) > 1 )
15014 if (
_dim( args(18), 0 ) != Alen )
15019 temp23 = args(18).matrix_value();
15020 arg23 =
new PLINT[
Alen];
15023 for ( i = 0; i <
Xlen; i++ )
15024 if ( arg23[i] >
Ylen )
15028 if (
_n_dims( args(19) ) > 2 )
15030 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15032 if (
_dim( args(19), 0 ) != Xlen )
15034 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
15036 if (
_dim( args(19), 1 ) !=
Ylen )
15038 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
15040 temp24 = args(19).matrix_value();
15041 arg24 = &temp24( 0, 0 );
15043 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);
15044 _outv = octave_value();
15063 if ( arg18 != NULL )
15065 for ( i = 0; i <
Alen; i++ )
15074 if ( arg20 != NULL )
15076 for ( i = 0; i <
Alen; i++ )
15102 if ( arg18 != NULL )
15104 for ( i = 0; i <
Alen; i++ )
15113 if ( arg20 != NULL )
15115 for ( i = 0; i <
Alen; i++ )
15134 return octave_value_list();
15145 octave_value_list _out;
15146 octave_value_list *_outp=&_out;
15147 octave_value _outv;
15161 arg2 = (int)(val2);
15162 if (arg1) (arg1)->type = arg2;
15163 _outv = octave_value();
15167 return octave_value_list();
15175 octave_value_list _out;
15176 octave_value_list *_outp=&_out;
15177 octave_value _outv;
15188 result = (int) ((arg1)->type);
15193 return octave_value_list();
15199 unsigned int arg2 ;
15202 unsigned int val2 ;
15204 octave_value_list _out;
15205 octave_value_list *_outp=&_out;
15206 octave_value _outv;
15220 arg2 = (
unsigned int)(val2);
15221 if (arg1) (arg1)->state = arg2;
15222 _outv = octave_value();
15226 return octave_value_list();
15234 octave_value_list _out;
15235 octave_value_list *_outp=&_out;
15236 octave_value _outv;
15237 unsigned int result;
15247 result = (
unsigned int) ((arg1)->state);
15252 return octave_value_list();
15258 unsigned int arg2 ;
15261 unsigned int val2 ;
15263 octave_value_list _out;
15264 octave_value_list *_outp=&_out;
15265 octave_value _outv;
15279 arg2 = (
unsigned int)(val2);
15280 if (arg1) (arg1)->keysym = arg2;
15281 _outv = octave_value();
15285 return octave_value_list();
15293 octave_value_list _out;
15294 octave_value_list *_outp=&_out;
15295 octave_value _outv;
15296 unsigned int result;
15306 result = (
unsigned int) ((arg1)->keysym);
15311 return octave_value_list();
15317 unsigned int arg2 ;
15320 unsigned int val2 ;
15322 octave_value_list _out;
15323 octave_value_list *_outp=&_out;
15324 octave_value _outv;
15338 arg2 = (
unsigned int)(val2);
15339 if (arg1) (arg1)->button = arg2;
15340 _outv = octave_value();
15344 return octave_value_list();
15352 octave_value_list _out;
15353 octave_value_list *_outp=&_out;
15354 octave_value _outv;
15355 unsigned int result;
15365 result = (
unsigned int) ((arg1)->button);
15370 return octave_value_list();
15381 octave_value_list _out;
15382 octave_value_list *_outp=&_out;
15383 octave_value _outv;
15397 arg2 = (
PLINT)(val2);
15398 if (arg1) (arg1)->subwindow = arg2;
15399 _outv = octave_value();
15403 return octave_value_list();
15411 octave_value_list _out;
15412 octave_value_list *_outp=&_out;
15413 octave_value _outv;
15424 result = (
PLINT) ((arg1)->subwindow);
15429 return octave_value_list();
15440 octave_value_list _out;
15441 octave_value_list *_outp=&_out;
15442 octave_value _outv;
15456 arg2 = (
char *)(temp2);
15457 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
15458 else memset(arg1->
string,0,16*
sizeof(
char));
15459 _outv = octave_value();
15463 return octave_value_list();
15471 octave_value_list _out;
15472 octave_value_list *_outp=&_out;
15473 octave_value _outv;
15484 result = (
char *)(
char *) ((arg1)->
string);
15488 while (size && (result[size - 1] ==
'\0')) --size;
15495 return octave_value_list();
15506 octave_value_list _out;
15507 octave_value_list *_outp=&_out;
15508 octave_value _outv;
15522 arg2 = (int)(val2);
15523 if (arg1) (arg1)->pX = arg2;
15524 _outv = octave_value();
15528 return octave_value_list();
15536 octave_value_list _out;
15537 octave_value_list *_outp=&_out;
15538 octave_value _outv;
15549 result = (int) ((arg1)->pX);
15554 return octave_value_list();
15565 octave_value_list _out;
15566 octave_value_list *_outp=&_out;
15567 octave_value _outv;
15581 arg2 = (int)(val2);
15582 if (arg1) (arg1)->pY = arg2;
15583 _outv = octave_value();
15587 return octave_value_list();
15595 octave_value_list _out;
15596 octave_value_list *_outp=&_out;
15597 octave_value _outv;
15608 result = (int) ((arg1)->pY);
15613 return octave_value_list();
15624 octave_value_list _out;
15625 octave_value_list *_outp=&_out;
15626 octave_value _outv;
15640 arg2 = (
PLFLT)(val2);
15641 if (arg1) (arg1)->dX = arg2;
15642 _outv = octave_value();
15646 return octave_value_list();
15654 octave_value_list _out;
15655 octave_value_list *_outp=&_out;
15656 octave_value _outv;
15667 result = (
PLFLT) ((arg1)->dX);
15672 return octave_value_list();
15683 octave_value_list _out;
15684 octave_value_list *_outp=&_out;
15685 octave_value _outv;
15699 arg2 = (
PLFLT)(val2);
15700 if (arg1) (arg1)->dY = arg2;
15701 _outv = octave_value();
15705 return octave_value_list();
15713 octave_value_list _out;
15714 octave_value_list *_outp=&_out;
15715 octave_value _outv;
15726 result = (
PLFLT) ((arg1)->dY);
15731 return octave_value_list();
15742 octave_value_list _out;
15743 octave_value_list *_outp=&_out;
15744 octave_value _outv;
15758 arg2 = (
PLFLT)(val2);
15759 if (arg1) (arg1)->wX = arg2;
15760 _outv = octave_value();
15764 return octave_value_list();
15772 octave_value_list _out;
15773 octave_value_list *_outp=&_out;
15774 octave_value _outv;
15785 result = (
PLFLT) ((arg1)->wX);
15790 return octave_value_list();
15801 octave_value_list _out;
15802 octave_value_list *_outp=&_out;
15803 octave_value _outv;
15817 arg2 = (
PLFLT)(val2);
15818 if (arg1) (arg1)->wY = arg2;
15819 _outv = octave_value();
15823 return octave_value_list();
15831 octave_value_list _out;
15832 octave_value_list *_outp=&_out;
15833 octave_value _outv;
15844 result = (
PLFLT) ((arg1)->wY);
15849 return octave_value_list();
15854 octave_value_list _out;
15855 octave_value_list *_outp=&_out;
15856 octave_value _outv;
15867 return octave_value_list();
15875 octave_value_list _out;
15876 octave_value_list *_outp=&_out;
15877 octave_value _outv;
15888 _outv = octave_value();
15892 return octave_value_list();
15922 octave_value_list _out;
15923 octave_value_list *_outp=&_out;
15924 octave_value _outv;
15933 arg1 = (
PLINT)(val1);
15938 arg2 = (
PLINT)(val2);
15940 _outv = octave_value();
15944 return octave_value_list();
15961 octave_value_list _out;
15962 octave_value_list *_outp=&_out;
15963 octave_value _outv;
15972 arg1 = (
PLFLT)(val1);
15977 arg2 = (
PLFLT)(val2);
15982 arg3 = (
PLFLT)(val3);
15987 arg4 = (
PLINT)(val4);
15989 _outv = octave_value();
15993 return octave_value_list();
16001 octave_value_list _out;
16002 octave_value_list *_outp=&_out;
16003 octave_value _outv;
16012 arg1 = (
PLINT)(val1);
16014 _outv = octave_value();
16018 return octave_value_list();
16047 octave_value_list _out;
16048 octave_value_list *_outp=&_out;
16049 octave_value _outv;
16058 arg1 = (
PLFLT)(val1);
16063 arg2 = (
PLFLT)(val2);
16068 arg3 = (
PLFLT)(val3);
16073 arg4 = (
PLFLT)(val4);
16078 arg5 = (
PLFLT)(val5);
16083 arg6 = (
PLFLT)(val6);
16088 arg7 = (
PLFLT)(val7);
16094 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16095 _outv = octave_value();
16099 return octave_value_list();
16106 char *arg3 = (
char *) 0 ;
16109 char *arg6 = (
char *) 0 ;
16130 octave_value_list _out;
16131 octave_value_list *_outp=&_out;
16132 octave_value _outv;
16141 arg1 = (
PLFLT)(val1);
16146 arg2 = (
PLFLT)(val2);
16151 arg3 = (
char *)(buf3);
16156 arg4 = (
PLFLT)(val4);
16161 arg5 = (
PLINT)(val5);
16166 arg6 = (
char *)(buf6);
16171 arg7 = (
PLFLT)(val7);
16176 arg8 = (
PLINT)(val8);
16177 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
16178 _outv = octave_value();
16186 return octave_value_list();
16192 PLFLT *arg2 = (PLFLT *) 0 ;
16193 PLFLT *arg3 = (PLFLT *) 0 ;
16199 octave_value_list _out;
16200 octave_value_list *_outp=&_out;
16201 octave_value _outv;
16207 if (
_n_dims( args(0) ) > 1 )
16211 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16212 temp1 = args(0).matrix_value();
16213 arg2 = &temp1( 0, 0 );
16216 if (
_n_dims( args(1) ) > 1 )
16220 if (
_dim( args(1), 0 ) != Alen )
16224 temp3 = args(1).matrix_value();
16225 arg3 = &temp3( 0, 0 );
16231 arg4 = (
PLINT)(val4);
16232 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16233 _outv = octave_value();
16249 return octave_value_list();
16254 PLINT *arg1 = (PLINT *) 0 ;
16255 PLINT *arg2 = (PLINT *) 0 ;
16256 PLINT *arg3 = (PLINT *) 0 ;
16257 PLINT *arg4 = (PLINT *) 0 ;
16258 PLINT *arg5 = (PLINT *) 0 ;
16259 PLFLT *arg6 = (PLFLT *) 0 ;
16275 octave_value_list _out;
16276 octave_value_list *_outp=&_out;
16277 octave_value _outv;
16292 arg7 = (
PLFLT)(val7);
16293 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16294 _outv = octave_value();
16334 return octave_value_list();
16339 octave_value_list _out;
16340 octave_value_list *_outp=&_out;
16341 octave_value _outv;
16347 _outv = octave_value();
16351 return octave_value_list();
16356 char *arg1 = (
char *) 0 ;
16359 char *arg4 = (
char *) 0 ;
16376 octave_value_list _out;
16377 octave_value_list *_outp=&_out;
16378 octave_value _outv;
16387 arg1 = (
char *)(buf1);
16392 arg2 = (
PLFLT)(val2);
16397 arg3 = (
PLINT)(val3);
16402 arg4 = (
char *)(buf4);
16407 arg5 = (
PLFLT)(val5);
16412 arg6 = (
PLINT)(val6);
16413 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
16414 _outv = octave_value();
16422 return octave_value_list();
16427 char *arg1 = (
char *) 0 ;
16428 char *arg2 = (
char *) 0 ;
16431 char *arg5 = (
char *) 0 ;
16432 char *arg6 = (
char *) 0 ;
16435 char *arg9 = (
char *) 0 ;
16436 char *arg10 = (
char *) 0 ;
16469 octave_value_list _out;
16470 octave_value_list *_outp=&_out;
16471 octave_value _outv;
16480 arg1 = (
char *)(buf1);
16485 arg2 = (
char *)(buf2);
16490 arg3 = (
PLFLT)(val3);
16495 arg4 = (
PLINT)(val4);
16500 arg5 = (
char *)(buf5);
16505 arg6 = (
char *)(buf6);
16510 arg7 = (
PLFLT)(val7);
16515 arg8 = (
PLINT)(val8);
16520 arg9 = (
char *)(buf9);
16525 arg10 = (
char *)(buf10);
16530 arg11 = (
PLFLT)(val11);
16535 arg12 = (
PLINT)(val12);
16536 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);
16537 _outv = octave_value();
16553 return octave_value_list();
16560 PLFLT *arg3 = (PLFLT *) 0 ;
16561 PLFLT *arg4 = (PLFLT *) 0 ;
16562 PLINT *arg5 = (PLINT *) 0 ;
16573 octave_value_list _out;
16574 octave_value_list *_outp=&_out;
16575 octave_value _outv;
16587 arg1 = (
PLFLT)(val1);
16592 arg2 = (
PLFLT)(val2);
16594 _outv = octave_value();
16616 return octave_value_list();
16621 octave_value_list _out;
16622 octave_value_list *_outp=&_out;
16623 octave_value _outv;
16629 _outv = octave_value();
16633 return octave_value_list();
16641 octave_value_list _out;
16642 octave_value_list *_outp=&_out;
16643 octave_value _outv;
16652 arg1 = (
PLINT)(val1);
16654 _outv = octave_value();
16658 return octave_value_list();
16666 octave_value_list _out;
16667 octave_value_list *_outp=&_out;
16668 octave_value _outv;
16677 arg1 = (
PLFLT)(val1);
16679 _outv = octave_value();
16683 return octave_value_list();
16721 octave_value_list _out;
16722 octave_value_list *_outp=&_out;
16723 octave_value _outv;
16732 arg1 = (
PLFLT)(val1);
16737 arg2 = (
PLFLT)(val2);
16742 arg3 = (
PLFLT)(val3);
16747 arg4 = (
PLINT)(val4);
16757 arg6 = (
PLINT)(val6);
16762 arg7 = (
PLINT)(val7);
16767 arg8 = (
PLINT)(val8);
16772 arg9 = (
PLINT)(val9);
16777 arg10 = (
PLINT)(val10);
16782 arg11 = (
PLFLT)(val11);
16783 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16784 _outv = octave_value();
16788 return octave_value_list();
16799 PLFLT *arg7 = (PLFLT *) 0 ;
16814 octave_value_list _out;
16815 octave_value_list *_outp=&_out;
16816 octave_value _outv;
16826 arg1 = (
PLINT)(val1);
16831 arg2 = (
PLINT)(val2);
16836 arg3 = (
PLINT)(val3);
16841 arg4 = (
PLINT)(val4);
16846 arg5 = (
PLINT)(val5);
16851 arg6 = (
PLFLT)(val6);
16852 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16853 _outv = octave_value();
16863 return octave_value_list();
16874 octave_value_list _out;
16875 octave_value_list *_outp=&_out;
16876 octave_value _outv;
16885 arg1 = (
PLINT)(val1);
16892 _outv = octave_value();
16896 return octave_value_list();
16901 octave_value_list _out;
16902 octave_value_list *_outp=&_out;
16903 octave_value _outv;
16909 _outv = octave_value();
16913 return octave_value_list();
16918 octave_value_list _out;
16919 octave_value_list *_outp=&_out;
16920 octave_value _outv;
16926 _outv = octave_value();
16930 return octave_value_list();
16953 octave_value_list _out;
16954 octave_value_list *_outp=&_out;
16955 octave_value _outv;
16964 arg1 = (
PLFLT)(val1);
16969 arg2 = (
PLFLT)(val2);
16974 arg3 = (
PLFLT)(val3);
16979 arg4 = (
PLFLT)(val4);
16984 arg5 = (
PLINT)(val5);
16989 arg6 = (
PLINT)(val6);
16990 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16991 _outv = octave_value();
16995 return octave_value_list();
17018 octave_value_list _out;
17019 octave_value_list *_outp=&_out;
17020 octave_value _outv;
17029 arg1 = (
PLFLT)(val1);
17034 arg2 = (
PLFLT)(val2);
17039 arg3 = (
PLFLT)(val3);
17044 arg4 = (
PLFLT)(val4);
17049 arg5 = (
PLINT)(val5);
17054 arg6 = (
PLINT)(val6);
17055 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17056 _outv = octave_value();
17060 return octave_value_list();
17065 octave_value_list _out;
17066 octave_value_list *_outp=&_out;
17067 octave_value _outv;
17073 _outv = octave_value();
17077 return octave_value_list();
17083 PLFLT *arg2 = (PLFLT *) 0 ;
17084 PLFLT *arg3 = (PLFLT *) 0 ;
17085 PLFLT *arg4 = (PLFLT *) 0 ;
17089 octave_value_list _out;
17090 octave_value_list *_outp=&_out;
17091 octave_value _outv;
17097 if (
_n_dims( args(0) ) > 1 )
17101 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17102 temp1 = args(0).matrix_value();
17103 arg2 = &temp1( 0, 0 );
17106 if (
_n_dims( args(1) ) > 1 )
17110 if (
_dim( args(1), 0 ) != Alen )
17114 temp3 = args(1).matrix_value();
17115 arg3 = &temp3( 0, 0 );
17118 if (
_n_dims( args(2) ) > 1 )
17122 if (
_dim( args(2), 0 ) != Alen )
17126 temp4 = args(2).matrix_value();
17127 arg4 = &temp4( 0, 0 );
17129 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17130 _outv = octave_value();
17152 return octave_value_list();
17158 PLFLT *arg2 = (PLFLT *) 0 ;
17159 PLFLT *arg3 = (PLFLT *) 0 ;
17160 PLFLT *arg4 = (PLFLT *) 0 ;
17164 octave_value_list _out;
17165 octave_value_list *_outp=&_out;
17166 octave_value _outv;
17172 if (
_n_dims( args(0) ) > 1 )
17176 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17177 temp1 = args(0).matrix_value();
17178 arg2 = &temp1( 0, 0 );
17181 if (
_n_dims( args(1) ) > 1 )
17185 if (
_dim( args(1), 0 ) != Alen )
17189 temp3 = args(1).matrix_value();
17190 arg3 = &temp3( 0, 0 );
17193 if (
_n_dims( args(2) ) > 1 )
17197 if (
_dim( args(2), 0 ) != Alen )
17201 temp4 = args(2).matrix_value();
17202 arg4 = &temp4( 0, 0 );
17204 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17205 _outv = octave_value();
17227 return octave_value_list();
17232 octave_value_list _out;
17233 octave_value_list *_outp=&_out;
17234 octave_value _outv;
17240 _outv = octave_value();
17244 return octave_value_list();
17250 PLFLT *arg2 = (PLFLT *) 0 ;
17251 PLFLT *arg3 = (PLFLT *) 0 ;
17254 octave_value_list _out;
17255 octave_value_list *_outp=&_out;
17256 octave_value _outv;
17262 if (
_n_dims( args(0) ) > 1 )
17266 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17267 temp1 = args(0).matrix_value();
17268 arg2 = &temp1( 0, 0 );
17271 if (
_n_dims( args(1) ) > 1 )
17275 if (
_dim( args(1), 0 ) != Alen )
17279 temp3 = args(1).matrix_value();
17280 arg3 = &temp3( 0, 0 );
17282 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
17283 _outv = octave_value();
17299 return octave_value_list();
17305 PLFLT *arg2 = (PLFLT *) 0 ;
17306 PLFLT *arg3 = (PLFLT *) 0 ;
17307 PLFLT *arg4 = (PLFLT *) 0 ;
17311 octave_value_list _out;
17312 octave_value_list *_outp=&_out;
17313 octave_value _outv;
17319 if (
_n_dims( args(0) ) > 1 )
17323 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17324 temp1 = args(0).matrix_value();
17325 arg2 = &temp1( 0, 0 );
17328 if (
_n_dims( args(1) ) > 1 )
17332 if (
_dim( args(1), 0 ) != Alen )
17336 temp3 = args(1).matrix_value();
17337 arg3 = &temp3( 0, 0 );
17340 if (
_n_dims( args(2) ) > 1 )
17344 if (
_dim( args(2), 0 ) != Alen )
17348 temp4 = args(2).matrix_value();
17349 arg4 = &temp4( 0, 0 );
17351 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17352 _outv = octave_value();
17374 return octave_value_list();
17380 PLFLT *arg2 = (PLFLT *) 0 ;
17381 PLFLT *arg3 = (PLFLT *) 0 ;
17387 octave_value_list _out;
17388 octave_value_list *_outp=&_out;
17389 octave_value _outv;
17395 if (
_n_dims( args(0) ) > 1 )
17399 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17400 temp1 = args(0).matrix_value();
17401 arg2 = &temp1( 0, 0 );
17404 if (
_n_dims( args(1) ) > 1 )
17408 if (
_dim( args(1), 0 ) != Alen )
17412 temp3 = args(1).matrix_value();
17413 arg3 = &temp3( 0, 0 );
17419 arg4 = (
PLFLT)(val4);
17420 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17421 _outv = octave_value();
17437 return octave_value_list();
17442 octave_value_list _out;
17443 octave_value_list *_outp=&_out;
17444 octave_value _outv;
17450 _outv = octave_value();
17454 return octave_value_list();
17462 octave_value_list _out;
17463 octave_value_list *_outp=&_out;
17464 octave_value _outv;
17473 arg1 = (
PLINT)(val1);
17475 _outv = octave_value();
17479 return octave_value_list();
17487 octave_value_list _out;
17488 octave_value_list *_outp=&_out;
17489 octave_value _outv;
17498 arg1 = (
PLINT)(val1);
17500 _outv = octave_value();
17504 return octave_value_list();
17509 PLFLT *arg1 = (PLFLT *) 0 ;
17510 PLFLT *arg2 = (PLFLT *) 0 ;
17515 octave_value_list _out;
17516 octave_value_list *_outp=&_out;
17517 octave_value _outv;
17525 _outv = octave_value();
17541 return octave_value_list();
17547 PLINT *arg2 = (PLINT *) 0 ;
17548 PLINT *arg3 = (PLINT *) 0 ;
17549 PLINT *arg4 = (PLINT *) 0 ;
17558 octave_value_list _out;
17559 octave_value_list *_outp=&_out;
17560 octave_value _outv;
17572 arg1 = (
PLINT)(val1);
17573 plgcol0(arg1,arg2,arg3,arg4);
17574 _outv = octave_value();
17596 return octave_value_list();
17602 PLINT *arg2 = (PLINT *) 0 ;
17603 PLINT *arg3 = (PLINT *) 0 ;
17604 PLINT *arg4 = (PLINT *) 0 ;
17605 PLFLT *arg5 = (PLFLT *) 0 ;
17616 octave_value_list _out;
17617 octave_value_list *_outp=&_out;
17618 octave_value _outv;
17631 arg1 = (
PLINT)(val1);
17632 plgcol0a(arg1,arg2,arg3,arg4,arg5);
17633 _outv = octave_value();
17661 return octave_value_list();
17666 PLINT *arg1 = (PLINT *) 0 ;
17667 PLINT *arg2 = (PLINT *) 0 ;
17668 PLINT *arg3 = (PLINT *) 0 ;
17675 octave_value_list _out;
17676 octave_value_list *_outp=&_out;
17677 octave_value _outv;
17686 _outv = octave_value();
17708 return octave_value_list();
17713 PLINT *arg1 = (PLINT *) 0 ;
17714 PLINT *arg2 = (PLINT *) 0 ;
17715 PLINT *arg3 = (PLINT *) 0 ;
17716 PLFLT *arg4 = (PLFLT *) 0 ;
17725 octave_value_list _out;
17726 octave_value_list *_outp=&_out;
17727 octave_value _outv;
17737 _outv = octave_value();
17765 return octave_value_list();
17770 PLINT *arg1 = (PLINT *) 0 ;
17773 octave_value_list _out;
17774 octave_value_list *_outp=&_out;
17775 octave_value _outv;
17782 _outv = octave_value();
17792 return octave_value_list();
17797 char *arg1 = (
char *) 0 ;
17798 octave_value_list retval1 ;
17799 octave_value_list _out;
17800 octave_value_list *_outp=&_out;
17801 octave_value _outv;
17805 # if OCTAVE_API_VERSION_NUMBER < 45
17806 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
17808 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17810 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
17816 _outv = octave_value();
17823 return octave_value_list();
17828 PLFLT *arg1 = (PLFLT *) 0 ;
17829 PLFLT *arg2 = (PLFLT *) 0 ;
17830 PLFLT *arg3 = (PLFLT *) 0 ;
17831 PLFLT *arg4 = (PLFLT *) 0 ;
17840 octave_value_list _out;
17841 octave_value_list *_outp=&_out;
17842 octave_value _outv;
17852 _outv = octave_value();
17880 return octave_value_list();
17885 PLFLT *arg1 = (PLFLT *) 0 ;
17888 octave_value_list _out;
17889 octave_value_list *_outp=&_out;
17890 octave_value _outv;
17897 _outv = octave_value();
17907 return octave_value_list();
17912 PLFLT *arg1 = (PLFLT *) 0 ;
17913 PLFLT *arg2 = (PLFLT *) 0 ;
17914 PLFLT *arg3 = (PLFLT *) 0 ;
17915 PLFLT *arg4 = (PLFLT *) 0 ;
17924 octave_value_list _out;
17925 octave_value_list *_outp=&_out;
17926 octave_value _outv;
17936 _outv = octave_value();
17964 return octave_value_list();
17969 PLINT *arg1 = (PLINT *) 0 ;
17970 PLINT *arg2 = (PLINT *) 0 ;
17971 PLINT *arg3 = (PLINT *) 0 ;
17978 octave_value_list _out;
17979 octave_value_list *_outp=&_out;
17980 octave_value _outv;
17989 _outv = octave_value();
18011 return octave_value_list();
18019 octave_value_list _out;
18020 octave_value_list *_outp=&_out;
18021 octave_value _outv;
18028 _outv = octave_value();
18038 return octave_value_list();
18043 char *arg1 = (
char *) 0 ;
18044 octave_value_list retval1 ;
18045 octave_value_list _out;
18046 octave_value_list *_outp=&_out;
18047 octave_value _outv;
18051 # if OCTAVE_API_VERSION_NUMBER < 45
18052 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
18054 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
18056 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
18062 _outv = octave_value();
18069 return octave_value_list();
18074 PLINT *arg1 = (PLINT *) 0 ;
18075 PLINT *arg2 = (PLINT *) 0 ;
18076 PLINT *arg3 = (PLINT *) 0 ;
18083 octave_value_list _out;
18084 octave_value_list *_outp=&_out;
18085 octave_value _outv;
18094 _outv = octave_value();
18116 return octave_value_list();
18121 PLINT *arg1 = (PLINT *) 0 ;
18124 octave_value_list _out;
18125 octave_value_list *_outp=&_out;
18126 octave_value _outv;
18133 _outv = octave_value();
18143 return octave_value_list();
18148 PLFLT *arg1 = (PLFLT *) 0 ;
18149 PLFLT *arg2 = (PLFLT *) 0 ;
18150 PLINT *arg3 = (PLINT *) 0 ;
18151 PLINT *arg4 = (PLINT *) 0 ;
18152 PLINT *arg5 = (PLINT *) 0 ;
18153 PLINT *arg6 = (PLINT *) 0 ;
18166 octave_value_list _out;
18167 octave_value_list *_outp=&_out;
18168 octave_value _outv;
18179 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18180 _outv = octave_value();
18220 return octave_value_list();
18225 octave_value_list _out;
18226 octave_value_list *_outp=&_out;
18227 octave_value _outv;
18233 _outv = octave_value();
18237 return octave_value_list();
18242 PLFLT *arg1 = (PLFLT *) 0 ;
18243 PLFLT *arg2 = (PLFLT *) 0 ;
18244 PLFLT *arg3 = (PLFLT *) 0 ;
18245 PLFLT *arg4 = (PLFLT *) 0 ;
18254 octave_value_list _out;
18255 octave_value_list *_outp=&_out;
18256 octave_value _outv;
18265 plgspa(arg1,arg2,arg3,arg4);
18266 _outv = octave_value();
18294 return octave_value_list();
18299 PLINT *arg1 = (PLINT *) 0 ;
18302 octave_value_list _out;
18303 octave_value_list *_outp=&_out;
18304 octave_value _outv;
18311 _outv = octave_value();
18321 return octave_value_list();
18326 char *arg1 = (
char *) 0 ;
18327 octave_value_list retval1 ;
18328 octave_value_list _out;
18329 octave_value_list *_outp=&_out;
18330 octave_value _outv;
18334 # if OCTAVE_API_VERSION_NUMBER < 45
18335 retval1( 0 ) = octave_value( charMatrix( 80, 1 ),
true );
18337 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
18339 arg1 = (
char *) retval1( 0 ).char_matrix_value().data();
18345 _outv = octave_value();
18352 return octave_value_list();
18357 PLFLT *arg1 = (PLFLT *) 0 ;
18358 PLFLT *arg2 = (PLFLT *) 0 ;
18359 PLFLT *arg3 = (PLFLT *) 0 ;
18360 PLFLT *arg4 = (PLFLT *) 0 ;
18369 octave_value_list _out;
18370 octave_value_list *_outp=&_out;
18371 octave_value _outv;
18380 plgvpd(arg1,arg2,arg3,arg4);
18381 _outv = octave_value();
18409 return octave_value_list();
18414 PLFLT *arg1 = (PLFLT *) 0 ;
18415 PLFLT *arg2 = (PLFLT *) 0 ;
18416 PLFLT *arg3 = (PLFLT *) 0 ;
18417 PLFLT *arg4 = (PLFLT *) 0 ;
18426 octave_value_list _out;
18427 octave_value_list *_outp=&_out;
18428 octave_value _outv;
18437 plgvpw(arg1,arg2,arg3,arg4);
18438 _outv = octave_value();
18466 return octave_value_list();
18471 PLINT *arg1 = (PLINT *) 0 ;
18472 PLINT *arg2 = (PLINT *) 0 ;
18477 octave_value_list _out;
18478 octave_value_list *_outp=&_out;
18479 octave_value _outv;
18487 _outv = octave_value();
18503 return octave_value_list();
18508 PLINT *arg1 = (PLINT *) 0 ;
18509 PLINT *arg2 = (PLINT *) 0 ;
18514 octave_value_list _out;
18515 octave_value_list *_outp=&_out;
18516 octave_value _outv;
18524 _outv = octave_value();
18540 return octave_value_list();
18545 PLINT *arg1 = (PLINT *) 0 ;
18546 PLINT *arg2 = (PLINT *) 0 ;
18551 octave_value_list _out;
18552 octave_value_list *_outp=&_out;
18553 octave_value _outv;
18561 _outv = octave_value();
18577 return octave_value_list();
18583 PLFLT *arg2 = (PLFLT *) 0 ;
18597 octave_value_list _out;
18598 octave_value_list *_outp=&_out;
18599 octave_value _outv;
18605 if (
_n_dims( args(0) ) > 1 )
18609 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18610 temp1 = args(0).matrix_value();
18611 arg2 = &temp1( 0, 0 );
18617 arg3 = (
PLFLT)(val3);
18622 arg4 = (
PLFLT)(val4);
18627 arg5 = (
PLINT)(val5);
18632 arg6 = (
PLINT)(val6);
18633 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
18634 _outv = octave_value();
18644 return octave_value_list();
18652 PLFLT *arg4 = (PLFLT *) 0 ;
18653 PLFLT *arg5 = (PLFLT *) 0 ;
18654 PLFLT *arg6 = (PLFLT *) 0 ;
18667 octave_value_list _out;
18668 octave_value_list *_outp=&_out;
18669 octave_value _outv;
18681 arg1 = (
PLFLT)(val1);
18686 arg2 = (
PLFLT)(val2);
18691 arg3 = (
PLFLT)(val3);
18692 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
18693 _outv = octave_value();
18715 return octave_value_list();
18720 octave_value_list _out;
18721 octave_value_list *_outp=&_out;
18722 octave_value _outv;
18728 _outv = octave_value();
18732 return octave_value_list();
18749 octave_value_list _out;
18750 octave_value_list *_outp=&_out;
18751 octave_value _outv;
18760 arg1 = (
PLFLT)(val1);
18765 arg2 = (
PLFLT)(val2);
18770 arg3 = (
PLFLT)(val3);
18775 arg4 = (
PLFLT)(val4);
18776 pljoin(arg1,arg2,arg3,arg4);
18777 _outv = octave_value();
18781 return octave_value_list();
18786 char *arg1 = (
char *) 0 ;
18787 char *arg2 = (
char *) 0 ;
18788 char *arg3 = (
char *) 0 ;
18798 octave_value_list _out;
18799 octave_value_list *_outp=&_out;
18800 octave_value _outv;
18809 arg1 = (
char *)(buf1);
18814 arg2 = (
char *)(buf2);
18819 arg3 = (
char *)(buf3);
18820 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
18821 _outv = octave_value();
18831 return octave_value_list();
18836 PLFLT *arg1 = (PLFLT *) 0 ;
18837 PLFLT *arg2 = (PLFLT *) 0 ;
18849 PLINT *arg14 = (PLINT *) 0 ;
18854 PLINT *arg19 = (PLINT *) 0 ;
18855 char **arg20 = (
char **) 0 ;
18856 PLINT *arg21 = (PLINT *) 0 ;
18857 PLINT *arg22 = (PLINT *) 0 ;
18858 PLFLT *arg23 = (PLFLT *) 0 ;
18859 PLFLT *arg24 = (PLFLT *) 0 ;
18860 PLINT *arg25 = (PLINT *) 0 ;
18861 PLINT *arg26 = (PLINT *) 0 ;
18862 PLFLT *arg27 = (PLFLT *) 0 ;
18863 PLINT *arg28 = (PLINT *) 0 ;
18864 PLFLT *arg29 = (PLFLT *) 0 ;
18865 PLINT *arg30 = (PLINT *) 0 ;
18866 char **arg31 = (
char **) 0 ;
18911 octave_value_list _out;
18912 octave_value_list *_outp=&_out;
18913 octave_value _outv;
18924 arg3 = (
PLINT)(val3);
18929 arg4 = (
PLINT)(val4);
18934 arg5 = (
PLFLT)(val5);
18939 arg6 = (
PLFLT)(val6);
18944 arg7 = (
PLFLT)(val7);
18949 arg8 = (
PLINT)(val8);
18954 arg9 = (
PLINT)(val9);
18959 arg10 = (
PLINT)(val10);
18964 arg11 = (
PLINT)(val11);
18969 arg12 = (
PLINT)(val12);
18971 if (
_n_dims( args(10) ) > 1 )
18975 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
18976 arg14 =
new PLINT[
Alen];
18977 temp13 = args(10).matrix_value();
18984 arg15 = (
PLFLT)(val15);
18989 arg16 = (
PLFLT)(val16);
18994 arg17 = (
PLFLT)(val17);
18999 arg18 = (
PLFLT)(val18);
19001 if (
_n_dims( args(15) ) > 1 )
19005 if (
_dim( args(15), 0 ) != Alen )
19009 temp19 = args(15).matrix_value();
19010 arg19 =
new PLINT[
Alen];
19014 charMatrix temp_matrix;
19018 size_t max_length = 0, non_blank_length;
19020 if (
_n_dims( args(16) ) > 2 )
19022 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19024 if ( !args(16).is_empty() )
19026 if (
_dim( args(16), 0 ) != Alen )
19028 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19030 arg20 =
new char*[
Alen];
19031 ifcell = args(16).is_cell();
19034 temp_cell = args(16).cell_value();
19038 temp_matrix = args(16).char_matrix_value();
19040 max_length =
_dim( args(16), 1 ) + 1;
19043 for ( i = 0; i <
Alen; i++ )
19050 if ( temp_cell.elem( i ).is_string() )
19052 str = temp_cell.elem( i ).string_value();
19054 max_length = str.size() + 1;
19055 tmp_cstring = (
char *) str.c_str();
19065 tmp_cstring = (
char *)
"";
19070 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
19072 arg20[i] =
new char[max_length];
19073 strncpy( arg20[i], tmp_cstring, max_length - 1 );
19074 arg20[i][max_length - 1] =
'\0';
19089 non_blank_length = max_length - 2;
19090 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
19092 non_blank_length--;
19094 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
19096 non_blank_length--;
19098 arg20[i][non_blank_length + 1] =
'\0';
19108 if (
_n_dims( args(17) ) > 1 )
19112 if ( !args(17).is_empty() )
19114 if (
_dim( args(17), 0 ) != Alen )
19118 temp21 = args(17).matrix_value();
19119 arg21 =
new PLINT[
Alen];
19128 if (
_n_dims( args(18) ) > 1 )
19132 if ( !args(18).is_empty() )
19134 if (
_dim( args(18), 0 ) != Alen )
19138 temp22 = args(18).matrix_value();
19139 arg22 =
new PLINT[
Alen];
19148 if (
_n_dims( args(19) ) > 1 )
19152 if ( !args(19).is_empty() )
19154 if (
_dim( args(19), 0 ) != Alen )
19158 temp23 = args(19).matrix_value();
19159 arg23 = &temp23( 0, 0 );
19167 if (
_n_dims( args(20) ) > 1 )
19171 if ( !args(20).is_empty() )
19173 if (
_dim( args(20), 0 ) != Alen )
19177 temp24 = args(20).matrix_value();
19178 arg24 = &temp24( 0, 0 );
19186 if (
_n_dims( args(21) ) > 1 )
19190 if ( !args(21).is_empty() )
19192 if (
_dim( args(21), 0 ) != Alen )
19196 temp25 = args(21).matrix_value();
19197 arg25 =
new PLINT[
Alen];
19206 if (
_n_dims( args(22) ) > 1 )
19210 if ( !args(22).is_empty() )
19212 if (
_dim( args(22), 0 ) != Alen )
19216 temp26 = args(22).matrix_value();
19217 arg26 =
new PLINT[
Alen];
19226 if (
_n_dims( args(23) ) > 1 )
19230 if ( !args(23).is_empty() )
19232 if (
_dim( args(23), 0 ) != Alen )
19236 temp27 = args(23).matrix_value();
19237 arg27 = &temp27( 0, 0 );
19245 if (
_n_dims( args(24) ) > 1 )
19249 if ( !args(24).is_empty() )
19251 if (
_dim( args(24), 0 ) != Alen )
19255 temp28 = args(24).matrix_value();
19256 arg28 =
new PLINT[
Alen];
19265 if (
_n_dims( args(25) ) > 1 )
19269 if ( !args(25).is_empty() )
19271 if (
_dim( args(25), 0 ) != Alen )
19275 temp29 = args(25).matrix_value();
19276 arg29 = &temp29( 0, 0 );
19284 if (
_n_dims( args(26) ) > 1 )
19288 if ( !args(26).is_empty() )
19290 if (
_dim( args(26), 0 ) != Alen )
19294 temp30 = args(26).matrix_value();
19295 arg30 =
new PLINT[
Alen];
19304 charMatrix temp_matrix;
19308 size_t max_length = 0, non_blank_length;
19310 if (
_n_dims( args(27) ) > 2 )
19312 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19314 if ( !args(27).is_empty() )
19316 if (
_dim( args(27), 0 ) != Alen )
19318 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19320 arg31 =
new char*[
Alen];
19321 ifcell = args(27).is_cell();
19324 temp_cell = args(27).cell_value();
19328 temp_matrix = args(27).char_matrix_value();
19330 max_length =
_dim( args(27), 1 ) + 1;
19333 for ( i = 0; i <
Alen; i++ )
19340 if ( temp_cell.elem( i ).is_string() )
19342 str = temp_cell.elem( i ).string_value();
19344 max_length = str.size() + 1;
19345 tmp_cstring = (
char *) str.c_str();
19355 tmp_cstring = (
char *)
"";
19360 tmp_cstring = (
char *) temp_matrix.row_as_string( i ).c_str();
19362 arg31[i] =
new char[max_length];
19363 strncpy( arg31[i], tmp_cstring, max_length - 1 );
19364 arg31[i][max_length - 1] =
'\0';
19379 non_blank_length = max_length - 2;
19380 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
19382 non_blank_length--;
19384 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
19386 non_blank_length--;
19388 arg31[i][non_blank_length + 1] =
'\0';
19397 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);
19398 _outv = octave_value();
19420 if ( arg20 != NULL )
19422 for ( i = 0; i <
Alen; i++ )
19430 if ( arg21 != NULL )
19434 if ( arg22 != NULL )
19444 if ( arg25 != NULL )
19448 if ( arg26 != NULL )
19455 if ( arg28 != NULL )
19462 if ( arg30 != NULL )
19467 if ( arg31 != NULL )
19469 for ( i = 0; i <
Alen; i++ )
19486 if ( arg20 != NULL )
19488 for ( i = 0; i <
Alen; i++ )
19496 if ( arg21 != NULL )
19500 if ( arg22 != NULL )
19510 if ( arg25 != NULL )
19514 if ( arg26 != NULL )
19521 if ( arg28 != NULL )
19528 if ( arg30 != NULL )
19533 if ( arg31 != NULL )
19535 for ( i = 0; i <
Alen; i++ )
19542 return octave_value_list();
19556 octave_value_list _out;
19557 octave_value_list *_outp=&_out;
19558 octave_value _outv;
19567 arg1 = (
PLFLT)(val1);
19572 arg2 = (
PLFLT)(val2);
19577 arg3 = (
PLFLT)(val3);
19579 _outv = octave_value();
19583 return octave_value_list();
19589 PLFLT *arg2 = (PLFLT *) 0 ;
19590 PLFLT *arg3 = (PLFLT *) 0 ;
19593 octave_value_list _out;
19594 octave_value_list *_outp=&_out;
19595 octave_value _outv;
19601 if (
_n_dims( args(0) ) > 1 )
19605 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19606 temp1 = args(0).matrix_value();
19607 arg2 = &temp1( 0, 0 );
19610 if (
_n_dims( args(1) ) > 1 )
19614 if (
_dim( args(1), 0 ) != Alen )
19618 temp3 = args(1).matrix_value();
19619 arg3 = &temp3( 0, 0 );
19621 plline(arg1,(
double const *)arg2,(
double const *)arg3);
19622 _outv = octave_value();
19638 return octave_value_list();
19644 PLFLT *arg2 = (PLFLT *) 0 ;
19645 PLFLT *arg3 = (PLFLT *) 0 ;
19646 PLFLT *arg4 = (PLFLT *) 0 ;
19650 octave_value_list _out;
19651 octave_value_list *_outp=&_out;
19652 octave_value _outv;
19658 if (
_n_dims( args(0) ) > 1 )
19662 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19663 temp1 = args(0).matrix_value();
19664 arg2 = &temp1( 0, 0 );
19667 if (
_n_dims( args(1) ) > 1 )
19671 if (
_dim( args(1), 0 ) != Alen )
19675 temp3 = args(1).matrix_value();
19676 arg3 = &temp3( 0, 0 );
19679 if (
_n_dims( args(2) ) > 1 )
19683 if (
_dim( args(2), 0 ) != Alen )
19687 temp4 = args(2).matrix_value();
19688 arg4 = &temp4( 0, 0 );
19690 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
19691 _outv = octave_value();
19713 return octave_value_list();
19721 octave_value_list _out;
19722 octave_value_list *_outp=&_out;
19723 octave_value _outv;
19732 arg1 = (
PLINT)(val1);
19734 _outv = octave_value();
19738 return octave_value_list();
19743 PLINT *arg1 = (PLINT *) 0 ;
19746 octave_value_list _out;
19747 octave_value_list *_outp=&_out;
19748 octave_value _outv;
19755 _outv = octave_value();
19765 return octave_value_list();
19770 char *arg1 = (
char *) 0 ;
19774 char *arg5 = (
char *) 0 ;
19787 octave_value_list _out;
19788 octave_value_list *_outp=&_out;
19789 octave_value _outv;
19798 arg1 = (
char *)(buf1);
19803 arg2 = (
PLFLT)(val2);
19808 arg3 = (
PLFLT)(val3);
19813 arg4 = (
PLFLT)(val4);
19818 arg5 = (
char *)(buf5);
19819 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
19820 _outv = octave_value();
19828 return octave_value_list();
19833 char *arg1 = (
char *) 0 ;
19837 char *arg5 = (
char *) 0 ;
19850 octave_value_list _out;
19851 octave_value_list *_outp=&_out;
19852 octave_value _outv;
19861 arg1 = (
char *)(buf1);
19866 arg2 = (
PLFLT)(val2);
19871 arg3 = (
PLFLT)(val3);
19876 arg4 = (
PLFLT)(val4);
19881 arg5 = (
char *)(buf5);
19882 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
19883 _outv = octave_value();
19891 return octave_value_list();
19896 int *arg1 = (
int *) 0 ;
19897 char **arg2 = (
char **) 0 ;
19905 octave_value_list _out;
19906 octave_value_list *_outp=&_out;
19907 octave_value _outv;
19917 arg1 = (
int *)(argp1);
19922 arg2 = (
char **)(argp2);
19927 arg3 = (
PLINT)(val3);
19933 return octave_value_list();
19939 PLINT *arg2 = (PLINT *) 0 ;
19940 PLINT *arg3 = (PLINT *) 0 ;
19943 octave_value_list _out;
19944 octave_value_list *_outp=&_out;
19945 octave_value _outv;
19951 if (
_n_dims( args(0) ) > 1 )
19955 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
19956 arg2 =
new PLINT[
Alen];
19957 temp1 = args(0).matrix_value();
19961 if (
_n_dims( args(1) ) > 1 )
19965 if (
_dim( args(1), 0 ) != Alen )
19969 temp3 = args(1).matrix_value();
19970 arg3 =
new PLINT[
Alen];
19973 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
19974 _outv = octave_value();
19990 return octave_value_list();
20010 octave_value_list _out;
20011 octave_value_list *_outp=&_out;
20012 octave_value _outv;
20021 arg1 = (
PLINT)(val1);
20026 arg2 = (
PLFLT)(val2);
20031 arg3 = (
PLFLT)(val3);
20036 arg4 = (
PLFLT)(val4);
20041 arg5 = (
PLFLT)(val5);
20042 plpath(arg1,arg2,arg3,arg4,arg5);
20043 _outv = octave_value();
20047 return octave_value_list();
20053 PLFLT *arg2 = (PLFLT *) 0 ;
20054 PLFLT *arg3 = (PLFLT *) 0 ;
20060 octave_value_list _out;
20061 octave_value_list *_outp=&_out;
20062 octave_value _outv;
20068 if (
_n_dims( args(0) ) > 1 )
20072 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20073 temp1 = args(0).matrix_value();
20074 arg2 = &temp1( 0, 0 );
20077 if (
_n_dims( args(1) ) > 1 )
20081 if (
_dim( args(1), 0 ) != Alen )
20085 temp3 = args(1).matrix_value();
20086 arg3 = &temp3( 0, 0 );
20092 arg4 = (
PLINT)(val4);
20093 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
20094 _outv = octave_value();
20110 return octave_value_list();
20116 PLFLT *arg2 = (PLFLT *) 0 ;
20117 PLFLT *arg3 = (PLFLT *) 0 ;
20118 PLFLT *arg4 = (PLFLT *) 0 ;
20125 octave_value_list _out;
20126 octave_value_list *_outp=&_out;
20127 octave_value _outv;
20133 if (
_n_dims( args(0) ) > 1 )
20137 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20138 temp1 = args(0).matrix_value();
20139 arg2 = &temp1( 0, 0 );
20142 if (
_n_dims( args(1) ) > 1 )
20146 if (
_dim( args(1), 0 ) != Alen )
20150 temp3 = args(1).matrix_value();
20151 arg3 = &temp3( 0, 0 );
20154 if (
_n_dims( args(2) ) > 1 )
20158 if (
_dim( args(2), 0 ) != Alen )
20162 temp4 = args(2).matrix_value();
20163 arg4 = &temp4( 0, 0 );
20169 arg5 = (
PLINT)(val5);
20170 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
20171 _outv = octave_value();
20193 return octave_value_list();
20199 PLFLT *arg2 = (PLFLT *) 0 ;
20200 PLFLT *arg3 = (PLFLT *) 0 ;
20201 PLFLT *arg4 = (PLFLT *) 0 ;
20210 octave_value_list _out;
20211 octave_value_list *_outp=&_out;
20212 octave_value _outv;
20218 if (
_n_dims( args(0) ) > 1 )
20222 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20223 temp1 = args(0).matrix_value();
20224 arg2 = &temp1( 0, 0 );
20227 if (
_n_dims( args(1) ) > 1 )
20231 if (
_dim( args(1), 0 ) != Alen )
20235 temp3 = args(1).matrix_value();
20236 arg3 = &temp3( 0, 0 );
20239 if (
_n_dims( args(2) ) > 1 )
20243 if (
_dim( args(2), 0 ) != Alen )
20247 temp4 = args(2).matrix_value();
20248 arg4 = &temp4( 0, 0 );
20251 if (
_n_dims( args(3) ) > 1 )
20255 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
20257 error(
"argument vector must be same length or one less" );
SWIG_fail;
20259 temp5 = args(3).matrix_value();
20260 arg5 =
new PLINT[
Alen];
20268 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
20269 _outv = octave_value();
20297 return octave_value_list();
20308 octave_value_list _out;
20309 octave_value_list *_outp=&_out;
20310 octave_value _outv;
20319 arg1 = (
PLINT)(val1);
20324 arg2 = (
PLINT)(val2);
20326 _outv = octave_value();
20330 return octave_value_list();
20338 octave_value_list _out;
20339 octave_value_list *_outp=&_out;
20340 octave_value _outv;
20349 arg1 = (
PLINT)(val1);
20351 _outv = octave_value();
20355 return octave_value_list();
20365 char *arg6 = (
char *) 0 ;
20379 octave_value_list _out;
20380 octave_value_list *_outp=&_out;
20381 octave_value _outv;
20390 arg1 = (
PLFLT)(val1);
20395 arg2 = (
PLFLT)(val2);
20400 arg3 = (
PLFLT)(val3);
20405 arg4 = (
PLFLT)(val4);
20410 arg5 = (
PLFLT)(val5);
20415 arg6 = (
char *)(buf6);
20416 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
20417 _outv = octave_value();
20423 return octave_value_list();
20438 char *arg11 = (
char *) 0 ;
20462 octave_value_list _out;
20463 octave_value_list *_outp=&_out;
20464 octave_value _outv;
20473 arg1 = (
PLFLT)(val1);
20478 arg2 = (
PLFLT)(val2);
20483 arg3 = (
PLFLT)(val3);
20488 arg4 = (
PLFLT)(val4);
20493 arg5 = (
PLFLT)(val5);
20498 arg6 = (
PLFLT)(val6);
20503 arg7 = (
PLFLT)(val7);
20508 arg8 = (
PLFLT)(val8);
20513 arg9 = (
PLFLT)(val9);
20518 arg10 = (
PLFLT)(val10);
20523 arg11 = (
char *)(buf11);
20524 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
20525 _outv = octave_value();
20531 return octave_value_list();
20536 octave_value_list _out;
20537 octave_value_list *_outp=&_out;
20538 octave_value _outv;
20549 return octave_value_list();
20554 octave_value_list _out;
20555 octave_value_list *_outp=&_out;
20556 octave_value _outv;
20562 _outv = octave_value();
20566 return octave_value_list();
20574 PLFLT *arg4 = (PLFLT *) 0 ;
20575 PLFLT *arg5 = (PLFLT *) 0 ;
20576 PLFLT *arg6 = (PLFLT *) 0 ;
20589 octave_value_list _out;
20590 octave_value_list *_outp=&_out;
20591 octave_value _outv;
20603 arg1 = (
PLFLT)(val1);
20608 arg2 = (
PLFLT)(val2);
20613 arg3 = (
PLFLT)(val3);
20614 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
20615 _outv = octave_value();
20637 return octave_value_list();
20648 octave_value_list _out;
20649 octave_value_list *_outp=&_out;
20650 octave_value _outv;
20659 arg1 = (
PLFLT)(val1);
20664 arg2 = (
PLFLT)(val2);
20666 _outv = octave_value();
20670 return octave_value_list();
20675 PLINT *arg1 = (PLINT *) 0 ;
20676 PLINT *arg2 = (PLINT *) 0 ;
20677 PLINT *arg3 = (PLINT *) 0 ;
20682 octave_value_list _out;
20683 octave_value_list *_outp=&_out;
20684 octave_value _outv;
20690 if (
_n_dims( args(0) ) > 1 )
20695 temp1 = args(0).matrix_value();
20696 arg1 =
new PLINT[
Alen];
20700 if (
_n_dims( args(1) ) > 1 )
20704 if (
_dim( args(1), 0 ) != Alen )
20708 temp2 = args(1).matrix_value();
20709 arg2 =
new PLINT[
Alen];
20713 if (
_n_dims( args(2) ) > 1 )
20717 if (
_dim( args(2), 0 ) != Alen )
20721 temp3 = args(2).matrix_value();
20722 arg3 =
new PLINT[
Alen];
20726 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
20727 _outv = octave_value();
20749 return octave_value_list();
20754 PLINT *arg1 = (PLINT *) 0 ;
20755 PLINT *arg2 = (PLINT *) 0 ;
20756 PLINT *arg3 = (PLINT *) 0 ;
20757 PLFLT *arg4 = (PLFLT *) 0 ;
20763 octave_value_list _out;
20764 octave_value_list *_outp=&_out;
20765 octave_value _outv;
20771 if (
_n_dims( args(0) ) > 1 )
20776 temp1 = args(0).matrix_value();
20777 arg1 =
new PLINT[
Alen];
20781 if (
_n_dims( args(1) ) > 1 )
20785 if (
_dim( args(1), 0 ) != Alen )
20789 temp2 = args(1).matrix_value();
20790 arg2 =
new PLINT[
Alen];
20794 if (
_n_dims( args(2) ) > 1 )
20798 if (
_dim( args(2), 0 ) != Alen )
20802 temp3 = args(2).matrix_value();
20803 arg3 =
new PLINT[
Alen];
20807 if (
_n_dims( args(3) ) > 1 )
20811 if (
_dim( args(3), 0 ) != Alen )
20815 temp4 = args(3).matrix_value();
20816 arg4 = &temp4( 0, 0 );
20819 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
20820 _outv = octave_value();
20848 return octave_value_list();
20856 octave_value_list _out;
20857 octave_value_list *_outp=&_out;
20858 octave_value _outv;
20867 arg1 = (
PLINT)(val1);
20869 _outv = octave_value();
20873 return octave_value_list();
20878 PLINT *arg1 = (PLINT *) 0 ;
20879 PLINT *arg2 = (PLINT *) 0 ;
20880 PLINT *arg3 = (PLINT *) 0 ;
20885 octave_value_list _out;
20886 octave_value_list *_outp=&_out;
20887 octave_value _outv;
20893 if (
_n_dims( args(0) ) > 1 )
20898 temp1 = args(0).matrix_value();
20899 arg1 =
new PLINT[
Alen];
20903 if (
_n_dims( args(1) ) > 1 )
20907 if (
_dim( args(1), 0 ) != Alen )
20911 temp2 = args(1).matrix_value();
20912 arg2 =
new PLINT[
Alen];
20916 if (
_n_dims( args(2) ) > 1 )
20920 if (
_dim( args(2), 0 ) != Alen )
20924 temp3 = args(2).matrix_value();
20925 arg3 =
new PLINT[
Alen];
20929 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
20930 _outv = octave_value();
20952 return octave_value_list();
20957 PLINT *arg1 = (PLINT *) 0 ;
20958 PLINT *arg2 = (PLINT *) 0 ;
20959 PLINT *arg3 = (PLINT *) 0 ;
20960 PLFLT *arg4 = (PLFLT *) 0 ;
20966 octave_value_list _out;
20967 octave_value_list *_outp=&_out;
20968 octave_value _outv;
20974 if (
_n_dims( args(0) ) > 1 )
20979 temp1 = args(0).matrix_value();
20980 arg1 =
new PLINT[
Alen];
20984 if (
_n_dims( args(1) ) > 1 )
20988 if (
_dim( args(1), 0 ) != Alen )
20992 temp2 = args(1).matrix_value();
20993 arg2 =
new PLINT[
Alen];
20997 if (
_n_dims( args(2) ) > 1 )
21001 if (
_dim( args(2), 0 ) != Alen )
21005 temp3 = args(2).matrix_value();
21006 arg3 =
new PLINT[
Alen];
21010 if (
_n_dims( args(3) ) > 1 )
21014 if (
_dim( args(3), 0 ) != Alen )
21018 temp4 = args(3).matrix_value();
21019 arg4 = &temp4( 0, 0 );
21022 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
21023 _outv = octave_value();
21051 return octave_value_list();
21058 PLFLT *arg3 = (PLFLT *) 0 ;
21059 PLFLT *arg4 = (PLFLT *) 0 ;
21060 PLFLT *arg5 = (PLFLT *) 0 ;
21061 PLFLT *arg6 = (PLFLT *) 0 ;
21070 octave_value_list _out;
21071 octave_value_list *_outp=&_out;
21072 octave_value _outv;
21083 if (
_n_dims( args(1) ) > 1 )
21087 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
21088 temp2 = args(1).matrix_value();
21089 arg3 = &temp2( 0, 0 );
21092 if (
_n_dims( args(2) ) > 1 )
21096 if (
_dim( args(2), 0 ) != Alen )
21100 temp4 = args(2).matrix_value();
21101 arg4 = &temp4( 0, 0 );
21104 if (
_n_dims( args(3) ) > 1 )
21108 if (
_dim( args(3), 0 ) != Alen )
21112 temp5 = args(3).matrix_value();
21113 arg5 = &temp5( 0, 0 );
21116 if (
_n_dims( args(4) ) > 1 )
21120 if (
_dim( args(4), 0 ) != Alen )
21124 temp6 = args(4).matrix_value();
21125 arg6 = &temp6( 0, 0 );
21128 if (
_n_dims( args(5) ) > 1 )
21132 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
21134 error(
"argument vector must be same length or one less" );
SWIG_fail;
21136 temp7 = args(5).matrix_value();
21137 arg7 =
new PLINT[
Alen];
21140 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
21141 _outv = octave_value();
21175 return octave_value_list();
21182 PLFLT *arg3 = (PLFLT *) 0 ;
21183 PLFLT *arg4 = (PLFLT *) 0 ;
21184 PLFLT *arg5 = (PLFLT *) 0 ;
21185 PLFLT *arg6 = (PLFLT *) 0 ;
21186 PLFLT *arg7 = (PLFLT *) 0 ;
21196 octave_value_list _out;
21197 octave_value_list *_outp=&_out;
21198 octave_value _outv;
21209 if (
_n_dims( args(1) ) > 1 )
21213 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
21214 temp2 = args(1).matrix_value();
21215 arg3 = &temp2( 0, 0 );
21218 if (
_n_dims( args(2) ) > 1 )
21222 if (
_dim( args(2), 0 ) != Alen )
21226 temp4 = args(2).matrix_value();
21227 arg4 = &temp4( 0, 0 );
21230 if (
_n_dims( args(3) ) > 1 )
21234 if (
_dim( args(3), 0 ) != Alen )
21238 temp5 = args(3).matrix_value();
21239 arg5 = &temp5( 0, 0 );
21242 if (
_n_dims( args(4) ) > 1 )
21246 if (
_dim( args(4), 0 ) != Alen )
21250 temp6 = args(4).matrix_value();
21251 arg6 = &temp6( 0, 0 );
21254 if (
_n_dims( args(5) ) > 1 )
21258 if (
_dim( args(5), 0 ) != Alen )
21262 temp7 = args(5).matrix_value();
21263 arg7 = &temp7( 0, 0 );
21266 if (
_n_dims( args(6) ) > 1 )
21270 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
21272 error(
"argument vector must be same length or one less" );
SWIG_fail;
21274 temp8 = args(6).matrix_value();
21275 arg8 =
new PLINT[
Alen];
21278 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
21279 _outv = octave_value();
21319 return octave_value_list();
21327 octave_value_list _out;
21328 octave_value_list *_outp=&_out;
21329 octave_value _outv;
21338 arg1 = (
PLINT)(val1);
21340 _outv = octave_value();
21344 return octave_value_list();
21355 octave_value_list _out;
21356 octave_value_list *_outp=&_out;
21357 octave_value _outv;
21366 arg1 = (
PLFLT)(val1);
21371 arg2 = (
PLFLT)(val2);
21373 _outv = octave_value();
21377 return octave_value_list();
21382 PLFLT *arg1 = (PLFLT *) 0 ;
21383 PLFLT *arg2 = (PLFLT *) 0 ;
21388 octave_value_list _out;
21389 octave_value_list *_outp=&_out;
21390 octave_value _outv;
21398 _outv = octave_value();
21414 return octave_value_list();
21431 octave_value_list _out;
21432 octave_value_list *_outp=&_out;
21433 octave_value _outv;
21442 arg1 = (
PLINT)(val1);
21447 arg2 = (
PLINT)(val2);
21452 arg3 = (
PLINT)(val3);
21457 arg4 = (
PLINT)(val4);
21458 plscol0(arg1,arg2,arg3,arg4);
21459 _outv = octave_value();
21463 return octave_value_list();
21483 octave_value_list _out;
21484 octave_value_list *_outp=&_out;
21485 octave_value _outv;
21494 arg1 = (
PLINT)(val1);
21499 arg2 = (
PLINT)(val2);
21504 arg3 = (
PLINT)(val3);
21509 arg4 = (
PLINT)(val4);
21514 arg5 = (
PLFLT)(val5);
21515 plscol0a(arg1,arg2,arg3,arg4,arg5);
21516 _outv = octave_value();
21520 return octave_value_list();
21534 octave_value_list _out;
21535 octave_value_list *_outp=&_out;
21536 octave_value _outv;
21545 arg1 = (
PLINT)(val1);
21550 arg2 = (
PLINT)(val2);
21555 arg3 = (
PLINT)(val3);
21557 _outv = octave_value();
21561 return octave_value_list();
21578 octave_value_list _out;
21579 octave_value_list *_outp=&_out;
21580 octave_value _outv;
21589 arg1 = (
PLINT)(val1);
21594 arg2 = (
PLINT)(val2);
21599 arg3 = (
PLINT)(val3);
21604 arg4 = (
PLFLT)(val4);
21606 _outv = octave_value();
21610 return octave_value_list();
21618 octave_value_list _out;
21619 octave_value_list *_outp=&_out;
21620 octave_value _outv;
21629 arg1 = (
PLINT)(val1);
21631 _outv = octave_value();
21635 return octave_value_list();
21643 octave_value_list _out;
21644 octave_value_list *_outp=&_out;
21645 octave_value _outv;
21654 arg1 = (
PLINT)(val1);
21656 _outv = octave_value();
21660 return octave_value_list();
21665 char *arg1 = (
char *) 0 ;
21669 octave_value_list _out;
21670 octave_value_list *_outp=&_out;
21671 octave_value _outv;
21680 arg1 = (
char *)(buf1);
21681 plsdev((
char const *)arg1);
21682 _outv = octave_value();
21688 return octave_value_list();
21705 octave_value_list _out;
21706 octave_value_list *_outp=&_out;
21707 octave_value _outv;
21716 arg1 = (
PLFLT)(val1);
21721 arg2 = (
PLFLT)(val2);
21726 arg3 = (
PLFLT)(val3);
21731 arg4 = (
PLFLT)(val4);
21733 _outv = octave_value();
21737 return octave_value_list();
21760 octave_value_list _out;
21761 octave_value_list *_outp=&_out;
21762 octave_value _outv;
21771 arg1 = (
PLINT)(val1);
21776 arg2 = (
PLINT)(val2);
21781 arg3 = (
PLINT)(val3);
21786 arg4 = (
PLINT)(val4);
21791 arg5 = (
PLFLT)(val5);
21796 arg6 = (
PLFLT)(val6);
21797 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
21798 _outv = octave_value();
21802 return octave_value_list();
21810 octave_value_list _out;
21811 octave_value_list *_outp=&_out;
21812 octave_value _outv;
21821 arg1 = (
PLFLT)(val1);
21823 _outv = octave_value();
21827 return octave_value_list();
21844 octave_value_list _out;
21845 octave_value_list *_outp=&_out;
21846 octave_value _outv;
21855 arg1 = (
PLFLT)(val1);
21860 arg2 = (
PLFLT)(val2);
21865 arg3 = (
PLFLT)(val3);
21870 arg4 = (
PLFLT)(val4);
21872 _outv = octave_value();
21876 return octave_value_list();
21893 octave_value_list _out;
21894 octave_value_list *_outp=&_out;
21895 octave_value _outv;
21904 arg1 = (
PLFLT)(val1);
21909 arg2 = (
PLFLT)(val2);
21914 arg3 = (
PLFLT)(val3);
21919 arg4 = (
PLFLT)(val4);
21921 _outv = octave_value();
21925 return octave_value_list();
21930 unsigned int arg1 ;
21931 unsigned int val1 ;
21933 octave_value_list _out;
21934 octave_value_list *_outp=&_out;
21935 octave_value _outv;
21944 arg1 = (
unsigned int)(val1);
21946 _outv = octave_value();
21950 return octave_value_list();
21958 octave_value_list _out;
21959 octave_value_list *_outp=&_out;
21960 octave_value _outv;
21969 arg1 = (char)(val1);
21971 _outv = octave_value();
21975 return octave_value_list();
21980 char *arg1 = (
char *) 0 ;
21981 char *arg2 = (
char *) 0 ;
21988 octave_value_list _out;
21989 octave_value_list *_outp=&_out;
21990 octave_value _outv;
22000 arg1 = (
char *)(buf1);
22005 arg2 = (
char *)(buf2);
22006 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
22015 return octave_value_list();
22029 octave_value_list _out;
22030 octave_value_list *_outp=&_out;
22031 octave_value _outv;
22040 arg1 = (
PLINT)(val1);
22045 arg2 = (
PLINT)(val2);
22050 arg3 = (
PLINT)(val3);
22052 _outv = octave_value();
22056 return octave_value_list();
22062 unsigned int val1 ;
22064 octave_value_list _out;
22065 octave_value_list *_outp=&_out;
22066 octave_value _outv;
22077 _outv = octave_value();
22081 return octave_value_list();
22086 char *arg1 = (
char *) 0 ;
22090 octave_value_list _out;
22091 octave_value_list *_outp=&_out;
22092 octave_value _outv;
22101 arg1 = (
char *)(buf1);
22103 _outv = octave_value();
22109 return octave_value_list();
22123 octave_value_list _out;
22124 octave_value_list *_outp=&_out;
22125 octave_value _outv;
22134 arg1 = (
PLINT)(val1);
22139 arg2 = (
PLINT)(val2);
22144 arg3 = (
PLINT)(val3);
22146 _outv = octave_value();
22150 return octave_value_list();
22158 octave_value_list _out;
22159 octave_value_list *_outp=&_out;
22160 octave_value _outv;
22166 octave_value obj = args(0);
22167 if ( !obj.is_empty() )
22169 if ( obj.is_function_handle() || obj.is_inline_function() )
22171 fcnLabelFunc = obj.function_value();
22173 else if ( obj.is_string() )
22175 nameLabelFunc = obj.string_value();
22176 fcnLabelFunc = NULL;
22190 _outv = octave_value();
22194 return octave_value_list();
22205 octave_value_list _out;
22206 octave_value_list *_outp=&_out;
22207 octave_value _outv;
22216 arg1 = (
PLFLT)(val1);
22221 arg2 = (
PLFLT)(val2);
22223 _outv = octave_value();
22227 return octave_value_list();
22238 octave_value_list _out;
22239 octave_value_list *_outp=&_out;
22240 octave_value _outv;
22249 arg1 = (
PLFLT)(val1);
22254 arg2 = (
PLFLT)(val2);
22256 _outv = octave_value();
22260 return octave_value_list();
22268 octave_value_list _out;
22269 octave_value_list *_outp=&_out;
22270 octave_value _outv;
22279 arg1 = (
PLINT)(val1);
22281 _outv = octave_value();
22285 return octave_value_list();
22308 octave_value_list _out;
22309 octave_value_list *_outp=&_out;
22310 octave_value _outv;
22319 arg1 = (
PLFLT)(val1);
22324 arg2 = (
PLFLT)(val2);
22329 arg3 = (
PLINT)(val3);
22334 arg4 = (
PLINT)(val4);
22339 arg5 = (
PLINT)(val5);
22344 arg6 = (
PLINT)(val6);
22345 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22346 _outv = octave_value();
22350 return octave_value_list();
22355 char *arg1 = (
char *) 0 ;
22359 octave_value_list _out;
22360 octave_value_list *_outp=&_out;
22361 octave_value _outv;
22370 arg1 = (
char *)(buf1);
22372 _outv = octave_value();
22378 return octave_value_list();
22383 char *arg1 = (
char *) 0 ;
22390 octave_value_list _out;
22391 octave_value_list *_outp=&_out;
22392 octave_value _outv;
22401 arg1 = (
char *)(buf1);
22407 plspal1((
char const *)arg1,arg2);
22408 _outv = octave_value();
22414 return octave_value_list();
22422 octave_value_list _out;
22423 octave_value_list *_outp=&_out;
22424 octave_value _outv;
22435 _outv = octave_value();
22439 return octave_value_list();
22447 octave_value_list _out;
22448 octave_value_list *_outp=&_out;
22449 octave_value _outv;
22458 arg1 = (
PLINT)(val1);
22460 _outv = octave_value();
22464 return octave_value_list();
22475 octave_value_list _out;
22476 octave_value_list *_outp=&_out;
22477 octave_value _outv;
22486 arg1 = (
PLINT)(val1);
22491 arg2 = (
PLINT)(val2);
22493 _outv = octave_value();
22497 return octave_value_list();
22508 octave_value_list _out;
22509 octave_value_list *_outp=&_out;
22510 octave_value _outv;
22519 arg1 = (
PLFLT)(val1);
22524 arg2 = (
PLFLT)(val2);
22526 _outv = octave_value();
22530 return octave_value_list();
22541 octave_value_list _out;
22542 octave_value_list *_outp=&_out;
22543 octave_value _outv;
22552 arg1 = (
PLINT)(val1);
22557 arg2 = (
PLINT)(val2);
22559 _outv = octave_value();
22563 return octave_value_list();
22568 char *arg1 = (
char *) 0 ;
22578 octave_value_list _out;
22579 octave_value_list *_outp=&_out;
22580 octave_value _outv;
22589 arg1 = (
char *)(buf1);
22594 arg2 = (
PLINT)(val2);
22599 arg3 = (
PLINT)(val3);
22600 plstart((
char const *)arg1,arg2,arg3);
22601 _outv = octave_value();
22607 return octave_value_list();
22615 octave_value_list _out;
22616 octave_value_list *_outp=&_out;
22617 octave_value _outv;
22623 octave_value obj = args(0);
22624 if ( !obj.is_empty() )
22626 if ( obj.is_function_handle() || obj.is_inline_function() )
22628 fcnCoordTrans = obj.function_value();
22630 else if ( obj.is_string() )
22632 nameCoordTrans = obj.string_value();
22633 fcnCoordTrans = NULL;
22647 _outv = octave_value();
22651 return octave_value_list();
22657 PLFLT *arg2 = (PLFLT *) 0 ;
22658 PLFLT *arg3 = (PLFLT *) 0 ;
22659 char *arg4 = (
char *) 0 ;
22665 octave_value_list _out;
22666 octave_value_list *_outp=&_out;
22667 octave_value _outv;
22673 if (
_n_dims( args(0) ) > 1 )
22677 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
22678 temp1 = args(0).matrix_value();
22679 arg2 = &temp1( 0, 0 );
22682 if (
_n_dims( args(1) ) > 1 )
22686 if (
_dim( args(1), 0 ) != Alen )
22690 temp3 = args(1).matrix_value();
22691 arg3 = &temp3( 0, 0 );
22697 arg4 = (
char *)(buf4);
22698 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
22699 _outv = octave_value();
22717 return octave_value_list();
22723 PLFLT *arg2 = (PLFLT *) 0 ;
22724 PLFLT *arg3 = (PLFLT *) 0 ;
22725 PLFLT *arg4 = (PLFLT *) 0 ;
22726 char *arg5 = (
char *) 0 ;
22733 octave_value_list _out;
22734 octave_value_list *_outp=&_out;
22735 octave_value _outv;
22741 if (
_n_dims( args(0) ) > 1 )
22745 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
22746 temp1 = args(0).matrix_value();
22747 arg2 = &temp1( 0, 0 );
22750 if (
_n_dims( args(1) ) > 1 )
22754 if (
_dim( args(1), 0 ) != Alen )
22758 temp3 = args(1).matrix_value();
22759 arg3 = &temp3( 0, 0 );
22762 if (
_n_dims( args(2) ) > 1 )
22766 if (
_dim( args(2), 0 ) != Alen )
22770 temp4 = args(2).matrix_value();
22771 arg4 = &temp4( 0, 0 );
22777 arg5 = (
char *)(buf5);
22778 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
22779 _outv = octave_value();
22803 return octave_value_list();
22820 octave_value_list _out;
22821 octave_value_list *_outp=&_out;
22822 octave_value _outv;
22831 arg1 = (
PLINT)(val1);
22836 arg2 = (
PLINT)(val2);
22841 arg3 = (
PLFLT)(val3);
22846 arg4 = (
PLFLT)(val4);
22848 _outv = octave_value();
22852 return octave_value_list();
22860 octave_value_list _out;
22861 octave_value_list *_outp=&_out;
22862 octave_value _outv;
22871 arg1 = (
PLINT)(val1);
22873 _outv = octave_value();
22877 return octave_value_list();
22883 PLINT *arg2 = (PLINT *) 0 ;
22884 PLINT *arg3 = (PLINT *) 0 ;
22887 octave_value_list _out;
22888 octave_value_list *_outp=&_out;
22889 octave_value _outv;
22895 if (
_n_dims( args(0) ) > 1 )
22899 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
22900 arg2 =
new PLINT[
Alen];
22901 temp1 = args(0).matrix_value();
22905 if (
_n_dims( args(1) ) > 1 )
22909 if (
_dim( args(1), 0 ) != Alen )
22913 temp3 = args(1).matrix_value();
22914 arg3 =
new PLINT[
Alen];
22917 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
22918 _outv = octave_value();
22934 return octave_value_list();
22939 PLFLT *arg1 = (PLFLT *) 0 ;
22940 PLFLT *arg2 = (PLFLT *) 0 ;
22947 octave_value_list _out;
22948 octave_value_list *_outp=&_out;
22949 octave_value _outv;
22955 if (
_n_dims( args(0) ) > 1 )
22959 if ( !args(0).is_empty() )
22962 temp1 = args(0).matrix_value();
22963 arg1 = &temp1( 0, 0 );
22972 if (
_n_dims( args(1) ) > 1 )
22976 if ( !args(1).is_empty() )
22978 if (
_dim( args(1), 0 ) != Alen )
22982 temp2 = args(1).matrix_value();
22983 arg2 = &temp2( 0, 0 );
22997 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
22998 _outv = octave_value();
23014 return octave_value_list();
23031 octave_value_list _out;
23032 octave_value_list *_outp=&_out;
23033 octave_value _outv;
23042 arg1 = (
PLFLT)(val1);
23047 arg2 = (
PLFLT)(val2);
23052 arg3 = (
PLFLT)(val3);
23057 arg4 = (
PLFLT)(val4);
23058 plsvpa(arg1,arg2,arg3,arg4);
23059 _outv = octave_value();
23063 return octave_value_list();
23074 octave_value_list _out;
23075 octave_value_list *_outp=&_out;
23076 octave_value _outv;
23085 arg1 = (
PLINT)(val1);
23090 arg2 = (
PLINT)(val2);
23092 _outv = octave_value();
23096 return octave_value_list();
23107 octave_value_list _out;
23108 octave_value_list *_outp=&_out;
23109 octave_value _outv;
23118 arg1 = (
PLINT)(val1);
23123 arg2 = (
PLINT)(val2);
23125 _outv = octave_value();
23129 return octave_value_list();
23135 PLFLT *arg2 = (PLFLT *) 0 ;
23136 PLFLT *arg3 = (PLFLT *) 0 ;
23142 octave_value_list _out;
23143 octave_value_list *_outp=&_out;
23144 octave_value _outv;
23150 if (
_n_dims( args(0) ) > 1 )
23154 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
23155 temp1 = args(0).matrix_value();
23156 arg2 = &temp1( 0, 0 );
23159 if (
_n_dims( args(1) ) > 1 )
23163 if (
_dim( args(1), 0 ) != Alen )
23167 temp3 = args(1).matrix_value();
23168 arg3 = &temp3( 0, 0 );
23174 arg4 = (
PLINT)(val4);
23175 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
23176 _outv = octave_value();
23192 return octave_value_list();
23203 octave_value_list _out;
23204 octave_value_list *_outp=&_out;
23205 octave_value _outv;
23214 arg1 = (
PLINT)(val1);
23219 arg2 = (
PLINT)(val2);
23221 _outv = octave_value();
23225 return octave_value_list();
23230 octave_value_list _out;
23231 octave_value_list *_outp=&_out;
23232 octave_value _outv;
23238 _outv = octave_value();
23242 return octave_value_list();
23247 char *arg1 = (
char *) 0 ;
23251 octave_value_list _out;
23252 octave_value_list *_outp=&_out;
23253 octave_value _outv;
23262 arg1 = (
char *)(buf1);
23264 _outv = octave_value();
23270 return octave_value_list();
23278 octave_value_list _out;
23279 octave_value_list *_outp=&_out;
23280 octave_value _outv;
23289 arg1 = (
PLFLT)(val1);
23291 _outv = octave_value();
23295 return octave_value_list();
23315 octave_value_list _out;
23316 octave_value_list *_outp=&_out;
23317 octave_value _outv;
23326 arg1 = (
PLFLT)(val1);
23331 arg2 = (
PLFLT)(val2);
23336 arg3 = (
PLFLT)(val3);
23341 arg4 = (
PLFLT)(val4);
23346 arg5 = (
PLFLT)(val5);
23347 plvpas(arg1,arg2,arg3,arg4,arg5);
23348 _outv = octave_value();
23352 return octave_value_list();
23369 octave_value_list _out;
23370 octave_value_list *_outp=&_out;
23371 octave_value _outv;
23380 arg1 = (
PLFLT)(val1);
23385 arg2 = (
PLFLT)(val2);
23390 arg3 = (
PLFLT)(val3);
23395 arg4 = (
PLFLT)(val4);
23396 plvpor(arg1,arg2,arg3,arg4);
23397 _outv = octave_value();
23401 return octave_value_list();
23406 octave_value_list _out;
23407 octave_value_list *_outp=&_out;
23408 octave_value _outv;
23414 _outv = octave_value();
23418 return octave_value_list();
23456 octave_value_list _out;
23457 octave_value_list *_outp=&_out;
23458 octave_value _outv;
23467 arg1 = (
PLFLT)(val1);
23472 arg2 = (
PLFLT)(val2);
23477 arg3 = (
PLFLT)(val3);
23482 arg4 = (
PLFLT)(val4);
23487 arg5 = (
PLFLT)(val5);
23492 arg6 = (
PLFLT)(val6);
23497 arg7 = (
PLFLT)(val7);
23502 arg8 = (
PLFLT)(val8);
23507 arg9 = (
PLFLT)(val9);
23512 arg10 = (
PLFLT)(val10);
23517 arg11 = (
PLFLT)(val11);
23518 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23519 _outv = octave_value();
23523 return octave_value_list();
23531 octave_value_list _out;
23532 octave_value_list *_outp=&_out;
23533 octave_value _outv;
23542 arg1 = (
PLFLT)(val1);
23544 _outv = octave_value();
23548 return octave_value_list();
23565 octave_value_list _out;
23566 octave_value_list *_outp=&_out;
23567 octave_value _outv;
23576 arg1 = (
PLFLT)(val1);
23581 arg2 = (
PLFLT)(val2);
23586 arg3 = (
PLFLT)(val3);
23591 arg4 = (
PLFLT)(val4);
23592 plwind(arg1,arg2,arg3,arg4);
23593 _outv = octave_value();
23597 return octave_value_list();
23608 octave_value_list _out;
23609 octave_value_list *_outp=&_out;
23610 octave_value _outv;
23622 _outv = octave_value();
23632 return octave_value_list();
23638 char *arg2 = (
char *) 0 ;
23654 octave_value_list _out;
23655 octave_value_list *_outp=&_out;
23656 octave_value _outv;
23662 octave_value obj = args(0);
23663 if ( !obj.is_empty() )
23665 if ( obj.is_function_handle() || obj.is_inline_function() )
23667 fcnMapForm = obj.function_value();
23669 else if ( obj.is_string() )
23671 nameMapForm = obj.string_value();
23685 arg2 = (
char *)(buf2);
23690 arg3 = (
PLFLT)(val3);
23695 arg4 = (
PLFLT)(val4);
23700 arg5 = (
PLFLT)(val5);
23705 arg6 = (
PLFLT)(val6);
23706 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
23707 _outv = octave_value();
23713 return octave_value_list();
23719 char *arg2 = (
char *) 0 ;
23724 PLINT *arg7 = (PLINT *) 0 ;
23738 octave_value_list _out;
23739 octave_value_list *_outp=&_out;
23740 octave_value _outv;
23746 octave_value obj = args(0);
23747 if ( !obj.is_empty() )
23749 if ( obj.is_function_handle() || obj.is_inline_function() )
23751 fcnMapForm = obj.function_value();
23753 else if ( obj.is_string() )
23755 nameMapForm = obj.string_value();
23769 arg2 = (
char *)(buf2);
23774 arg3 = (
PLFLT)(val3);
23779 arg4 = (
PLFLT)(val4);
23784 arg5 = (
PLFLT)(val5);
23789 arg6 = (
PLFLT)(val6);
23791 if (
_n_dims( args(6) ) > 1 )
23795 if ( !args(6).is_empty() )
23798 temp7 = args(6).matrix_value();
23799 arg7 =
new PLINT[arg8];
23808 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
23809 _outv = octave_value();
23821 return octave_value_list();
23827 char *arg2 = (
char *) 0 ;
23828 char *arg3 = (
char *) 0 ;
23833 PLINT *arg8 = (PLINT *) 0 ;
23850 octave_value_list _out;
23851 octave_value_list *_outp=&_out;
23852 octave_value _outv;
23858 octave_value obj = args(0);
23859 if ( !obj.is_empty() )
23861 if ( obj.is_function_handle() || obj.is_inline_function() )
23863 fcnMapForm = obj.function_value();
23865 else if ( obj.is_string() )
23867 nameMapForm = obj.string_value();
23881 arg2 = (
char *)(buf2);
23886 arg3 = (
char *)(buf3);
23891 arg4 = (
PLFLT)(val4);
23896 arg5 = (
PLFLT)(val5);
23901 arg6 = (
PLFLT)(val6);
23906 arg7 = (
PLFLT)(val7);
23908 if (
_n_dims( args(7) ) > 1 )
23912 if ( !args(7).is_empty() )
23915 temp8 = args(7).matrix_value();
23916 arg8 =
new PLINT[arg9];
23925 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
23926 _outv = octave_value();
23940 return octave_value_list();
23946 char *arg2 = (
char *) 0 ;
23950 char *arg6 = (
char *) 0 ;
23978 octave_value_list _out;
23979 octave_value_list *_outp=&_out;
23980 octave_value _outv;
23986 octave_value obj = args(0);
23987 if ( !obj.is_empty() )
23989 if ( obj.is_function_handle() || obj.is_inline_function() )
23991 fcnMapForm = obj.function_value();
23993 else if ( obj.is_string() )
23995 nameMapForm = obj.string_value();
24009 arg2 = (
char *)(buf2);
24014 arg3 = (
PLFLT)(val3);
24019 arg4 = (
PLFLT)(val4);
24024 arg5 = (
PLFLT)(val5);
24029 arg6 = (
char *)(buf6);
24034 arg7 = (
PLFLT)(val7);
24039 arg8 = (
PLFLT)(val8);
24044 arg9 = (
PLFLT)(val9);
24049 arg10 = (
PLFLT)(val10);
24054 arg11 = (
PLINT)(val11);
24055 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24056 _outv = octave_value();
24064 return octave_value_list();
24070 char *arg2 = (
char *) 0 ;
24075 PLINT *arg7 = (PLINT *) 0 ;
24089 octave_value_list _out;
24090 octave_value_list *_outp=&_out;
24091 octave_value _outv;
24097 octave_value obj = args(0);
24098 if ( !obj.is_empty() )
24100 if ( obj.is_function_handle() || obj.is_inline_function() )
24102 fcnMapForm = obj.function_value();
24104 else if ( obj.is_string() )
24106 nameMapForm = obj.string_value();
24120 arg2 = (
char *)(buf2);
24125 arg3 = (
PLFLT)(val3);
24130 arg4 = (
PLFLT)(val4);
24135 arg5 = (
PLFLT)(val5);
24140 arg6 = (
PLFLT)(val6);
24142 if (
_n_dims( args(6) ) > 1 )
24146 if ( !args(6).is_empty() )
24149 temp7 = args(6).matrix_value();
24150 arg7 =
new PLINT[arg8];
24159 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
24160 _outv = octave_value();
24172 return octave_value_list();
24196 octave_value_list _out;
24197 octave_value_list *_outp=&_out;
24198 octave_value _outv;
24204 octave_value obj = args(0);
24205 if ( !obj.is_empty() )
24207 if ( obj.is_function_handle() || obj.is_inline_function() )
24209 fcnMapForm = obj.function_value();
24211 else if ( obj.is_string() )
24213 nameMapForm = obj.string_value();
24227 arg2 = (
PLFLT)(val2);
24232 arg3 = (
PLFLT)(val3);
24237 arg4 = (
PLFLT)(val4);
24242 arg5 = (
PLFLT)(val5);
24247 arg6 = (
PLFLT)(val6);
24252 arg7 = (
PLFLT)(val7);
24254 _outv = octave_value();
24258 return octave_value_list();
24263 octave_value_list _out;
24264 octave_value_list *_outp=&_out;
24265 octave_value _outv;
24271 _outv = octave_value();
24275 return octave_value_list();
24280 octave_value_list _out;
24281 octave_value_list *_outp=&_out;
24282 octave_value _outv;
24288 _outv = octave_value();
24292 return octave_value_list();
24297 char *arg1 = (
char *) 0 ;
24298 char *arg2 = (
char *) 0 ;
24305 octave_value_list _out;
24306 octave_value_list *_outp=&_out;
24307 octave_value _outv;
24316 arg1 = (
char *)(buf1);
24321 arg2 = (
char *)(buf2);
24322 plSetUsage((
char const *)arg1,(
char const *)arg2);
24323 _outv = octave_value();
24331 return octave_value_list();
24336 octave_value_list _out;
24337 octave_value_list *_outp=&_out;
24338 octave_value _outv;
24344 _outv = octave_value();
24348 return octave_value_list();
24354 {
"testppchar",_wrap_testppchar,0,0,2,0},
24356 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24359 {
"plcont0",_wrap_plcont0,0,0,2,0},
24360 {
"plcont1",_wrap_plcont1,0,0,2,0},
24361 {
"plcont2",_wrap_plcont2,0,0,2,0},
24362 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
24372 {
"plshade1",_wrap_plshade1,0,0,2,0},
24373 {
"plshade2",_wrap_plshade2,0,0,2,0},
24375 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
24376 {
"plshades1",_wrap_plshades1,0,0,2,0},
24377 {
"plshades2",_wrap_plshades2,0,0,2,0},
24379 {
"plvect1",_wrap_plvect1,0,0,2,0},
24380 {
"plvect2",_wrap_plvect2,0,0,2,0},
24381 {
"pplimage",_wrap_pplimage,0,0,2,0},
24383 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24384 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24385 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24520 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
24671 #define SWIGRUNTIME_DEBUG
24682 if (swig_module.
next==0) {
24694 if (!module_head) {
24704 if (iter==&swig_module) {
24709 }
while (iter!= module_head);
24714 swig_module.
next = module_head->
next;
24722 if (init == 0)
return;
24725 #ifdef SWIGRUNTIME_DEBUG
24726 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
24728 for (i = 0; i < swig_module.
size; ++i) {
24733 #ifdef SWIGRUNTIME_DEBUG
24734 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
24738 if (swig_module.
next != &swig_module) {
24743 #ifdef SWIGRUNTIME_DEBUG
24744 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
24748 #ifdef SWIGRUNTIME_DEBUG
24749 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
24758 while (cast->
type) {
24762 #ifdef SWIGRUNTIME_DEBUG
24763 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
24765 if (swig_module.
next != &swig_module) {
24767 #ifdef SWIGRUNTIME_DEBUG
24768 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
24773 #ifdef SWIGRUNTIME_DEBUG
24774 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
24781 #ifdef SWIGRUNTIME_DEBUG
24782 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
24784 if (!ocast) ret = 0;
24789 #ifdef SWIGRUNTIME_DEBUG
24790 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
24801 swig_module.
types[i] = type;
24803 swig_module.
types[i] = 0;
24805 #ifdef SWIGRUNTIME_DEBUG
24806 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
24807 for (i = 0; i < swig_module.
size; ++i) {
24810 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
24811 while (cast->
type) {
24812 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
24816 printf(
"---- Total casts: %d\n",j);
24818 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
24831 static int init_run = 0;
24833 if (init_run)
return;
24836 for (i = 0; i < swig_module.
size; i++) {
24844 equiv = equiv->
next;
24864 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24865 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
24866 unwind_protect_int(error_state);
24867 unwind_protect_int(warning_state);
24868 unwind_protect_bool(discard_error_messages);
24869 unwind_protect_bool(discard_warning_messages);
24871 unwind_protect frame;
24872 frame.protect_var(error_state);
24873 frame.protect_var(warning_state);
24874 frame.protect_var(discard_error_messages);
24875 frame.protect_var(discard_warning_messages);
24879 discard_error_messages =
true;
24880 discard_warning_messages =
true;
24881 feval(name, octave_value_list(), 0);
24882 retn = (error_state == 0);
24883 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24884 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
24896 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24897 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
24898 unwind_protect_int(error_state);
24899 unwind_protect_int(warning_state);
24900 unwind_protect_bool(discard_error_messages);
24901 unwind_protect_bool(discard_warning_messages);
24903 unwind_protect frame;
24904 frame.protect_var(error_state);
24905 frame.protect_var(warning_state);
24906 frame.protect_var(discard_error_messages);
24907 frame.protect_var(discard_warning_messages);
24911 discard_error_messages =
true;
24912 discard_warning_messages =
true;
24913 octave_value_list args;
24915 args.append(octloadfcn->fcn_file_name());
24917 feval(
"autoload", args, 0);
24918 retn = (error_state == 0);
24919 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24920 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
24930 @deftypefn {Loadable Function} {} subclass()\n\
24931 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
24932 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
24934 See the SWIG manual for usage examples.\n\
24939 for (
int j = 0; j < args.length(); ++j) {
24940 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
24943 if (!ost->is_owned()) {
24944 error(
"subclass: cannot subclass object not constructed on octave side");
24945 return octave_value_list();
24948 }
else if (args(j).is_function_handle()) {
24949 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
24950 }
else if (args(j).is_string()) {
24951 if (j + 1 >= args.length()) {
24952 error(
"subclass: member assignments must be of string,value form");
24953 return octave_value_list();
24955 top->
assign(args(j).string_value(), args(j + 1));
24958 error(
"subclass: invalid arguments to subclass()");
24959 return octave_value_list();
24966 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
24967 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
24971 if (args.length() != 1) {
24972 error(
"swig_type: must be called with only a single object");
24973 return octave_value_list();
24977 error(
"swig_type: object is not a swig_ref");
24978 return octave_value_list();
24984 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
24985 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
24986 otherwise return `<unknown>'.\n\
24989 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
24990 if (args.length() != 1 || !args(0).is_string()) {
24991 error(
"swig_typequery: must be called with single string argument");
24992 return octave_value_list();
24997 return octave_value(
"<unknown>");
24998 return octave_value(type->
name);
25002 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25003 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25007 if (args.length() != 1) {
25008 error(
"swig_this: must be called with only a single object");
25009 return octave_value_list();
25011 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25012 return octave_value(octave_uint64(0));
25015 error(
"swig_this: object is not a swig_ref");
25016 return octave_value_list();
25018 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
25022 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25023 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25034 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25035 #if SWIG_OCTAVE_PREREQ(3,2,0) && !SWIG_OCTAVE_PREREQ(3,4,1)
25036 octave_exit = ::_Exit;
25041 if (args.length() != 0 || nargout != 0) {
25043 return octave_value_list();
25051 #if SWIG_OCTAVE_PREREQ(3,2,0)
25052 octave_value_list eval_args;
25053 eval_args.append(
"base");
25054 eval_args.append(
"function __swig_atexit__; "
25061 "__swig_atexit__; "
25062 "atexit(\"__swig_atexit__\", false); "
25063 "atexit(\"__swig_atexit__\")");
25064 feval(
"evalin", eval_args, 0);
25067 octave_swig_ref::register_type();
25068 octave_swig_packed::register_type();
25072 octave_function *me = octave_call_stack::current();
25075 return octave_value_list();
25078 return octave_value_list();
25081 return octave_value_list();
25084 return octave_value_list();
25090 for (
int j=0;swig_globals[j].
name;++j)
25092 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25100 for (
int j=0;swig_globals[j].
name;++j)
25102 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25104 for (
int j=0;swig_globals[j].
name;++j)
25105 if (swig_globals[j].
method)
25106 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25111 for (
int j=0;swig_types[j];++j)
25112 if (swig_types[j]->clientdata) {
25122 return octave_value_list();
25129 if (mb->second.first && mb->second.first->method) {
25131 return octave_value_list();
25136 #if !SWIG_OCTAVE_PREREQ(3,2,0)
25146 if (mb->second.second.is_defined()) {
25155 return octave_value_list();
static const char * _wrap_pljoin_texinfo
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
void c_plstripc(PLINT *id, PLCHAR_VECTOR xspec, PLCHAR_VECTOR yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, PLINT_VECTOR colline, PLINT_VECTOR styline, PLCHAR_MATRIX legline, PLCHAR_VECTOR labx, PLCHAR_VECTOR laby, PLCHAR_VECTOR labtop)
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[]
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)
static const char * _wrap_plimagefr_texinfo
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_plgriddata_texinfo
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)
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)
PLINT plGetCursor(PLGraphicsIn *plg)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
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)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
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
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(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_plmapline_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
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)
static const char * _wrap_plgcmap1_range_texinfo
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
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
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
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
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
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
PL_NC_GENERIC_POINTER PLPointer
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
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 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 plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
static const char * _wrap_plmesh_texinfo
#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)
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)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT plTranslateCursor(PLGraphicsIn *plg)
static const char * _wrap_plpsty_texinfo
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
std::map< std::string, member_value_pair > member_map
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
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
octave_swig_type * get_ptr() const
static swig_type_info _swigt__p_p_char
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plcont_texinfo
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
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)
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
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)
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)
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
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)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plgcompression_texinfo
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_plGetCursor_texinfo
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
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
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
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)
static const char * _wrap_plstripc_texinfo
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[]
static const char * _wrap_plscmap1_range_texinfo
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 c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
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
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)
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)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plshades_texinfo
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)
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
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
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)
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]
static const char * _wrap_plbtime_texinfo
void c_plshades(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plot3dcl_texinfo
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)
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)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
static const char * _wrap_plsurf3dl_texinfo
#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
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
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)
static const char * _wrap_plcolorbar_texinfo
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
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)
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_plvect_texinfo
static const char * _wrap_plw3d_texinfo
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
const swig_octave_member * members
#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)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsurf3d_texinfo
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
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_plot3d_texinfo
static const char * _wrap_plslabelfunc_texinfo
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
static const char * _wrap_plshade_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)
static const char * _wrap_plmeshc_texinfo
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
static const char * _wrap_plpath_texinfo
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbga_texinfo
#define swig_unary_op(name)
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
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
void c_plshade(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
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
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)
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)
static const char * _wrap_plmaptex_texinfo
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
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[]
static const char * _wrap_plmapfill_texinfo
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
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)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plspause_texinfo
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmapstring_texinfo
static const char * _wrap_plctime_texinfo
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)
static const char * _wrap_plconfigtime_texinfo
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plot3dc_texinfo
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
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)